6 files changed, 64 insertions, 71 deletions

diff --git a/src/lanes.cpp b/src/lanes.cpp
index bd5f69e..a82e4ba 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -684,7 +684,7 @@ LUAG_FUNC(configure)
     STACK_CHECK(L_, 1);
 
     // Serialize calls to 'require' from now on, also in the primary state
-    serialize_require(L_);
+    tools::SerializeRequire(L_);
 
     // Retrieve main module interface table
     lua_pushvalue(L_, lua_upvalueindex(2));                                                        // L_: settings M
diff --git a/src/state.cpp b/src/state.cpp
index d9f5499..8520346 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -43,72 +43,6 @@ THE SOFTWARE.
 
 // #################################################################################################
 
-/*---=== Serialize require ===---
- */
-
-//---
-// [val,...]= new_require( ... )
-//
-// Call 'old_require' but only one lane at a time.
-//
-// Upvalues: [1]: original 'require' function
-//
-[[nodiscard]] static int luaG_new_require(lua_State* L_)
-{
-    int const _args{ lua_gettop(L_) };                                                             // L_: args
-    Universe* const _U{ universe_get(L_) };
-    //[[maybe_unused]] std::string_view const _modname{ luaL_checkstringview(L_, 1) };
-
-    STACK_GROW(L_, 1);
-
-    lua_pushvalue(L_, lua_upvalueindex(1));                                                        // L_: args require
-    lua_insert(L_, 1);                                                                             // L_: require args
-
-    // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
-    // leave us locked, blocking any future 'require' calls from other lanes.
-
-    _U->requireMutex.lock();
-    // starting with Lua 5.4, require may return a second optional value, so we need LUA_MULTRET
-    LuaError const _rc{ lua_pcall(L_, _args, LUA_MULTRET, 0 /*errfunc*/) };                        // L_: err|result(s)
-    _U->requireMutex.unlock();
-
-    // the required module (or an error message) is left on the stack as returned value by original require function
-
-    if (_rc != LuaError::OK) { // LUA_ERRRUN / LUA_ERRMEM ?
-        raise_lua_error(L_);
-    }
-    // should be 1 for Lua <= 5.3, 1 or 2 starting with Lua 5.4
-    return lua_gettop(L_);                                                                         // L_: result(s)
-}
-
-// #################################################################################################
-
-/*
- * Serialize calls to 'require', if it exists
- */
-void serialize_require(lua_State* L_)
-{
-    STACK_GROW(L_, 1);
-    STACK_CHECK_START_REL(L_, 0);
-    DEBUGSPEW_CODE(DebugSpew(universe_get(L_)) << "serializing require()" << std::endl);
-
-    // Check 'require' is there and not already wrapped; if not, do nothing
-    //
-    lua_getglobal(L_, "require");
-    if (lua_isfunction(L_, -1) && lua_tocfunction(L_, -1) != luaG_new_require) {
-        // [-1]: original 'require' function
-        lua_pushcclosure(L_, luaG_new_require, 1 /*upvalues*/);
-        lua_setglobal(L_, "require");
-    } else {
-        // [-1]: nil
-        lua_pop(L_, 1);
-    }
-
-    STACK_CHECK(L_, 0);
-}
-
-// #################################################################################################
-
 /*---=== luaG_newstate ===---*/
 
 [[nodiscard]] static int require_lanes_core(lua_State* L_)
@@ -397,7 +331,7 @@ lua_State* luaG_newstate(Universe* U_, SourceState from_, std::optional<std::str
     }
     lua_gc(_L, LUA_GCRESTART, 0);
 
-    serialize_require(_L);
+    tools::SerializeRequire(_L);
 
     // call this after the base libraries are loaded and GC is restarted
     // will raise an error in from_ in case of problem
diff --git a/src/state.h b/src/state.h
index a97fdab..ff70196 100644
--- a/src/state.h
+++ b/src/state.h
@@ -7,8 +7,6 @@
 enum class LookupMode;
 class Universe;
 
