Deep userdata improvements

Support for user-provided __gc
Improved example

5 files changed, 78 insertions, 34 deletions

diff --git a/CHANGES b/CHANGES
index 338c48f..92fb7f9 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,9 @@
 CHANGES:
 
+CHANGE 123: BGe 2-Aug-17
+   * added support for user-provided __gc in deep userdata
+   * more complete deep userdata sample
+
 CHANGE 122: BGe 1-Aug-17
    * fix crash trying to use a deep-aware module while not requiring Lanes
    * bumped version to 3.12
diff --git a/deep_test/deep_test.c b/deep_test/deep_test.c
index a48ecb2..abe9fdc 100644
--- a/deep_test/deep_test.c
+++ b/deep_test/deep_test.c
@@ -1,3 +1,5 @@
+#include <malloc.h>
+
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
@@ -10,19 +12,46 @@
 #define LANES_API
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
+struct s_MyDeepUserdata
+{
+        lua_Integer val;
+};
+static void* deep_test_id( lua_State* L, enum eDeepOp op_);
+
+// ################################################################################################
+
+static int deep_set( lua_State* L)
+{
+        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
+        lua_Integer i = lua_tointeger( L, 2);
+        self->val = i;
+        return 0;
+}
+
 // ################################################################################################
 
-static int deep_tostring(lua_State* L)
+static int deep_tostring( lua_State* L)
 {
-        lua_pushliteral( L, "I am a deep_test");
+        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
+        lua_pushfstring( L, "deep_test(%d)", self->val);
         return 1;
 }
 
 // ################################################################################################
 
+static int deep_gc( lua_State* L)
+{
+        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
+        return 0;
+}
+
+// ################################################################################################
+
 static luaL_Reg const deep_mt[] =
 {
         { "__tostring", deep_tostring},
+        { "__gc", deep_gc},
+        { "set", deep_set},
         { NULL, NULL }
 };
 
@@ -34,26 +63,25 @@ static void* deep_test_id( lua_State* L, enum eDeepOp op_)
         {
                 case eDO_new:
                 {
-                        void* allocUD;
-                        lua_Alloc allocF = lua_getallocf( L, &allocUD);
-                        void* deep_test = allocF( allocUD, NULL, 0, sizeof(void*));
+                        struct s_MyDeepUserdata* deep_test = (struct s_MyDeepUserdata*) malloc( sizeof(struct s_MyDeepUserdata));
+                        deep_test->val = 0;
                         return deep_test;
                 }
 
                 case eDO_delete:
                 {
-                        void* allocUD;
-                        lua_Alloc allocF = lua_getallocf( L, &allocUD);
-                        void* deep_test = lua_touserdata( L, 1);
-                        allocF( allocUD, deep_test, sizeof(void*), 0);
+                        struct s_MyDeepUserdata* deep_test = (struct s_MyDeepUserdata*) lua_touserdata( L, 1);
+                        free( deep_test);
                         return NULL;
                 }
 
                 case eDO_metatable:
                 {
-                        lua_newtable( L);
-                        luaL_setfuncs( L, deep_mt, 0);
-                        luaG_pushdeepversion( L);
+                        lua_newtable( L);                          // mt
+                        luaL_setfuncs( L, deep_mt, 0);             // mt
+                        lua_pushvalue( L, -1);                     // mt mt
+                        lua_setfield( L, -2, "__index");           // mt
+                        luaG_pushdeepversion( L);                  // mt version
                         return NULL;
                 }
 
@@ -69,7 +97,7 @@ static void* deep_test_id( lua_State* L, enum eDeepOp op_)
 
 // ################################################################################################
 
-int luaD_new_deep(lua_State* L)
+int luaD_new_deep( lua_State* L)
 {
         return luaG_newdeepuserdata( L, deep_test_id);
 }
diff --git a/deep_test/deep_test.lua b/deep_test/deep_test.lua
index 034c07d..fd78115 100644
--- a/deep_test/deep_test.lua
+++ b/deep_test/deep_test.lua
@@ -1,13 +1,15 @@
 -- create a deep-aware full userdata while Lanes isn't loaded
 local dt = require "deep_test"
 local deep = dt.new_deep()
+deep:set(666)
 print( deep)
 
 -- now load Lanes and see if that userdata is transferable
-
+--[[
 local lanes = require("lanes").configure()
 
 local l = lanes.linda "my linda"
 l.put( "key", deep)
 local out = l.get( "key")
-print( out)
\ No newline at end of file
+print( out)
+]]
\ No newline at end of file
diff --git a/src/deep.c b/src/deep.c
index 71a798c..737ebe9 100644
--- a/src/deep.c
+++ b/src/deep.c
@@ -104,7 +104,7 @@ void push_registry_subtable( lua_State* L, void* key_)
 
 /*---=== Deep userdata ===---*/
 
-void luaG_pushdeepversion( lua_State* L) { (void) lua_pushliteral( L, "f248e77a-a84d-44b5-9ad0-96c05679b885");}
+void luaG_pushdeepversion( lua_State* L) { (void) lua_pushliteral( L, "ab8743e5-84f8-485d-9c39-008e84656188");}
 
 
 
@@ -219,11 +219,11 @@ void free_deep_prelude( lua_State* L, struct DEEP_PRELUDE* prelude_)
 
 
 /*
-* void= mt.__gc( proxy_ud )
-*
-* End of life for a proxy object; reduce the deep reference count and clean
-* it up if reaches 0.
-*/
+ * void= mt.__gc( proxy_ud )
+ *
+ * End of life for a proxy object; reduce the deep reference count and clean it up if reaches 0.
+ *
+ */
 static int deep_userdata_gc( lua_State* L)
 {
         struct DEEP_PRELUDE** proxy = (struct DEEP_PRELUDE**) lua_touserdata( L, 1);
@@ -231,8 +231,6 @@ static int deep_userdata_gc( lua_State* L)
         struct s_Universe* U = universe_get( L);
         int v;
 
-        *proxy = 0;  // make sure we don't use it any more
-
         // can work without a universe if creating a deep userdata from some external C module when Lanes isn't loaded
         // in that case, we are not multithreaded and locking isn't necessary anyway
         if( U) MUTEX_LOCK( &U->deep_lock);
@@ -241,6 +239,13 @@ static int deep_userdata_gc( lua_State* L)
 
         if( v == 0)
         {
+                // retrieve wrapped __gc
+                lua_pushvalue( L, lua_upvalueindex( 1));                            // self __gc?
+                if( !lua_isnil( L, -1))
+                {
+                        lua_insert( L, -2);                                               // __gc self
+                        lua_call( L, 1, 0);                                               //
+                }
                 // 'idfunc' expects a clean stack to work on
                 lua_settop( L, 0);
                 free_deep_prelude( L, p);
@@ -251,6 +256,7 @@ static int deep_userdata_gc( lua_State* L)
                         luaL_error( L, "Bad idfunc(eDO_delete): should not push anything");
                 }
         }
+        *proxy = NULL;  // make sure we don't use it any more, just in case
         return 0;
 }
 
