Lane cancellation rework

opt.cancelstep is gone, hook is installed by lane:cancel() if requested
lane:cancel() rework (see doc)

7 files changed, 133 insertions, 90 deletions

diff --git a/src/Makefile b/src/Makefile
index aff06ba..9dc75a1 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -7,7 +7,7 @@
 
 MODULE=lanes
 
-SRC=lanes.c compat.c threading.c tools.c linda.c deep.c keeper.c universe.c
+SRC=lanes.c cancel.c compat.c threading.c tools.c linda.c deep.c keeper.c universe.c
 
 OBJ=$(SRC:.c=.o)
 
diff --git a/src/cancel.c b/src/cancel.c
index 11e100d..8ce00c8 100644
--- a/src/cancel.c
+++ b/src/cancel.c
@@ -77,12 +77,13 @@ LUAG_FUNC( cancel_test)
 // ################################################################################################
 // ################################################################################################
 
-void cancel_hook( lua_State* L, lua_Debug* ar)
+static void cancel_hook( lua_State* L, lua_Debug* ar)
 {
         (void)ar;
         DEBUGSPEW_CODE( fprintf( stderr, "cancel_hook\n"));
         if( cancel_test( L) != CANCEL_NONE)
         {
+                lua_sethook( L, NULL, 0, 0);
                 cancel_error( L);
         }
 }
@@ -110,10 +111,10 @@ void cancel_hook( lua_State* L, lua_Debug* ar)
 
 // ################################################################################################
 
-static cancel_result thread_cancel_soft( Lane* s, bool_t wake_lindas_)
+static cancel_result thread_cancel_soft( Lane* s, double secs_, bool_t wake_lindas_)
 {
-        s->cancel_request = CANCEL_SOFT;    // it's now signaled to stop
-                                                                                                                                                        // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
+        s->cancel_request = CANCEL_SOFT; // it's now signaled to stop
+        // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
         if( wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
         {
                 SIGNAL_T *waiting_on = s->waiting_on;
@@ -122,8 +123,8 @@ static cancel_result thread_cancel_soft( Lane* s, bool_t wake_lindas_)
                         SIGNAL_ALL( waiting_on);
                 }
         }
-        // say we succeeded though
-        return CR_Cancelled;
+
+        return THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
 }
 
 // ################################################################################################
@@ -163,9 +164,9 @@ static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bo
                 (void) waitkill_timeout_; // unused
                 (void) L; // unused
 #endif // THREADAPI == THREADAPI_PTHREAD
-                s->mstatus = KILLED;     // mark 'gc' to wait for it
-                                                                                                                 // note that s->status value must remain to whatever it was at the time of the kill
-                                                                                                                 // because we need to know if we can lua_close() the Lua State or not.
+                s->mstatus = KILLED; // mark 'gc' to wait for it
+                // note that s->status value must remain to whatever it was at the time of the kill
+                // because we need to know if we can lua_close() the Lua State or not.
                 result = CR_Killed;
         }
         return result;
@@ -173,7 +174,7 @@ static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bo
 
 // ################################################################################################
 
