1 files changed, 17 insertions, 17 deletions

diff --git a/src/tools.cpp b/src/tools.cpp
index e7d1775..302a0df 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -78,7 +78,7 @@ static constexpr int kWriterReturnCode{ 666 };
         // the provided writer fails with code kWriterReturnCode
         // therefore, anytime we get kWriterReturnCode, this means that lua_dump() attempted a dump
         // all other cases mean this is either a C or LuaJIT-fast function
-        int const _dumpres{ lua504_dump(L_, dummy_writer, nullptr, 0) };
+        int const _dumpres{ luaG_dump(L_, dummy_writer, nullptr, 0) };
         lua_pop(L_, _mustpush);
         if (_dumpres == kWriterReturnCode) {
             return FuncSubType::Bytecode;
@@ -111,7 +111,7 @@ namespace tools {
         // &b is popped at that point (-> replaced by the result)
         luaL_pushresult(&_b);                                                                      // L_: ... {} ... "<result>"
         STACK_CHECK(L_, 1);
-        return lua_tostringview(L_, -1);
+        return luaG_tostringview(L_, -1);
     }
 
 } // namespace tools
@@ -141,10 +141,10 @@ static void update_lookup_entry(lua_State* L_, int ctxBase_, int depth_)
     // first, raise an error if the function is already known
     lua_pushvalue(L_, -1);                                                                         // L_: ... {bfc} k o o
     lua_rawget(L_, _dest);                                                                         // L_: ... {bfc} k o name?
-    std::string_view const _prevName{ lua_tostringview(L_, -1) }; // nullptr if we got nil (first encounter of this object)
+    std::string_view const _prevName{ luaG_tostringview(L_, -1) }; // nullptr if we got nil (first encounter of this object)
     // push name in fqn stack (note that concatenation will crash if name is a not string or a number)
     lua_pushvalue(L_, -3);                                                                         // L_: ... {bfc} k o name? k
-    LUA_ASSERT(L_, lua_type(L_, -1) == LUA_TNUMBER || lua_type(L_, -1) == LUA_TSTRING);
+    LUA_ASSERT(L_, luaG_type(L_, -1) == LuaType::NUMBER || luaG_type(L_, -1) == LuaType::STRING);
     ++depth_;
     lua_rawseti(L_, _fqn, depth_);                                                                 // L_: ... {bfc} k o name?
     // generate name
@@ -157,7 +157,7 @@ static void update_lookup_entry(lua_State* L_, int ctxBase_, int depth_)
     // Therefore, when we encounter an object for which a name was previously registered, we need to select the a single name
     // based on some sorting order so that we end up with the same name in all databases whatever order the table walk yielded
     if (!_prevName.empty() && ((_prevName.size() < _newName.size()) || (_prevName <= _newName))) {
-        DEBUGSPEW_CODE(DebugSpew(_U) << lua_typename(L_, lua_type(L_, -3)) << " '" << _newName << "' remains named '" << _prevName << "'" << std::endl);
+        DEBUGSPEW_CODE(DebugSpew(_U) << luaG_typename(L_, luaG_type(L_, -3)) << " '" << _newName << "' remains named '" << _prevName << "'" << std::endl);
         // the previous name is 'smaller' than the one we just generated: keep it!
         lua_pop(L_, 3);                                                                            // L_: ... {bfc} k
     } else {
@@ -171,7 +171,7 @@ static void update_lookup_entry(lua_State* L_, int ctxBase_, int depth_)
         } else {
             lua_remove(L_, -2);                                                                    // L_: ... {bfc} k o "f.q.n"
         }
-        DEBUGSPEW_CODE(DebugSpew(_U) << lua_typename(L_, lua_type(L_, -2)) << " '" << _newName << "'" << std::endl);
+        DEBUGSPEW_CODE(DebugSpew(_U) << luaG_typename(L_, luaG_type(L_, -2)) << " '" << _newName << "'" << std::endl);
         // prepare the stack for database feed
         lua_pushvalue(L_, -1);                                                                     // L_: ... {bfc} k o "f.q.n" "f.q.n"
         lua_pushvalue(L_, -3);                                                                     // L_: ... {bfc} k o "f.q.n" "f.q.n" o