@@ -321,22 +327,26 @@ char const* push_deep_proxy( struct s_Universe* U, lua_State* L, struct DEEP_PRE
                                 return "Bad idfunc(eOP_metatable): mismatched deep version";
                         }
                         lua_pop( L, 2);                                                                                // DPC proxy metatable
-                        // make sure the idfunc didn't export __gc, as we will store our own
+                        // if the metatable contains a __gc, we will call it from our own
                         lua_getfield( L, -1, "__gc");                                                                  // DPC proxy metatable __gc
-                        if( !lua_isnil( L, -1))
-                        {
-                                lua_pop( L, 4);                                                                              //
-                                return "idfunc-created metatable shouldn't contain __gc";
-                        }
-                        lua_pop( L, 1);                                                                                // DPC proxy metatable
                 }
                 else
                 {
-                        // keepers need a minimal metatable that only contains __gc
+                        // keepers need a minimal metatable that only contains our own __gc
                         lua_newtable( L);                                                                              // DPC proxy metatable
+                        lua_pushnil( L);                                                                               // DPC proxy metatable nil
+                }
+                if (lua_isnil(L, -1))
+                {
+                        // Add our own '__gc' method
+                        lua_pop( L, 1);                                                                                // DPC proxy metatable
+                        lua_pushcfunction( L, deep_userdata_gc);                                                       // DPC proxy metatable deep_userdata_gc
+                }
+                else
+                {
+                        // Add our own '__gc' method wrapping the original
+                        lua_pushcclosure( L, deep_userdata_gc, 1);                                                     // DPC proxy metatable deep_userdata_gc
                 }
-                // Add our own '__gc' method
-                lua_pushcfunction( L, deep_userdata_gc);                                                         // DPC proxy metatable __gc
                 lua_setfield( L, -2, "__gc");                                                                    // DPC proxy metatable
 
                 // Memorize for later rounds
diff --git a/src/tools.c b/src/tools.c
index f935c26..9403fd6 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -822,7 +822,7 @@ static int func_lookup_sentinel( lua_State* L)
 // 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)));
+        return luaL_error( L, "table lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
 }
 
 /*