version 3.5.1v3.5.1

   * new lanes.h header and API call luaopen_lanes_embedded() for embedders
   * "lanes.core" is an acceptable library in the generator libs argument
   * library "*" wildcard also opens lanes.core
   * tweaked code for Xbox 360 build

11 files changed, 263 insertions, 67 deletions

diff --git a/CHANGES b/CHANGES
index 3957956..b6a3d53 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,12 @@
 CHANGES:
 
+CHANGE 59: BGe 12-Feb-13
+   * version 3.5.1
+   * new lanes.h header and API call luaopen_lanes_embedded() for embedders
+   * "lanes.core" is an acceptable library in the generator libs argument
+   * library "*" wildcard also opens lanes.core
+   * tweaked code for Xbox 360 build
+
 CHANGE 58: BGe 30-Jan-13
    * version 3.5.0
    * new: API lanes.require(), use it instead of regular require() for modules that export C functions you need to send over.
diff --git a/docs/index.html b/docs/index.html
index 8b21a97..89710ab 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -37,7 +37,8 @@
                 <p class="bar">
                         <a href="#description">Description</a> &middot;
                         <a href="#systems">Supported systems</a> &middot;
-                        <a href="#installing">Building and Installing</a>
+                        <a href="#installing">Building and Installing</a> &middot;
+                        <a href="#embedding">Embedding</a>
                 </p>
 
                 <p class="bar">
@@ -69,7 +70,7 @@
                         </p>
 
                         <p>
-                                This document was revised on 30-Jan-13, and applies to version <tt>3.5.0</tt>.
+                                This document was revised on 12-Feb-13, and applies to version <tt>3.5.1</tt>.
                         </p>
                 </font>
         </center>
@@ -164,6 +165,65 @@
 </pre>
 
 
+<!-- embedding +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+<hr/>
+<h2 id="embedding">Embedding</h2>
+<p>
+        When Lanes is embedded, it is possible to statically initialize with
+</p>
+<table border=1 bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
+        <tr>
+                <td>
+                        <pre>   extern void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes);</pre>
+                </td>
+        </tr>
+</table>
+<p>
+        <tt>luaopen_lanes_embedded</tt> leaves the module table on the stack. <tt>lanes.configure()</tt> must still be called in order to use Lanes.
+        <br/>
+        If <tt>_luaopen_lanes</tt> is <tt>NULL</tt>, a default loader will simply attempt the equivalent of <tt>luaL_dofile( L, "lanes.lua")</tt>.
+</p>
+
+<p>
+        To embed Lanes, compile source files in you application. In any Lua state were you want to use Lanes, initialize it as follows:
+</p>
+
+<p>
+        <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%">
+        <tr>
+                        <td>
+                                <pre>   #include "lanes.h"</pre>
+                                <br/>
+                                <pre>   int load_lanes_lua( lua_State* L)</pre>
+                                <pre>   {</pre>
+                                <pre>           // retrieve lanes.lua from wherever it is stored and return the result of its execution</pre>
+                                <pre>           // trivial example 1:</pre>
+                                <pre>           luaL_dofile( L, "lanes.lua");</pre>
+                                <br/>
+                                <pre>           // trivial example 2:</pre>
+                                <pre>           luaL_dostring( L, bin2c_lanes_lua);</pre>
+                                <pre>   }</pre>
+                                <br/>
+                                <pre>   void embed_lanes( lua_State* L)</pre>
+                                <pre>   {</pre>
+                                <pre>           // we need base libraries for Lanes for work</pre>
+                                <pre>           luaL_openlibs( L);</pre>
+                                <pre>           ...</pre>
+                                <pre>           // will attempt luaL_dofile( L, "lanes.lua");</pre>
+                                <pre>           luaopen_lanes_embedded( L, NULL);</pre>
+                                <pre>           lua_pop( L, 1);</pre>
+                                <pre>           // another example with a custom loader</pre>
+                                <pre>           luaopen_lanes_embedded( L, load_lanes_lua);</pre>
+                                <pre>           lua_pop( L, 1);</pre>
+                                <br/>
+                                <pre>           // a little test to make sure things work as expected</pre>
+                                <pre>           luaL_dostring( L, "local lanes = require 'lanes'.configure{with_timers = false}; local l = lanes.linda()");</pre>
+                                <pre>   }</pre>
+                        </td>
+                </tr>
+        </table>
+</p>
+
 <!-- launching +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
 <hr/>
 
@@ -438,7 +498,7 @@
                         </td>
                         <td/>
                         <td>
-                                All standard libraries (including those specific to LuaJIT and not listed above). This must be used alone.
+                                All standard libraries (including those specific to LuaJIT and not listed above), as well as <tt>lanes.core</tt>. This must be used alone.
                         </td>
                 </tr>
         </table>
@@ -765,7 +825,7 @@
 </p>
 
 <p>
-        If the lane is still running after the timeout expired and <tt>force_kill</tt> is <tt>true</tt>, the OS thread running the lane is forcefully killed. This means no GC, and should generally be the last resort.
+        If the lane is still running after the timeout expired and <tt>force_kill</tt> is <tt>true</tt>, the OS thread running the lane is forcefully killed. This means no GC, probable OS resource leaks (thread stack, locks, DLL notifications), and should generally be the last resort.
 </p>
 
 <p>
diff --git a/lanes-3.4.2-1.rockspec b/lanes-3.5.1-1.rockspec
index 23699ea..39191f2 100644
--- a/lanes-3.4.2-1.rockspec
+++ b/lanes-3.5.1-1.rockspec
@@ -7,11 +7,11 @@
 
 package = "Lanes"
 
-version = "3.4.2-1"
+version = "3.5.1-1"
 
 source= {
         url= "git://github.com/LuaLanes/lanes.git",
-        branch= "v3.4.2"
+        branch= "v3.5.1"
 }
 
 description = {
diff --git a/src/keeper.c b/src/keeper.c
index 3511b56..848fe2a 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -572,7 +572,7 @@ char const* init_keepers( lua_State* L, int _on_state_create, int const _nbKeepe
                 // 
                 // 'io' for debugging messages, 'package' because we need to require modules exporting idfuncs
                 // the others because they export functions that we may store in a keeper for transfer between lanes
-                K = luaG_newstate( L, _on_state_create, "*");
+                K = luaG_newstate( L, _on_state_create, "K");
 
                 STACK_CHECK( K);
 
diff --git a/src/lanes.c b/src/lanes.c
index 2b3d8ac..7bd29ee 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.5.0";
+char const* VERSION = "3.5.1";
 
 /*
 ===============================================================================
@@ -92,8 +92,9 @@ THE SOFTWARE.
 #include "threading.h"
 #include "tools.h"
 #include "keeper.h"
+#include "lanes.h"
 
-#if !((defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC))
+#if !(defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
 # include <sys/time.h>
 #endif
 
@@ -2580,6 +2581,26 @@ static const struct luaL_Reg lanes_functions [] = {
     {NULL, NULL}
 };
 
+
+/*
+ * minimal function registration for keepers, just so that we can populate the transfer databases with them
+ * without recursively deadlocking ourselves during one-time inits
+ */
+void register_core_libfuncs_for_keeper( lua_State* L)
+{
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.register_core_libfuncs_for_keeper()\n" INDENT_END));
+        DEBUGSPEW_CODE( ++ debugspew_indent_depth);
+        STACK_GROW( L, 1);
+        STACK_CHECK( L);
+        lua_newtable( L);
+        luaG_registerlibfuncs( L, lanes_functions);
+        STACK_MID( L, 1);
+        populate_func_lookup_table( L, -1, "lanes.core");
+        lua_pop( L, 1);
+        STACK_END( L, 0);
+        DEBUGSPEW_CODE( -- debugspew_indent_depth);
+}
+
 /*
 * One-time initializations
 */
@@ -2645,7 +2666,7 @@ static void init_once_LOCKED( lua_State* L, int const _on_state_create, int cons
     {
             (void) luaL_error( L, "Unable to initialize: %s", err );
     }
-    
+
     // Initialize 'timer_deep'; a common Linda object shared by all states
     //
     ASSERT_L( timer_deep == NULL);
@@ -2842,43 +2863,54 @@ void EnableCrashingOnCrashes()
 #endif // PLATFORM_WIN32
 }
 
-int 
-#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-__declspec(dllexport)
-#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-luaopen_lanes_core( lua_State* L)
+int LANES_API luaopen_lanes_core( lua_State* L)
 {
         EnableCrashingOnCrashes();
 
         STACK_GROW( L, 3);
         STACK_CHECK( L);
 
-        // sanity check: let's see if _"VERSION" matches what we we built against
-        lua_getglobal( L, "_VERSION");
-        lua_pushstring( L, LUA_VERSION_NUM == 501 ? "Lua 5.1" : "Lua 5.2");
-        if( !lua_rawequal( L, -1, -2))
-        {
-                return luaL_error( L, "Lanes is built against %s, but you are running %s", lua_tostring( L, -1), lua_tostring( L, -2));
-        }
-        lua_pop( L, 2);
-
         // Create main module interface table
         // we only have 1 closure, which must be called to configure Lanes
-        lua_newtable(L);
-        lua_pushvalue(L, 1); // module name
-        lua_pushvalue(L, -2); // module table
-        lua_pushcclosure( L, LG_configure, 2);
+        lua_newtable(L);                         // M
+        lua_pushvalue(L, 1);                     // M "lanes.core"
+        lua_pushvalue(L, -2);                    // M "lanes.core" M
+        lua_pushcclosure( L, LG_configure, 2);   // M LG_configure()
         if( s_initCount == 0)
         {
-                lua_setfield( L, -2, "configure");
+                lua_setfield( L, -2, "configure");     // M
         }
         else // already initialized: call it immediately and be done
         {
-                lua_pushinteger( L, 666); // any value will do, it will be ignored
-                lua_pushnil( L); // almost idem
-                lua_call( L, 2, 0);
+                // any parameter value will do, they will be ignored
+                lua_pushinteger( L, 666);              // M LG_configure() 666
+                lua_pushnil( L);                       // M LG_configure() 666 nil
+                lua_call( L, 2, 0);                    // M
         }
 
         STACK_END( L, 1);
         return 1;
 }
+
+static int default_luaopen_lanes( lua_State* L)
+{
+        int rc = luaL_loadfile( L, "lanes.lua") || lua_pcall( L, 0, 1, 0);
+        if( rc != LUA_OK)
+        {
+                return luaL_error( L, "failed to initialize embedded Lanes");
+        }
+        return 1;
+}
+
+// call this instead of luaopen_lanes_core() when embedding Lua and Lanes in a custom application
+void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes)
+{
+        STACK_CHECK( L);
+        // pre-require lanes.core so that when lanes.lua calls require "lanes.core" it finds it is already loaded
+        luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);                                       // ... lanes.core
+        lua_pop( L, 1);                                                                               // ...
+        STACK_MID( L, 0);
+        // call user-provided function that runs the chunk "lanes.lua" from wherever they stored it
+        luaL_requiref( L, "lanes", _luaopen_lanes ? _luaopen_lanes : default_luaopen_lanes, 0);       // ... lanes
+        STACK_END( L, 1);
+}
diff --git a/src/lanes.h b/src/lanes.h
new file mode 100644
index 0000000..d07750a
--- /dev/null
+++ b/src/lanes.h
@@ -0,0 +1,17 @@
+#if !defined( __lanes_h__)
+#define __lanes_h__ 1
+
+#include "lua.h"
+
+#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
+#define LANES_API __declspec(dllexport)
+#else
+#define LANES_API
+#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
+
+extern int LANES_API luaopen_lanes_core( lua_State* L);
+
+// Call this to work with embedded Lanes instead of calling luaopen_lanes_core()
+extern void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes);
+
+#endif // __lanes_h__
\ No newline at end of file
diff --git a/src/lanes.lua b/src/lanes.lua
index f4eef81..729116e 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -52,7 +52,7 @@ lanes.configure = function( _params)
         end
 
         -- 
-        -- Cache globals for code that might run under sandboxing 
+        -- Cache globals for code that might run under sandboxing
         --
         local assert = assert
         local string_gmatch = assert( string.gmatch)
@@ -199,18 +199,20 @@ end
 -- and call the generator later (maybe multiple times, with different parameters) 
 -- or add on actual thread arguments to also ignite the thread on the same call.
 
-local valid_libs= {
-    ["package"]= true,
-    ["table"]= true,
-    ["io"]= true,
-    ["os"]= true,
-    ["string"]= true,
-    ["math"]= true,
-    ["debug"]= true,
-    ["bit32"]= true, -- Lua 5.2 only, ignored silently under 5.1
-    --
-    ["base"]= true,
-    ["coroutine"]= true
+local valid_libs=
+{
+        ["package"] = true,
+        ["table"] = true,
+        ["io"] = true,
+        ["os"] = true,
+        ["string"] = true,
+        ["math"] = true,
+        ["debug"] = true,
+        ["bit32"] = true, -- Lua 5.2 only, ignored silently under 5.1
+        --
+        ["base"] = true,
+        ["coroutine"] = true, -- part of "base" in Lua 5.1
+        ["lanes.core"] = true
 }
 
 -- PUBLIC LANES API
@@ -253,7 +255,7 @@ local function gen( ... )
     if libs and libs ~= "*" then
         local found = {}
         -- check that the caller only provides reserved library names
-        for s in string_gmatch(libs, "[%a%d]+") do
+        for s in string_gmatch(libs, "[%a%d.]+") do
             if not valid_libs[s] then
                 error( "Bad library name: " .. s)
             else
diff --git a/src/threading.c b/src/threading.c
index d19fe1a..754b6d1 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -42,7 +42,7 @@ THE SOFTWARE.
 #include "threading.h"
 #include "lua.h"
 
-#if !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC)
+#if !defined( PLATFORM_XBOX) && !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC)
 # include <sys/time.h>
 #endif // non-WIN32 timing
 
@@ -83,7 +83,7 @@ THE SOFTWARE.
 * FAIL is for unexpected API return values - essentially programming 
 * error in _this_ code. 
 */
-#if defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
+#if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
 static void FAIL( const char *funcname, int rc ) {
     fprintf( stderr, "%s() failed! (%d)\n", funcname, rc );
 #ifdef _MSC_VER
@@ -102,7 +102,7 @@ static void FAIL( const char *funcname, int rc ) {
 */
 time_d now_secs(void) {
 
-#if defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
+#if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
     /*
     * Windows FILETIME values are "100-nanosecond intervals since 
     * January 1, 1601 (UTC)" (MSDN). Well, we'd want Unix Epoch as
@@ -226,7 +226,7 @@ static void prepare_timeout( struct timespec *ts, time_d abs_secs ) {
 //                      valid values N * 4KB
 //
 #ifndef _THREAD_STACK_SIZE
-# if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC) || (defined PLATFORM_CYGWIN)
+# if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC) || defined( PLATFORM_CYGWIN)
 #  define _THREAD_STACK_SIZE 0
       // Win32: does it work with less?
 # elif (defined PLATFORM_OSX)
@@ -311,10 +311,15 @@ bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs)
     return TRUE;
   }
   //
-  void THREAD_KILL( THREAD_T *ref ) {
-    if (!TerminateThread( *ref, 0 )) FAIL("TerminateThread", GetLastError());
-    *ref= NULL;
-  }
+        void THREAD_KILL( THREAD_T *ref )
+        {
+                // nonexistent on Xbox360, simply disable until a better solution is found
+                #if !defined( PLATFORM_XBOX)
+                // in theory no-one should call this as it is very dangerous (memory and mutex leaks, no notification of DLLs, etc.)
+                if (!TerminateThread( *ref, 0 )) FAIL("TerminateThread", GetLastError());
+                #endif // PLATFORM_XBOX
+                *ref= NULL;
+        }
 
 #if !defined __GNUC__
         //see http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
diff --git a/src/threading.h b/src/threading.h
index 1d304fa..1b218b9 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -11,6 +11,8 @@
  */
 #ifdef _WIN32_WCE
   #define PLATFORM_POCKETPC
+#elif defined(_XBOX)
+  #define PLATFORM_XBOX
 #elif (defined _WIN32)
   #define PLATFORM_WIN32
 #elif (defined __linux__)
@@ -47,7 +49,7 @@ enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
 #define THREADAPI_WINDOWS 1
 #define THREADAPI_PTHREAD 2
 
-#if( defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)) && !defined( HAVE_WIN32_PTHREAD)
+#if( defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)) && !defined( HAVE_WIN32_PTHREAD)
 #define THREADAPI THREADAPI_WINDOWS
 #else // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 #define THREADAPI THREADAPI_PTHREAD
@@ -57,10 +59,14 @@ enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
 */
 
 #if THREADAPI == THREADAPI_WINDOWS
-  #define WIN32_LEAN_AND_MEAN
-  // 'SignalObjectAndWait' needs this (targets Windows 2000 and above)
-  #define _WIN32_WINNT 0x0400
-  #include <windows.h>
+  #if defined ( PLATFORM_XBOX)
+    #include <xtl.h>
+  #else // !PLATFORM_XBOX
+    #define WIN32_LEAN_AND_MEAN
+    // 'SignalObjectAndWait' needs this (targets Windows 2000 and above)
+    #define _WIN32_WINNT 0x0400
+    #include <windows.h>
+  #endif // !PLATFORM_XBOX
   #include <process.h>
 
   // MSDN: http://msdn2.microsoft.com/en-us/library/ms684254.aspx
@@ -119,7 +125,7 @@ enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
   //
   #if defined( PLATFORM_OSX)
     #define YIELD() pthread_yield_np()
-  #elif defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
+  #elif defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC) // no PTHREAD for PLATFORM_XBOX
     // for some reason win32-pthread doesn't have pthread_yield(), but sched_yield()
     #define YIELD() sched_yield()
   #else
diff --git a/src/tools.c b/src/tools.c
index 13a3ebd..f72663f 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -33,6 +33,7 @@ THE SOFTWARE.
 
 #include "tools.h"
 #include "keeper.h"
+#include "lanes.h"
 
 #include "lualib.h"
 #include "lauxlib.h"
@@ -42,6 +43,43 @@ THE SOFTWARE.
 #include <ctype.h>
 #include <stdlib.h>
 
+/*
+** Copied from Lua 5.2 loadlib.c
+*/
+#if LUA_VERSION_NUM == 501
+static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
+{
+        lua_getfield(L, idx, fname);
+        if (lua_istable(L, -1))
+                return 1;  /* table already there */
+        else
+        {
+                lua_pop(L, 1);  /* remove previous result */
+                idx = lua_absindex(L, idx);
+                lua_newtable(L);
+                lua_pushvalue(L, -1);  /* copy to be left at top */
+                lua_setfield(L, idx, fname);  /* assign new table to field */
+                return 0;  /* false, because did not find table there */
+        }
+}
+
+void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb)
+{
+        lua_pushcfunction(L, openf);
+        lua_pushstring(L, modname);  /* argument to open function */
+        lua_call(L, 1, 1);  /* open module */
+        luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+        lua_pushvalue(L, -2);  /* make copy of module (call result) */
+        lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
+        lua_pop(L, 1);  /* remove _LOADED table */
+        if (glb)
+        {
+                lua_pushvalue(L, -1);  /* copy of 'mod' */
+                lua_setglobal(L, modname);  /* _G[modname] = module */
+        }
+}
+#endif // LUA_VERSION_NUM
+
 DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!----+----!----+----!----+----!----+----!----+");
 DEBUGSPEW_CODE( int debugspew_indent_depth = 0);
 
@@ -98,14 +136,24 @@ void luaG_dump( lua_State* L ) {
 
 /*---=== luaG_newstate ===---*/
 
+static int require_lanes_core( lua_State* L)
+{
+        // leaves a copy of 'lanes.core' module table on the stack
+        luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);
+        return 1;
+}
+
+
 static const luaL_Reg libs[] =
 {
         { LUA_LOADLIBNAME, luaopen_package},
         { LUA_TABLIBNAME, luaopen_table},
         { LUA_STRLIBNAME, luaopen_string},
         { LUA_MATHLIBNAME, luaopen_math},
+#ifndef PLATFORM_XBOX // no os/io libs on xbox
         { LUA_OSLIBNAME, luaopen_os},
         { LUA_IOLIBNAME, luaopen_io},
+#endif // PLATFORM_XBOX
 #if LUA_VERSION_NUM >= 502
         { LUA_BITLIBNAME, luaopen_bit32},
         { LUA_COLIBNAME, luaopen_coroutine}, // Lua 5.2: coroutine is no longer a part of base!
@@ -113,6 +161,7 @@ static const luaL_Reg libs[] =
         { LUA_COLIBNAME, NULL},              // Lua 5.1: part of base package
 #endif // LUA_VERSION_NUM
         { LUA_DBLIBNAME, luaopen_debug},
+        { "lanes.core", require_lanes_core}, // So that we can open it like any base library (possible since we have access to the init function)
         //
         { "base", NULL},                     // ignore "base" (already acquired it)
         { NULL, NULL }
@@ -135,9 +184,11 @@ static void open1lib( lua_State* L, char const* name, size_t len)
                                 lua_pop( L, 1);
 #else // LUA_VERSION_NUM
                                 STACK_GROW( L, 1);
+                                // push function and 1 argument on the stack
                                 lua_pushcfunction( L, libs[i].func);
-                                // pushes the module table on the stack
-                                lua_call( L, 0, 0);
+                                lua_pushstring( L, libs[i].name);
+                                // call function, pushes the module table on the stack
+                                lua_call( L, 1, 0);
 #endif // LUA_VERSION_NUM
                                 STACK_END( L, 0);
                         }
@@ -443,6 +494,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* _name)
 * Base ("unpack", "print" etc.) is always added, unless 'libs' is NULL.
 *
 */
+extern void register_core_libfuncs_for_keeper( lua_State* L);
 
 lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char const* libs)
 {
@@ -475,10 +527,24 @@ lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char con
         //
         if( libs)
         {
-                if( libs[0] == '*' && libs[1] == 0) // special "*" case (mainly to help with LuaJIT compatibility)
+                // special "*" case (mainly to help with LuaJIT compatibility)
+                // "K" is used when opening keeper states: almost the same as "*", but for the fact we don't open lanes.core
+                // as we are called from luaopen_lanes_core() already, and that would deadlock
+                if( (libs[0] == '*' || libs[0] == 'K') && libs[1] == 0)
                 {
                         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "opening ALL standard libraries\n" INDENT_END));
                         luaL_openlibs( L);
+                        if( libs[0] == '*')
+                        {
+                                // don't forget lanes.core for regular lane states
+                                open1lib( L, "lanes.core", 10);
+                        }
+                        else
+                        {
+                                // In keeper states however, we only want to register the lanes.core functions to be able to transfer them through lindas
+                                // (we don't care about a full lanes.core init in the keeper states as we won't call anything in there)
+                                register_core_libfuncs_for_keeper( L);
+                        }
                         libs = NULL; // done with libs
                 }
                 else
@@ -504,12 +570,12 @@ lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char con
                 unsigned int len = 0;
                 for( p = libs; *p; p += len)
                 {
-                        len = 0;
-                        // skip delimiters
-                        while( *p && !isalnum( *p))
+                        // skip delimiters ('.' can be part of name for "lanes.core")
+                        while( *p && !isalnum( *p) && *p != '.')
                                 ++ p;
                         // skip name
-                        while( isalnum( p[len]))
+                        len = 0;
+                        while( isalnum( p[len]) || p[len] == '.')
                                 ++ len;
                         // open library
                         open1lib( L, p, len);
diff --git a/src/tools.h b/src/tools.h
index a06e23f..10711d4 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -27,6 +27,7 @@
 #define luaG_registerlibfuncs( L, _funcs) luaL_register( L, NULL, _funcs)
 #define LUA_OK 0
 #define LUA_ERRGCMM 666 // doesn't exist in Lua 5.1, we don't care about the actual value
+void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int glb); // implementation copied from Lua 5.2 sources
 #endif // LUA_VERSION_NUM == 501
 
 // wrap Lua 5.2 calls under Lua 5.1 API when it is simpler that way