fix function transfer with lua_dump for Lua 5.4 failing for functions big enough to necessitate a buffer reallocation

5 files changed, 98 insertions, 16 deletions

diff --git a/CHANGES b/CHANGES
index 792a52b..c21a3ed 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,9 @@
 CHANGES:
 
+CHANGE 149: BGe 8-Jul-21
+   * bumped version to 3.15.1
+   * fix function transfer with lua_dump for Lua 5.4 failing for functions big enough to necessitate a buffer reallocation
+
 CHANGE 148: BGe 23-Jun-21
    * __lanesclone now receives the original as light userdata the first time it is called -> BREAKS CUSTOM DEEP USERDATA API
 
diff --git a/docs/index.html b/docs/index.html
index 76752f5..82b1f24 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -70,7 +70,7 @@
                         </p>
 
                         <p>
-                                This document was revised on 23-Jun-21, and applies to version <tt>3.15.0</tt>.
+                                This document was revised on 8-Jul-21, and applies to version <tt>3.15.1</tt>.
                         </p>
                 </font>
         </center>
diff --git a/lanes-3.15.1-0.rockspec b/lanes-3.15.1-0.rockspec
new file mode 100644
index 0000000..0ad4fd6
--- /dev/null
+++ b/lanes-3.15.1-0.rockspec
@@ -0,0 +1,66 @@
+--
+-- Lanes rockspec
+--
+-- Ref:
+--      <http://luarocks.org/en/Rockspec_format>
+--
+
+package = "Lanes"
+
+version = "3.15.1-0"
+
+source= {
+        url= "git://github.com/LuaLanes/lanes.git",
+        branch= "v3.15.1"
+}
+
+description = {
+        summary= "Multithreading support for Lua",
+        detailed= [[
+                Lua Lanes is a portable, message passing multithreading library
+                providing the possibility to run multiple Lua states in parallel.
+        ]],
+        license= "MIT/X11",
+        homepage="https://github.com/LuaLanes/lanes",
+        maintainer="Benoit Germain <bnt.germain@gmail.com>"
+}
+
+-- Q: What is the difference of "windows" and "win32"? Seems there is none;
+--    so should we list either one or both?
+--
+supported_platforms= { "win32",
+                                           "macosx",
+                                           "linux",
+                                           "freebsd",   -- TBD: not tested
+                                           "msys",      -- TBD: not supported by LuaRocks 1.0 (or is it?)
+}
+
+dependencies= {
+        "lua >= 5.1", -- builds with either 5.1, 5.2, 5.3 and 5.4
+}
+
+build = {
+        type = "builtin",
+        platforms =
+        {
+                linux =
+                {
+                        modules =
+                        {
+                                ["lanes.core"] =
+                                {
+                                        libraries = "pthread"
+                                },
+                        }
+                }
+        },
+        modules =
+        {
+                ["lanes.core"] =
+                {
+                        sources = { "src/compat.c", "src/deep.c", "src/lanes.c", "src/linda.c", "src/keeper.c", "src/tools.c", "src/state.c", "src/threading.c", "src/universe.c"},
+                        incdirs = { "src"},
+                },
+                lanes = "src/lanes.lua"
+        }
+}
diff --git a/src/lanes.h b/src/lanes.h
index 1a38ba5..41a6b73 100644
--- a/src/lanes.h
+++ b/src/lanes.h
@@ -12,7 +12,7 @@
 
 #define LANES_VERSION_MAJOR 3
 #define LANES_VERSION_MINOR 15
-#define LANES_VERSION_PATCH 0
+#define LANES_VERSION_PATCH 1
 
 #define LANES_MIN_VERSION_REQUIRED(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
 #define LANES_VERSION_LESS_THAN(MAJOR, MINOR, PATCH)        ((LANES_VERSION_MAJOR<MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR<MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH<PATCH))))
diff --git a/src/tools.c b/src/tools.c
index 18015c1..1436e8d 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -297,7 +297,8 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
         int i = 1;
         luaL_Buffer b;
         STACK_CHECK( L, 0);
-        luaL_buffinit( L, &b);
+        // Lua 5.4 pushes &b as light userdata on the stack. be aware of it...
+        luaL_buffinit( L, &b);                            // ... {} ... &b?
         for( ; i < last; ++ i)
         {
                 lua_rawgeti( L, t, i);
@@ -309,7 +310,8 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
                 lua_rawgeti( L, t, i);
                 luaL_addvalue( &b);
         }
-        luaL_pushresult( &b);
+        // &b is popped at that point (-> replaced by the result)
+        luaL_pushresult( &b);                             // ... {} ... "<result>"
         STACK_END( L, 1);
         return lua_tolstring( L, -1, length);
 }
@@ -631,14 +633,6 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
         return id;
 }
 
-
-static int buf_writer( lua_State *L, const void* b, size_t n, void* B ) {
-  (void)L;
-  luaL_addlstring((luaL_Buffer*) B, (const char *)b, n);
-  return 0;
-}
-
-
 // function sentinel used to transfer native functions from/to keeper states
 static int func_lookup_sentinel( lua_State* L)
 {
@@ -1138,14 +1132,32 @@ static char const* vt_names[] =
 };
 #endif // USE_DEBUG_SPEW
 
+// Lua 5.4.3 style of dumping (see lstrlib.c)
+// we have to do it that way because we can't unbalance the stack between buffer operations
+// namely, this means we can't push a function on top of the stack *after* we initialize the buffer!
+// luckily, this also works with earlier Lua versions
+static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
+{
+    luaL_Buffer* B = (luaL_Buffer*) ud;
+    if( !B->L)
+    {
+        luaL_buffinit( L, B);
+    }
+    luaL_addlstring( B, (char const*) b, size);
+    return 0;
+}
+
 static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
 {
         int n, needToPush;
-        luaL_Buffer b;
+        luaL_Buffer B;
+        B.L = NULL;
+
         ASSERT_L( L2_cache_i != 0);                                                       // ... {cache} ... p
         STACK_GROW( L, 2);
         STACK_CHECK( L, 0);
 
+
         // 'lua_dump()' needs the function at top of stack
         // if already on top of the stack, no need to push again
         needToPush = (i != (uint_t)lua_gettop( L));
@@ -1154,18 +1166,18 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
                 lua_pushvalue( L, i);                                // ... f
         }
 
-        luaL_buffinit( L, &b);
         //
         // "value returned is the error code returned by the last call 
         // to the writer" (and we only return 0)
         // not sure this could ever fail but for memory shortage reasons
-        if( lua504_dump( L, buf_writer, &b, 0) != 0)
+        // last parameter is Lua 5.4-specific (no stripping)
+        if( lua504_dump( L, buf_writer, &B, 0) != 0)
         {
                 luaL_error( L, "internal error: function dump failed.");
         }
 
         // pushes dumped string on 'L'
-        luaL_pushresult( &b);                                  // ... f b
+        luaL_pushresult( &B);                                  // ... f b
 
         // if not pushed, no need to pop
         if( needToPush)