1 files changed, 96 insertions, 60 deletions

diff --git a/src/lanes.c b/src/lanes.c
index 08bdb9a..e36a073 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.6.2";
+char const* VERSION = "3.6.3";
 
 /*
 ===============================================================================
@@ -115,10 +115,21 @@ THE SOFTWARE.
 */
 #define ERROR_FULL_STACK
 
+/*
+ * Lane cancellation request modes
+ */
+enum e_cancel_request
+{
+        CANCEL_NONE, // no pending cancel request
+        CANCEL_SOFT, // user wants the lane to cancel itself manually on cancel_test()
+        CANCEL_HARD  // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
+};
+
 // NOTE: values to be changed by either thread, during execution, without
 //       locking, are marked "volatile"
 //
-struct s_lane {
+struct s_lane
+{
         THREAD_T thread;
         //
         // M: sub-thread OS thread
@@ -140,7 +151,7 @@ struct s_lane {
         //
         // When status is WAITING, points on the linda's signal the thread waits on, else NULL
 
-        volatile bool_t cancel_request;
+        volatile enum e_cancel_request cancel_request;
         //
         // M: sets to FALSE, flags TRUE for cancel request
         // S: reads to see if cancel is requested
@@ -178,7 +189,7 @@ struct s_lane {
         // For tracking only
 };
 
-static bool_t cancel_test( lua_State*L );
+static enum e_cancel_request cancel_test( lua_State* L);
 static void cancel_error( lua_State*L );
 
 #define CANCEL_TEST_KEY ((void*)cancel_test)    // used as registry key
@@ -372,7 +383,7 @@ LUAG_FUNC( linda_send)
 {
         struct s_Linda *linda = lua_toLinda( L, 1);
         bool_t ret;
-        bool_t cancel = FALSE;
+        enum e_cancel_request cancel = CANCEL_NONE;
         int pushed;
         time_d timeout= -1.0;
         uint_t key_i = 2; // index of first key, if timeout not there
@@ -434,7 +445,7 @@ LUAG_FUNC( linda_send)
                         /* limit faced; push until timeout */
 
                         cancel = cancel_test( L);   // testing here causes no delays
-                        if (cancel)
+                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without sending anything
                         {
                                 break;
                         }
@@ -486,7 +497,8 @@ LUAG_FUNC( linda_send)
                 return luaL_error( L, "tried to copy unsupported types");
         }
 
-        if( cancel)
+        // raise an error interrupting execution only in case of hard cancel
+        if( cancel == CANCEL_HARD)
                 cancel_error( L);
 
         lua_pushboolean( L, ret);
@@ -510,7 +522,7 @@ LUAG_FUNC( linda_receive)
 {
         struct s_Linda *linda = lua_toLinda( L, 1);
         int pushed, expected_pushed_min, expected_pushed_max;
-        bool_t cancel = FALSE;
+        enum e_cancel_request cancel = CANCEL_NONE;
         keeper_api_t keeper_receive;
         
         time_d timeout = -1.0;
@@ -592,16 +604,16 @@ LUAG_FUNC( linda_receive)
                         /* nothing received; wait until timeout */
 
                         cancel = cancel_test( L);   // testing here causes no delays
-                        if( cancel)
+                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without providing anything
                         {
                                 break;
                         }
 
                         // change status of lane to "waiting"
                         {
-                                struct s_lane *s;
+                                struct s_lane* s;
                                 enum e_status prev_status = ERROR_ST; // prevent 'might be used uninitialized' warnings
-                                STACK_GROW(L,1);
+                                STACK_GROW( L, 1);
 
                                 STACK_CHECK( L);
                                 lua_pushlightuserdata( L, CANCEL_TEST_KEY);
@@ -643,7 +655,8 @@ LUAG_FUNC( linda_receive)
                 return luaL_error( L, "tried to copy unsupported types");
         }
 
-        if( cancel)
+        // raise an error interrupting execution only in case of hard cancel
+        if( cancel == CANCEL_HARD)
                 cancel_error( L);
 
         return pushed;
@@ -1176,31 +1189,41 @@ static cancel_result thread_cancel( struct s_lane *s, double secs, bool_t force)
         }
         else if( s->status < DONE)
         {
-                s->cancel_request = TRUE;    // it's now signaled to stop
                 // 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)
+                {
+                        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
+                        // say we succeeded though
+                        result = CR_Cancelled;
+                }
+                else
                 {
-                        SIGNAL_T *waiting_on = s->waiting_on;
-                        if( s->status == WAITING && waiting_on != NULL)
+                        s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
                         {
-                                SIGNAL_ALL( waiting_on);
+                                SIGNAL_T *waiting_on = s->waiting_on;
+                                if( s->status == WAITING && waiting_on != NULL)
+                                {
+                                        SIGNAL_ALL( waiting_on);
+                                }
                         }
-                }
 
-                result = THREAD_WAIT( &s->thread, secs, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
+                        result = THREAD_WAIT( &s->thread, secs, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
 
-                if( (result == CR_Timeout) && force)
-                {
-                        // Killing is asynchronous; we _will_ wait for it to be done at
-                        // GC, to make sure the data structure can be released (alternative
-                        // would be use of "cancellation cleanup handlers" that at least
-                        // PThread seems to have).
-                        //
-                        THREAD_KILL( &s->thread);
-                        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;
+                        if( (result == CR_Timeout) && force)
+                        {
+                                // Killing is asynchronous; we _will_ wait for it to be done at
+                                // GC, to make sure the data structure can be released (alternative
+                                // would be use of "cancellation cleanup handlers" that at least
+                                // PThread seems to have).
+                                //
+                                THREAD_KILL( &s->thread);
+                                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;
+                        }
                 }
         }
         else
@@ -1307,7 +1330,7 @@ static int selfdestruct_gc( lua_State* L)
                         struct s_lane* s = selfdestruct_first;
                         while( s != SELFDESTRUCT_END )
                         {
-                                // attempt a regular unforced cancel with a small timeout
+                                // attempt a regular unforced hard cancel with a small timeout
                                 bool_t cancelled = THREAD_ISNULL( s->thread) || thread_cancel( s, 0.0001, FALSE);
                                 // if we failed, and we know the thread is waiting on a linda
                                 if( cancelled == FALSE && s->status == WAITING && s->waiting_on != NULL)
@@ -1353,7 +1376,7 @@ static int selfdestruct_gc( lua_State* L)
                                                 struct s_lane* s = selfdestruct_first;
                                                 while( s != SELFDESTRUCT_END)
                                                 {
-                                                        if( s->cancel_request)
+                                                        if( s->cancel_request == CANCEL_HARD)
                                                                 ++ n;
                                                         s = s->selfdestruct_next;
                                                 }
@@ -1444,21 +1467,22 @@ static int selfdestruct_gc( lua_State* L)
 * Returns TRUE if any locks are to be exited, and 'cancel_error()' called,
 * to make execution of the lane end.
 */
-static bool_t cancel_test( lua_State*L ) {
-    struct s_lane *s;
+static enum e_cancel_request cancel_test( lua_State* L)
+{
+        struct s_lane* s;
 
-    STACK_GROW(L,1);
+        STACK_GROW( L, 1);
 
-  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
-    lua_pop(L,1);
-  STACK_END( L, 0);
+        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
+        lua_pop( L, 1);
+        STACK_END( L, 0);
 
-    // 's' is NULL for the original main state (no-one can cancel that)
-    //
-    return s && s->cancel_request;
+        // 's' is NULL for the original main state (no-one can cancel that)
+        //
+        return s ? s->cancel_request : CANCEL_NONE;
 }
 
 static void cancel_error( lua_State*L ) {
@@ -1467,22 +1491,24 @@ static void cancel_error( lua_State*L ) {
     lua_error(L);   // no return
 }
 
-static void cancel_hook( lua_State*L, lua_Debug *ar ) {
-    (void)ar;
-    if (cancel_test(L)) cancel_error(L);
+static void cancel_hook( lua_State*L, lua_Debug *ar )
+{
+        (void)ar;
+        if( cancel_test( L) != CANCEL_NONE)
+                cancel_error( L);
 }
 
 
 //---
-// bool= cancel_test()
+// bool = cancel_test()
 //
 // Available inside the global namespace of lanes
 // returns a boolean saying if a cancel request is pending
 //
 LUAG_FUNC( cancel_test)
 {
-        bool_t test = cancel_test( L);
-        lua_pushboolean( L, test);
+        enum e_cancel_request test = cancel_test( L);
+        lua_pushboolean( L, test != CANCEL_NONE);
         return 1;
 }
 
@@ -1724,7 +1750,7 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
     // Tie "cancel_test()" to the state
     //
     lua_pushcfunction( L, LG_cancel_test);
-    lua_setglobal( L, "cancel_test" );
+    lua_setglobal( L, "cancel_test");
 
 #ifdef ERROR_FULL_STACK
     // Tie "set_error_reporting()" to the state
@@ -2065,7 +2091,7 @@ LUAG_FUNC( thread_new)
         s->status= PENDING;
         s->waiting_on = NULL;
         s->debug_name = NULL;
-        s->cancel_request= FALSE;
+        s->cancel_request = CANCEL_NONE;
 
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
         MUTEX_INIT( &s->done_lock);
@@ -2183,6 +2209,10 @@ LUAG_FUNC( thread_cancel)
                 if( lua_isnumber( L, 2))
                 {
                         secs = lua_tonumber( L, 2);
+                        if( secs < 0.0 && lua_gettop( L) > 2)
+                        {
+                                return luaL_error( L, "can't force a soft cancel");
+                        }
                         ++ force_i;
                 }
                 else if( lua_isnil( L, 2))
@@ -2611,8 +2641,9 @@ void register_core_libfuncs_for_keeper( lua_State* L)
 /*
 ** One-time initializations
 */
-static void init_once_LOCKED( lua_State* L, int const _on_state_create, int const nbKeepers, lua_Number _shutdown_timeout, bool_t _track_lanes)
+static void init_once_LOCKED( lua_State* L, int const _on_state_create, int const nbKeepers, lua_Number _shutdown_timeout, bool_t _track_lanes, bool_t verbose_errors)
 {
+        GVerboseErrors = verbose_errors;
 #if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
         now_secs();     // initialize 'now_secs()' internal offset
 #endif
@@ -2724,10 +2755,12 @@ LUAG_FUNC( configure)
         char const* name = luaL_checkstring( L, lua_upvalueindex( 1));
         // all parameter checks are done lua-side
         int const nbKeepers = (int)lua_tointeger( L, 1);
+        // all these can be nil when lanes.core is required internally! (but are only processed at first init anyway)
         int const on_state_create = lua_isfunction( L, 2) ? 2 : 0;
         lua_Number shutdown_timeout = lua_tonumber( L, 3);
         bool_t track_lanes = lua_toboolean( L, 4);
         bool_t protect_allocator = lua_toboolean( L, 5);
+        bool_t verbose_errors = lua_toboolean( L, 6);
 
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() BEGIN\n" INDENT_END, L));
         DEBUGSPEW_CODE( ++ debugspew_indent_depth);
@@ -2738,11 +2771,14 @@ LUAG_FUNC( configure)
         {
                 void* ud;
                 lua_Alloc allocf = lua_getallocf( L, &ud);
-                struct ProtectedAllocator_s* s = (struct ProtectedAllocator_s*) allocf( ud, NULL, 0, sizeof( struct ProtectedAllocator_s));
-                s->allocf = allocf;
-                s->ud = ud;
-                MUTEX_INIT( &s->lock);
-                lua_setallocf( L, protected_lua_Alloc, s);
+                if( allocf != protected_lua_Alloc) // just in case
+                {
+                        struct ProtectedAllocator_s* s = (struct ProtectedAllocator_s*) allocf( ud, NULL, 0, sizeof( struct ProtectedAllocator_s));
+                        s->allocf = allocf;
+                        s->ud = ud;
+                        MUTEX_INIT( &s->lock);
+                        lua_setallocf( L, protected_lua_Alloc, s);
+                }
         }
 
         // Create main module interface table
@@ -2818,7 +2854,7 @@ LUAG_FUNC( configure)
                 static volatile int /*bool*/ go_ahead; // = 0
                 if( InterlockedCompareExchange( &s_initCount, 1, 0) == 0)
                 {
-                        init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes);
+                        init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes, verbose_errors);
                         go_ahead = 1;    // let others pass
                 }
                 else
@@ -2836,7 +2872,7 @@ LUAG_FUNC( configure)
                         //
                         if( s_initCount == 0)
                         {
-                                init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes);
+                                init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes, verbose_errors);
                                 s_initCount = 1;
                         }
                 }