Changed idfunc signature and contract to clarify that fact it is not lua-callable and to be able to require the module it was exported from in the target lanes.

4 files changed, 163 insertions, 129 deletions

diff --git a/src/lanes.c b/src/lanes.c
index f4bef7b..16a8edc 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -64,7 +64,7 @@
  *      ...
  */
 
-const char *VERSION= "2.0.10";
+const char *VERSION= "2.0.11";
 
 /*
 ===============================================================================
@@ -359,7 +359,8 @@ static const char *init_keepers(void) {
         lua_State *L= luaL_newstate();
         if (!L) return "out of memory";
 
-        luaG_openlibs( L, "io,table" );     // 'io' for debugging messages
+        luaG_openlibs( L, "io,table,package" );     // 'io' for debugging messages, package because we need to require modules exporting idfuncs
+        serialize_require( L);
 
         lua_pushlightuserdata( L, &nil_sentinel );
         lua_setglobal( L, "nil_sentinel" );
@@ -449,9 +450,9 @@ struct s_Linda {
     SIGNAL_T write_happened;
 };
 
-static int LG_linda_id( lua_State* );
+static void linda_id( lua_State*, char const * const which);
 
-#define lua_toLinda(L,n) ((struct s_Linda *)luaG_todeep( L, LG_linda_id, n ))
+#define lua_toLinda(L,n) ((struct s_Linda *)luaG_todeep( L, linda_id, n ))
 
 
 /*
@@ -462,7 +463,8 @@ static int LG_linda_id( lua_State* );
 * Returns:  'true' if the value was queued
 *           'false' for timeout (only happens when the queue size is limited)
 */
