1 files changed, 74 insertions, 66 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index 5bba9fc..6812b0d 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -38,6 +38,53 @@ THE SOFTWARE.
 #include "debugspew.hpp"
 #include "lane.hpp"
 
+namespace {
+    namespace local {
+
+        // #########################################################################################
+        // #########################################################################################
+
+        [[nodiscard]]
+        static std::optional<CancelOp> WhichCancelOp(std::string_view const& opString_)
+        {
+            if (opString_ == "soft") {
+                return std::make_optional<CancelOp>(CancelRequest::Soft, LuaHookMask::None);
+            } else if (opString_ == "hard") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::None);
+            } else if (opString_ == "call") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Call);
+            } else if (opString_ == "ret") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Ret);
+            } else if (opString_ == "line") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Line);
+            } else if (opString_ == "count") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Count);
+            } else if (opString_ == "all") {
+                return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::All);
+            }
+            return std::nullopt;
+        }
+
+        // #########################################################################################
+
+        [[nodiscard]]
+        static CancelOp WhichCancelOp(lua_State* const L_, StackIndex const idx_)
+        {
+            if (luaW_type(L_, idx_) == LuaType::STRING) {
+                std::string_view const _str{ luaW_tostring(L_, idx_) };
+                auto const _op{ WhichCancelOp(_str) };
+                lua_remove(L_, idx_); // argument is processed, remove it
+                if (!_op.has_value()) {
+                    raise_luaL_error(L_, "Invalid cancel operation '%s'", _str.data());
+                }
+                return _op.value();
+            }
+            return CancelOp{ CancelRequest::Hard, LuaHookMask::None };
+        }
+
+    } // namespace local
+} // namespace
+
 // #################################################################################################
 // #################################################################################################
 
@@ -60,66 +107,6 @@ CancelRequest CheckCancelRequest(lua_State* const L_)
 
 // #################################################################################################
 // #################################################################################################
-
-//---
-// = lane_cancel( lane_ud [,timeout_secs=0.0] [,wake_lindas_bool=false] )
-//
-// The originator thread asking us specifically to cancel the other thread.
-//
-// 'timeout': <0: wait forever, until the lane is finished
-//            0.0: just signal it to cancel, no time waited
-//            >0: time to wait for the lane to detect cancellation
-//
-// 'wake_lindas_bool': if true, signal any linda the thread is waiting on
-//                     instead of waiting for its timeout (if any)
-//
-// Returns: true if the lane was already finished (Done/Error/Cancelled) or if we
-//          managed to cancel it.
-//          false if the cancellation timed out, or a kill was needed.
-//
-
-// #################################################################################################
-// #################################################################################################
-
-static std::optional<CancelOp> WhichCancelOp(std::string_view const& opString_)
-{
-    if (opString_ == "soft") {
-        return std::make_optional<CancelOp>(CancelRequest::Soft, LuaHookMask::None);
-    } else if (opString_ == "hard") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::None);
-    } else if (opString_== "call") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Call);
-    } else if (opString_ == "ret") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Ret);
-    } else if (opString_ == "line") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Line);
-    } else if (opString_ == "count") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Count);
-    } else if (opString_ == "all") {
-        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::All);
-    }
-    return std::nullopt;
-}
-
-// #################################################################################################
-
-[[nodiscard]]
-static CancelOp WhichCancelOp(lua_State* const L_, StackIndex const idx_)
-{
-    if (luaG_type(L_, idx_) == LuaType::STRING) {
-        std::string_view const _str{ luaG_tostring(L_, idx_) };
-        auto const _op{ WhichCancelOp(_str) };
-        lua_remove(L_, idx_); // argument is processed, remove it
-        if (!_op.has_value()) {
-            raise_luaL_error(L_, "Invalid cancel operation '%s'", _str.data());
-        }
-        return _op.value();
-    }
-    return CancelOp{ CancelRequest::Hard, LuaHookMask::None };
-}
-
-// #################################################################################################
-// #################################################################################################
 // ######################################### Lua API ###############################################
 // #################################################################################################
 // #################################################################################################
@@ -133,24 +120,45 @@ static CancelOp WhichCancelOp(lua_State* const L_, StackIndex const idx_)
 LUAG_FUNC(cancel_test)
 {
     CancelRequest const _test{ CheckCancelRequest(L_) };
-    lua_pushboolean(L_, _test != CancelRequest::None);
+    if (_test == CancelRequest::None) {
+        lua_pushboolean(L_, 0);
+    } else {
+        luaW_pushstring(L_, (_test == CancelRequest::Soft) ? "soft" : "hard");
+    }
     return 1;
 }
 
 // #################################################################################################
 
+//---
+// = lane_cancel( lane_ud [,timeout_secs=0.0] [,wake_lindas_bool=false] )
+//
+// The originator thread asking us specifically to cancel the other thread.
+//
+// 'timeout': <0: wait forever, until the lane is finished
+//            0.0: just signal it to cancel, no time waited
+//            >0: time to wait for the lane to detect cancellation
+//
+// 'wake_lindas_bool': if true, signal any linda the thread is waiting on
+//                     instead of waiting for its timeout (if any)
+//
+// Returns: true if the lane was already finished (Done/Error/Cancelled) or if we
+//          managed to cancel it.
+//          false if the cancellation timed out, or a kill was needed.
+//
+
 // bool[,reason] = lane_h:cancel( [cancel_op, hookcount] [, timeout] [, wake_lane])
 LUAG_FUNC(lane_cancel)
 {
     Lane* const _lane{ ToLane(L_, StackIndex{ 1 }) };                                              // L_: lane [cancel_op, hookcount] [, timeout] [, wake_lane]
-    CancelOp const _op{ WhichCancelOp(L_, StackIndex{ 2 }) };                                      // L_: lane [hookcount] [, timeout] [, wake_lane]
+    CancelOp const _op{ local::WhichCancelOp(L_, StackIndex{ 2 }) };                               // L_: lane [hookcount] [, timeout] [, wake_lane]
 
     int const _hook_count{ std::invoke([_op, L_]() {
         if (_op.hookMask == LuaHookMask::None) {
             // the caller shouldn't have provided a hook count in that case
             return 0;
         }
-        if (luaG_type(L_, StackIndex{ 2 }) != LuaType::NUMBER) {
+        if (luaW_type(L_, StackIndex{ 2 }) != LuaType::NUMBER) {
             raise_luaL_error(L_, "Hook count expected");
         }
         auto const _hook_count{ static_cast<int>(lua_tointeger(L_, 2)) };
@@ -162,7 +170,7 @@ LUAG_FUNC(lane_cancel)
     }) };
 
     std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
-    if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
+    if (luaW_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
         lua_Duration const duration{ lua_tonumber(L_, 2) };
         if (duration.count() >= 0.0) {
             _until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration);
@@ -178,7 +186,7 @@ LUAG_FUNC(lane_cancel)
     WakeLane _wake_lane{ (_op.mode == CancelRequest::Hard) ? WakeLane::Yes : WakeLane::No };
     if (lua_gettop(L_) >= 2) {
         if (!lua_isboolean(L_, 2)) {
-            raise_luaL_error(L_, "Boolean expected for wake_lane argument, got %s", luaG_typename(L_, StackIndex{ 2 }).data());
+            raise_luaL_error(L_, "Boolean expected for wake_lane argument, got %s", luaW_typename(L_, StackIndex{ 2 }).data());
         }
         _wake_lane = lua_toboolean(L_, 2) ? WakeLane::Yes : WakeLane::No;
         lua_remove(L_, 2); // argument is processed, remove it                                     // L_: lane
@@ -198,7 +206,7 @@ LUAG_FUNC(lane_cancel)
 
     case CancelResult::Timeout:
         lua_pushboolean(L_, 0);                                                                    // L_: false
-        luaG_pushstring(L_, "timeout");                                                            // L_: false "timeout"
+        luaW_pushstring(L_, "timeout");                                                            // L_: false "timeout"
         break;
 
     case CancelResult::Cancelled: