1 files changed, 73 insertions, 96 deletions

diff --git a/src/linda.cpp b/src/linda.cpp
index fa28385..1f4b19d 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -47,7 +47,7 @@ namespace {
     {
         STACK_CHECK_START_REL(L_, 0);
         for (StackIndex const _i : std::ranges::iota_view{ start_, StackIndex{ end_ + 1 } }) {
-            LuaType const _t{ luaG_type(L_, _i) };
+            LuaType const _t{ luaW_type(L_, _i) };
             switch (_t) {
             case LuaType::BOOLEAN:
             case LuaType::NUMBER:
@@ -109,13 +109,13 @@ namespace {
     {
         Linda* const _linda{ ToLinda<OPT>(L_, idx_) };
         if (_linda != nullptr) {
-            luaG_pushstring(L_, "Linda: ");
+            luaW_pushstring(L_, "Linda: ");
             std::string_view const _lindaName{ _linda->getName() };
             if (!_lindaName.empty()) {
-                luaG_pushstring(L_, _lindaName);
+                luaW_pushstring(L_, _lindaName);
             } else {
                 // obfuscate the pointer so that we can't read the value with our eyes out of a script
-                luaG_pushstring(L_, "%p", _linda->obfuscated());
+                luaW_pushstring(L_, "%p", _linda->obfuscated());
             }
             lua_concat(L_, 2);
             return 1;
@@ -132,7 +132,7 @@ namespace {
         StackIndex _key_i{ 2 }; // index of first slot, if timeout not there
 
         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);
@@ -147,6 +147,42 @@ namespace {
     }
 
     // #############################################################################################
+    static bool WaitInternal([[maybe_unused]] lua_State* const L_, Lane* const lane_, Linda* const linda_, Keeper* const keeper_, std::condition_variable& waitingOn_, std::chrono::time_point<std::chrono::steady_clock> until_)
+    {
+        Lane::Status _prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
+        if (lane_ != nullptr) {
+            // change status of lane to "waiting"
+            _prev_status = lane_->status.load(std::memory_order_acquire); // Running, most likely
+            LUA_ASSERT(L_, _prev_status == Lane::Running); // but check, just in case
+            LUA_ASSERT(L_, lane_->waiting_on == nullptr);
+            lane_->waiting_on = &waitingOn_;
+            lane_->status.store(Lane::Waiting, std::memory_order_release);
+        }
+
+        // wait until the final target date by small increments, interrupting regularly so that we can check for cancel requests,
+        // in case some timing issue caused a cancel request to be issued, and the condvar signalled, before we actually wait for it
+        auto const [_forceTryAgain, _until_check_cancel] = std::invoke([until_, wakePeriod = linda_->getWakePeriod()] {
+            auto _until_check_cancel{ std::chrono::time_point<std::chrono::steady_clock>::max() };
+            if (wakePeriod.count() > 0.0f) {
+                _until_check_cancel = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(wakePeriod);
+            }
+            bool const _forceTryAgain{ _until_check_cancel < until_ };
+            return std::make_tuple(_forceTryAgain, _forceTryAgain ? _until_check_cancel : until_);
+        });
+
+        // operation can't complete: wake when it is signalled to be possible, or when timeout is reached
+        std::unique_lock<std::mutex> _guard{ keeper_->mutex, std::adopt_lock };
+        std::cv_status const _status{ waitingOn_.wait_until(_guard, _until_check_cancel) };
+        _guard.release(); // we don't want to unlock the mutex on exit!
+        bool const _try_again{ _forceTryAgain || (_status == std::cv_status::no_timeout) }; // detect spurious wakeups
+        if (lane_ != nullptr) {
+            lane_->waiting_on = nullptr;
+            lane_->status.store(_prev_status, std::memory_order_release);
+        }
+        return _try_again;
+    }
+
+    // #############################################################################################
 
     // the implementation for linda:receive() and linda:receive_batched()
     static int ReceiveInternal(lua_State* const L_, bool const batched_)
@@ -201,6 +237,7 @@ namespace {
             _cancel = (_cancel != CancelRequest::None)
                 ? _cancel
                 : ((_linda->cancelStatus == Linda::Cancelled) ? CancelRequest::Soft : CancelRequest::None);
+
             // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
             if (!_try_again || _cancel != CancelRequest::None) {
                 _pushed.emplace(0);
@@ -227,38 +264,7 @@ namespace {
             }
 
             // nothing received, wait until timeout or signalled that we should try again
-            {
-                Lane::Status _prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
-                if (_lane != nullptr) {
-                    // change status of lane to "waiting"
-                    _prev_status = _lane->status.load(std::memory_order_acquire); // Running, most likely
-                    LUA_ASSERT(L_, _prev_status == Lane::Running); // but check, just in case
-                    LUA_ASSERT(L_, _lane->waiting_on == nullptr);
-                    _lane->waiting_on = &_linda->writeHappened;
-                    _lane->status.store(Lane::Waiting, std::memory_order_release);
-                }
-
-                // wait until the final target date by small increments, interrupting regularly so that we can check for cancel requests,
-                // in case some timing issue caused a cancel request to be issued, and the condvar signalled, before we actually wait for it
-                auto const [_forceTryAgain, _until_check_cancel] = std::invoke([_until, wakePeriod = _linda->getWakePeriod()] {
-                    auto _until_check_cancel{ std::chrono::time_point<std::chrono::steady_clock>::max() };
-                    if (wakePeriod.count() > 0.0f) {
-                        _until_check_cancel = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(wakePeriod);
-                    }
-                    bool const _forceTryAgain{ _until_check_cancel < _until };
-                    return std::make_tuple(_forceTryAgain, _forceTryAgain ? _until_check_cancel : _until);
-                });
-
-                // not enough data to read: wakeup when data was sent, or when timeout is reached
-                std::unique_lock<std::mutex> _guard{ _keeper->mutex, std::adopt_lock };
-                std::cv_status const _status{ _linda->writeHappened.wait_until(_guard, _until_check_cancel) };
-                _guard.release(); // we don't want to unlock the mutex on exit!
-                _try_again = _forceTryAgain || (_status == std::cv_status::no_timeout); // detect spurious wakeups
-                if (_lane != nullptr) {
-                    _lane->waiting_on = nullptr;
-                    _lane->status.store(_prev_status, std::memory_order_release);
-                }
-            }
+            _try_again = WaitInternal(L_, _lane, _linda, _keeper, _linda->writeHappened, _until);
         }
         STACK_CHECK(_K, 0);
 
@@ -273,7 +279,7 @@ namespace {
                 if (_nbPushed == 0) {
                     // not enough data in the linda slot to fulfill the request, return nil, "timeout"
                     lua_pushnil(L_);
-                    luaG_pushstring(L_, "timeout");
+                    luaW_pushstring(L_, "timeout");
                     return 2;
                 }
                 return _nbPushed;
@@ -332,6 +338,7 @@ Keeper* Linda::acquireKeeper() const
     Keeper* const _keeper{ whichKeeper() };
     if (_keeper) {
         _keeper->mutex.lock();
+        keeperOperationCount.fetch_add(1, std::memory_order_seq_cst);
     }
     return _keeper;
 }
@@ -344,16 +351,16 @@ Linda* Linda::CreateTimerLinda(lua_State* const L_)
     // Initialize 'timerLinda'; a common Linda object shared by all states
     lua_pushcfunction(L_, LG_linda);                                                               // L_: lanes.linda
     lua_createtable(L_, 0, 3);                                                                     // L_: lanes.linda {}
-    luaG_pushstring(L_, "lanes-timer");                                                            // L_: lanes.linda {} "lanes-timer"
-    luaG_setfield(L_, StackIndex{ -2 }, std::string_view{ "name" });                               // L_: lanes.linda { .name="lanes-timer" }
+    luaW_pushstring(L_, "lanes-timer");                                                            // L_: lanes.linda {} "lanes-timer"
+    luaW_setfield(L_, StackIndex{ -2 }, std::string_view{ "name" });                               // L_: lanes.linda { .name="lanes-timer" }
     lua_pushinteger(L_, 0);                                                                        // L_: lanes.linda { .name="lanes-timer" } 0
-    luaG_setfield(L_, StackIndex{ -2 }, std::string_view{ "group" });                              // L_: lanes.linda { .name="lanes-timer" .group = 0 }
+    luaW_setfield(L_, StackIndex{ -2 }, std::string_view{ "group" });                              // L_: lanes.linda { .name="lanes-timer" .group = 0 }
     // note that wake_period is not set (will default to the value in the universe)
     lua_call(L_, 1, 1);                                                                            // L_: linda
     STACK_CHECK(L_, 1);
 
     // Proxy userdata contents is only a 'DeepPrelude*' pointer
-    auto const _timerLinda{ *luaG_tofulluserdata<Linda*>(L_, kIdxTop) };
+    auto const _timerLinda{ *luaW_tofulluserdata<Linda*>(L_, kIdxTop) };
     // increment refcount so that this linda remains alive as long as the universe exists.
     _timerLinda->refcount.fetch_add(1, std::memory_order_relaxed);
     lua_pop(L_, 1);                                                                                // L_:
@@ -416,7 +423,6 @@ int Linda::ProtectedCall(lua_State* const L_, lua_CFunction const f_)
     // doing LindaFactory::deleteDeepObjectInternal -> keeper_call(clear)
     lua_gc(L_, LUA_GCSTOP, 0);
 
-    LUA_ASSERT_CODE(auto const _koip{ _linda->startKeeperOperation(L_) });
     // if we didn't do anything wrong, the keeper stack should be clean
     LUA_ASSERT(L_, lua_gettop(_K) == 0);
 
@@ -424,7 +430,7 @@ int Linda::ProtectedCall(lua_State* const L_, lua_CFunction const f_)
     lua_pushcfunction(L_, f_);
     lua_insert(L_, 1);
     // do a protected call
-    LuaError const _rc{ lua_pcall(L_, lua_gettop(L_) - 1, LUA_MULTRET, 0) };
+    LuaError const _rc{ ToLuaError(lua_pcall(L_, lua_gettop(L_) - 1, LUA_MULTRET, 0)) };
     // whatever happens, the keeper state stack must be empty when we are done
     lua_settop(_K, 0);
 
@@ -446,7 +452,7 @@ int Linda::ProtectedCall(lua_State* const L_, lua_CFunction const f_)
 
 void Linda::pushCancelString(lua_State* L_) const
 {
-    luaG_pushstring(L_, cancelStatus == Status::Cancelled ? "cancelled" : "active");
+    luaW_pushstring(L_, cancelStatus == Status::Cancelled ? "cancelled" : "active");
 }
 
 // #################################################################################################
@@ -455,6 +461,7 @@ void Linda::releaseKeeper(Keeper* const keeper_) const
 {
     if (keeper_) { // can be nullptr if we tried to acquire during shutdown
         assert(keeper_ == whichKeeper());
+        keeperOperationCount.fetch_sub(1, std::memory_order_seq_cst);
         keeper_->mutex.unlock();
     }
 }
@@ -498,7 +505,7 @@ void Linda::setName(std::string_view const& name_)
 LUAG_FUNC(linda_cancel)
 {
     Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-    std::string_view const _who{ luaG_optstring(L_, StackIndex{ 2 }, "both") };
+    std::string_view const _who{ luaW_optstring(L_, StackIndex{ 2 }, "both") };
     // make sure we got 2 arguments: the linda and the cancellation mode
     luaL_argcheck(L_, lua_gettop(L_) <= 2, 2, "wrong number of arguments");
 
@@ -586,13 +593,13 @@ static int linda_index_string(lua_State* L_)
     Linda* const _linda{ ToLinda<false>(L_, kIdxSelf) };
     LUA_ASSERT(L_, lua_gettop(L_) == 2);                                                           // L_: linda "key"
 
-    std::string_view const _keystr{ luaG_tostring(L_, kIdxKey) };
+    std::string_view const _keystr{ luaW_tostring(L_, kIdxKey) };
     lua_settop(L_, 2); // keep only our original arguments on the stack
 
     // look in metatable first
     lua_getmetatable(L_, kIdxSelf);                                                                // L_: linda "key" mt
     lua_replace(L_, -3);                                                                           // L_: mt "key"
-    if (luaG_rawget(L_, StackIndex{ -2 }) != LuaType::NIL) { // found something?                   // L_: mt value
+    if (luaW_rawget(L_, StackIndex{ -2 }) != LuaType::NIL) { // found something?                   // L_: mt value
         return 1; // done
     }
 
@@ -612,12 +619,12 @@ static LUAG_FUNC(linda_index)
     static constexpr StackIndex kIdxKey{ 2 };
     LUA_ASSERT(L_, lua_gettop(L_) == 2);
 
-    switch (luaG_type(L_, kIdxKey)) {
+    switch (luaW_type(L_, kIdxKey)) {
     case LuaType::STRING:
         return linda_index_string(L_); // stack modification is undefined, returned value is at the top
 
     default: // unknown key
-        raise_luaL_error(L_, "Unsupported linda indexing key type %s", luaG_typename(L_, kIdxKey).data());
+        raise_luaL_error(L_, "Unsupported linda indexing key type %s", luaW_typename(L_, kIdxKey).data());
     }
 }
 
@@ -760,7 +767,7 @@ LUAG_FUNC(linda_limit)
             int const _nargs{ lua_gettop(L_) };
             luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
             // make sure we got a numeric limit, or "unlimited", (or nothing)
-            bool const _unlimited{ luaG_tostring(L_, StackIndex{ 3 }) == "unlimited" };
+            bool const _unlimited{ luaW_tostring(L_, StackIndex{ 3 }) == "unlimited" };
             LindaLimit const _val{ _unlimited ? std::numeric_limits<LindaLimit::type>::max() : static_cast<LindaLimit::type>(luaL_optinteger(L_, 3, 0)) };
             if (_val < 0) {
                 raise_luaL_argerror(L_, StackIndex{ 3 }, "limit must be >= 0");
@@ -771,23 +778,23 @@ LUAG_FUNC(linda_limit)
             KeeperCallResult _pushed;
             if (_linda->cancelStatus == Linda::Active) {
                 if (_unlimited) {
-                    LUA_ASSERT(L_, lua_gettop(L_) == 3 && luaG_tostring(L_, StackIndex{ 3 }) == "unlimited");
+                    LUA_ASSERT(L_, lua_gettop(L_) == 3 && luaW_tostring(L_, StackIndex{ 3 }) == "unlimited");
                     // inside the Keeper, unlimited is signified with a -1 limit (can't use nil because of nil kNilSentinel conversions!)
                     lua_pop(L_, 1);                                                                // L_: linda slot
                     lua_pushinteger(L_, -1);                                                       // L_: linda slot nil
                 }
                 Keeper* const _keeper{ _linda->whichKeeper() };
                 _pushed = keeper_call(_keeper->K, KEEPER_API(limit), L_, _linda, StackIndex{ 2 });
-                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 2) && luaG_type(L_, kIdxTop) == LuaType::STRING);
+                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 2) && luaW_type(L_, kIdxTop) == LuaType::STRING);
                 if (_nargs == 3) { // 3 args: setting the limit
                     // changing the limit: no error, boolean value saying if we should wake blocked writer threads
-                    LUA_ASSERT(L_, luaG_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);           // L_: bool string
+                    LUA_ASSERT(L_, luaW_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);           // L_: bool string
                     if (lua_toboolean(L_, -2)) {
                         _linda->readHappened.notify_all(); // To be done from within the 'K' locking area
                     }
                 } else { // 2 args: reading the limit
                     // reading the limit: a number >=0 or "unlimited"
-                    LUA_ASSERT(L_, luaG_type(L_, StackIndex{ -2 }) == LuaType::NUMBER || luaG_tostring(L_, StackIndex{ -2 }) == "unlimited");
+                    LUA_ASSERT(L_, luaW_type(L_, StackIndex{ -2 }) == LuaType::NUMBER || luaW_tostring(L_, StackIndex{ -2 }) == "unlimited");
                 }
             } else { // linda is cancelled
                 // do nothing and return nil,lanes.cancel_error
@@ -843,7 +850,7 @@ LUAG_FUNC(linda_restrict)
             int const _nargs{ lua_gettop(L_) };
             luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
             // make sure we got a known restrict mode, (or nothing)
-            std::string_view const _mode{ luaG_tostring(L_, StackIndex{ 3 }) };
+            std::string_view const _mode{ luaW_tostring(L_, StackIndex{ 3 }) };
             if (!_mode.empty() && (_mode != "none" && _mode != "set/get" && _mode != "send/receive")) {
                 raise_luaL_argerror(L_, StackIndex{ 3 }, "unknown restrict mode");
             }
@@ -855,7 +862,7 @@ LUAG_FUNC(linda_restrict)
                 Keeper* const _keeper{ _linda->whichKeeper() };
                 _pushed = keeper_call(_keeper->K, KEEPER_API(restrict), L_, _linda, StackIndex{ 2 });
                 // we should get a single return value: the string describing the previous restrict mode
-                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 1) && luaG_type(L_, kIdxTop) == LuaType::STRING);
+                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 1) && luaW_type(L_, kIdxTop) == LuaType::STRING);
             } else { // linda is cancelled
                 // do nothing and return nil,lanes.cancel_error
                 lua_pushnil(L_);
@@ -916,6 +923,7 @@ LUAG_FUNC(linda_send)
                 _cancel = (_cancel != CancelRequest::None)
                     ? _cancel
                     : ((_linda->cancelStatus == Linda::Cancelled) ? CancelRequest::Soft : CancelRequest::None);
+
                 // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
                 if (!_try_again || _cancel != CancelRequest::None) {
                     _pushed.emplace(0);
@@ -948,38 +956,7 @@ LUAG_FUNC(linda_send)
                 }
 
                 // storage limit hit, wait until timeout or signalled that we should try again
-                {
-                    Lane::Status _prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
-                    if (_lane != nullptr) {
-                        // change status of lane to "waiting"
-                        _prev_status = _lane->status.load(std::memory_order_acquire); // Running, most likely
-                        LUA_ASSERT(L_, _prev_status == Lane::Running); // but check, just in case
-                        LUA_ASSERT(L_, _lane->waiting_on == nullptr);
-                        _lane->waiting_on = &_linda->readHappened;
-                        _lane->status.store(Lane::Waiting, std::memory_order_release);
-                    }
-
-                    // wait until the final target date by small increments, interrupting regularly so that we can check for cancel requests,
-                    // in case some timing issue caused a cancel request to be issued, and the condvar signalled, before we actually wait for it
-                    auto const [_forceTryAgain, _until_check_cancel] = std::invoke([_until, wakePeriod = _linda->getWakePeriod()] {
-                        auto _until_check_cancel{ std::chrono::time_point<std::chrono::steady_clock>::max() };
-                        if (wakePeriod.count() > 0.0f) {
-                            _until_check_cancel = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(wakePeriod);
-                        }
-                        bool const _forceTryAgain{ _until_check_cancel < _until };
-                        return std::make_tuple(_forceTryAgain, _forceTryAgain ? _until_check_cancel : _until);
-                    });
-
-                    // could not send because no room: wait until some data was read before trying again, or until timeout is reached
-                    std::unique_lock<std::mutex> _guard{ _keeper->mutex, std::adopt_lock };
-                    std::cv_status const status{ _linda->readHappened.wait_until(_guard, _until_check_cancel) };
-                    _guard.release(); // we don't want to unlock the mutex on exit!
-                    _try_again = _forceTryAgain || (status == std::cv_status::no_timeout); // detect spurious wakeups
-                    if (_lane != nullptr) {
-                        _lane->waiting_on = nullptr;
-                        _lane->status.store(_prev_status, std::memory_order_release);
-                    }
-                }
+                _try_again = WaitInternal(L_, _lane, _linda, _keeper, _linda->readHappened, _until);
             }
             STACK_CHECK(_K, 0);
 
@@ -1005,7 +982,7 @@ LUAG_FUNC(linda_send)
                 } else {
                     // not enough room in the Linda slot to fulfill the request, return nil, "timeout"
                     lua_pushnil(L_);
-                    luaG_pushstring(L_, "timeout");
+                    luaW_pushstring(L_, "timeout");
                     return 2;
                 }
             }
@@ -1040,7 +1017,7 @@ LUAG_FUNC(linda_set)
                     if (kRestrictedChannel.equals(L_, kIdxTop)) {
                         raise_luaL_error(L_, "Key is restricted");
                     }
-                    LUA_ASSERT(L_, _pushed.value() == 2 && luaG_type(L_, kIdxTop) == LuaType::STRING && luaG_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);
+                    LUA_ASSERT(L_, _pushed.value() == 2 && luaW_type(L_, kIdxTop) == LuaType::STRING && luaW_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);
 
                     if (_has_data) {
                         // we put some data in the slot, tell readers that they should wake
@@ -1102,7 +1079,7 @@ LUAG_FUNC(linda_towatch)
 LUAG_FUNC(linda_wake)
 {
     Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-    std::string_view const _who{ luaG_optstring(L_, StackIndex{ 2 }, "both") };
+    std::string_view const _who{ luaW_optstring(L_, StackIndex{ 2 }, "both") };
     // make sure we got 2 arguments: the linda and the wake targets
     luaL_argcheck(L_, lua_gettop(L_) <= 2, 2, "wrong number of arguments");
 
@@ -1178,8 +1155,8 @@ LUAG_FUNC(linda)
         if (lua_isnil(L_, kIdxTop)) {
             lua_pop(L_, 1);
             lua_pushnumber(L_, _U->lindaWakePeriod.count());
-        } else if (luaG_type(L_, kIdxTop) == LuaType::STRING) {
-            if (luaG_tostring(L_, kIdxTop) != "never") {
+        } else if (luaW_type(L_, kIdxTop) == LuaType::STRING) {
+            if (luaW_tostring(L_, kIdxTop) != "never") {
                 luaL_argerror(L_, 1, "invalid wake_period");
             } else {
                 lua_pop(L_, 1);
@@ -1201,7 +1178,7 @@ LUAG_FUNC(linda)
 
 #if LUA_VERSION_NUM >= 504 // to-be-closed support starts with Lua 5.4
         lua_getfield(L_, 1, "close_handler");                                                      // L_: {} wake_period group close_handler
-        LuaType const _handlerType{ luaG_type(L_, kIdxTop) };
+        LuaType const _handlerType{ luaW_type(L_, kIdxTop) };
         if (_handlerType == LuaType::NIL) {
             lua_pop(L_, 1);                                                                        // L_: {} wake_period group
         } else if (_handlerType == LuaType::USERDATA || _handlerType == LuaType::TABLE) {
@@ -1212,7 +1189,7 @@ LUAG_FUNC(linda)
         }
 #endif // LUA_VERSION_NUM >= 504
 
-        auto const _nameType{ luaG_getfield(L_, StackIndex{ 1 }, "name") };                        // L_: {} wake_period group [close_handler] name
+        auto const _nameType{ luaW_getfield(L_, StackIndex{ 1 }, "name") };                        // L_: {} wake_period group [close_handler] name
         luaL_argcheck(L_, _nameType == LuaType::NIL || _nameType == LuaType::STRING, 1, "name is not a string");
         lua_replace(L_, 1);                                                                        // L_: name wake_period group [close_handler]
     }