-LUAG_FUNC( linda_send ) {
+LUAG_FUNC( linda_send )
+{
     struct s_Linda *linda= lua_toLinda( L, 1 );
     bool_t ret;
     bool_t cancel= FALSE;
@@ -750,21 +752,22 @@ LUAG_FUNC( linda_deep ) {
 * Returns a metatable for the proxy objects ('__gc' method not needed; will
 * be added by 'luaG_...')
 *
+*   string= linda_id( "module")
+*
+* Returns the name of the module that a state should require
+* in order to keep a handle on the shared library that exported the idfunc
+*
 *   = linda_id( str, ... )
 *
 * For any other strings, the ID function must not react at all. This allows
 * future extensions of the system. 
 */
-LUAG_FUNC( linda_id ) {
-    const char *which= lua_tostring(L,1);
-
-    if (strcmp( which, "new" )==0) {
+static void linda_id( lua_State *L, char const * const which)
+{
+    if (strcmp( which, "new" )==0)
+    {
         struct s_Linda *s;
 
-        /* We don't use any parameters, but one could (they're at [2..TOS])
-        */
-        ASSERT_L( lua_gettop(L)==1 );
-
         /* The deep data is allocated separately of Lua stack; we might no
         * longer be around when last reference to it is being released.
         * One can use any memory allocation scheme.
@@ -776,11 +779,11 @@ LUAG_FUNC( linda_id ) {
         SIGNAL_INIT( &s->write_happened );
 
         lua_pushlightuserdata( L, s );
-        return 1;
-
-    } else if (strcmp( which, "delete" )==0) {
+    }
+    else if (strcmp( which, "delete" )==0)
+    {
         struct s_Keeper *K;
-        struct s_Linda *s= lua_touserdata(L,2);
+        struct s_Linda *s= lua_touserdata(L,1);
         ASSERT_L(s);
 
         /* Clean associated structures in the keeper state.
@@ -797,18 +800,20 @@ LUAG_FUNC( linda_id ) {
         SIGNAL_FREE( &s->read_happened );
         SIGNAL_FREE( &s->write_happened );
         free(s);
+    }
+    else if (strcmp( which, "metatable" )==0)
+    {
 
-        return 0;
-
-    } else if (strcmp( which, "metatable" )==0) {
-
-      STACK_CHECK(L)
+        STACK_CHECK(L)
         lua_newtable(L);
-        lua_newtable(L);
-            //
-            // [-2]: linda metatable
-            // [-1]: metatable's to-be .__index table
-    
+        // metatable is its own index
+        lua_pushvalue( L, -1);
+        lua_setfield( L, -2, "__index");
+        // protect metatable from external access
+        lua_pushboolean( L, 0);
+        lua_setfield( L, -2, "__metatable");
+        //
+        // [-1]: linda metatable
         lua_pushcfunction( L, LG_linda_send );
         lua_setfield( L, -2, "send" );
     
@@ -827,13 +832,17 @@ LUAG_FUNC( linda_id ) {
         lua_pushcfunction( L, LG_linda_deep );
         lua_setfield( L, -2, "deep" );
 
-        lua_setfield( L, -2, "__index" );
-      STACK_END(L,1)
-    
-        return 1;
+        STACK_END(L,1)
     }
-    
-    return 0;   // unknown request, be quiet
+    else if( strcmp( which, "module") == 0)
+    {
+        lua_pushliteral( L, "lua51-lanes");
+    }
+}
+
+LUAG_FUNC( linda)
+{
+    return luaG_deep_userdata( L, linda_id);
 }
 
 
@@ -1014,8 +1023,10 @@ static void selfdestruct_atexit( void ) {
     MUTEX_UNLOCK( &selfdestruct_cs );
 
     // Tell the timer thread to check it's cancel request
-    struct s_Linda *td = timer_deep->deep;
-    SIGNAL_ALL( &td->write_happened);
+    {
+        struct s_Linda *td = timer_deep->deep;
+        SIGNAL_ALL( &td->write_happened);
+    }
 
     // When noticing their cancel, the lanes will remove themselves from
     // the selfdestruct chain.
@@ -1855,21 +1866,21 @@ LUAG_FUNC( wakeup_conv )
 */
 
 static const struct luaL_reg lanes_functions [] = {
-    {"linda_id", LG_linda_id},
+    {"linda", LG_linda},
     {"thread_status", LG_thread_status},
     {"thread_join", LG_thread_join},
     {"thread_cancel", LG_thread_cancel},
     {"now_secs", LG_now_secs},
     {"wakeup_conv", LG_wakeup_conv},
     {"_single", LG__single},
-    {"_deep_userdata", luaG_deep_userdata},
     {NULL, NULL}
 };
 
 /*
 * One-time initializations
 */
-static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_ref ) {
+static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_ref )
+{
     const char *err;
 
 #if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
@@ -1919,8 +1930,9 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
         }
   #endif
 #endif
-        err= init_keepers();
-    if (err) {
+    err= init_keepers();
+    if (err)
+    {
             luaL_error( L, "Unable to initialize: %s", err );
     }
     
@@ -1928,13 +1940,11 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
     //
     ASSERT_L( timer_deep_ref && (!(*timer_deep_ref)) );
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
     {
         // proxy_ud= deep_userdata( idfunc )
         //
-        lua_pushcfunction( L, luaG_deep_userdata );
-        lua_pushcfunction( L, LG_linda_id );
-        lua_call( L, 1 /*args*/, 1 /*retvals*/ );
+        luaG_deep_userdata( L, linda_id);
 
         ASSERT_L( lua_isuserdata(L,-1) );
         
@@ -1950,7 +1960,7 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
         lua_rawset(L, LUA_REGISTRYINDEX);
 
     }
-  STACK_END(L,0)
+    STACK_END(L,0)
 }
 
 int 
@@ -2014,7 +2024,7 @@ __declspec(dllexport)
     lua_pushcclosure( L, LG_thread_new, 1 );    // metatable as closure param
     lua_setfield(L, -2, "thread_new");
 
-    luaG_push_proxy( L, LG_linda_id, (DEEP_PRELUDE *) timer_deep );
+    luaG_push_proxy( L, linda_id, (DEEP_PRELUDE *) timer_deep );
     lua_setfield(L, -2, "timer_gateway");
 
     lua_pushstring(L, VERSION);
diff --git a/src/lanes.lua b/src/lanes.lua
index 42e946b..b6fbc08 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -45,8 +45,6 @@ local mm = require "lua51-lanes"
 assert( type(mm)=="table" )
 
 
-local linda_id=    assert( mm.linda_id )
-
 local thread_new=   assert(mm.thread_new)
 local thread_status= assert(mm.thread_status)
 local thread_join=  assert(mm.thread_join)
@@ -55,8 +53,6 @@ local thread_cancel= assert(mm.thread_cancel)
 local _single= assert(mm._single)
 local _version= assert(mm._version)
 
-local _deep_userdata= assert(mm._deep_userdata)
-
 local now_secs= assert( mm.now_secs )
 local wakeup_conv= assert( mm.wakeup_conv )
 local timer_gateway= assert( mm.timer_gateway )
@@ -336,11 +332,7 @@ end
 -----
 -- linda_ud= lanes.linda()
 --
-function linda()
-    local proxy= _deep_userdata( linda_id )
-    assert( (type(proxy) == "userdata") and getmetatable(proxy) )
-    return proxy
-end
+linda = mm.linda
 
 
 ---=== Timers ===---
@@ -505,7 +497,7 @@ if first_time then
     -- We let the timer lane be a "free running" thread; no handle to it
     -- remains.
     --
-    gen( "io", { priority=max_prio, globals={threadName="LanesTimer"} }, function()
+    gen( "io,package", { priority=max_prio, globals={threadName="LanesTimer"} }, function()
 
         while true do
             local next_wakeup= check_timers()
diff --git a/src/tools.c b/src/tools.c
index 6692890..d09b11e 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -280,26 +280,27 @@ void get_deep_lookup( lua_State *L ) {
 * or NULL if 'index' is not a deep userdata proxy.
 */
 static
-lua_CFunction get_idfunc( lua_State *L, int index ) {
-    lua_CFunction ret;
+luaG_IdFunction get_idfunc( lua_State *L, int index )
+{
+    luaG_IdFunction ret;
 
     index= STACK_ABS(L,index);
 
     STACK_GROW(L,1);
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
     if (!lua_getmetatable( L, index ))
         return NULL;    // no metatable
     
     // [-1]: metatable of [index]
 
     get_deep_lookup(L);
-        //    
-        // [-1]: idfunc/nil
+    //    
+    // [-1]: idfunc/nil
 
-    ret= lua_tocfunction(L,-1);
+    ret= (luaG_IdFunction)lua_touserdata(L,-1);
     lua_pop(L,1);
-  STACK_END(L,0)
+    STACK_END(L,0)
     return ret;
 }
 
@@ -311,7 +312,8 @@ lua_CFunction get_idfunc( lua_State *L, int index ) {
 * it up if reaches 0.
 */
 static
-int deep_userdata_gc( lua_State *L ) {
+int deep_userdata_gc( lua_State *L )
+{
     DEEP_PRELUDE **proxy= (DEEP_PRELUDE**)lua_touserdata( L, 1 );
     DEEP_PRELUDE *p= *proxy;
     int v;
@@ -319,27 +321,26 @@ int deep_userdata_gc( lua_State *L ) {
     *proxy= 0;  // make sure we don't use it any more
 
     MUTEX_LOCK( &deep_lock );
-      v= --(p->refcount);
+    v= --(p->refcount);
     MUTEX_UNLOCK( &deep_lock );
 
-    if (v==0) {
-        int pushed;
-
+    if (v==0)
+    {
         // Call 'idfunc( "delete", deep_ptr )' to make deep cleanup
         //
-        lua_CFunction idfunc= get_idfunc(L,1);
+        luaG_IdFunction idfunc = get_idfunc(L,1);
         ASSERT_L(idfunc);
         
-        lua_settop(L,0);    // clean stack so we can call 'idfunc' directly
+        lua_settop( L, 0);    // clean stack so we can call 'idfunc' directly
 
         // void= idfunc( "delete", lightuserdata )
         //
-        lua_pushliteral( L, "delete" );
         lua_pushlightuserdata( L, p->deep );
-        pushed= idfunc(L);
-        
-        if (pushed)
-            luaL_error( L, "Bad idfunc on \"delete\": returned something" );
+        idfunc( L, "delete");
+
+        // top was set to 0, then userdata was pushed. "delete" might want to pop the userdata (we don't care), but should not push anything!
+        if ( lua_gettop( L) > 1)
+            luaL_error( L, "Bad idfunc on \"delete\": returned something");
 
         DEEP_FREE( (void*)p );
     }
@@ -354,28 +355,31 @@ int deep_userdata_gc( lua_State *L ) {
 * used in this Lua state (metatable, registring it). Otherwise, increments the
 * reference count.
 */
-void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude ) {
+void luaG_push_proxy( lua_State *L, luaG_IdFunction idfunc, DEEP_PRELUDE *prelude )
+{
     DEEP_PRELUDE **proxy;
 
     // Check if a proxy already exists
     push_registry_subtable_mode(L, DEEP_PROXY_CACHE_KEY, "v");
     lua_pushlightuserdata(L, prelude->deep);
     lua_rawget(L, -2);
-    if (!lua_isnil(L, -1)) {
+    if (!lua_isnil(L, -1))
+    {
         lua_remove(L, -2); // deep proxy cache table
         return;
-    } else {
+    }
+    else
+    {
         lua_pop(L, 2); // Pop the nil and proxy cache table
     }
 
-
     MUTEX_LOCK( &deep_lock );
-      ++(prelude->refcount);  // one more proxy pointing to this deep data
+    ++(prelude->refcount);  // one more proxy pointing to this deep data
     MUTEX_UNLOCK( &deep_lock );
 
     STACK_GROW(L,4);
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
 
     proxy= lua_newuserdata( L, sizeof( DEEP_PRELUDE* ) );
     ASSERT_L(proxy);
@@ -383,28 +387,32 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
 
     // Get/create metatable for 'idfunc' (in this state)
     //
-    lua_pushcfunction( L, idfunc );    // key
+    lua_pushlightuserdata( L, idfunc );    // key
     get_deep_lookup(L);
         //
         // [-2]: proxy
         // [-1]: metatable / nil
     
-    if (lua_isnil(L,-1)) {
-        // No metatable yet; make one and register it
-        //
+    if (lua_isnil(L,-1))
+    {
+        int oldtop;
+        // No metatable yet. We have two things to do:
+
+        // 1 - make one and register it
         lua_pop(L,1);
 
         // tbl= idfunc( "metatable" )
         //
-        lua_pushcfunction( L, idfunc );
-        lua_pushliteral( L, "metatable" );
-        lua_call( L, 1 /*args*/, 1 /*results*/ );
-            //
-            // [-2]: proxy
-            // [-1]: metatable (returned by 'idfunc')
+        oldtop = lua_gettop( L);
+        idfunc( L, "metatable");
+        //
+        // [-2]: proxy
+        // [-1]: metatable (returned by 'idfunc')
 
-        if (!lua_istable(L,-1))
+        if (lua_gettop( L) - oldtop != 1 || !lua_istable(L, -1))
+        {
             luaL_error( L, "Bad idfunc on \"metatable\": did not return one" );
+        }
 
         // Add '__gc' method
         //
@@ -414,16 +422,40 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
         // Memorize for later rounds
         //
         lua_pushvalue( L,-1 );
-        lua_pushcfunction( L, idfunc );
-            //
-            // [-4]: proxy
-            // [-3]: metatable (2nd ref)
-            // [-2]: metatable
-            // [-1]: idfunc
+        lua_pushlightuserdata( L, idfunc );
+        //
+        // [-4]: proxy
+        // [-3]: metatable (2nd ref)
+        // [-2]: metatable
+        // [-1]: idfunc
 
         set_deep_lookup(L);
-    } 
-  STACK_MID(L,2)
+
+        // 2 - cause the target state to require the module that exported the idfunc
+        // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc
+        lua_getglobal( L, "require");
+        if( lua_isfunction( L, -1)) // just in case...
+        {
+            // make sure the function pushed a single value on the stack!
+            int oldtop = lua_gettop( L);
+            idfunc( L, "module");
+            if( lua_gettop( L) - oldtop != 1 || !lua_isstring( L, -1))
+            {
+                luaL_error( L, "Bad idfunc on \"module\": should return a string");
+            }
+            // if we are inside a call to require, this will raise a "reentrency" error that we absorb silently (we don't care, this probably means the module is already being required, which is what we need)
+            if( lua_pcall( L, 1, 0, 0) != 0)
+            {
+                //char const * const errMsg = lua_tostring( L, -1); // just to see it in the debugger
+                lua_pop( L, 1);
+            }
+        }
+        else
+        {
+            lua_pop( L, 1);
+        }
+    }
+    STACK_MID(L,2)
     ASSERT_L( lua_isuserdata(L,-2) );
     ASSERT_L( lua_istable(L,-1) );
 
@@ -439,7 +471,7 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
     lua_rawset(L, -3);
     lua_pop(L, 1); // Remove the cache proxy table
 
-  STACK_END(L,1)
+    STACK_END(L,1)
     // [-1]: proxy userdata
 }
 
@@ -466,9 +498,9 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
 *
 * Returns:  'proxy' userdata for accessing the deep data via 'luaG_todeep()'
 */
-int luaG_deep_userdata( lua_State *L ) {
-    lua_CFunction idfunc= lua_tocfunction( L,1 );
-    int pushed;
+int luaG_deep_userdata( lua_State *L, luaG_IdFunction idfunc)
+{
+    int oldtop;
 
     DEEP_PRELUDE *prelude= DEEP_MALLOC( sizeof(DEEP_PRELUDE) );
     ASSERT_L(prelude);
@@ -476,20 +508,17 @@ int luaG_deep_userdata( lua_State *L ) {
     prelude->refcount= 0;   // 'luaG_push_proxy' will lift it to 1
 
     STACK_GROW(L,1);
-  STACK_CHECK(L)
-
-    // Replace 'idfunc' with "new" in the stack (keep possible other params)
-    //
-    lua_remove(L,1);
-    lua_pushliteral( L, "new" );
-    lua_insert(L,1);
+    STACK_CHECK(L)
 
     // lightuserdata= idfunc( "new" [, ...] )
     //
-    pushed= idfunc(L);
+                oldtop = lua_gettop( L);
+    idfunc(L, "new");
 
-    if ((pushed!=1) || lua_type(L,-1) != LUA_TLIGHTUSERDATA)
-        luaL_error( L, "Bad idfunc on \"new\": did not return light userdata" );
+    if( lua_gettop( L) - oldtop != 1 || lua_type( L, -1) != LUA_TLIGHTUSERDATA)
+    {
+        luaL_error( L, "Bad idfunc on \"new\": did not return light userdata");
+    }
 
     prelude->deep= lua_touserdata(L,-1);
     ASSERT_L(prelude->deep);
@@ -497,10 +526,10 @@ int luaG_deep_userdata( lua_State *L ) {
     lua_pop(L,1);   // pop deep data
 
     luaG_push_proxy( L, idfunc, prelude );
-        //
-        // [-1]: proxy userdata
+    //
+    // [-1]: proxy userdata
 
-  STACK_END(L,1)
+    STACK_END(L,1)
     return 1;
 }
 
@@ -511,15 +540,16 @@ int luaG_deep_userdata( lua_State *L ) {
 * Reference count is not changed, and access to the deep userdata is not
 * serialized. It is the module's responsibility to prevent conflicting usage.
 */
-void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index ) {
+void *luaG_todeep( lua_State *L, luaG_IdFunction idfunc, int index )
+{
     DEEP_PRELUDE **proxy;
 
-  STACK_CHECK(L)
-    if (get_idfunc(L,index) != idfunc)
+    STACK_CHECK(L)
+    if( get_idfunc(L,index) != idfunc)
         return NULL;    // no metatable, or wrong kind
 
     proxy= (DEEP_PRELUDE**)lua_touserdata( L, index );
-  STACK_END(L,0)
+    STACK_END(L,0)
 
     return (*proxy)->deep;
 }
@@ -533,14 +563,14 @@ void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index ) {
 *   (not copied)
 */
 static
-lua_CFunction luaG_copydeep( lua_State *L, lua_State *L2, int index ) {
+luaG_IdFunction luaG_copydeep( lua_State *L, lua_State *L2, int index )
+{
     DEEP_PRELUDE **proxy;
     DEEP_PRELUDE *p;
 
-    lua_CFunction idfunc;
-    
-    idfunc= get_idfunc( L, index );
-    if (!idfunc) return NULL;   // not a deep userdata
+    luaG_IdFunction idfunc = get_idfunc( L, index);
+    if (!idfunc)
+        return NULL;   // not a deep userdata
 
     // Increment reference count
     //
diff --git a/src/tools.h b/src/tools.h
index aad26df..05bee59 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -48,19 +48,21 @@
 
 #define luaG_typename( L, index ) lua_typename( L, lua_type(L,index) )
 
+typedef void (*luaG_IdFunction)( lua_State *L, char const * const which);
+
 void luaG_dump( lua_State* L );
 
 const char *luaG_openlibs( lua_State *L, const char *libs );
 
-int luaG_deep_userdata( lua_State *L );
-void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index );
+int luaG_deep_userdata( lua_State *L, luaG_IdFunction idfunc);
+void *luaG_todeep( lua_State *L, luaG_IdFunction idfunc, int index );
 
 typedef struct {
     volatile int refcount;
     void *deep;
 } DEEP_PRELUDE;
 
-void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *deep_userdata );
+void luaG_push_proxy( lua_State *L, luaG_IdFunction idfunc, DEEP_PRELUDE *deep_userdata );
 
 void luaG_inter_copy( lua_State *L, lua_State *L2, uint_t n );
 void luaG_inter_move( lua_State *L, lua_State *L2, uint_t n );