-void serialize_require(lua_State* L_);
-
 // #################################################################################################
 
 [[nodiscard]] lua_State* create_state(Universe* U_, lua_State* from_);
diff --git a/src/tools.cpp b/src/tools.cpp
index 0b10464..d270aac 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -526,3 +526,60 @@ int luaG_nameof(lua_State* L_)
     lua_replace(L_, -3);                                                                           // L_: "type" "result"
     return 2;
 }
+
+// #################################################################################################
+
+namespace tools {
+
+    // Serialize calls to 'require', if it exists
+    void SerializeRequire(lua_State* L_)
+    {
+        static constexpr lua_CFunction _lockedRequire{
+            +[](lua_State* L_)
+            {
+                int const _args{ lua_gettop(L_) };                                                 // L_: args...
+                //[[maybe_unused]] std::string_view const _modname{ luaL_checkstringview(L_, 1) };
+
+                STACK_GROW(L_, 1);
+
+                lua_pushvalue(L_, lua_upvalueindex(1));                                            // L_: args... require
+                lua_insert(L_, 1);                                                                 // L_: require args...
+
+                // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
+                // leave us locked, blocking any future 'require' calls from other lanes.
+                LuaError const _rc{ std::invoke(
+                    [L = L_, args = _args]()
+                    {
+                        std::lock_guard _guard{ universe_get(L)->requireMutex };
+                        // starting with Lua 5.4, require may return a second optional value, so we need LUA_MULTRET
+                        return lua_pcall(L, args, LUA_MULTRET, 0 /*errfunc*/);                     // L_: err|result(s)
+                    })
+                };
+
+                // the required module (or an error message) is left on the stack as returned value by original require function
+
+                if (_rc != LuaError::OK) { // LUA_ERRRUN / LUA_ERRMEM ?
+                    raise_lua_error(L_);
+                }
+                // should be 1 for Lua <= 5.3, 1 or 2 starting with Lua 5.4
+                return lua_gettop(L_);                                                             // L_: result(s)
+            }
+        };
+
+        STACK_GROW(L_, 1);
+        STACK_CHECK_START_REL(L_, 0);
+        DEBUGSPEW_CODE(DebugSpew(universe_get(L_)) << "serializing require()" << std::endl);
+
+        // Check 'require' is there and not already wrapped; if not, do nothing
+        lua_getglobal(L_, "require");                                                              // L_: _G.require()|nil
+        if (lua_isfunction(L_, -1) && lua_tocfunction(L_, -1) != _lockedRequire) {
+            lua_pushcclosure(L_, _lockedRequire, 1 /*upvalues*/);                                  // L_: _lockedRequire()
+            lua_setglobal(L_, "require");                                                          // L_:
+        } else {
+            lua_pop(L_, 1);                                                                        // L_:
+        }
+
+        STACK_CHECK(L_, 0);
+    }
+} // namespace tools
+
diff --git a/src/tools.h b/src/tools.h
index 4857eeb..3659b42 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -26,6 +26,10 @@ enum class FuncSubType
 
 void populate_func_lookup_table(lua_State* const L_, int const i_, std::string_view const& name_);
 
+namespace tools {
+    void SerializeRequire(lua_State* L_);
+} // namespace tools
+
 // #################################################################################################
 
 // xxh64 of string "kConfigRegKey" generated at https://www.pelock.com/products/hash-calculator
diff --git a/src/universe.cpp b/src/universe.cpp
index 620be79..172cc4c 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -287,7 +287,7 @@ void Universe::initializeKeepers(lua_State* L_)
         luaL_requiref(_K, LUA_LOADLIBNAME, luaopen_package, 1);                                    // L_: settings                                    K: package
         lua_pop(_K, 1);                                                                            // L_: settings                                    K:
         STACK_CHECK(_K, 0);
-        serialize_require(_K);
+        tools::SerializeRequire(_K);
         STACK_CHECK(_K, 0);
 
         // copy package.path and package.cpath from the source state