1 files changed, 167 insertions, 167 deletions

diff --git a/src/cancel.c b/src/cancel.c
index cd930b5..0a5adb6 100644
--- a/src/cancel.c
+++ b/src/cancel.c
@@ -55,9 +55,9 @@ THE SOFTWARE.
 */
 static inline enum e_cancel_request cancel_test( lua_State* L)
 {
-        Lane* const s = get_lane_from_registry( L);
-        // 's' is NULL for the original main state (and no-one can cancel that)
-        return s ? s->cancel_request : CANCEL_NONE;
+    Lane* const s = get_lane_from_registry( L);
+    // 's' is NULL for the original main state (and no-one can cancel that)
+    return s ? s->cancel_request : CANCEL_NONE;
 }
 
 // ################################################################################################
@@ -70,9 +70,9 @@ static inline enum e_cancel_request cancel_test( lua_State* L)
 //
 LUAG_FUNC( cancel_test)
 {
-        enum e_cancel_request test = cancel_test( L);
-        lua_pushboolean( L, test != CANCEL_NONE);
-        return 1;
+    enum e_cancel_request test = cancel_test( L);
+    lua_pushboolean( L, test != CANCEL_NONE);
+    return 1;
 }
 
 // ################################################################################################
@@ -80,13 +80,13 @@ LUAG_FUNC( cancel_test)
 
 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);
-        }
+    (void)ar;
+    DEBUGSPEW_CODE( fprintf( stderr, "cancel_hook\n"));
+    if( cancel_test( L) != CANCEL_NONE)
+    {
+        lua_sethook( L, NULL, 0, 0);
+        cancel_error( L);
+    }
 }
 
 // ################################################################################################
@@ -114,90 +114,90 @@ static void cancel_hook( lua_State* L, lua_Debug* ar)
 
 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
-        if( wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
-        {
-                SIGNAL_T *waiting_on = s->waiting_on;
-                if( s->status == WAITING && waiting_on != NULL)
-                {
-                        SIGNAL_ALL( waiting_on);
-                }
-        }
-
-        return THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
+    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;
+        if( s->status == WAITING && waiting_on != NULL)
+        {
+            SIGNAL_ALL( waiting_on);
+        }
+    }
+
+    return THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
 }
 
 // ################################################################################################
 
 static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_)
 {
-        cancel_result result;
-
-        s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
-        {
-                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;
-
-        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);
+    cancel_result result;
+
+    s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
+    {
+        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;
+
+    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);
 #if THREADAPI == THREADAPI_PTHREAD
-                // pthread: make sure the thread is really stopped!
-                // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
-                result = THREAD_WAIT( &s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status);
-                if( result == CR_Timeout)
-                {
-                        return luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
-                }
+        // pthread: make sure the thread is really stopped!
+        // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
+        result = THREAD_WAIT( &s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status);
+        if( result == CR_Timeout)
+        {
+            return luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
+        }
 #else
-                (void) waitkill_timeout_; // unused
-                (void) L; // unused
+        (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.
-                result = CR_Killed;
-        }
-        return result;
+        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;
 }
 
 // ################################################################################################
 
 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)
-        if( s->mstatus == KILLED)
-        {
-                return CR_Killed;
-        }
-
-        if( s->status >= DONE)
-        {
-                // say "ok" by default, including when lane is already done
-                return CR_Cancelled;
-        }
-
-        // 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( op_ == CO_Soft)
-        {
-                return thread_cancel_soft( s, secs_, force_);
-        }
-
-        return thread_cancel_hard( L, s, secs_, force_, 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)
+    if( s->mstatus == KILLED)
+    {
+        return CR_Killed;
+    }
+
+    if( s->status >= DONE)
+    {
+        // say "ok" by default, including when lane is already done
+        return CR_Cancelled;
+    }
+
+    // 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( op_ == CO_Soft)
+    {
+        return thread_cancel_soft( s, secs_, force_);
+    }
+
+    return thread_cancel_hard( L, s, secs_, force_, waitkill_timeout_);
 }
 
 // ################################################################################################
@@ -208,95 +208,95 @@ cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_,
 // < 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;
+    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;
-        CancelOp op = which_op( L, 2); // this removes the op string from the stack
-
-        if( op > 0) // hook is requested
-        {
-                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, "hook count cannot be < 1");
-                }
-                lua_sethook( s->L, cancel_hook, op, hook_count);
-        }
-
-        if( lua_type( L, 2) == LUA_TNUMBER)
-        {
-                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, 2);     // FALSE if nothing there
-                double forcekill_timeout = luaL_optnumber( L, 3, 0.0);
-
-                switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
-                {
-                        case CR_Timeout:
-                        lua_pushboolean( L, 0);
-                        lua_pushstring( L, "timeout");
-                        return 2;
-
-                        case CR_Cancelled:
-                        lua_pushboolean( L, 1);
-                        push_thread_status( L, s);
-                        return 2;
-
-                        case CR_Killed:
-                        lua_pushboolean( L, 1);
-                        push_thread_status( L, s);
-                        return 2;
-                }
-        }
-        // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
-        return 0;
+    Lane* s = lua_toLane( L, 1);
+    double secs = 0.0;
+    CancelOp op = which_op( L, 2); // this removes the op string from the stack
+
+    if( op > 0) // hook is requested
+    {
+        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, "hook count cannot be < 1");
+        }
+        lua_sethook( s->L, cancel_hook, op, hook_count);
+    }
+
+    if( lua_type( L, 2) == LUA_TNUMBER)
+    {
+        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, 2);     // FALSE if nothing there
+        double forcekill_timeout = luaL_optnumber( L, 3, 0.0);
+
+        switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
+        {
+            case CR_Timeout:
+            lua_pushboolean( L, 0);
+            lua_pushstring( L, "timeout");
+            return 2;
+
+            case CR_Cancelled:
+            lua_pushboolean( L, 1);
+            push_thread_status( L, s);
+            return 2;
+
+            case CR_Killed:
+            lua_pushboolean( L, 1);
+            push_thread_status( L, s);
+            return 2;
+        }
+    }
+    // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
+    return 0;
 }