1 files changed, 8 insertions, 9 deletions

diff --git a/src/state.cpp b/src/state.cpp
index 7585132..77e1fd9 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -31,6 +31,7 @@ THE SOFTWARE.
 ===============================================================================
 */
 
+#include "_pch.h"
 #include "state.h"
 
 #include "intercopycontext.h"
@@ -39,8 +40,6 @@ THE SOFTWARE.
 #include "tools.h"
 #include "universe.h"
 
-#include <source_location>
-
 // #################################################################################################
 
 static constexpr char const* kOnStateCreate{ "on_state_create" }; // update lanes.lua if the name changes!
@@ -184,9 +183,9 @@ namespace state {
         STACK_CHECK(L_, 1);
         // capture error and raise it in caller state
         std::string_view const _stateType{ mode_ == LookupMode::LaneBody ? "lane" : "keeper" };
-        std::ignore = lua_pushstringview(L_, _stateType);                                          // L_: on_state_create() "<type>"
+        std::ignore = 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, lua_isstring(L_, -1) ? lua_tostring(L_, -1) : lua_typename(L_, lua_type(L_, -1)));
+            raise_luaL_error(from_, "%s failed: \"%s\"", kOnStateCreate, lua_isstring(L_, -1) ? lua_tostring(L_, -1) : luaG_typename(L_, luaG_type(L_, -1)));
         }
         STACK_CHECK(L_, 0);
     }
@@ -205,7 +204,7 @@ namespace state {
                         if (U->provideAllocator != nullptr) { // we have a function we can call to obtain an allocator
                             lua_pushcclosure(from, U->provideAllocator, 0);
                             lua_call(from, 0, 1);
-                            AllocatorDefinition* const _def{ lua_tofulluserdata<AllocatorDefinition>(from, -1) };
+                            AllocatorDefinition* const _def{ luaG_tofulluserdata<AllocatorDefinition>(from, -1) };
                             lua_State* const _L{ lua_newstate(_def->allocF, _def->allocUD) };
                             lua_pop(from, 1);
                             return _L;
@@ -353,7 +352,7 @@ namespace state {
 
         STACK_CHECK(_L, 0);
         // after all this, register everything we find in our name<->function database
-        lua_pushglobaltable(_L);                                                                   // L: _G
+        luaG_pushglobaltable(_L);                                                                  // L: _G
         tools::PopulateFuncLookupTable(_L, -1, {});
         lua_pop(_L, 1);                                                                            // L:
         STACK_CHECK(_L, 0);
@@ -365,19 +364,19 @@ namespace state {
             kLookupRegKey.pushValue(_L);                                                           // L: {}
             lua_pushnil(_L);                                                                       // L: {} nil
             while (lua_next(_L, -2)) {                                                             // L: {} k v
-                std::ignore = lua_pushstringview(_L, "[");                                         // L: {} k v "["
+                std::ignore = luaG_pushstring(_L, "[");                                            // L: {} k v "["
 
                 lua_getglobal(_L, "tostring");                                                     // L: {} k v "[" tostring
                 lua_pushvalue(_L, -4);                                                             // L: {} k v "[" tostring k
                 lua_call(_L, 1, 1);                                                                // L: {} k v "[" 'k'
 
-                std::ignore = lua_pushstringview(_L, "] = ");                                      // L: {} k v "[" 'k' "] = "
+                std::ignore = luaG_pushstring(_L, "] = ");                                         // L: {} k v "[" 'k' "] = "
 
                 lua_getglobal(_L, "tostring");                                                     // L: {} k v "[" 'k' "] = " tostring
                 lua_pushvalue(_L, -5);                                                             // L: {} k v "[" 'k' "] = " tostring v
                 lua_call(_L, 1, 1);                                                                // L: {} k v "[" 'k' "] = " 'v'
                 lua_concat(_L, 4);                                                                 // L: {} k v "[k] = v"
-                DEBUGSPEW_CODE(DebugSpew(U_) << lua_tostringview(_L, -1) << std::endl);
+                DEBUGSPEW_CODE(DebugSpew(U_) << luaG_tostring(_L, -1) << std::endl);
                 lua_pop(_L, 2);                                                                    // L: {} k
             } // lua_next()                                                                        // L: {}
             lua_pop(_L, 1);                                                                        // L: