Move some cancel-related code around

1 files changed, 25 insertions, 88 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index 4205d1f..a62fcdf 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -50,7 +50,7 @@ THE SOFTWARE.
  * Returns CANCEL_SOFT/HARD if any locks are to be exited, and 'raise_cancel_error()' called,
  * to make execution of the lane end.
  */
-[[nodiscard]] static inline CancelRequest cancel_test(lua_State* L_)
+[[nodiscard]] CancelRequest cancel_test(lua_State* const L_)
 {
     Lane* const _lane{ kLanePointerRegKey.readLightUserDataValue<Lane>(L_) };
     // 'lane' is nullptr for the original main state (and no-one can cancel that)
@@ -58,33 +58,6 @@ THE SOFTWARE.
 }
 
 // #################################################################################################
-
-//---
-// bool = cancel_test()
-//
-// Available inside the global namespace of lanes
-// returns a boolean saying if a cancel request is pending
-//
-LUAG_FUNC(cancel_test)
-{
-    CancelRequest _test{ cancel_test(L_) };
-    lua_pushboolean(L_, _test != CancelRequest::None);
-    return 1;
-}
-
-// #################################################################################################
-// #################################################################################################
-
-[[nodiscard]] static void cancel_hook(lua_State* L_, [[maybe_unused]] lua_Debug* ar_)
-{
-    DEBUGSPEW_CODE(DebugSpew(nullptr) << "cancel_hook" << std::endl);
-    if (cancel_test(L_) != CancelRequest::None) {
-        lua_sethook(L_, nullptr, 0, 0);
-        raise_cancel_error(L_);
-    }
-}
-
-// #################################################################################################
 // #################################################################################################
 
 //---
@@ -105,64 +78,9 @@ LUAG_FUNC(cancel_test)
 //
 
 // #################################################################################################
-
-[[nodiscard]] static CancelResult thread_cancel_soft(Lane* lane_, std::chrono::time_point<std::chrono::steady_clock> until_, bool wakeLane_)
-{
-    lane_->cancelRequest = 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 (wakeLane_) { // wake the thread so that execution returns from any pending linda operation if desired
-        std::condition_variable* const _waiting_on{ lane_->waiting_on };
-        if (lane_->status == Lane::Waiting && _waiting_on != nullptr) {
-            _waiting_on->notify_all();
-        }
-    }
-
-    return lane_->waitForCompletion(until_) ? CancelResult::Cancelled : CancelResult::Timeout;
-}
-
 // #################################################################################################
 
-[[nodiscard]] static CancelResult thread_cancel_hard(Lane* lane_, std::chrono::time_point<std::chrono::steady_clock> until_, bool wakeLane_)
-{
-    lane_->cancelRequest = CancelRequest::Hard; // it's now signaled to stop
-    // lane_->thread.get_stop_source().request_stop();
-    if (wakeLane_) { // wake the thread so that execution returns from any pending linda operation if desired
-        std::condition_variable* const _waiting_on{ lane_->waiting_on };
-        if (lane_->status == Lane::Waiting && _waiting_on != nullptr) {
-            _waiting_on->notify_all();
-        }
-    }
-
-    CancelResult result{ lane_->waitForCompletion(until_) ? CancelResult::Cancelled : CancelResult::Timeout };
-    return result;
-}
-
-// #################################################################################################
-
-CancelResult thread_cancel(Lane* lane_, CancelOp op_, int hookCount_, std::chrono::time_point<std::chrono::steady_clock> until_, bool wakeLane_)
-{
-    // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
-    // We can read 'lane_->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
-    if (lane_->status >= Lane::Done) {
-        // say "ok" by default, including when lane is already done
-        return CancelResult::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_ == CancelOp::Soft) {
-        return thread_cancel_soft(lane_, until_, wakeLane_);
-    } else if (static_cast<int>(op_) > static_cast<int>(CancelOp::Soft)) {
-        lua_sethook(lane_->L, cancel_hook, static_cast<int>(op_), hookCount_);
-    }
-
-    return thread_cancel_hard(lane_, until_, wakeLane_);
-}
-
-// #################################################################################################
-// #################################################################################################
-
-CancelOp which_cancel_op(std::string_view const& opString_)
+CancelOp WhichCancelOp(std::string_view const& opString_)
 {
     CancelOp _op{ CancelOp::Invalid };
     if (opString_ == "hard") {
@@ -183,11 +101,11 @@ CancelOp which_cancel_op(std::string_view const& opString_)
 
 // #################################################################################################
 
-[[nodiscard]] static CancelOp which_cancel_op(lua_State* L_, int idx_)
+[[nodiscard]] static CancelOp WhichCancelOp(lua_State* const L_, int const idx_)
 {
     if (luaG_type(L_, idx_) == LuaType::STRING) {
         std::string_view const _str{ luaG_tostring(L_, idx_) };
-        CancelOp _op{ which_cancel_op(_str) };
+        CancelOp _op{ WhichCancelOp(_str) };
         lua_remove(L_, idx_); // argument is processed, remove it
         if (_op == CancelOp::Invalid) {
             raise_luaL_error(L_, "invalid hook option %s", _str);
@@ -198,12 +116,31 @@ CancelOp which_cancel_op(std::string_view const& opString_)
 }
 
 // #################################################################################################
+// #################################################################################################
+// ######################################### Lua API ###############################################
+// #################################################################################################
+// #################################################################################################
+
+//---
+// bool = cancel_test()
+//
+// Available inside the global namespace of a lane
+// returns a boolean saying if a cancel request is pending
+//
+LUAG_FUNC(cancel_test)
+{
+    CancelRequest _test{ cancel_test(L_) };
+    lua_pushboolean(L_, _test != CancelRequest::None);
+    return 1;
+}
+
+// #################################################################################################
 
 // bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, wake_lane])
 LUAG_FUNC(thread_cancel)
 {
     Lane* const _lane{ ToLane(L_, 1) };
-    CancelOp const _op{ which_cancel_op(L_, 2) }; // this removes the op string from the stack
+    CancelOp const _op{ WhichCancelOp(L_, 2) }; // this removes the op string from the stack
 
     int _hook_count{ 0 };
     if (static_cast<int>(_op) > static_cast<int>(CancelOp::Soft)) { // hook is requested
@@ -237,7 +174,7 @@ LUAG_FUNC(thread_cancel)
         lua_remove(L_, 2); // argument is processed, remove it
     }
     STACK_CHECK_START_REL(L_, 0);
-    switch (thread_cancel(_lane, _op, _hook_count, _until, _wake_lane)) {
+    switch (_lane->cancel(_op, _hook_count, _until, _wake_lane)) {
     default: // should never happen unless we added a case and forgot to handle it
         LUA_ASSERT(L_, false);
         break;