1 files changed, 18 insertions, 15 deletions

diff --git a/src/tools.cpp b/src/tools.cpp
index ba0785b..5f12995 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -129,7 +129,7 @@ static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA(Universe* U_) lua_State* L
     // slot 2 contains a table that, when concatenated, produces the fully qualified name of scanned elements in the table provided at slot _i
     int const _fqn{ ctxBase_ + 1 };
 
-    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "update_lookup_entry()\n" INDENT_END(U_)));
+    DEBUGSPEW_CODE(DebugSpew(U_) << "update_lookup_entry()" << std::endl);
     DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ U_ });
 
     STACK_CHECK_START_REL(L_, 0);
@@ -154,7 +154,7 @@ static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA(Universe* U_) lua_State* L
     // Therefore, when we encounter an object for which a name was previously registered, we need to select the names
     // 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() || lua_lessthan(L_, -2, -1))) {
-        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "%s '%s' remained named '%s'\n" INDENT_END(U_), lua_typename(L_, lua_type(L_, -3)), _newName.data(), _prevName.data()));
+        DEBUGSPEW_CODE(DebugSpew(U_) << lua_typename(L_, lua_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 {
@@ -168,7 +168,7 @@ static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA(Universe* U_) lua_State* L
         } else {
             lua_remove(L_, -2);                                                                    // L_: ... {bfc} k o "f.q.n"
         }
-        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "%s '%s'\n" INDENT_END(U_), lua_typename(L_, lua_type(L_, -2)), _newName.data()));
+        DEBUGSPEW_CODE(DebugSpew(U_) << lua_typename(L_, lua_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
@@ -195,7 +195,7 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U_)
     int const _fqn{ dbIdx_ + 1 };
     // slot dbIdx_ + 2 contains a cache that stores all already visited tables to avoid infinite recursion loops
     int const _cache{ dbIdx_ + 2 };
-    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "populate_func_lookup_table_recur()\n" INDENT_END(U_)));
+    DEBUGSPEW_CODE(DebugSpew(U_) << "populate_func_lookup_table_recur()" << std::endl);
     DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ U_ });
 
     STACK_GROW(L_, 6);
@@ -215,7 +215,7 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U_)
     lua_pop(L_, 1);                                                                                // L_: ... {i_}
     STACK_CHECK(L_, 0);
     if (_visit_count > 0) {
-        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "already visited\n" INDENT_END(U_)));
+        DEBUGSPEW_CODE(DebugSpew(U_) << "already visited" << std::endl);
         return;
     }
 
@@ -262,8 +262,8 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U_)
     ++depth_;
     lua_pushnil(L_);                                                                               // L_: ... {i_} {bfc} nil
     while (lua_next(L_, breadthFirstCache) != 0) {                                                 // L_: ... {i_} {bfc} k {}
-        DEBUGSPEW_CODE(char const* _key = (lua_type(L_, -2) == LUA_TSTRING) ? lua_tostring(L_, -2) : "not a string");
-        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "table '%s'\n" INDENT_END(U_), _key));
+        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(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 {} {}
@@ -298,11 +298,12 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U_)
 // #################################################################################################
 
 // create a "fully.qualified.name" <-> function equivalence database
-void populate_func_lookup_table(lua_State* L_, int i_, char const* name_)
+void populate_func_lookup_table(lua_State* const L_, int const i_, std::string_view const& name_)
 {
     int const _in_base = lua_absindex(L_, i_);
     DEBUGSPEW_CODE(Universe* _U = universe_get(L_));
-    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END(_U), L_, name_ ? name_ : "nullptr"));
+    std::string_view _name{ name_.empty() ? std::string_view{} : name_ };
+    DEBUGSPEW_CODE(DebugSpew(_U) << L_ << ": populate_func_lookup_table('" << _name << "')" << std::endl);
     DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ _U });
     STACK_GROW(L_, 3);
     STACK_CHECK_START_REL(L_, 0);
@@ -311,20 +312,22 @@ void populate_func_lookup_table(lua_State* L_, int i_, char const* name_)
     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
-        name_ = name_ ? name_ : "nullptr";
+        if (_name.empty()) {
+            _name = "nullptr";
+        }
         lua_pushvalue(L_, _in_base);                                                               // L_: {} f
-        lua_pushstring(L_, name_);                                                                 // L_: {} f _name
+        std::ignore = lua_pushstringview(L_, _name);                                               // L_: {} f name_
         lua_rawset(L_, -3);                                                                        // L_: {}
-        lua_pushstring(L_, name_);                                                                 // L_: {} _name
-        lua_pushvalue(L_, _in_base);                                                               // L_: {} _name f
+        std::ignore = lua_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) {
         lua_newtable(L_);                                                                          // L_: {} {fqn}
         int _startDepth{ 0 };
-        if (name_) {
+        if (!_name.empty()) {
             STACK_CHECK(L_, 2);
-            lua_pushstring(L_, name_);                                                             // L_: {} {fqn} "name"
+            std::ignore = lua_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(DEBUGSPEW_PARAM_COMMA(_U) L_, _dbIdx, _startDepth);                // L_: {} {fqn} "name"