1 files changed, 367 insertions, 230 deletions

diff --git a/src/tools.c b/src/tools.c
index f1b0372..c2491ba 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -8,7 +8,7 @@
 ===============================================================================
 
 Copyright (C) 2002-10 Asko Kauppi <akauppi@gmail.com>
-              2011-14 benoit Germain <bnt.germain@gmail.com>
+              2011-17 benoit Germain <bnt.germain@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -71,48 +71,52 @@ DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!--
 
 /*---=== luaG_dump ===---*/
 
-void luaG_dump( lua_State* L ) {
-
-    int top= lua_gettop(L);
-    int i;
+void luaG_dump( lua_State* L)
+{
+        int top = lua_gettop( L);
+        int i;
 
-        fprintf( stderr, "\n\tDEBUG STACK:\n" );
+        fprintf( stderr, "\n\tDEBUG STACK:\n");
 
-        if (top==0)
-                fprintf( stderr, "\t(none)\n" );
+        if( top == 0)
+                fprintf( stderr, "\t(none)\n");
 
-        for( i=1; i<=top; i++ ) {
-                int type= lua_type( L, i );
+        for( i = 1; i <= top; ++ i)
+        {
+                int type = lua_type( L, i);
 
-                fprintf( stderr, "\t[%d]= (%s) ", i, lua_typename(L,type) );
+                fprintf( stderr, "\t[%d]= (%s) ", i, lua_typename( L, type));
 
                 // Print item contents here...
                 //
                 // Note: this requires 'tostring()' to be defined. If it is NOT,
                 //       enable it for more debugging.
                 //
-    STACK_CHECK( L);
-        STACK_GROW( L, 2);
-
-        lua_getglobal( L, "tostring" );
-            //
-            // [-1]: tostring function, or nil
-        
-        if (!lua_isfunction(L,-1)) {
-             fprintf( stderr, "('tostring' not available)" );
-         } else {
-             lua_pushvalue( L, i );
-             lua_call( L, 1 /*args*/, 1 /*retvals*/ );
-
-             // Don't trust the string contents
-             //                
-             fprintf( stderr, "%s", lua_tostring(L,-1) );
-         }
-         lua_pop(L,1);
-    STACK_END( L, 0);
-                fprintf( stderr, "\n" );
+                STACK_CHECK( L);
+                STACK_GROW( L, 2);
+
+                lua_getglobal( L, "tostring");
+                //
+                // [-1]: tostring function, or nil
+
+                if( !lua_isfunction( L, -1))
+                {
+                        fprintf( stderr, "('tostring' not available)");
                 }
-        fprintf( stderr, "\n" );
+                else
+                {
+                        lua_pushvalue( L, i);
+                        lua_call( L, 1 /*args*/, 1 /*retvals*/);
+
+                        // Don't trust the string contents
+                        //                
+                        fprintf( stderr, "%s", lua_tostring( L, -1));
+                }
+                lua_pop( L, 1);
+                STACK_END( L, 0);
+                fprintf( stderr, "\n");
+        }
+        fprintf( stderr, "\n");
 }
 
 void initialize_on_state_create( struct s_Universe* U, lua_State* L)
@@ -206,6 +210,14 @@ static const luaL_Reg libs[] =
         { LUA_COLIBNAME, NULL},              // Lua 5.1: part of base package
 #endif // LUA_VERSION_NUM
         { LUA_DBLIBNAME, luaopen_debug},
+#if defined LUA_JITLIBNAME // building against LuaJIT headers, add some LuaJIT-specific libs
+//#pragma message( "supporting JIT base libs")
+        { LUA_BITLIBNAME, luaopen_bit},
+        { LUA_JITLIBNAME, luaopen_jit},
+        { LUA_FFILIBNAME, luaopen_ffi},
+#endif // LUA_JITLIBNAME
+
+        { 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)
@@ -246,7 +258,8 @@ static void open1lib( struct s_Universe* U, lua_State* L, char const* name_, siz
         }
 }
 
-static int dummy_writer(lua_State *L, const void* p, size_t sz, void* ud)
+
+static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
 {
         (void)L; (void)p; (void)sz; (void) ud; // unused
         return 666;
@@ -314,12 +327,12 @@ static lua_CFunction luaG_tocfunction( lua_State *L, int _i, FuncSubType *_out)
 
 
 // inspired from tconcat() in ltablib.c
-static char const* luaG_pushFQN(lua_State *L, int t, int last, size_t* length)
+static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
 {
         int i = 1;
         luaL_Buffer b;
         STACK_CHECK( L);
-        luaL_buffinit(L, &b);
+        luaL_buffinit( L, &b);
         for( ; i < last; ++ i)
         {
                 lua_rawgeti( L, t, i);
@@ -336,12 +349,89 @@ static char const* luaG_pushFQN(lua_State *L, int t, int last, size_t* length)
         return lua_tolstring( L, -1, length);
 }
 
+/*
+ * receives 2 arguments: a name k and an object o
+ * add two entries ["fully.qualified.name"] = o
+ * and             [o] = "fully.qualified.name"
+ * where <o> is either a table or a function
+ * if we already had an entry of type [o] = ..., replace the name if the new one is shorter
+ * pops the processed object from the stack
+ */
+static void update_lookup_entry( lua_State* L, int _ctx_base, int _depth)
+{
+        // slot 1 in the stack contains the table that receives everything we found
+        int const dest = _ctx_base;
+        // slot 2 contains a table that, when concatenated, produces the fully qualified name of scanned elements in the table provided at slot _i
+        int const fqn = _ctx_base + 1;
+
+        size_t prevNameLength, newNameLength;
+        char const* prevName;
+        DEBUGSPEW_CODE( char const *newName);
+        DEBUGSPEW_CODE( struct s_Universe* U = get_universe( L));
+
+        STACK_CHECK( L);
+        // first, raise an error if the function is already known
+        lua_pushvalue( L, -1);                                                                // ... {bfc} k o o
+        lua_rawget( L, dest);                                                                 // ... {bfc} k o name?
+        prevName = lua_tolstring( L, -1, &prevNameLength); // NULL if we got nil (first encounter of this object)
+        // push name in fqn stack (note that concatenation will crash if name is a not string or a number)
+        lua_pushvalue( L, -3);                                                                // ... {bfc} k o name? k
+        ASSERT_L( lua_type( L, -1) == LUA_TNUMBER || lua_type( L, -1) == LUA_TSTRING);
+        ++ _depth;
+        lua_rawseti( L, fqn, _depth);                                                         // ... {bfc} k o name?
+        // generate name
+        DEBUGSPEW_CODE( newName =) luaG_pushFQN( L, fqn, _depth, &newNameLength);             // ... {bfc} k o name? "f.q.n"
+        // Lua 5.2 introduced a hash randomizer seed which causes table iteration to yield a different key order
+        // on different VMs even when the tables are populated the exact same way.
+        // When Lua is built with compatibility options (such as LUA_COMPAT_ALL),
+        // this causes several base libraries to register functions under multiple names.
+        // This, with the randomizer, can cause the first generated name of an object to be different on different VMs,
+        // which breaks function transfer.
+        // Also, nothing prevents any external module from exposing a given object under several names, so...
+        // Therefore, when we encounter an object for which a name was previously registered, we need to select the names
+        // based on some sorting order so that we end up with the same name in all databases whatever order the table walk yielded
+        if( prevName != NULL && (prevNameLength < newNameLength || lua_lessthan( L, -2, -1)))
+        {
+                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s '%s' remained named '%s'\n" INDENT_END, lua_typename( L, lua_type( L, -3)), newName, prevName));
+                // the previous name is 'smaller' than the one we just generated: keep it!
+                lua_pop( L, 3);                                                                     // ... {bfc} k
+        }
+        else
+        {
+                // the name we generated is either the first one, or a better fit for our purposes
+                if( prevName)
+                {
+                        // clear the previous name for the database to avoid clutter
+                        lua_insert( L, -2);                                                               // ... {bfc} k o "f.q.n" prevName
+                        // t[prevName] = nil
+                        lua_pushnil( L);                                                                  // ... {bfc} k o "f.q.n" prevName nil
+                        lua_rawset( L, dest);                                                             // ... {bfc} k o "f.q.n"
+                }
+                else
+                {
+                        lua_remove( L, -2);                                                               // ... {bfc} k o "f.q.n"
+                }
+                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s '%s'\n" INDENT_END, lua_typename( L, lua_type( L, -2)), newName));
+                // prepare the stack for database feed
+                lua_pushvalue( L, -1);                                                              // ... {bfc} k o "f.q.n" "f.q.n"
+                lua_pushvalue( L, -3);                                                              // ... {bfc} k o "f.q.n" "f.q.n" o
+                ASSERT_L( lua_rawequal( L, -1, -4));
+                ASSERT_L( lua_rawequal( L, -2, -3));
+                // t["f.q.n"] = o
+                lua_rawset( L, dest);                                                               // ... {bfc} k o "f.q.n"
+                // t[o] = "f.q.n"
+                lua_rawset( L, dest);                                                               // ... {bfc} k
+                // remove table name from fqn stack
+                lua_pushnil( L);                                                                    // ... {bfc} k nil
+                lua_rawseti( L, fqn, _depth);                                                       // ... {bfc} k
+        }
+        -- _depth;
+        STACK_END( L, -1);
+}
 
 static void populate_func_lookup_table_recur( lua_State* L, int _ctx_base, int _i, int _depth)
 {
         lua_Integer visit_count;
-        // slot 1 in the stack contains the table that receives everything we found
-        int const dest = _ctx_base;
         // slot 2 contains a table that, when concatenated, produces the fully qualified name of scanned elements in the table provided at slot _i
         int const fqn = _ctx_base + 1;
         // slot 3 contains a cache that stores all already visited tables to avoid infinite recursion loops
@@ -400,69 +490,15 @@ static void populate_func_lookup_table_recur( lua_State* L, int _ctx_base, int _
                         lua_rawset( L, cache);                                                                // ... {_i} {bfc} k {}
                         // store the table in the breadth-first cache
                         lua_pushvalue( L, -2);                                                                // ... {_i} {bfc} k {} k
-                        lua_insert( L, -2);                                                                   // ... {_i} {bfc} k k {}
-                        lua_rawset( L, breadth_first_cache);                                                  // ... {_i} {bfc} k
+                        lua_pushvalue( L, -2);                                                                // ... {_i} {bfc} k {} k {}
+                        lua_rawset( L, breadth_first_cache);                                                  // ... {_i} {bfc} k {}
+                        // generate a name, and if we already had one name, keep whichever is the shorter
+                        update_lookup_entry( L, _ctx_base, _depth);                                           // ... {_i} {bfc} k
                 }
                 else if( lua_isfunction( L, -1) && (luaG_getfuncsubtype( L, -1) != FST_Bytecode))       // ... {_i} {bfc} k func
                 {
-                        size_t prevNameLength, newNameLength;
-                        char const* prevName;
-                        DEBUGSPEW_CODE( char const *newName);
-                        // first, raise an error if the function is already known
-                        lua_pushvalue( L, -1);                                                                // ... {_i} {bfc} k func func
-                        lua_rawget( L, dest);                                                                 // ... {_i} {bfc} k func name?
-                        prevName = lua_tolstring( L, -1, &prevNameLength); // NULL if we got nil (first encounter of this function)
-                        // push function name in fqn stack (note that concatenation will crash if name is a not string or a number)
-                        lua_pushvalue( L, -3);                                                                // ... {_i} {bfc} k func name? k
-                        ++ _depth;
-                        lua_rawseti( L, fqn, _depth);                                                         // ... {_i} {bfc} k func name?
-                        // generate name
-                        DEBUGSPEW_CODE( newName =) luaG_pushFQN( L, fqn, _depth, &newNameLength);             // ... {_i} {bfc} k func name? "f.q.n"
-                        // Lua 5.2 introduced a hash randomizer seed which causes table iteration to yield a different key order
-                        // on different VMs even when the tables are populated the exact same way.
-                        // When Lua is built with compatibility options (such as LUA_COMPAT_ALL),
-                        // this causes several base libraries to register functions under multiple names.
-                        // This, with the randomizer, can cause the first name of a function to be different on different VMs,
-                        // which breaks function transfer.
-                        // Also, nothing prevents any external module from exposing a given function under several names, so...
-                        // Therefore, when we encounter a function for which a name was previously registered, we need to select the names
-                        // based on some sorting order so that we end up with the same name in all databases whatever order the table walk yielded
-                        if( prevName != NULL && (prevNameLength < newNameLength || lua_lessthan( L, -2, -1)))
-                        {
-                                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function '%s' remained named '%s'\n" INDENT_END, newName, prevName));
-                                // the previous name is 'smaller' than the one we just generated: keep it!
-                                lua_pop( L, 3);                                                                     // ... {_i} {bfc} k
-                        }
-                        else
-                        {
-                                // the name we generated is either the first one, or a better fit for our purposes
-                                if( prevName)
-                                {
-                                        // clear the previous name for the database to avoid clutter
-                                        lua_insert( L, -2);                                                               // ... {_i} {bfc} k func "f.q.n" prevName
-                                        // t[prevName] = nil
-                                        lua_pushnil( L);                                                                  // ... {_i} {bfc} k func "f.q.n" prevName nil
-                                        lua_rawset( L, dest);                                                             // ... {_i} {bfc} k func "f.q.n"
-                                }
-                                else
-                                {
-                                        lua_remove( L, -2);                                                               // ... {_i} {bfc} k func "f.q.n"
-                                }
-                                // prepare the stack for database feed
-                                lua_pushvalue( L, -1);                                                              // ... {_i} {bfc} k func "f.q.n" "f.q.n"
-                                lua_pushvalue( L, -3);                                                              // ... {_i} {bfc} k func "f.q.n" "f.q.n" func
-                                ASSERT_L( lua_rawequal( L, -1, -4));
-                                ASSERT_L( lua_rawequal( L, -2, -3));
-                                // t["f.q.n"] = func 
-                                lua_rawset( L, dest);                                                               // ... {_i} {bfc} k func "f.q.n"
-                                // t[func] = "f.q.n"
-                                lua_rawset( L, dest);                                                               // ... {_i} {bfc} k
-                                // remove table name from fqn stack
-                                lua_pushnil( L);                                                                    // ... {_i} {bfc} k nil
-                                lua_rawseti( L, fqn, _depth);                                                       // ... {_i} {bfc} k
-                                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function '%s'\n" INDENT_END, newName));
-                        }
-                        -- _depth;
+                        // generate a name, and if we already had one name, keep whichever is the shorter
+                        update_lookup_entry( L, _ctx_base, _depth);                                           // ... {_i} {bfc} k
                 }
                 else
                 {
@@ -519,7 +555,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
 {
         int const ctx_base = lua_gettop( L) + 1;
         int const in_base = lua_absindex( L, _i);
-        int const start_depth = name_ ? 1 : 0;
+        int start_depth = 0;
         DEBUGSPEW_CODE( struct s_Universe* U = get_universe( L));
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "NULL"));
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
@@ -543,9 +579,17 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
                 lua_newtable( L);                                                       // {} {fqn}
                 if( name_)
                 {
+                        STACK_MID( L, 2);
                         lua_pushstring( L, name_);                                            // {} {fqn} "name"
+                        // generate a name, and if we already had one name, keep whichever is the shorter
+                        lua_pushvalue( L, in_base);                                           // {} {fqn} "name" t
+                        update_lookup_entry( L, ctx_base, start_depth);                       // {} {fqn} "name"
+                        // don't forget to store the name at the bottom of the fqn stack
+                        ++ start_depth;
                         lua_rawseti( L, -2, start_depth);                                     // {} {fqn}
+                        STACK_MID( L, 2);
                 }
+                // retrieve the cache, create it if we haven't done it yet
                 lua_getfield( L, LUA_REGISTRYINDEX, LOOKUP_KEY_CACHE);                  // {} {fqn} {cache}?
                 if( lua_isnil( L, -1))
                 {
@@ -554,6 +598,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
                         lua_pushvalue( L, -1);                                                // {} {fqn} {cache} {cache}
                         lua_setfield( L, LUA_REGISTRYINDEX, LOOKUP_KEY_CACHE);                // {} {fqn} {cache}
                 }
+                // process everything we find in that table, filling in lookup data for all functions and tables we see there
                 populate_func_lookup_table_recur( L, ctx_base, in_base, start_depth);   // {...} {fqn} {cache}
                 lua_pop( L, 3);
         }
@@ -795,6 +840,158 @@ static int buf_writer( lua_State *L, const void* b, size_t n, void* B ) {
 }
 
 
+// function sentinel used to transfer native functions from/to keeper states
+static int func_lookup_sentinel( lua_State* L)
+{
+        return luaL_error( L, "function lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+}
+
+
+// function sentinel used to transfer native table from/to keeper states
+static int table_lookup_sentinel( lua_State* L)
+{
+        return luaL_error( L, "table lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex(1)));
+}
+
+/*
+ * retrieve the name of a function/table in the lookup database
+ */
+static char const* find_lookup_name( lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_, size_t* len_)
+{
+        DEBUGSPEW_CODE( struct s_Universe* const U = get_universe( L));
+        char const* fqn;
+        ASSERT_L( lua_isfunction( L, i) || lua_istable( L, i));  // ... v ...
+        STACK_CHECK( L);
+        STACK_GROW( L, 3); // up to 3 slots are necessary on error
+        if( mode_ == eLM_FromKeeper)
+        {
+                lua_CFunction f = lua_tocfunction( L, i); // should *always* be func_lookup_sentinel or table_lookup_sentinel!
+                if( f == func_lookup_sentinel || f == table_lookup_sentinel)
+                {
+                        lua_getupvalue( L, i, 1);                            // ... v ... "f.q.n"
+                }
+                else
+                {
+                        // if this is not a sentinel, this is some user-created table we wanted to lookup
+                        ASSERT_L( NULL == f && lua_istable( L, i));
+                        // push anything that will convert to NULL string
+                        lua_pushnil( L);                                     // ... v ... nil
+                }
+        }
+        else
+        {
+                // fetch the name from the source state's lookup table
+                lua_getfield( L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);    // ... v ... {}
+                ASSERT_L( lua_istable( L, -1));
+                lua_pushvalue( L, i);                                  // ... v ... {} v
+                lua_rawget( L, -2);                                    // ... v ... {} "f.q.n"
+        }
+        fqn = lua_tolstring( L, -1, len_);
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function [C] %s \n" INDENT_END, fqn));
+        // popping doesn't invalidate the pointer since this is an interned string gotten from the lookup database
+        lua_pop( L, (mode_ == eLM_FromKeeper) ? 1 : 2);          // ... v ...
+        STACK_MID( L, 0);
+        if( NULL == fqn && !lua_istable( L, i)) // raise an error if we try to send an unknown function (but not for tables)
+        {
+                char const *from, *typewhat, *what, *gotchaA, *gotchaB;
+                // try to discover the name of the function we want to send
+                lua_getglobal( L, "decoda_name");                      // ... v ... decoda_name
+                from = lua_tostring( L, -1);
+                lua_pushcfunction( L, luaG_nameof);                    // ... v ... decoda_name luaG_nameof
+                lua_pushvalue( L, i);                                  // ... v ... decoda_name luaG_nameof t
+                lua_call( L, 1, 2);                                    // ... v ... decoda_name "type" "name"|nil
+                typewhat = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : luaL_typename( L, -2);
+                // second return value can be nil if the table was not found
+                // probable reason: the function was removed from the source Lua state before Lanes was required.
+                if( lua_isnil( L, -1))
+                {
+                        gotchaA = " referenced by";
+                        gotchaB = "\n(did you remove it from the source Lua state before requiring Lanes?)";
+                        what = upName_;
+                }
+                else
+                {
+                        gotchaA = "";
+                        gotchaB = "";
+                        what = (lua_type( L, -1) == LUA_TSTRING) ? lua_tostring( L, -1) : luaL_typename( L, -1);
+                }
+                (void) luaL_error( L, "%s%s '%s' not found in %s origin transfer database.%s", typewhat, gotchaA, what, from ? from : "main", gotchaB);
+                *len_ = 0;
+                return NULL;
+        }
+        STACK_END( L, 0);
+        return fqn;
+}
+
+
+/*
+ * Push a looked-up table, or nothing if we found nothing
+ */
+static bool_t lookup_table( lua_State* L2, lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_)
+{
+        // get the name of the table we want to send
+        size_t len;
+        char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
+        if( NULL == fqn) // name not found, it is some user-created table
+        {
+                return FALSE;
+        }
+        // push the equivalent table in the destination's stack, retrieved from the lookup table
+        STACK_CHECK( L2);                                        // L                          // L2
+        STACK_GROW( L2, 3); // up to 3 slots are necessary on error
+        switch( mode_)
+        {
+                default: // shouldn't happen, in theory...
+                (void) luaL_error( L, "internal error: unknown lookup mode");
+                return FALSE;
+
+                case eLM_ToKeeper:
+                // push a sentinel closure that holds the lookup name as upvalue
+                lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
+                lua_pushcclosure( L2, table_lookup_sentinel, 1);                                     // f
+                break;
+
+                case eLM_LaneBody:
+                case eLM_FromKeeper:
+                lua_getfield( L2, LUA_REGISTRYINDEX, LOOKUP_REGKEY);                                 // {}
+                ASSERT_L( lua_istable( L2, -1));
+                lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
+                lua_rawget( L2, -2);                                                                 // {} t
+                // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead)
+                // but not when we extract something out of a keeper, as there is nothing to clone!
+                if( lua_isnil( L2, -1) && mode_ == eLM_LaneBody)
+                {
+                        lua_pop( L2, 2);                                                                   //
+                        STACK_MID( L2, 0);
+                        return FALSE;
+                }
+                else if( !lua_istable( L2, -1))
+                {
+                        char const* from, *to;
+                        lua_getglobal( L, "decoda_name");                    // ... t ... decoda_name
+                        from = lua_tostring( L, -1);
+                        lua_pop( L, 1);                                      // ... t ...
+                        lua_getglobal( L2, "decoda_name");                                                 // {} t decoda_name
+                        to = lua_tostring( L2, -1);
+                        lua_pop( L2, 1);                                                                   // {} t
+                        // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
+                        (void) luaL_error(
+                                (mode_ == eLM_FromKeeper) ? L2 : L
+                                , "INTERNAL ERROR IN %s: table '%s' not found in %s destination transfer database."
+                                , from ? from : "main"
+                                , fqn
+                                , to ? to : "main"
+                        );
+                        return FALSE;
+                }
+                lua_remove( L2, -2);                                                                 // t
+                break;
+        }
+        STACK_END( L2, 1);
+        return TRUE;
+}
+
+
 /* 
  * Check if we've already copied the same table from 'L', and
  * reuse the old copy. This allows table upvalues shared by multiple
@@ -805,60 +1002,35 @@ static int buf_writer( lua_State *L, const void* b, size_t n, void* B ) {
  * Returns TRUE if the table was cached (no need to fill it!); FALSE if
  * it's a virgin.
  */
-static bool_t push_cached_table( lua_State *L2, uint_t L2_cache_i, lua_State *L, uint_t i )
+static bool_t push_cached_table( lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i)
 {
-        bool_t ret;
+        bool_t not_found_in_cache;                                                                     // L2
+        void* const p = (void*)lua_topointer( L, i);
 
-        ASSERT_L( L2_cache_i != 0 );
-
-        STACK_GROW(L2,3);
-
-        // L2_cache[id_str]= [{...}]
-        //
+        ASSERT_L( L2_cache_i != 0);
+        STACK_GROW( L2, 3);
         STACK_CHECK( L2);
 
         // We don't need to use the from state ('L') in ID since the life span
         // is only for the duration of a copy (both states are locked).
-        //
-        lua_pushlightuserdata( L2, (void*)lua_topointer( L, i )); // push a light userdata uniquely representing the table
-
-        //fprintf( stderr, "<< ID: %s >>\n", lua_tostring(L2,-1) );
+        // push a light userdata uniquely representing the table
+        lua_pushlightuserdata( L2, p);                                                                 // ... p
 
-        lua_pushvalue( L2, -1 );
-        lua_rawget( L2, L2_cache_i );
-        //
-        // [-2]: identity table pointer lightuserdata
-        // [-1]: table|nil
+        //fprintf( stderr, "<< ID: %s >>\n", lua_tostring( L2, -1));
 
-        if (lua_isnil(L2,-1))
+        lua_rawget( L2, L2_cache_i);                                                                   // ... {cached|nil}
+        not_found_in_cache = lua_isnil( L2, -1);
+        if( not_found_in_cache)
         {
-                lua_pop(L2,1);
-                lua_newtable(L2);
-                lua_pushvalue(L2,-1);
-                lua_insert(L2,-3);
-                //
-                // [-3]: new table (2nd ref)
-                // [-2]: identity table pointer lightuserdata
-                // [-1]: new table
-
-                lua_rawset(L2, L2_cache_i);
-                //
-                // [-1]: new table (tied to 'L2_cache' table')
-
-                ret= FALSE;     // brand new
-
-        }
-        else
-        {
-                lua_remove(L2,-2);
-                ret= TRUE;      // from cache
+                lua_pop( L2, 1);                                                                             // ...
+                lua_newtable( L2);                                                                           // ... {}
+                lua_pushlightuserdata( L2, p);                                                               // ... {} p
+                lua_pushvalue( L2, -2);                                                                      // ... {} p {}
+                lua_rawset( L2, L2_cache_i);                                                                 // ... {}
         }
         STACK_END( L2, 1);
-        //
-        // L2 [-1]: table to use as destination
-
-        ASSERT_L( lua_istable(L2,-1) );
-        return ret;
+        ASSERT_L( lua_istable( L2, -1));
+        return !not_found_in_cache;
 }
 
 
@@ -999,6 +1171,7 @@ static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
         return shortest_;
 }
 
+
 /*
  * "type", "name" = lanes.nameof( o)
  */
@@ -1046,72 +1219,17 @@ int luaG_nameof( lua_State* L)
         return 2;
 }
 
-// function sentinel used to transfer native functions from/to keeper states
-static int sentinelfunc( lua_State* L)
-{
-        return luaL_error( L, "transfer sentinel function for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
-}
 
 /*
-* Push a looked-up native/LuaJIT function.
-*/
-static void lookup_native_func( struct s_Universe* U, lua_State* L2, lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_)
+ * Push a looked-up native/LuaJIT function.
+ */
+static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_)
 {
-        char const* fqn;                                         // L                          // L2
+        // get the name of the function we want to send
         size_t len;
-        ASSERT_L( lua_isfunction( L, i));                        // ... f ...
-        STACK_CHECK( L);
-        STACK_GROW( L, 3); // up to 3 slots are necessary on error
-        if( mode_ == eLM_FromKeeper)
-        {
-                lua_CFunction f = lua_tocfunction( L, i); // should *always* be sentinelfunc!
-                ASSERT_L( f == sentinelfunc);
-                lua_getupvalue( L, i, 1);                              // ... f ... "f.q.n"
-                fqn = lua_tolstring( L, -1, &len);
-        }
-        else
-        {
-                // fetch the name from the source state's lookup table
-                lua_getfield( L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);    // ... f ... {}
-                ASSERT_L( lua_istable( L, -1));
-                lua_pushvalue( L, i);                                  // ... f ... {} f
-                lua_rawget( L, -2);                                    // ... f ... {} "f.q.n"
-                fqn = lua_tolstring( L, -1, &len);
-        }
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function [C] %s \n" INDENT_END, fqn));
-        // popping doesn't invalidate the pointer since this is an interned string gotten from the lookup database
-        lua_pop( L, (mode_ == eLM_FromKeeper) ? 1 : 2);          // ... f ...
-        STACK_MID( L, 0);
-        if( !fqn)
-        {
-                char const *from, *typewhat, *what, *gotchaA, *gotchaB;
-                // try to discover the name of the function we want to send
-                lua_getglobal( L, "decoda_name");                      // ... f ... decoda_name
-                from = lua_tostring( L, -1);
-                lua_pushcfunction( L, luaG_nameof);                    // ... f ... decoda_name luaG_nameof
-                lua_pushvalue( L, i);                                  // ... f ... decoda_name luaG_nameof f
-                lua_call( L, 1, 2);                                    // ... f ... decoda_name "type" "name"|nil
-                typewhat = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : luaL_typename( L, -2);
-                // second return value can be nil if the function was not found
-                // probable reason: the function was removed from the source Lua state before Lanes was required.
-                if( lua_isnil( L, -1))
-                {
-                        gotchaA = " referenced by";
-                        gotchaB = "\n(did you remove it from the source Lua state before requiring Lanes?)";
-                        what = upName_;
-                }
-                else
-                {
-                        gotchaA = "";
-                        gotchaB = "";
-                        what = (lua_type( L, -1) == LUA_TSTRING) ? lua_tostring( L, -1) : luaL_typename( L, -1);
-                }
-                (void) luaL_error( L, "%s%s '%s' not found in %s origin transfer database.%s", typewhat, gotchaA, what, from ? from : "main", gotchaB);
-                return;
-        }
-        STACK_END( L, 0);
+        char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
         // push the equivalent function in the destination's stack, retrieved from the lookup table
-        STACK_CHECK( L2);
+        STACK_CHECK( L2);                                        // L                          // L2
         STACK_GROW( L2, 3); // up to 3 slots are necessary on error
         switch( mode_)
         {
@@ -1122,7 +1240,7 @@ static void lookup_native_func( struct s_Universe* U, lua_State* L2, lua_State*
                 case eLM_ToKeeper:
                 // push a sentinel closure that holds the lookup name as upvalue
                 lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
-                lua_pushcclosure( L2, sentinelfunc, 1);                                              // f
+                lua_pushcclosure( L2, func_lookup_sentinel, 1);                                      // f
                 break;
 
                 case eLM_LaneBody:
@@ -1131,15 +1249,26 @@ static void lookup_native_func( struct s_Universe* U, lua_State* L2, lua_State*
                 ASSERT_L( lua_istable( L2, -1));
                 lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
                 lua_rawget( L2, -2);                                                                 // {} f
-                if( !lua_isfunction( L2, -1))
+                // nil means we don't know how to transfer stuff: user should do something
+                // anything other than function or table should not happen!
+                if( !lua_isfunction( L2, -1) && !lua_istable( L2, -1))
                 {
                         char const* from, * to;
                         lua_getglobal( L, "decoda_name");                    // ... f ... decoda_name
                         from = lua_tostring( L, -1);
+                        lua_pop( L, 1);                                      // ... f ...
                         lua_getglobal( L2, "decoda_name");                                                 // {} f decoda_name
                         to = lua_tostring( L2, -1);
+                        lua_pop( L2, 1);                                                                   // {} f
                         // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
-                        (void) luaL_error( (mode_ == eLM_FromKeeper) ? L2 : L, "%s: function '%s' not found in %s destination transfer database.", from ? from : "main", fqn, to ? to : "main");
+                        (void) luaL_error(
+                                (mode_ == eLM_FromKeeper) ? L2 : L
+                                , "%s%s: function '%s' not found in %s destination transfer database."
+                                , lua_isnil( L2, -1) ? "" : "INTERNAL ERROR IN "
+                                , from ? from : "main"
+                                , fqn
+                                , to ? to : "main"
+                        );
                         return;
                 }
                 lua_remove( L2, -2);                                                                 // f
@@ -1164,6 +1293,7 @@ static void lookup_native_func( struct s_Universe* U, lua_State* L2, lua_State*
         STACK_END( L2, 1);
 }
 
+
 /*
  * Copy a function over, which has not been found in the cache.
  * L2 has the cache key for this function at the top of the stack
@@ -1181,7 +1311,7 @@ static void inter_copy_func( struct s_Universe* U, lua_State* L2, uint_t L2_cach
         int n, needToPush;
         luaL_Buffer b;
         ASSERT_L( L2_cache_i != 0);                                                       // ... {cache} ... p
-        STACK_GROW(L,2);
+        STACK_GROW( L, 2);
         STACK_CHECK( L);
 
         // 'lua_dump()' needs the function at top of stack
@@ -1223,7 +1353,7 @@ static void inter_copy_func( struct s_Universe* U, lua_State* L2, uint_t L2_cach
                         lua_Debug ar;
                         lua_pushvalue( L, i);                              // ... b f
                         // fills 'name' 'namewhat' and 'linedefined', pops function
-                        lua_getinfo(L, ">nS", &ar);                        // ... b
+                        lua_getinfo( L, ">nS", &ar);                       // ... b
                         name = ar.namewhat;
                         fprintf( stderr, INDENT_BEGIN "FNAME: %s @ %d\n", i, s_indent, ar.short_src, ar.linedefined);  // just gives NULL
                 }
@@ -1348,12 +1478,12 @@ static void push_cached_func( struct s_Universe* U, lua_State* L2, uint_t L2_cac
                 // push a light userdata uniquely representing the function
                 lua_pushlightuserdata( L2, aspointer);                        // ... {cache} ... p
 
-                //fprintf( stderr, "<< ID: %s >>\n", lua_tostring(L2,-1) );
+                //fprintf( stderr, "<< ID: %s >>\n", lua_tostring( L2, -1));
 
                 lua_pushvalue( L2, -1);                                       // ... {cache} ... p p
                 lua_rawget( L2, L2_cache_i);                                  // ... {cache} ... p function|nil|true
 
-                if( lua_isnil(L2,-1)) // function is unknown
+                if( lua_isnil( L2, -1)) // function is unknown
                 {
                         lua_pop( L2, 1);                                            // ... {cache} ... p
 
@@ -1368,15 +1498,14 @@ static void push_cached_func( struct s_Universe* U, lua_State* L2, uint_t L2_cac
                         lua_remove( L2, -2);                                        // ... {cache} ... function
                 }
                 STACK_END( L2, 1);
+                ASSERT_L( lua_isfunction( L2, -1));
         }
         else // function is native/LuaJIT: no need to cache
         {
-                lookup_native_func( U, L2, L, i, mode_, upName_);             // ... {cache} ... function
+                lookup_native_func( L2, L, i, mode_, upName_);                // ... {cache} ... function
+                // if the function was in fact a lookup sentinel, we can either get a function or a table here
+                ASSERT_L( lua_isfunction( L2, -1) || lua_istable( L2, -1));
         }
-
-        //
-        // L2 [-1]: function
-        ASSERT_L( lua_isfunction( L2, -1));
 }
 
 /*
@@ -1393,25 +1522,23 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
 {
         bool_t ret = TRUE;
         bool_t ignore = FALSE;
+        int val_type = lua_type( L, i);
         STACK_GROW( L2, 1);
         STACK_CHECK( L2);
 
         /* Skip the object if it has metatable with { __lanesignore = true } */
-        if( lua_getmetatable( L, i))                                                                    // ... mt
+        if( lua_getmetatable( L, i))                                                                  // ... mt
         {
-                lua_pushstring( L, "__lanesignore");                                                        // ... mt "__lanesignore"
-                lua_gettable( L, -2);                                                                       // ... mt ignore?
-
+                lua_getfield( L, -1, "__lanesignore");                                                      // ... mt ignore?
                 if( lua_isboolean( L, -1) && lua_toboolean( L, -1))
                 {
-                        ignore = TRUE;
+                        val_type = LUA_TNIL;
                 }
-
                 lua_pop( L, 2);                                                                             // ...
         }
 
         /* Lets push nil to L2 if the object should be ignored */
-        switch( ignore ? LUA_TNIL : lua_type( L, i))
+        switch( val_type)
         {
                 /* Basic types allowed both as values, and as table keys */
 
@@ -1425,7 +1552,7 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                 if( lua_isinteger( L, i))
                 {
                         lua_Integer v = lua_tointeger( L, i);
-                        DEBUGSPEW_CODE( if( vt == VT_KEY) fprintf( stderr, INDENT_BEGIN "KEY: %d\n" INDENT_END, v));
+                        DEBUGSPEW_CODE( if( vt == VT_KEY) fprintf( stderr, INDENT_BEGIN "KEY: " LUA_INTEGER_FMT "\n" INDENT_END, v));
                         lua_pushinteger( L2, v);
                         break;
                 }
@@ -1448,7 +1575,7 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                 break;
 
                 case LUA_TLIGHTUSERDATA:
-                lua_pushlightuserdata( L2, lua_touserdata(L, i));
+                lua_pushlightuserdata( L2, lua_touserdata( L, i));
                 break;
 
                         /* The following types are not allowed as table keys */
@@ -1524,6 +1651,16 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                         STACK_CHECK( L);
                         STACK_CHECK( L2);
 
+                        /*
+                         * First, let's try to see if this table is special (aka is it some table that we registered in our lookup databases during module registration?)
+                         * Note that this table CAN be a module table, but we just didn't register it, in which case we'll send it through the table cloning mechanism
+                         */
+                        if( lookup_table( L2, L, i, mode_, upName_))
+                        {
+                                ASSERT_L( lua_istable( L2, -1) || (lua_tocfunction( L2, -1) == table_lookup_sentinel));    // from lookup datables // can also be table_lookup_sentinel if this is a table we know
+                                break;
+                        }
+
                         /* Check if we've already copied the same table from 'L' (during this transmission), and
                         * reuse the old copy. This allows table upvalues shared by multiple
                         * local functions to point to the same table, also in the target.
@@ -1531,14 +1668,14 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                         * to the same subtable.
                         *
                         * Note: Even metatables need to go through this test; to detect
-                        *      loops s.a. those in required module tables (getmetatable(lanes).lanes == lanes)
+                        *       loops such as those in required module tables (getmetatable(lanes).lanes == lanes)
                         */
                         if( push_cached_table( L2, L2_cache_i, L, i))
                         {
                                 ASSERT_L( lua_istable( L2, -1));    // from cache
                                 break;
                         }
-                        ASSERT_L( lua_istable( L2,-1));
+                        ASSERT_L( lua_istable( L2, -1));
 
                         STACK_GROW( L, 2);
                         STACK_GROW( L2, 2);
@@ -1546,11 +1683,10 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                         lua_pushnil( L);    // start iteration
                         while( lua_next( L, i))
                         {
-                                uint_t val_i = lua_gettop(L);
+                                uint_t val_i = lua_gettop( L);
                                 uint_t key_i = val_i - 1;
 
-                                /* Only basic key types are copied over; others ignored
-                                */
+                                // Only basic key types are copied over; others ignored
                                 if( inter_copy_one_( U, L2, 0 /*key*/, L, key_i, VT_KEY, mode_, upName_))
                                 {
                                         char* valPath = (char*) upName_;
@@ -1613,8 +1749,8 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
                                 {   /* L2 did not know the metatable */
                                         lua_pop( L2, 1);
                                         STACK_MID( L2, 2);
-                                        ASSERT_L( lua_istable(L,-1));
-                                        if( inter_copy_one_( U, L2, L2_cache_i /*for function cacheing*/, L, lua_gettop(L) /*[-1]*/, VT_METATABLE, mode_, upName_))
+                                        ASSERT_L( lua_istable( L,-1));
+                                        if( inter_copy_one_( U, L2, L2_cache_i /*for function cacheing*/, L, lua_gettop( L) /*[-1]*/, VT_METATABLE, mode_, upName_))
                                         {
                                                 //
                                                 // L2 ([-3]: copied table)
@@ -1664,6 +1800,7 @@ static bool_t inter_copy_one_( struct s_Universe* U, lua_State* L2, uint_t L2_ca
 
                 /* The following types cannot be copied */
 
+                case 10: // LuaJIT CDATA
                 case LUA_TTHREAD: 
                 ret = FALSE;
                 break;