1 files changed, 75 insertions, 51 deletions

diff --git a/src/lanes.cpp b/src/lanes.cpp
index d1a353b..4373aee 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -137,13 +137,15 @@ LUAG_FUNC(set_singlethreaded)
 LUAG_FUNC(set_thread_priority)
 {
     lua_Integer const _prio{ luaL_checkinteger(L_, 1) };
+    NativePrioFlag const _native{ std::string_view{ "native" } == luaL_optstring(L_, 2, "mapped") };
     // public Lanes API accepts a generic range -3/+3
     // that will be remapped into the platform-specific scheduler priority scheme
     // On some platforms, -3 is equivalent to -2 and +3 to +2
-    if (_prio < kThreadPrioMin || _prio > kThreadPrioMax) {
+    if (!_native && (_prio < kThreadPrioMin || _prio > kThreadPrioMax)) {
         raise_luaL_error(L_, "priority out of range: %d..+%d (%d)", kThreadPrioMin, kThreadPrioMax, _prio);
     }
-    THREAD_SET_PRIORITY(static_cast<int>(_prio), Universe::Get(L_)->sudo);
+
+    THREAD_SET_PRIORITY(L_, static_cast<int>(_prio), _native, Universe::Get(L_)->sudo);
     return 0;
 }
 
@@ -155,7 +157,8 @@ LUAG_FUNC(set_thread_affinity)
     if (_affinity <= 0) {
         raise_luaL_error(L_, "invalid affinity (%d)", _affinity);
     }
-    THREAD_SET_AFFINITY(static_cast<unsigned int>(_affinity));
+
+    THREAD_SET_AFFINITY(L_, static_cast<unsigned int>(_affinity));
     return 0;
 }
 
@@ -170,17 +173,21 @@ LUAG_FUNC(sleep)
     lua_pushcfunction(L_, LG_linda_receive);                                                       // L_: duration|nil receive()
     STACK_CHECK_START_REL(L_, 0); // we pushed the function we intend to call, now prepare the arguments
     _U->timerLinda->push(L_);                                                                      // L_: duration|nil receive() timerLinda
