5 files changed, 107 insertions, 25 deletions

diff --git a/src/keeper.c b/src/keeper.c
index 338f794..83ec8f3 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -128,20 +128,31 @@ static void fifo_peek( lua_State* L, keeper_fifo* fifo, int _count)
 }
 
 // in: fifo
-// out: pushes as many items as required on the stack (function assumes they exist in sufficient number)
+// out: remove the fifo from the stack, push as many items as required on the stack (function assumes they exist in sufficient number)
 static void fifo_pop( lua_State* L, keeper_fifo* fifo, int _count)
 {
         int fifo_idx = lua_gettop( L);           // ... fifo
         int i;
         // each iteration pushes a value on the stack!
-        STACK_GROW( L, _count + 1);
-        for( i = 0; i < _count; ++ i)
+        STACK_GROW( L, _count + 2);
+        // skip first item, we will push it last
+        for( i = 1; i < _count; ++ i)
         {
-                int at = fifo->first + i;
+                int const at = fifo->first + i;
+                // push item on the stack
                 lua_rawgeti( L, fifo_idx, at);         // ... fifo val
+                // remove item from the fifo
                 lua_pushnil( L);                       // ... fifo val nil
                 lua_rawseti( L, fifo_idx, at);         // ... fifo val
         }
+        // now process first item
+        {
+                int const at = fifo->first;
+                lua_rawgeti( L, fifo_idx, at);         // ... fifo vals val
+                lua_pushnil( L);                       // ... fifo vals val nil
+                lua_rawseti( L, fifo_idx, at);         // ... fifo vals val
+                lua_replace( L, fifo_idx);             // ... vals
+        }
         fifo->first += _count;
         fifo->count -= _count;
 }
@@ -172,6 +183,47 @@ static void push_table( lua_State* L, int idx)
         STACK_END( L, 1);
 }
 
+int keeper_push_linda_storage( lua_State* L, void* ptr)
+{
+        struct s_Keeper* K = keeper_acquire( ptr);
+        STACK_CHECK( K->L)
+        lua_pushlightuserdata( K->L, fifos_key);                      // fifos_key
+        lua_rawget( K->L, LUA_REGISTRYINDEX);                         // fifos
+        lua_pushlightuserdata( K->L, ptr);                            // fifos ud
+        lua_rawget( K->L, -2);                                        // fifos storage
+        lua_remove( K->L, -2);                                        // storage
+        if( !lua_istable( K->L, -1))
+        {
+                lua_pop( K->L, 1);                                          //
+                STACK_MID( K->L, 0);
+                return 0;
+        }
+        lua_pushnil( K->L);                                           // storage nil
+        lua_newtable( L);                                                                        // out
+        while( lua_next( K->L, -2))                                   // storage key fifo
+        {
+                keeper_fifo* fifo = prepare_fifo_access( K->L, -1);         // storage key fifo
+                lua_pushvalue( K->L, -2);                                   // storage key fifo key
+                luaG_inter_move( K->L, L, 1);                               // storage key fifo        // out key
+                STACK_CHECK( L)
+                lua_newtable( L);                                                                      // out key keyout
+                luaG_inter_move( K->L, L, 1);                               // storage key             // out key keyout fifo
+                lua_pushinteger( L, fifo->first);                                                      // out key keyout fifo first
+                lua_setfield( L, -3, "first");                                                         // out key keyout fifo
+                lua_pushinteger( L, fifo->count);                                                      // out key keyout fifo count
+                lua_setfield( L, -3, "count");                                                         // out key keyout fifo
+                lua_pushinteger( L, fifo->limit);                                                      // out key keyout fifo limit
+                lua_setfield( L, -3, "limit");                                                         // out key keyout fifo
+                lua_setfield( L, -2, "fifo");                                                          // out key keyout
+                lua_rawset( L, -3);                                                                    // out
+                STACK_END( L, 0)
+        }
+        lua_pop( K->L, 1);                                            //
+        STACK_END( K->L, 0)
+        keeper_release( K);
+        return 1;
+}
+
 // in: linda_ud
 int keepercall_clear( lua_State* L)
 {
@@ -223,7 +275,7 @@ int keepercall_send( lua_State* L)
 }
 
 // in: linda_ud, key [, key]?