-cancel_result thread_cancel( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_)
+cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_, bool_t force_, double waitkill_timeout_)
 {
         // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
         // We can read 's->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
@@ -190,9 +191,9 @@ cancel_result thread_cancel( lua_State* L, Lane* s, double secs_, bool_t force_,
 
         // signal the linda the wake up the thread so that it can react to the cancel query
         // let us hope we never land here with a pointer on a linda that has been destroyed...
-        if( secs_ < 0.0)
+        if( op_ == CO_Soft)
         {
-                return thread_cancel_soft( s, force_);
+                return thread_cancel_soft( s, secs_, force_);
         }
 
         return thread_cancel_hard( L, s, secs_, force_, waitkill_timeout_);
@@ -201,49 +202,97 @@ cancel_result thread_cancel( lua_State* L, Lane* s, double secs_, bool_t force_,
 // ################################################################################################
 // ################################################################################################
 
-// lane_h:cancel( [timeout] [, force [, forcekill_timeout]])
+// > 0: the mask
+// = 0: soft
+// < 0: hard
+static CancelOp which_op( lua_State* L, int idx_)
+{
+        if( lua_type( L, idx_) == LUA_TSTRING)
+        {
+                CancelOp op = CO_Invalid;
+                char const* str = lua_tostring( L, idx_);
+                if( strcmp( str, "soft") == 0)
+                {
+                        op = CO_Soft;
+                }
+                else if( strcmp( str, "count") == 0)
+                {
+                        op = CO_Count;
+                }
+                else if( strcmp( str, "line") == 0)
+                {
+                        op = CO_Line;
+                }
+                else if( strcmp( str, "call") == 0)
+                {
+                        op = CO_Call;
+                }
+                else if( strcmp( str, "ret") == 0)
+                {
+                        op = CO_Ret;
+                }
+                else if( strcmp( str, "hard") == 0)
+                {
+                        op = CO_Hard;
+                }
+                lua_remove( L, idx_); // argument is processed, remove it
+                if( op == CO_Invalid)
+                {
+                        luaL_error( L, "invalid hook option %s", str);
+                }
+                return op;
+        }
+        return CO_Hard;
+}
+// ################################################################################################
+
+// bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, force [, forcekill_timeout]])
 LUAG_FUNC( thread_cancel)
 {
         Lane* s = lua_toLane( L, 1);
         double secs = 0.0;
-        int force_i = 2;
-        int forcekill_timeout_i = 3;
+        CancelOp op = which_op( L, 2); // this removes the op string from the stack
 
-        if( lua_isnumber( L, 2))
+        if( op > 0) // hook is requested
         {
-                secs = lua_tonumber( L, 2);
-                if( secs < 0.0 && lua_gettop( L) > 3)
+                int hook_count = (int) lua_tointeger( L, 2);
+                lua_remove( L, 2); // argument is processed, remove it
+                if( hook_count < 1)
                 {
-                        return luaL_error( L, "can't force_kill a soft cancel");
+                        return luaL_error( L, "hook count cannot be < 1");
                 }
-                // negative timeout and force flag means we want to wake linda-waiting threads
-                ++ force_i;
-                ++ forcekill_timeout_i;
+                lua_sethook( s->L, cancel_hook, op, hook_count);
         }
-        else if( lua_isnil( L, 2))
+
+        if( lua_type( L, 2) == LUA_TNUMBER)
         {
-                ++ force_i;
-                ++ forcekill_timeout_i;
+                secs = lua_tonumber( L, 2);
+                lua_remove( L, 2); // argument is processed, remove it
+                if( secs < 0.0)
+                {
+                        return luaL_error( L, "cancel timeout cannot be < 0");
+                }
         }
 
         {
-                bool_t force = lua_toboolean( L, force_i);     // FALSE if nothing there
-                double forcekill_timeout = luaL_optnumber( L, forcekill_timeout_i, 0.0);
+                bool_t force = lua_toboolean( L, 2);     // FALSE if nothing there
+                double forcekill_timeout = luaL_optnumber( L, 3, 0.0);
 
-                switch( thread_cancel( L, s, secs, force, forcekill_timeout))
+                switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
                 {
-                case CR_Timeout:
+                        case CR_Timeout:
                         lua_pushboolean( L, 0);
                         lua_pushstring( L, "timeout");
                         return 2;
 
-                case CR_Cancelled:
+                        case CR_Cancelled:
                         lua_pushboolean( L, 1);
-                        return 1;
+                        push_thread_status( L, s);
+                        return 2;
 
-                case CR_Killed:
-                        lua_pushboolean( L, 0);
-                        lua_pushstring( L, "killed");
+                        case CR_Killed:
+                        lua_pushboolean( L, 1);
+                        push_thread_status( L, s);
                         return 2;
                 }
         }
diff --git a/src/cancel.h b/src/cancel.h
index 3112809..e7656ac 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -29,15 +29,24 @@ typedef enum
         CR_Killed
 } cancel_result;
 
+typedef enum
+{
+        CO_Invalid = -2,
+        CO_Hard = -1,
+        CO_Soft = 0,
+        CO_Count = LUA_MASKCOUNT,
+        CO_Line = LUA_MASKLINE,
+        CO_Call = LUA_MASKCALL,
+        CO_Ret = LUA_MASKRET,
+} CancelOp;
+
 // crc64/we of string "CANCEL_ERROR" generated at http://www.nitrxgen.net/hashgen/
 static DECLARE_CONST_UNIQUE_KEY(CANCEL_ERROR, 0xe97d41626cc97577); // 'cancel_error' sentinel
 
 // crc64/we of string "CANCEL_TEST_KEY" generated at http://www.nitrxgen.net/hashgen/
 static DECLARE_CONST_UNIQUE_KEY(CANCEL_TEST_KEY, 0xe66f5960c57d133a); // used as registry key
 
-void cancel_hook( lua_State* L, lua_Debug* ar);
-
-cancel_result thread_cancel( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_);
+cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_, bool_t force_, double waitkill_timeout_);
 
 static inline int cancel_error( lua_State* L)
 {
diff --git a/src/lanes.c b/src/lanes.c
index cbac6da..8f159a9 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -452,7 +452,7 @@ static int selfdestruct_gc( lua_State* L)
                         while( s != SELFDESTRUCT_END)
                         {
                                 // attempt a regular unforced hard cancel with a small timeout
-                                bool_t cancelled = THREAD_ISNULL( s->thread) || thread_cancel( L, s, 0.0001, FALSE, 0.0);
+                                bool_t cancelled = THREAD_ISNULL( s->thread) || thread_cancel( L, s, CO_Hard, 0.0001, FALSE, 0.0);
                                 // if we failed, and we know the thread is waiting on a linda
                                 if( cancelled == FALSE && s->status == WAITING && s->waiting_on != NULL)
                                 {
@@ -1027,7 +1027,6 @@ static DECLARE_CONST_UNIQUE_KEY( GCCB_KEY, 0xcfb1f046ef074e88);
 //---
 // lane_ud = lane_new( function
 //                   , [libs_str]
-//                   , [cancelstep_uint=0]
 //                   , [priority_int=0]
 //                   , [globals_tbl]
 //                   , [package_tbl]
@@ -1044,14 +1043,13 @@ LUAG_FUNC( lane_new)
         Lane** ud;
 
         char const* libs_str = lua_tostring( L, 2);
-        uint_t cancelstep_idx = luaG_optunsigned( L, 3, 0);
-        int const priority = (int) luaL_optinteger( L, 4, 0);
-        uint_t globals_idx = lua_isnoneornil( L, 5) ? 0 : 5;
-        uint_t package_idx = lua_isnoneornil( L, 6) ? 0 : 6;
-        uint_t required_idx = lua_isnoneornil( L, 7) ? 0 : 7;
-        uint_t gc_cb_idx = lua_isnoneornil( L, 8) ? 0 : 8;
-
-#define FIXED_ARGS 8
+        int const priority = (int) luaL_optinteger( L, 3, 0);
+        uint_t globals_idx = lua_isnoneornil( L, 4) ? 0 : 4;
+        uint_t package_idx = lua_isnoneornil( L, 5) ? 0 : 5;
+        uint_t required_idx = lua_isnoneornil( L, 6) ? 0 : 6;
+        uint_t gc_cb_idx = lua_isnoneornil( L, 7) ? 0 : 7;
+
+#define FIXED_ARGS 7
         int const nargs = lua_gettop(L) - FIXED_ARGS;
         Universe* U = universe_get( L);
         ASSERT_L( nargs >= 0);
@@ -1074,7 +1072,7 @@ LUAG_FUNC( lane_new)
         STACK_GROW( L2, nargs + 3);                                                                                                                //
         STACK_CHECK( L2, 0);
 
-        STACK_GROW( L, 3);                                       // func libs cancelstep priority globals package required gc_cb [... args ...]
+        STACK_GROW( L, 3);                                       // func libs priority globals package required gc_cb [... args ...]
         STACK_CHECK( L, 0);
 
         // give a default "Lua" name to the thread to see VM name in Decoda debugger
@@ -1103,8 +1101,8 @@ LUAG_FUNC( lane_new)
                         return luaL_error( L, "expected required module list as a table, got %s", luaL_typename( L, required_idx));
                 }
 
-                lua_pushnil( L);                                       // func libs cancelstep priority globals package required gc_cb [... args ...] nil
-                while( lua_next( L, required_idx) != 0)                // func libs cancelstep priority globals package required gc_cb [... args ...] n "modname"
+                lua_pushnil( L);                                       // func libs priority globals package required gc_cb [... args ...] nil
+                while( lua_next( L, required_idx) != 0)                // func libs priority globals package required gc_cb [... args ...] n "modname"
                 {
                         if( lua_type( L, -1) != LUA_TSTRING || lua_type( L, -2) != LUA_TNUMBER || lua_tonumber( L, -2) != nbRequired)
                         {
@@ -1130,7 +1128,7 @@ LUAG_FUNC( lane_new)
                                         if( lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                             // ret/errcode
                                         {
                                                 // propagate error to main state if any
-                                                luaG_inter_move( U, L2, L, 1, eLM_LaneBody);   // func libs cancelstep priority globals package required gc_cb [... args ...] n "modname" error
+                                                luaG_inter_move( U, L2, L, 1, eLM_LaneBody);   // func libs priority globals package required gc_cb [... args ...] n "modname" error
                                                 return lua_error( L);
                                         }
                                         // after requiring the module, register the functions it exported in our name<->function database
@@ -1138,9 +1136,9 @@ LUAG_FUNC( lane_new)
                                         lua_pop( L2, 1);                                                                                                                   //
                                 }
                         }
-                        lua_pop( L, 1);                                      // func libs cancelstep priority globals package required gc_cb [... args ...] n
+                        lua_pop( L, 1);                                      // func libs priority globals package required gc_cb [... args ...] n
                         ++ nbRequired;
-                }                                                      // func libs cancelstep priority globals package required gc_cb [... args ...]
+                }                                                      // func libs priority globals package required gc_cb [... args ...]
                 DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
         }
         STACK_MID( L, 0);
@@ -1158,16 +1156,16 @@ LUAG_FUNC( lane_new)
                 }
 
                 DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-                lua_pushnil( L);                                       // func libs cancelstep priority globals package required gc_cb [... args ...] nil
+                lua_pushnil( L);                                       // func libs priority globals package required gc_cb [... args ...] nil
                 // Lua 5.2 wants us to push the globals table on the stack
                 lua_pushglobaltable( L2);                                                                                                                // _G
-                while( lua_next( L, globals_idx))                      // func libs cancelstep priority globals package required gc_cb [... args ...] k v
+                while( lua_next( L, globals_idx))                      // func libs priority globals package required gc_cb [... args ...] k v
                 {
                         luaG_inter_copy( U, L, L2, 2, eLM_LaneBody);                                                                                           // _G k v
                         // assign it in L2's globals table
                         lua_rawset( L2, -3);                                                                                                                   // _G
-                        lua_pop( L, 1);                                      // func libs cancelstep priority globals package required gc_cb [... args ...] k
-                }                                                      // func libs cancelstep priority globals package required gc_cb [... args ...]
+                        lua_pop( L, 1);                                      // func libs priority globals package required gc_cb [... args ...] k
+                }                                                      // func libs priority globals package required gc_cb [... args ...]
                 lua_pop( L2, 1);                                                                                                                         //
 
                 DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
@@ -1181,8 +1179,8 @@ LUAG_FUNC( lane_new)
                 int res;
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END));
                 DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-                lua_pushvalue( L, 1);                                  // func libs cancelstep priority globals package required gc_cb [... args ...] func
-                res = luaG_inter_move( U, L, L2, 1, eLM_LaneBody);     // func libs cancelstep priority globals package required gc_cb [... args ...]    // func
+                lua_pushvalue( L, 1);                                  // func libs priority globals package required gc_cb [... args ...] func
+                res = luaG_inter_move( U, L, L2, 1, eLM_LaneBody);     // func libs priority globals package required gc_cb [... args ...]    // func
                 DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
                 if( res != 0)
                 {
@@ -1207,7 +1205,7 @@ LUAG_FUNC( lane_new)
                 int res;
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END));
                 DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-                res = luaG_inter_move( U, L, L2, nargs, eLM_LaneBody); // func libs cancelstep priority globals package required gc_cb                   // func [... args ...]
+                res = luaG_inter_move( U, L, L2, nargs, eLM_LaneBody); // func libs priority globals package required gc_cb                   // func [... args ...]
                 DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
                 if( res != 0)
                 {
@@ -1222,7 +1220,7 @@ LUAG_FUNC( lane_new)
         // 's' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
         //
         // a Lane full userdata needs a single uservalue
-        ud = lua_newuserdatauv( L, sizeof( Lane*), 1);           // func libs cancelstep priority globals package required gc_cb lane
+        ud = lua_newuserdatauv( L, sizeof( Lane*), 1);           // func libs priority globals package required gc_cb lane
         s = *ud = (Lane*) malloc( sizeof( Lane));
         if( s == NULL)
         {
@@ -1252,8 +1250,8 @@ LUAG_FUNC( lane_new)
 
         // Set metatable for the userdata
         //
-        lua_pushvalue( L, lua_upvalueindex( 1));                 // func libs cancelstep priority globals package required gc_cb lane mt
-        lua_setmetatable( L, -2);                                // func libs cancelstep priority globals package required gc_cb lane
+        lua_pushvalue( L, lua_upvalueindex( 1));                 // func libs priority globals package required gc_cb lane mt
+        lua_setmetatable( L, -2);                                // func libs priority globals package required gc_cb lane
         STACK_MID( L, 1);
 
         // Create uservalue for the userdata
@@ -1263,21 +1261,16 @@ LUAG_FUNC( lane_new)
         // Store the gc_cb callback in the uservalue
         if( gc_cb_idx > 0)
         {
-                push_unique_key( L, GCCB_KEY);                         // func libs cancelstep priority globals package required gc_cb lane uv k
-                lua_pushvalue( L, gc_cb_idx);                          // func libs cancelstep priority globals package required gc_cb lane uv k gc_cb
-                lua_rawset( L, -3);                                    // func libs cancelstep priority globals package required gc_cb lane uv
+                push_unique_key( L, GCCB_KEY);                         // func libs priority globals package required gc_cb lane uv k
+                lua_pushvalue( L, gc_cb_idx);                          // func libs priority globals package required gc_cb lane uv k gc_cb
+                lua_rawset( L, -3);                                    // func libs priority globals package required gc_cb lane uv
         }
 
-        lua_setiuservalue( L, -2, 1);                            // func libs cancelstep priority globals package required gc_cb lane
+        lua_setiuservalue( L, -2, 1);                            // func libs priority globals package required gc_cb lane
 
-        // Store 's' in the lane's registry, for 'cancel_test()' (even if 'cs'==0 we still do cancel tests at pending send/receive).
+        // Store 's' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
         REGISTRY_SET( L2, CANCEL_TEST_KEY, lua_pushlightuserdata( L2, s));                                                                         // func [... args ...]
 
-        if( cancelstep_idx)
-        {
-                lua_sethook( L2, cancel_hook, LUA_MASKCOUNT, cancelstep_idx);
-        }
-
         STACK_END( L, 1);
         STACK_END( L2, 1 + nargs);
 
@@ -1402,7 +1395,7 @@ static char const * thread_status_string( Lane* s)
         return str;
 }
 
-static int push_thread_status( lua_State* L, Lane* s)
+int push_thread_status( lua_State* L, Lane* s)
 {
         char const* const str = thread_status_string( s);
         ASSERT_L( str);
diff --git a/src/lanes.h b/src/lanes.h
index de60d6d..da0dd26 100644
--- a/src/lanes.h
+++ b/src/lanes.h
@@ -11,7 +11,7 @@
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
 #define LANES_VERSION_MAJOR 3
-#define LANES_VERSION_MINOR 13
+#define LANES_VERSION_MINOR 14
 #define LANES_VERSION_PATCH 0
 
 #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))))
diff --git a/src/lanes.lua b/src/lanes.lua
index ba9da81..4d6deac 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -146,7 +146,7 @@ lanes.configure = function( settings_)
                 author= "Asko Kauppi <akauppi@gmail.com>, Benoit Germain <bnt.germain@gmail.com>",
                 description= "Running multiple Lua states in parallel",
                 license= "MIT/X11",
-                copyright= "Copyright (c) 2007-10, Asko Kauppi; (c) 2011-18, Benoit Germain",
+                copyright= "Copyright (c) 2007-10, Asko Kauppi; (c) 2011-19, Benoit Germain",
                 version = assert( core.version)
         }
 
@@ -198,13 +198,6 @@ lanes.configure = function( settings_)
         --
         -- 'opt': .priority:  int (-3..+3) smaller is lower priority (0 = default)
         --
-        --        .cancelstep: bool | uint
-        --            false: cancellation check only at pending Linda operations
-        --                   (send/receive) so no runtime performance penalty (default)
-        --            true:  adequate cancellation check (same as 100)
-        --            >0:    cancellation check every x Lua lines (small number= faster
-        --                   reaction but more performance overhead)
-        --
         --        .globals:  table of globals to set for a new thread (passed by value)
         --
         --        .required: table of packages to require
@@ -246,10 +239,6 @@ lanes.configure = function( settings_)
                         local tv = type( v_)
                         return (tv == "number") and v_ or raise_option_error( "priority", tv, v_)
                 end,
-                cancelstep = function( v_)
-                        local tv = type( v_)
-                        return (tv == "number") and v_ or (v_ == true) and 100 or (v_ == false) and 0 or raise_option_error( "cancelstep", tv, v_)
-                end,
                 globals = function( v_)
                         local tv = type( v_)
                         return (tv == "table") and v_ or raise_option_error( "globals", tv, v_)
@@ -334,10 +323,10 @@ lanes.configure = function( settings_)
                         end
                 end
 
-                local cancelstep, priority, globals, package, required, gc_cb = opt.cancelstep, opt.priority, opt.globals, opt.package or package, opt.required, opt.gc_cb
+                local priority, globals, package, required, gc_cb = opt.priority, opt.globals, opt.package or package, opt.required, opt.gc_cb
                 return function( ...)
                         -- must pass functions args last else they will be truncated to the first one
-                        return core_lane_new( func, libs, cancelstep, priority, globals, package, required, gc_cb, ...)
+                        return core_lane_new( func, libs, priority, globals, package, required, gc_cb, ...)
                 end
         end -- gen()
 
diff --git a/src/lanes_private.h b/src/lanes_private.h
index ac05129..1a15969 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -89,4 +89,7 @@ static inline Lane* get_lane_from_registry( lua_State* L)
         return s;
 }
 
+int push_thread_status( lua_State* L, Lane* s);
+
+
 #endif // __lanes_private_h__
\ No newline at end of file