1 files changed, 78 insertions, 1 deletions

diff --git a/src/universe.cpp b/src/universe.cpp
index 097c642..b63008a 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -41,6 +41,10 @@ extern LUAG_FUNC(linda);
 
 // #################################################################################################
 
+static constexpr std::string_view kOnStateCreate{ "on_state_create" }; // update lanes.lua if the name changes!
+
+// #################################################################################################
+
 // xxh64 of string "kUniverseFullRegKey" generated at https://www.pelock.com/products/hash-calculator
 static constexpr RegistryUniqueKey kUniverseFullRegKey{ 0x1C2D76870DD9DD9Full };
 
@@ -74,6 +78,48 @@ Universe::Universe()
 
 // #################################################################################################
 
+void Universe::callOnStateCreate(lua_State* const L_, lua_State* const from_, LookupMode const mode_)
+{
+    if (std::holds_alternative<std::nullptr_t>(onStateCreateFunc)) {
+        return;
+    }
+
+    STACK_CHECK_START_REL(L_, 0);
+    DEBUGSPEW_CODE(DebugSpew(U_) << "calling on_state_create()" << std::endl);
+    if (std::holds_alternative<lua_CFunction>(onStateCreateFunc)) {
+            
+        // C function: recreate a closure in the new state, bypassing the lookup scheme
+        lua_pushcfunction(L_, std::get<lua_CFunction>(onStateCreateFunc));                         // on_state_create()
+    } else { // Lua function located in the config table, copied when we opened "lanes.core"
+        LUA_ASSERT(from_, std::holds_alternative<uintptr_t>(onStateCreateFunc));
+        if (mode_ != LookupMode::LaneBody) {
+            // if attempting to call in a keeper state, do nothing because the function doesn't exist there
+            // this doesn't count as an error though
+            STACK_CHECK(L_, 0);
+            return;
+        }
+        kConfigRegKey.pushValue(L_);                                                               // L_: config
+        STACK_CHECK(L_, 1);
+        LuaType const _funcType{ luaG_getfield(L_, -1, kOnStateCreate) };                          // L_: config on_state_create()
+        if (_funcType != LuaType::FUNCTION) {
+            raise_luaL_error(L_, "INTERNAL ERROR: %s is a %s, not a function", kOnStateCreate.data(), luaG_typename(L_, _funcType).data());
+        }
+        lua_remove(L_, -2);                                                                        // L_: on_state_create()
+    }
+    STACK_CHECK(L_, 1);
+    // capture error and raise it in caller state
+    std::string_view const _stateType{ mode_ == LookupMode::LaneBody ? "lane" : "keeper" };
+    luaG_pushstring(L_, _stateType);                                                               // L_: on_state_create() "<type>"
+    if (lua_pcall(L_, 1, 0, 0) != LUA_OK) {
+        raise_luaL_error(from_, "%s failed: \"%s\"", kOnStateCreate.data(), lua_isstring(L_, -1) ? luaG_tostring(L_, -1).data() : luaG_typename(L_, -1).data());
+    }
+    STACK_CHECK(L_, 0);
+}
+
+
+
+// #################################################################################################
+
 // only called from the master state
 [[nodiscard]] Universe* Universe::Create(lua_State* const L_)
 {
@@ -125,7 +171,7 @@ Universe::Universe()
     // Linked chains handling
     _U->selfdestructFirst = SELFDESTRUCT_END;
     _U->initializeAllocatorFunction(L_);
-    state::InitializeOnStateCreate(_U, L_);
+    _U->initializeOnStateCreate(L_);
     _U->keepers.initialize(*_U, L_, _nbUserKeepers, _keepers_gc_threshold);
     STACK_CHECK(L_, 0);
 
@@ -252,6 +298,37 @@ int Universe::InitializeFinalizer(lua_State* const L_)
 
 // #################################################################################################
 
+void Universe::initializeOnStateCreate(lua_State* const L_)
+{
+    STACK_CHECK_START_REL(L_, 1);                                                                  // L_: settings
+    if (luaG_getfield(L_, -1, kOnStateCreate) != LuaType::NIL) {                                   // L_: settings on_state_create|nil
+        LUA_ASSERT(L_, luaG_type(L_, -1) == LuaType::FUNCTION); // ensured by lanes.lua parameter validation
+        // make sure the function doesn't have upvalues
+        char const* _upname{ lua_getupvalue(L_, -1, 1) };                                          // L_: settings on_state_create upval?
+        if (_upname != nullptr) { // should be "" for C functions with upvalues if any
+            raise_luaL_error(L_, "%s with upvalues are forbidden", kOnStateCreate.data());
+        }
+        // store C function pointer in an internal variable
+        lua_CFunction const _func{ lua_tocfunction(L_, -1) };                                      // L_: settings on_state_create
+        if (_func) {
+            onStateCreateFunc.emplace<lua_CFunction>(_func);
+            // remove this C function from the config table so that it doesn't cause problems
+            // when we transfer the config table in newly created Lua states
+            lua_pushnil(L_);                                                                       // L_: settings on_state_create nil
+            luaG_setfield(L_, -3, kOnStateCreate);                                                 // L_: settings on_state_create
+        } else {
+            // the function is still in the config table
+            onStateCreateFunc.emplace<uintptr_t>(std::bit_cast<uintptr_t>(kOnStateCreate.data()));
+        }
+    } else {
+        LUA_ASSERT(L_, std::holds_alternative<std::nullptr_t>(onStateCreateFunc));
+    };
+    lua_pop(L_, 1);                                                                                // L_: settings
+    STACK_CHECK(L_, 1);
+}
+
+// #################################################################################################
+
 lanes::AllocatorDefinition Universe::resolveAllocator(lua_State* const L_, std::string_view const& hint_) const
 {
     lanes::AllocatorDefinition _ret{ protectedAllocator };