-// out: (val, key) or nothing
+// out: (key, val) or nothing
 int keepercall_receive( lua_State* L)
 {
         int top = lua_gettop( L);
@@ -238,16 +290,17 @@ int keepercall_receive( lua_State* L)
                 fifo = prepare_fifo_access( L, -1);        // fifos keys fifo
                 if( fifo && fifo->count > 0)
                 {
-                        fifo_pop( L, fifo, 1);                   // fifos keys fifo val
+                        fifo_pop( L, fifo, 1);                   // fifos keys val
                         if( !lua_isnil( L, -1))
                         {
-                                lua_replace( L, 1);                    // val keys fifo
+                                lua_replace( L, 1);                    // val keys
+                                lua_settop( L, i);                     // val keys key[i]
                                 if( i != 2)
                                 {
-                                        lua_pushvalue( L, i);                // val keys fifo key[i]
-                                        lua_replace( L, 2);                  // val key keys fifo
+                                        lua_replace( L, 2);                  // val key keys
+                                        lua_settop( L, 2);                   // val key
                                 }
-                                lua_settop( L, 2);                     // val key
+                                lua_insert( L, 1);                     // key, val
                                 return 2;
                         }
                 }
@@ -266,16 +319,22 @@ int keepercall_receive_batched( lua_State* L)
                 keeper_fifo* fifo;
                 int const max_count = (int) luaL_optinteger( L, 4, min_count);
                 lua_settop( L, 2);                                    // ud key
-                push_table( L, 1);                                    // ud key fifos
-                lua_replace( L, 1);                                   // fifos key
-                lua_rawget( L, -2);                                   // fifos fifo
-                lua_remove( L, 1);                                    // fifo
-                fifo = prepare_fifo_access( L, 1);                    // fifo
+                lua_insert( L, 1);                                    // key ud
+                push_table( L, 2);                                    // key ud fifos
+                lua_remove( L, 2);                                    // key fifos
+                lua_pushvalue( L, 1);                                 // key fifos key
+                lua_rawget( L, 2);                                    // key fifos fifo
+                lua_remove( L, 2);                                    // key fifo
+                fifo = prepare_fifo_access( L, 2);                    // key fifo
                 if( fifo && fifo->count >= min_count)
                 {
-                        fifo_pop( L, fifo, __min( max_count, fifo->count)); // fifo ...
+                        fifo_pop( L, fifo, __min( max_count, fifo->count)); // key ...
+                }
+                else
+                {
+                        lua_settop( L, 0);
                 }
-                return lua_gettop( L) - 1;
+                return lua_gettop( L);
         }
         else
         {
@@ -521,6 +580,7 @@ char const* init_keepers( int const _nbKeepers, lua_CFunction _on_state_create)
         }
         // call close_keepers at the very last as we want to be sure no thread is GCing after.
         // (and therefore may perform linda object dereferencing after keepers are gone)
+        // problem: maybe on some platforms atexit() is called after DLL/so are unloaded...
         atexit( atexit_close_keepers);
         return NULL;    // ok
 }
diff --git a/src/keeper.h b/src/keeper.h
index a0ea8c5..a9b5a22 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -13,6 +13,7 @@ void populate_keepers( lua_State *L);
 struct s_Keeper *keeper_acquire( const void *ptr);
 void keeper_release( struct s_Keeper *K);
 void keeper_toggle_nil_sentinels( lua_State *L, int _val_i, int _nil_to_sentinel);
+int keeper_push_linda_storage( lua_State* L, void* ptr);
 
 #define KEEPER_MODEL_LUA 1
 #define KEEPER_MODEL_C 2
diff --git a/src/lanes-keeper.lua b/src/lanes-keeper.lua
index b07d6a9..a03ef4b 100644
--- a/src/lanes-keeper.lua
+++ b/src/lanes-keeper.lua
@@ -187,7 +187,7 @@ function receive( ud, ...)
         if fifo and fifo.count > 0 then
             local val = fifo_pop( fifo, 1)
             if val ~= nil then
-                return val, key
+                return key, val
             end
         end
     end
@@ -207,7 +207,7 @@ receive_batched = function( ud, key, min_count, max_count)
             if fifo_count >= min_count then
                 max_count = max_count or min_count
                 max_count = (max_count > fifo_count) and fifo_count or max_count
-                return fifo_pop( fifo, max_count)
+                return key, fifo_pop( fifo, max_count)
             end
         end
     end
diff --git a/src/lanes.c b/src/lanes.c
index eac4753..f2e8aa7 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -51,7 +51,7 @@
  *      ...
  */
 