-    if (luaG_tostring(L_, StackIndex{ 1 }) == "indefinitely") {
+    if (luaW_tostring(L_, StackIndex{ 1 }) == "indefinitely") {
         lua_pushnil(L_);                                                                           // L_: duration? receive() timerLinda nil
     } else if (lua_isnoneornil(L_, 1)) {
         lua_pushnumber(L_, 0);                                                                     // L_: duration? receive() timerLinda 0
     } else if (!lua_isnumber(L_, 1)) {
-        raise_luaL_argerror(L_, StackIndex{ 1 }, "invalid duration");
+        raise_luaL_argerror(L_, StackIndex{ 1 }, "duration must be a number");
     }
     else {
+        auto const _n{ lua_tonumber(L_, 1) };
+        if (_n < 0) {
+            raise_luaL_argerror(L_, StackIndex{ 1 }, "duration must be >= 0");
+        }
         lua_pushnumber(L_, lua_tonumber(L_, 1));                                                   // L_: duration? receive() timerLinda duration
     }
-    luaG_pushstring(L_, "ac100de1-a696-4619-b2f0-a26de9d58ab8");                                   // L_: duration? receive() timerLinda duration key
+    luaW_pushstring(L_, "ac100de1-a696-4619-b2f0-a26de9d58ab8");                                   // L_: duration? receive() timerLinda duration key
     STACK_CHECK(L_, 3); // 3 arguments ready
     lua_call(L_, 3, LUA_MULTRET); // timerLinda:receive(duration,key)                              // L_: duration? result...
     return lua_gettop(L_) - 1;
@@ -194,7 +201,7 @@ LUAG_FUNC(sleep)
 // upvalue[1]: _G.require
 LUAG_FUNC(require)
 {
-    std::string_view const _name{ luaG_tostring(L_, StackIndex{ 1 }) };                            // L_: "name" ...
+    std::string_view const _name{ luaW_tostring(L_, StackIndex{ 1 }) };                            // L_: "name" ...
     int const _nargs{ lua_gettop(L_) };
     DEBUGSPEW_CODE(Universe * _U{ Universe::Get(L_) });
     STACK_CHECK_START_REL(L_, 0);
@@ -220,8 +227,8 @@ int lanes_register(lua_State* const L_)
     if (!_U) {
         raise_luaL_error(L_, "Lanes is not ready");
     }
-    std::string_view const _name{ luaG_checkstring(L_, StackIndex{ 1 }) };
-    LuaType const _mod_type{ luaG_type(L_, StackIndex{ 2 }) };
+    std::string_view const _name{ luaW_checkstring(L_, StackIndex{ 1 }) };
+    LuaType const _mod_type{ luaW_type(L_, StackIndex{ 2 }) };
     // ignore extra arguments, just in case
     lua_settop(L_, 2);
     luaL_argcheck(L_, (_mod_type == LuaType::TABLE) || (_mod_type == LuaType::FUNCTION), 2, "unexpected module type");
@@ -236,9 +243,26 @@ int lanes_register(lua_State* const L_)
 
 // #################################################################################################
 
+LUAG_FUNC(thread_priority_range)
+{
+    NativePrioFlag const _native{ std::string_view{ "native" } == luaL_optstring(L_, 1, "mapped") };
+    if (_native) {
+        auto const [_prio_min, _prio_max] = THREAD_NATIVE_PRIOS();
+        lua_pushinteger(L_, _prio_min);
+        lua_pushinteger(L_, _prio_max);
+    } else {
+        lua_pushinteger(L_, kThreadPrioMin);
+        lua_pushinteger(L_, kThreadPrioMax);
+    }
+    return 2;
+}
+
+// #################################################################################################
+
 //--- [] means can be nil
 // lane_ud = lane_new( function
 //                   , [libs_str]
+//                   , [prio_is_native_bool]
 //                   , [priority_int]
 //                   , [globals_tbl]
 //                   , [package_tbl]
@@ -255,15 +279,16 @@ LUAG_FUNC(lane_new)
 {
     static constexpr StackIndex kFuncIdx{ 1 };
     static constexpr StackIndex kLibsIdx{ 2 };
-    static constexpr StackIndex kPrioIdx{ 3 };
-    static constexpr StackIndex kGlobIdx{ 4 };
-    static constexpr StackIndex kPackIdx{ 5 };
-    static constexpr StackIndex kRequIdx{ 6 };
-    static constexpr StackIndex kGcCbIdx{ 7 };
-    static constexpr StackIndex kNameIdx{ 8 };
-    static constexpr StackIndex kErTlIdx{ 9 };
-    static constexpr StackIndex kAsCoro{ 10 };
-    static constexpr StackIndex kFixedArgsIdx{ 10 };
+    static constexpr StackIndex kPrinIdx{ 3 };
+    static constexpr StackIndex kPrioIdx{ 4 };
+    static constexpr StackIndex kGlobIdx{ 5 };
+    static constexpr StackIndex kPackIdx{ 6 };
+    static constexpr StackIndex kRequIdx{ 7 };
+    static constexpr StackIndex kGcCbIdx{ 8 };
+    static constexpr StackIndex kNameIdx{ 9 };
+    static constexpr StackIndex kErTlIdx{ 10 };
+    static constexpr StackIndex kAsCoro{ 11 };
+    static constexpr StackIndex kFixedArgsIdx{ 11 };
 
     int const _nargs{ lua_gettop(L_) - kFixedArgsIdx };
     LUA_ASSERT(L_, _nargs >= 0);
@@ -271,7 +296,7 @@ LUAG_FUNC(lane_new)
     Universe* const _U{ Universe::Get(L_) };
     DEBUGSPEW_CODE(DebugSpew(_U) << "lane_new: setup" << std::endl);
 
-    std::optional<std::string_view> _libs_str{ lua_isnil(L_, kLibsIdx) ? std::nullopt : std::make_optional(luaG_tostring(L_, kLibsIdx)) };
+    std::optional<std::string_view> _libs_str{ lua_isnil(L_, kLibsIdx) ? std::nullopt : std::make_optional(luaW_tostring(L_, kLibsIdx)) };
     lua_State* const _S{ state::NewLaneState(_U, SourceState{ L_ }, _libs_str) };                 // L_: [fixed] ...                                L2:
     STACK_CHECK_START_REL(_S, 0);
 
@@ -333,7 +358,7 @@ LUAG_FUNC(lane_new)
             DEBUGSPEW_CODE(DebugSpew(lane->U) << "lane_new: preparing lane userdata" << std::endl);
             STACK_CHECK_START_REL(L, 0);
             // a Lane full userdata needs a single uservalue
-            Lane** const _ud{ luaG_newuserdatauv<Lane*>(L, UserValueCount{ 1 }) };                 // L: ... lane
+            Lane** const _ud{ luaW_newuserdatauv<Lane*>(L, UserValueCount{ 1 }) };                 // L: ... lane
             *_ud = lane; // don't forget to store the pointer in the userdata!
 
             // Set metatable for the userdata
@@ -357,25 +382,25 @@ LUAG_FUNC(lane_new)
             lua_setiuservalue(L, StackIndex{ -2 }, UserValueIndex{ 1 });                           // L: ... lane
 
             StackIndex const _name_idx{ lua_isnoneornil(L, kNameIdx) ? kIdxNone : kNameIdx };
-            std::string_view _debugName{ (_name_idx > 0) ? luaG_tostring(L, _name_idx) : std::string_view{} };
+            std::string_view _debugName{ (_name_idx > 0) ? luaW_tostring(L, _name_idx) : std::string_view{} };
             if (!_debugName.empty())
             {
                 if (_debugName == "auto") {
-                    if (luaG_type(L, kFuncIdx) == LuaType::STRING) {
+                    if (luaW_type(L, kFuncIdx) == LuaType::STRING) {
                         lua_Debug _ar;
                         if (lua_getstack(L, 2, &_ar) == 0) { // 0 is here, 1 is lanes.gen, 2 is its caller
                             lua_getstack(L, 1, &_ar); // level 2 may not exist with LuaJIT, try again with level 1
                         }
                         lua_getinfo(L, "Sl", &_ar);
-                        luaG_pushstring(L, "%s:%d", _ar.short_src, _ar.currentline);               // L: ... lane "<name>"
+                        luaW_pushstring(L, "%s:%d", _ar.short_src, _ar.currentline);               // L: ... lane "<name>"
                     } else {
                         lua_Debug _ar;
                         lua_pushvalue(L, kFuncIdx);                                                // L: ... lane func
                         lua_getinfo(L, ">S", &_ar);                                                // L: ... lane
-                        luaG_pushstring(L, "%s:%d", _ar.short_src, _ar.linedefined);               // L: ... lane "<name>"
+                        luaW_pushstring(L, "%s:%d", _ar.short_src, _ar.linedefined);               // L: ... lane "<name>"
                     }
                     lua_replace(L, _name_idx);                                                     // L: ... lane
-                    _debugName = luaG_tostring(L, _name_idx);
+                    _debugName = luaW_tostring(L, _name_idx);
                 }
                 lane->storeDebugName(_debugName);
             }
@@ -400,21 +425,22 @@ LUAG_FUNC(lane_new)
     // public Lanes API accepts a generic range -3/+3
     // that will be remapped into the platform-specific scheduler priority scheme
     // On some platforms, -3 is equivalent to -2 and +3 to +2
-    int const _priority{
+    auto const [_priority, _native] {
         std::invoke([L = L_]() {
+            NativePrioFlag const _native{ static_cast<bool>(lua_toboolean(L, kPrinIdx)) };
             StackIndex const _prio_idx{ lua_isnoneornil(L, kPrioIdx) ? kIdxNone : kPrioIdx };
-            if (_prio_idx == 0) {
-                return kThreadPrioDefault;
+            if (_prio_idx == kIdxNone) {
+                return std::make_pair(kThreadPrioDefault, _native);
             }
             int const _priority{ static_cast<int>(lua_tointeger(L, _prio_idx)) };
-            if ((_priority < kThreadPrioMin || _priority > kThreadPrioMax)) {
+            if (!_native && (_priority < kThreadPrioMin || _priority > kThreadPrioMax)) {
                 raise_luaL_error(L, "Priority out of range: %d..+%d (%d)", kThreadPrioMin, kThreadPrioMax, _priority);
             }
-            return _priority;
+            return std::make_pair(_priority, _native);
         })
     };
 
-    _lane->startThread(_priority);
+    _lane->startThread(L_, _priority, _native);
 
     STACK_GROW(_L2, _nargs + 3);
     STACK_GROW(L_, 3);
@@ -439,17 +465,17 @@ LUAG_FUNC(lane_new)
         DEBUGSPEW_CODE(DebugSpew(_U) << "lane_new: process 'required' list" << std::endl);
         DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ _U });
         // should not happen, was checked in lanes.lua before calling lane_new()
-        if (luaG_type(L_, _required_idx) != LuaType::TABLE) {
+        if (luaW_type(L_, _required_idx) != LuaType::TABLE) {
             raise_luaL_error(L_, "expected required module list as a table, got %s", luaL_typename(L_, _required_idx));
         }
 
         lua_pushnil(L_);                                                                           // L_: [fixed] args... nil                        L2:
         while (lua_next(L_, _required_idx) != 0) {                                                 // L_: [fixed] args... n "modname"                L2:
-            if (luaG_type(L_, kIdxTop) != LuaType::STRING || luaG_type(L_, StackIndex{ -2 }) != LuaType::NUMBER || lua_tonumber(L_, -2) != _nbRequired) {
+            if (luaW_type(L_, kIdxTop) != LuaType::STRING || luaW_type(L_, StackIndex{ -2 }) != LuaType::NUMBER || lua_tonumber(L_, -2) != _nbRequired) {
                 raise_luaL_error(L_, "required module list should be a list of strings");
             } else {
                 // require the module in the target state, and populate the lookup table there too
-                std::string_view const _name{ luaG_tostring(L_, kIdxTop) };
+                std::string_view const _name{ luaW_tostring(L_, kIdxTop) };
                 DEBUGSPEW_CODE(DebugSpew(_U) << "lane_new: require '" << _name << "'" << std::endl);
 
                 // require the module in the target lane
@@ -458,7 +484,7 @@ LUAG_FUNC(lane_new)
                     lua_pop(_L2, 1);                                                               // L_: [fixed] args... n "modname"                L2:
                     raise_luaL_error(L_, "cannot pre-require modules without loading 'package' library first");
                 } else {
-                    luaG_pushstring(_L2, _name);                                                   // L_: [fixed] args... n "modname"                L2: require() name
+                    luaW_pushstring(_L2, _name);                                                   // L_: [fixed] args... n "modname"                L2: require() name
                     LuaError const _rc{ lua_pcall(_L2, 1, 1, 0) };                                 // L_: [fixed] args... n "modname"                L2: ret/errcode
                     if (_rc != LuaError::OK) {
                         // propagate error to main state if any
@@ -493,7 +519,7 @@ LUAG_FUNC(lane_new)
         lua_pushnil(L_);                                                                           // L_: [fixed] args... nil                        L2:
         // Lua 5.2 wants us to push the globals table on the stack
         InterCopyContext _c{ _U, DestState{ _L2 }, SourceState{ L_ }, {}, {}, {}, {}, {} };
-        luaG_pushglobaltable(_L2);                                                                 // L_: [fixed] args... nil                        L2: _G
+        luaW_pushglobaltable(_L2);                                                                 // L_: [fixed] args... nil                        L2: _G
         while (lua_next(L_, _globals_idx)) {                                                       // L_: [fixed] args... k v                        L2: _G
             std::ignore = _c.interCopy(2);                                                         // L_: [fixed] args... k v                        L2: _G k v
             // assign it in L2's globals table
@@ -507,7 +533,7 @@ LUAG_FUNC(lane_new)
 
     // Lane main function
     [[maybe_unused]] int const _errorHandlerCount{ _lane->pushErrorHandler() };                    // L_: [fixed] args...                            L2: eh?
-    LuaType const _func_type{ luaG_type(L_, kFuncIdx) };
+    LuaType const _func_type{ luaW_type(L_, kFuncIdx) };
     if (_func_type == LuaType::FUNCTION) {
         DEBUGSPEW_CODE(DebugSpew(_U) << "lane_new: transfer lane body" << std::endl);
         DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ _U });
@@ -524,7 +550,7 @@ LUAG_FUNC(lane_new)
             raise_luaL_error(L_, "error when parsing lane function code");
         }
     } else {
-        raise_luaL_error(L_, "Expected function, got %s", luaG_typename(L_, _func_type).data());
+        raise_luaL_error(L_, "Expected function, got %s", luaW_typename(L_, _func_type).data());
     }
     STACK_CHECK(L_, 0);
     STACK_CHECK(_L2, _errorHandlerCount + 1);
@@ -612,7 +638,7 @@ LUAG_FUNC(wakeup_conv)
 
     STACK_CHECK_START_REL(L_, 0);
     auto _readInteger = [L = L_](std::string_view const& name_) {
-        std::ignore = luaG_getfield(L, StackIndex{ 1 }, name_);
+        std::ignore = luaW_getfield(L, StackIndex{ 1 }, name_);
         lua_Integer const val{ lua_tointeger(L, -1) };
         lua_pop(L, 1);
         return static_cast<int>(val);
@@ -628,7 +654,7 @@ LUAG_FUNC(wakeup_conv)
     // If Lua table has '.isdst' we trust that. If it does not, we'll let
     // 'mktime' decide on whether the time is within DST or not (value -1).
     //
-    int const _isdst{ (luaG_getfield(L_, StackIndex{ 1 }, "isdst") == LuaType::BOOLEAN) ? lua_toboolean(L_, -1) : -1 };
+    int const _isdst{ (luaW_getfield(L_, StackIndex{ 1 }, "isdst") == LuaType::BOOLEAN) ? lua_toboolean(L_, -1) : -1 };
     lua_pop(L_, 1);
     STACK_CHECK(L_, 0);
 
@@ -658,6 +684,7 @@ namespace {
             { Universe::kFinally, Universe::InitializeFinalizer },
             { "linda", LG_linda },
             { "nameof", LG_nameof },
+            { "thread_priority_range", LG_thread_priority_range },
             { "now_secs", LG_now_secs },
             { "register", lanes_register },
             { "set_singlethreaded", LG_set_singlethreaded },
@@ -692,8 +719,8 @@ LUAG_FUNC(configure)
 
     Universe* _U{ Universe::Get(L_) };
     bool const _from_master_state{ _U == nullptr };
-    std::string_view const _name{ luaG_checkstring(L_, StackIndex{ lua_upvalueindex(1) }) };
-    LUA_ASSERT(L_, luaG_type(L_, StackIndex{ 1 }) == LuaType::TABLE);
+    std::string_view const _name{ luaW_checkstring(L_, StackIndex{ lua_upvalueindex(1) }) };
+    LUA_ASSERT(L_, luaW_type(L_, StackIndex{ 1 }) == LuaType::TABLE);
 
     STACK_GROW(L_, 4);
     STACK_CHECK_START_ABS(L_, 1);                                                                  // L_: settings
@@ -703,7 +730,7 @@ LUAG_FUNC(configure)
 
     if (_U == nullptr) {
         // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
-        kLaneNameRegKey.setValue(L_, [](lua_State* L_) { luaG_pushstring(L_, "main"); });
+        kLaneNameRegKey.setValue(L_, [](lua_State* L_) { luaW_pushstring(L_, "main"); });
 
         // create the universe
         _U = Universe::Create(L_);                                                                 // L_: settings universe
@@ -719,7 +746,7 @@ LUAG_FUNC(configure)
     lua_pushnil(L_);                                                                               // L_: settings M nil
     lua_setfield(L_, -2, "configure");                                                             // L_: settings M
     // add functions to the module's table
-    luaG_registerlibfuncs(L_, local::sLanesFunctions);
+    luaW_registerlibfuncs(L_, local::sLanesFunctions);
 
     // register core.threads() only if settings say it should be available
     if (_U->tracker.isActive()) {
@@ -744,7 +771,7 @@ LUAG_FUNC(configure)
     lua_pushcclosure(L_, LG_require, 1);                                                           // L_: settings M lanes.require
     lua_setfield(L_, -2, "require");                                                               // L_: settings M
 
-    luaG_pushstring(
+    luaW_pushstring(
         L_,
         "%d.%d.%d",
         LANES_VERSION_MAJOR,
@@ -753,9 +780,6 @@ LUAG_FUNC(configure)
     );                                                                                             // L_: settings M VERSION
     lua_setfield(L_, -2, "version");                                                               // L_: settings M
 
-    lua_pushinteger(L_, kThreadPrioMax);                                                           // L_: settings M kThreadPrioMax
-    lua_setfield(L_, -2, "max_prio");                                                              // L_: settings M
-
     kCancelError.pushKey(L_);                                                                      // L_: settings M kCancelError
     lua_setfield(L_, -2, "cancel_error");                                                          // L_: settings M
 
@@ -779,7 +803,7 @@ LUAG_FUNC(configure)
         // don't do this when called during the initialization of a new lane,
         // because we will do it after on_state_create() is called,
         // and we don't want to skip _G because of caching in case globals are created then
-        luaG_pushglobaltable(L_);                                                                  // L_: settings M _G
+        luaW_pushglobaltable(L_);                                                                  // L_: settings M _G
         tools::PopulateFuncLookupTable(L_, kIdxTop, {});
         lua_pop(L_, 1);                                                                            // L_: settings M
     }
@@ -859,10 +883,10 @@ LANES_API int luaopen_lanes_core(lua_State* const L_)
 
     // Prevent PUC-Lua/LuaJIT mismatch. Hopefully this works for MoonJIT too
     if constexpr (LUAJIT_FLAVOR() == 0) {
-        if (luaG_getmodule(L_, LUA_JITLIBNAME) != LuaType::NIL)
+        if (luaW_getmodule(L_, LUA_JITLIBNAME) != LuaType::NIL)
             raise_luaL_error(L_, "Lanes is built for PUC-Lua, don't run from LuaJIT");
     } else {
-        if (luaG_getmodule(L_, LUA_JITLIBNAME) == LuaType::NIL)
+        if (luaW_getmodule(L_, LUA_JITLIBNAME) == LuaType::NIL)
             raise_luaL_error(L_, "Lanes is built for LuaJIT, don't run from PUC-Lua");
     }
     lua_pop(L_, 1);                                                                                // L_: