1 files changed, 27 insertions, 28 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index 81f25d5..73e50f5 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -53,11 +53,11 @@ THE SOFTWARE.
 * Returns CANCEL_SOFT/HARD if any locks are to be exited, and 'cancel_error()' called,
 * to make execution of the lane end.
 */
-static inline enum e_cancel_request cancel_test( lua_State* L)
+static inline CancelRequest cancel_test(lua_State* L)
 {
     Lane* const s = get_lane_from_registry( L);
     // 's' is nullptr for the original main state (and no-one can cancel that)
-    return s ? s->cancel_request : CANCEL_NONE;
+    return s ? s->cancel_request : CancelRequest::None;
 }
 
 // ################################################################################################
@@ -70,19 +70,18 @@ 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);
+    CancelRequest test{ cancel_test(L) };
+    lua_pushboolean(L, test != CancelRequest::None);
     return 1;
 }
 
 // ################################################################################################
 // ################################################################################################
 
-static void cancel_hook( lua_State* L, lua_Debug* ar)
+static void cancel_hook( lua_State* L, [[maybe_unused]] lua_Debug* ar)
 {
-    (void)ar;
     DEBUGSPEW_CODE( fprintf( stderr, "cancel_hook\n"));
-    if( cancel_test( L) != CANCEL_NONE)
+    if (cancel_test(L) != CancelRequest::None)
     {
         lua_sethook( L, nullptr, 0, 0);
         cancel_error( L);
@@ -112,40 +111,40 @@ static void cancel_hook( lua_State* L, lua_Debug* ar)
 
 // ################################################################################################
 
-static cancel_result thread_cancel_soft( Lane* s, double secs_, bool wake_lindas_)
+static CancelResult thread_cancel_soft(Lane* s, double secs_, bool wake_lindas_)
 {
-    s->cancel_request = CANCEL_SOFT; // it's now signaled to stop
+    s->cancel_request = CancelRequest::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;
+        SIGNAL_T* waiting_on = s->waiting_on;
         if( s->status == WAITING && waiting_on != nullptr)
         {
             SIGNAL_ALL( waiting_on);
         }
     }
 
-    return THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
+    return THREAD_WAIT(&s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CancelResult::Cancelled : CancelResult::Timeout;
 }
 
 // ################################################################################################
 
-static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bool force_, double waitkill_timeout_)
+static CancelResult thread_cancel_hard(lua_State* L, Lane* s, double secs_, bool force_, double waitkill_timeout_)
 {
-    cancel_result result;
+    CancelResult result;
 
-    s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
+    s->cancel_request = CancelRequest::Hard; // it's now signaled to stop
     {
-        SIGNAL_T *waiting_on = s->waiting_on;
+        SIGNAL_T* waiting_on = s->waiting_on;
         if( s->status == WAITING && waiting_on != nullptr)
         {
             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) ? CancelResult::Cancelled : CancelResult::Timeout;
 
-    if( (result == CR_Timeout) && force_)
+    if ((result == CancelResult::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
@@ -156,8 +155,8 @@ static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bo
 #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) ? CR_Killed : CR_Timeout;
-        if( result == CR_Timeout)
+        result = THREAD_WAIT(&s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status) ? CancelResult::Killed : CancelResult::Timeout;
+        if (result == CancelResult::Timeout)
         {
             (void) luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
         }
@@ -165,29 +164,29 @@ 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
+        s->mstatus = ThreadStatus::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;
+        result = CancelResult::Killed;
     }
     return result;
 }
 
 // ################################################################################################
 
-cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_, bool force_, double waitkill_timeout_)
+CancelResult thread_cancel(lua_State* L, Lane* s, CancelOp op_, double secs_, bool 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)
+    if (s->mstatus == ThreadStatus::Killed)
     {
-        return CR_Killed;
+        return CancelResult::Killed;
     }
 
     if( s->status >= DONE)
     {
         // say "ok" by default, including when lane is already done
-        return CR_Cancelled;
+        return CancelResult::Cancelled;
     }
 
     // signal the linda the wake up the thread so that it can react to the cancel query
@@ -281,17 +280,17 @@ LUAG_FUNC( thread_cancel)
 
         switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
         {
-            case CR_Timeout:
+            case CancelResult::Timeout:
             lua_pushboolean( L, 0);
             lua_pushstring( L, "timeout");
             return 2;
 
-            case CR_Cancelled:
+            case CancelResult::Cancelled:
             lua_pushboolean( L, 1);
             push_thread_status( L, s);
             return 2;
 
-            case CR_Killed:
+            case CancelResult::Killed:
             lua_pushboolean( L, 1);
             push_thread_status( L, s);
             return 2;