@@ -207,7 +207,7 @@ static void populate_func_lookup_table_recur(lua_State* L_, int dbIdx_, int i_,
     STACK_CHECK_START_REL(L_, 0);                                                                  // L_: ... {i_}
 
     // if object is a userdata, replace it by its metatable
-    if (lua_type(L_, i_) == LUA_TUSERDATA) {
+    if (luaG_type(L_, i_) == LuaType::USERDATA) {
         lua_getmetatable(L_, i_);                                                                  // L_: ... {i_} mt
         lua_replace(L_, i_);                                                                       // L_: ... {i_}
     }
@@ -236,7 +236,7 @@ static void populate_func_lookup_table_recur(lua_State* L_, int dbIdx_, int i_,
     lua_pushnil(L_);                                                                               // L_: ... {i_} {bfc} nil
     while (lua_next(L_, i_) != 0) {                                                                // L_: ... {i_} {bfc} k v
         // just for debug, not actually needed
-        // std::string_view const _key{ (lua_type(L_, -2) == LUA_TSTRING) ? lua_tostringview(L_, -2) : "not a string" };
+        // std::string_view const _key{ (luaG_type(L_, -2) == LuaType::STRING) ? luaG_tostringview(L_, -2) : "not a string" };
         // subtable: process it recursively
         if (lua_istable(L_, -1)) {                                                                 // L_: ... {i_} {bfc} k {}
             // increment visit count to make sure we will actually scan it at this recursive level
@@ -266,13 +266,13 @@ static void populate_func_lookup_table_recur(lua_State* L_, int dbIdx_, int i_,
     ++depth_;
     lua_pushnil(L_);                                                                               // L_: ... {i_} {bfc} nil
     while (lua_next(L_, breadthFirstCache) != 0) {                                                 // L_: ... {i_} {bfc} k {}
-        DEBUGSPEW_CODE(std::string_view const _key{ (lua_type(L_, -2) == LUA_TSTRING) ? lua_tostringview(L_, -2) : std::string_view{ "<not a string>" } });
+        DEBUGSPEW_CODE(std::string_view const _key{ (luaG_type(L_, -2) == LuaType::STRING) ? luaG_tostringview(L_, -2) : std::string_view{ "<not a string>" } });
         DEBUGSPEW_CODE(DebugSpew(_U) << "table '"<< _key <<"'" << std::endl);
         DEBUGSPEW_CODE(DebugSpewIndentScope _scope2{ _U });
         // un-visit this table in case we do need to process it
         lua_pushvalue(L_, -1);                                                                     // L_: ... {i_} {bfc} k {} {}
         lua_rawget(L_, _cache);                                                                    // L_: ... {i_} {bfc} k {} n
-        LUA_ASSERT(L_, lua_type(L_, -1) == LUA_TNUMBER);
+        LUA_ASSERT(L_, luaG_type(L_, -1) == LuaType::NUMBER);
         _visit_count = lua_tointeger(L_, -1) - 1;
         lua_pop(L_, 1);                                                                            // L_: ... {i_} {bfc} k {}
         lua_pushvalue(L_, -1);                                                                     // L_: ... {i_} {bfc} k {} {}
@@ -317,23 +317,23 @@ namespace tools {
         int const _dbIdx{ lua_gettop(L_) };
         STACK_CHECK(L_, 1);
         LUA_ASSERT(L_, lua_istable(L_, -1));
-        if (lua_type(L_, _in_base) == LUA_TFUNCTION) { // for example when a module is a simple function
+        if (luaG_type(L_, _in_base) == LuaType::FUNCTION) { // for example when a module is a simple function
             if (_name.empty()) {
                 _name = "nullptr";
             }
             lua_pushvalue(L_, _in_base);                                                           // L_: {} f
-            std::ignore = lua_pushstringview(L_, _name);                                           // L_: {} f name_
+            std::ignore = luaG_pushstringview(L_, _name);                                          // L_: {} f name_
             lua_rawset(L_, -3);                                                                    // L_: {}
-            std::ignore = lua_pushstringview(L_, _name);                                           // L_: {} name_
+            std::ignore = luaG_pushstringview(L_, _name);                                          // L_: {} name_
             lua_pushvalue(L_, _in_base);                                                           // L_: {} name_ f
             lua_rawset(L_, -3);                                                                    // L_: {}
             lua_pop(L_, 1);                                                                        // L_:
-        } else if (lua_type(L_, _in_base) == LUA_TTABLE) {
+        } else if (luaG_type(L_, _in_base) == LuaType::TABLE) {
             lua_newtable(L_);                                                                      // L_: {} {fqn}
             int _startDepth{ 0 };
             if (!_name.empty()) {
                 STACK_CHECK(L_, 2);
-                std::ignore = lua_pushstringview(L_, _name);                                       // L_: {} {fqn} "name"
+                std::ignore = luaG_pushstringview(L_, _name);                                      // L_: {} {fqn} "name"
                 // generate a name, and if we already had one name, keep whichever is the shorter
                 lua_pushvalue(L_, _in_base);                                                       // L_: {} {fqn} "name" t
                 update_lookup_entry(L_, _dbIdx, _startDepth);                                      // L_: {} {fqn} "name"
@@ -348,7 +348,7 @@ namespace tools {
             lua_pop(L_, 3);                                                                        // L_:
         } else {
             lua_pop(L_, 1);                                                                        // L_:
-            raise_luaL_error(L_, "unsupported module type %s", lua_typename(L_, lua_type(L_, _in_base)));
+            raise_luaL_error(L_, "unsupported module type %s", luaG_typename(L_, luaG_type(L_, _in_base)));
         }
         STACK_CHECK(L_, 0);
     }
@@ -366,7 +366,7 @@ namespace tools {
             +[](lua_State* L_)
             {
                 int const _args{ lua_gettop(L_) };                                                 // L_: args...
-                //[[maybe_unused]] std::string_view const _modname{ luaL_checkstringview(L_, 1) };
+                //[[maybe_unused]] std::string_view const _modname{ luaG_checkstringview(L_, 1) };
 
                 STACK_GROW(L_, 1);