-char const* VERSION = "3.3.0";
+char const* VERSION = "3.4.0";
 
 /*
 ===============================================================================
@@ -348,7 +348,7 @@ LUAG_FUNC( linda_send)
                                 STACK_CHECK(L)
                                 lua_pushlightuserdata( L, CANCEL_TEST_KEY);
                                 lua_rawget( L, LUA_REGISTRYINDEX);
-                                s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) / nil
+                                s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) or nil if in the main Lua state
                                 lua_pop(L, 1);
                                 STACK_END(L,0)
                                 if( s)
@@ -445,6 +445,9 @@ LUAG_FUNC( linda_receive)
                         // we expect a user-defined amount of return value
                         expected_pushed_min = (int)luaL_checkinteger( L, key_i + 1);
                         expected_pushed_max = (int)luaL_optinteger( L, key_i + 2, expected_pushed_min);
+                        // don't forget to count the key in addition to the values
+                        ++ expected_pushed_min;
+                        ++ expected_pushed_max;
                         if( expected_pushed_min > expected_pushed_max)
                         {
                                 return luaL_error( L, "batched min/max error");
@@ -503,7 +506,7 @@ LUAG_FUNC( linda_receive)
                                 STACK_CHECK(L)
                                 lua_pushlightuserdata( L, CANCEL_TEST_KEY);
                                 lua_rawget( L, LUA_REGISTRYINDEX);
-                                s= lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) / nil
+                                s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) or nil if in the main Lua state
                                 lua_pop(L, 1);
                                 STACK_END(L, 0)
                                 if( s)
@@ -771,6 +774,16 @@ LUAG_FUNC( linda_concat)
 }
 
 /*
+ * table = linda:dump()
+ * return a table listing all pending data inside the linda
+ */
+LUAG_FUNC( linda_dump)
+{
+        struct s_Linda* linda = lua_toLinda( L, 1);
+        return keeper_push_linda_storage( L, linda);
+}
+
+/*
 * Identity function of a shared userdata object.
 * 
 *   lightuserdata= linda_id( "new" [, ...] )
@@ -860,6 +873,10 @@ static void linda_id( lua_State *L, char const * const which)
         lua_pushcfunction( L, LG_linda_tostring);
         lua_setfield( L, -2, "__tostring");
 
+        // Decoda __towatch support
+        lua_pushcfunction( L, LG_linda_dump);
+        lua_setfield( L, -2, "__towatch");
+
         lua_pushcfunction( L, LG_linda_concat);
         lua_setfield( L, -2, "__concat");
 
@@ -886,6 +903,9 @@ static void linda_id( lua_State *L, char const * const which)
         lua_pushcfunction( L, LG_linda_deep );
         lua_setfield( L, -2, "deep" );
 
+        lua_pushcfunction( L, LG_linda_dump);
+        lua_setfield( L, -2, "dump" );
+        
         lua_pushliteral( L, BATCH_SENTINEL);
         lua_setfield(L, -2, "batched");
 
@@ -1752,7 +1772,8 @@ LUAG_FUNC( thread_new )
                 if( !lua_isnil( L2, -1)) // package library not loaded: do nothing
                 {
                         int i;
-                        char const *entries[] = { "path", "cpath", "preload", "loaders", NULL};
+                        // package.loaders is renamed package.searchers in Lua 5.2
+                        char const* entries[] = { "path", "cpath", "preload", (LUA_VERSION_NUM == 501) ? "loaders" : "searchers", NULL};
                         for( i = 0; entries[i]; ++ i)
                         {
                                 lua_getfield( L, package, entries[i]);
diff --git a/src/lanes.lua b/src/lanes.lua
index c9ab07d..20168b8 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -488,10 +488,10 @@ if first_time then
                                 secs =  next_wakeup - now_secs()
                                 if secs < 0 then secs = 0 end
                         end
-                        local linda = timer_gateway:receive( secs, TGW_KEY)
+                        local _, linda = timer_gateway:receive( secs, TGW_KEY)
 
                         if linda then
-                                local key, wakeup_at, period = timer_gateway:receive( 0, timer_gateway_batched, TGW_KEY, 3)
+                                local _, key, wakeup_at, period = timer_gateway:receive( 0, timer_gateway_batched, TGW_KEY, 3)
                                 assert( key)
                                 set_timer( linda, key, wakeup_at, period and period > 0 and period or nil)
                         --elseif secs == nil then -- got no value while block-waiting?