1 files changed, 616 insertions, 603 deletions

diff --git a/src/tools.c b/src/tools.cpp
index c43d8a2..a0a3018 100644
--- a/src/tools.c
+++ b/src/tools.cpp
@@ -31,24 +31,12 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdlib.h>
-#if !defined(__APPLE__)
-#include <malloc.h>
-#endif // __APPLE__
-
 #include "tools.h"
-#include "compat.h"
+
 #include "universe.h"
-#include "keeper.h"
-#include "lanes.h"
-#include "uniquekey.h"
 
 // functions implemented in deep.c
-extern bool_t copydeep( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_);
+extern bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_);
 extern void push_registry_subtable( lua_State* L, UniqueKey key_);
 
 DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!----+----!----+----!----+----!----+----!----+");
@@ -61,32 +49,32 @@ DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!--
  */
 void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode_)
 {
-  STACK_GROW( L, 3);
-  STACK_CHECK( L, 0);
-
-  REGISTRY_GET( L, key_);                               // {}|nil
-  STACK_MID( L, 1);
-
-  if( lua_isnil( L, -1))
-  {
-    lua_pop( L, 1);                                     //
-    lua_newtable( L);                                   // {}
-    // _R[key_] = {}
-    REGISTRY_SET( L, key_, lua_pushvalue( L, -2));      // {}
-    STACK_MID( L, 1);
-
-    // Set its metatable if requested
-    if( mode_)
-    {
-      lua_newtable( L);                                 // {} mt
-      lua_pushliteral( L, "__mode");                    // {} mt "__mode"
-      lua_pushstring( L, mode_);                        // {} mt "__mode" mode
-      lua_rawset( L, -3);                               // {} mt
-      lua_setmetatable( L, -2);                         // {}
-    }
-  }
-  STACK_END( L, 1);
-  ASSERT_L( lua_istable( L, -1));
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
+
+    key_.pushValue(L);                                                    // {}|nil
+    STACK_CHECK(L, 1);
+
+    if (lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);                                                    //
+        lua_newtable(L);                                                  // {}
+        // _R[key_] = {}
+        key_.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });     // {}
+        STACK_CHECK(L, 1);
+
+        // Set its metatable if requested
+        if (mode_)
+        {
+            lua_newtable(L);                                              // {} mt
+            lua_pushliteral(L, "__mode");                                 // {} mt "__mode"
+            lua_pushstring(L, mode_);                                     // {} mt "__mode" mode
+            lua_rawset(L, -3);                                            // {} mt
+            lua_setmetatable(L, -2);                                      // {}
+        }
+    }
+    STACK_CHECK(L, 1);
+    ASSERT_L(lua_istable(L, -1));
 }
 
 // ################################################################################################
@@ -97,7 +85,7 @@ void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode
  */
 void push_registry_subtable( lua_State* L, UniqueKey key_)
 {
-  push_registry_subtable_mode( L, key_, NULL);
+  push_registry_subtable_mode(L, key_, nullptr);
 }
 
 // ################################################################################################
@@ -116,7 +104,7 @@ void luaG_dump( lua_State* L)
 
     for( i = 1; i <= top; ++ i)
     {
-        int type = lua_type( L, i);
+        LuaType type{ lua_type_as_enum(L, i) };
 
         fprintf( stderr, "\t[%d]= (%s) ", i, lua_typename( L, type));
 
@@ -125,7 +113,7 @@ void luaG_dump( lua_State* L)
         // Note: this requires 'tostring()' to be defined. If it is NOT,
         //       enable it for more debugging.
         //
-        STACK_CHECK( L, 0);
+        STACK_CHECK_START_REL(L, 0);
         STACK_GROW( L, 2);
 
         lua_getglobal( L, "tostring");
@@ -146,7 +134,7 @@ void luaG_dump( lua_State* L)
             fprintf( stderr, "%s", lua_tostring( L, -1));
         }
         lua_pop( L, 1);
-        STACK_END( L, 0);
+        STACK_CHECK( L, 0);
         fprintf( stderr, "\n");
     }
     fprintf( stderr, "\n");
@@ -156,122 +144,97 @@ void luaG_dump( lua_State* L)
 // ################################################################################################
 
 // same as PUC-Lua l_alloc
-static void* libc_lua_Alloc(void* ud, void* ptr, size_t osize, size_t nsize)
+extern "C" [[nodiscard]] static void* libc_lua_Alloc([[maybe_unused]] void* ud, [[maybe_unused]] void* ptr_, [[maybe_unused]] size_t osize_, size_t nsize_)
 {
-    (void)ud; (void)osize;  /* not used */
-    if (nsize == 0)
+    if (nsize_ == 0)
     {
-        free(ptr);
-        return NULL;
+        free(ptr_);
+        return nullptr;
     }
     else
     {
-        return realloc(ptr, nsize);
+        return realloc(ptr_, nsize_);
     }
 }
 
-static void* protected_lua_Alloc( void *ud, void *ptr, size_t osize, size_t nsize)
-{
-    void* p;
-    ProtectedAllocator* s = (ProtectedAllocator*) ud;
-    MUTEX_LOCK( &s->lock);
-    p = s->definition.allocF( s->definition.allocUD, ptr, osize, nsize);
-    MUTEX_UNLOCK( &s->lock);
-    return p;
-}
+// #################################################################################################
 
-static int luaG_provide_protected_allocator( lua_State* L)
+[[nodiscard]] static int luaG_provide_protected_allocator(lua_State* L)
 {
-    Universe* U = universe_get( L);
-    AllocatorDefinition* const def = lua_newuserdatauv( L, sizeof(AllocatorDefinition), 0);
-    def->allocF = protected_lua_Alloc;
-    def->allocUD = &U->protected_allocator;
+    Universe* const U{ universe_get(L) };
+    // push a new full userdata on the stack, giving access to the universe's protected allocator
+    [[maybe_unused]] AllocatorDefinition* const def{ new (L) AllocatorDefinition{ U->protected_allocator.makeDefinition() } };
     return 1;
 }
 
+// #################################################################################################
+
 // called once at the creation of the universe (therefore L is the master Lua state everything originates from)
 // Do I need to disable this when compiling for LuaJIT to prevent issues?
-void initialize_allocator_function( Universe* U, lua_State* L)
+void initialize_allocator_function(Universe* U, lua_State* L)
 {
-    STACK_CHECK( L, 0);
-    lua_getfield( L, -1, "allocator");                      // settings allocator|nil|"protected"
-    if( !lua_isnil( L, -1))
+    STACK_CHECK_START_REL(L, 1);                            // settings
+    lua_getfield(L, -1, "allocator");                       // settings allocator|nil|"protected"
+    if (!lua_isnil(L, -1))
     {
         // store C function pointer in an internal variable
-        U->provide_allocator = lua_tocfunction( L, -1);     // settings allocator
-        if( U->provide_allocator != NULL)
+        U->provide_allocator = lua_tocfunction(L, -1);      // settings allocator
+        if (U->provide_allocator != nullptr)
         {
             // make sure the function doesn't have upvalues
-            char const* upname = lua_getupvalue( L, -1, 1); // settings allocator upval?
-            if( upname != NULL) // should be "" for C functions with upvalues if any
+            char const* upname = lua_getupvalue(L, -1, 1);  // settings allocator upval?
+            if (upname != nullptr) // should be "" for C functions with upvalues if any
             {
-                (void) luaL_error( L, "config.allocator() shouldn't have upvalues");
+                (void) luaL_error(L, "config.allocator() shouldn't have upvalues");
             }
             // 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);                                // settings allocator nil
-            lua_setfield( L, -3, "allocator");              // settings allocator
+            lua_pushnil(L);                                 // settings allocator nil
+            lua_setfield(L, -3, "allocator");               // settings allocator
         }
-        else if( lua_type( L, -1) == LUA_TSTRING) // should be "protected"
+        else if (lua_type(L, -1) == LUA_TSTRING) // should be "protected"
         {
-            // initialize all we need for the protected allocator
-            MUTEX_INIT( &U->protected_allocator.lock); // the mutex
-            // and the original allocator to call from inside protection by the mutex
-            U->protected_allocator.definition.allocF = lua_getallocf( L, &U->protected_allocator.definition.allocUD);
+            ASSERT_L(strcmp(lua_tostring(L, -1), "protected") == 0);
+            // set the original allocator to call from inside protection by the mutex
+            U->protected_allocator.initFrom(L);
+            U->protected_allocator.installIn(L);
             // before a state is created, this function will be called to obtain the allocator
             U->provide_allocator = luaG_provide_protected_allocator;
-
-            lua_setallocf( L, protected_lua_Alloc, &U->protected_allocator);
         }
     }
     else
     {
-        // initialize the mutex even if we are not going to use it, because cleanup_allocator_function will deinitialize it
-        MUTEX_INIT( &U->protected_allocator.lock);
         // just grab whatever allocator was provided to lua_newstate
-        U->protected_allocator.definition.allocF = lua_getallocf( L, &U->protected_allocator.definition.allocUD);
+        U->protected_allocator.initFrom(L);
     }
-    lua_pop( L, 1);                                         // settings
-    STACK_MID(L, 0);
+    lua_pop(L, 1);                                          // settings
+    STACK_CHECK(L, 1);
 
-    lua_getfield( L, -1, "internal_allocator");             // settings "libc"|"allocator"
+    lua_getfield(L, -1, "internal_allocator");              // settings "libc"|"allocator"
     {
-        char const* allocator = lua_tostring( L, -1);
+        char const* allocator = lua_tostring(L, -1);
         if (strcmp(allocator, "libc") == 0)
         {
-            U->internal_allocator.allocF = libc_lua_Alloc;
-            U->internal_allocator.allocUD = NULL;
+            U->internal_allocator = AllocatorDefinition{ libc_lua_Alloc, nullptr };
         }
         else if (U->provide_allocator == luaG_provide_protected_allocator)
         {
             // user wants mutex protection on the state's allocator. Use protection for our own allocations too, just in case.
-            U->internal_allocator.allocF = lua_getallocf(L, &U->internal_allocator.allocUD);
+            U->internal_allocator = U->protected_allocator.makeDefinition();
         }
         else
         {
             // no protection required, just use whatever we have as-is.
-            U->internal_allocator = U->protected_allocator.definition;
+            U->internal_allocator = U->protected_allocator;
         }
     }
-    lua_pop( L, 1);                                         // settings
-    STACK_END( L, 0);
-}
-
-void cleanup_allocator_function( Universe* U, lua_State* L)
-{
-    // remove the protected allocator, if any
-    if( U->protected_allocator.definition.allocF != NULL)
-    {
-        // install the non-protected allocator
-        lua_setallocf( L, U->protected_allocator.definition.allocF, U->protected_allocator.definition.allocUD);
-        // release the mutex
-        MUTEX_FREE( &U->protected_allocator.lock);
-    }
+    lua_pop(L, 1);                                          // settings
+    STACK_CHECK(L, 1);
 }
 
 // ################################################################################################
 
-static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
+[[nodiscard]] static int dummy_writer(lua_State* L, void const* p, size_t sz, void* ud)
 {
     (void)L; (void)p; (void)sz; (void) ud; // unused
     return 666;
@@ -287,18 +250,18 @@ static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
  * +-----------------+----------+------------+----------+
  * | lua_topointer   |          |            |          |
  * +-----------------+----------+------------+----------+
- * | lua_tocfunction |  NULL    |            |  NULL    |
+ * | lua_tocfunction |  nullptr |            |  nullptr |
  * +-----------------+----------+------------+----------+
  * | lua_dump        |  666     |  1         |  1       |
  * +-----------------+----------+------------+----------+
  */
 
-typedef enum
+enum FuncSubType
 {
     FST_Bytecode,
     FST_Native,
     FST_FastJIT
-} FuncSubType;
+} ;
 
 FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
 {
@@ -316,7 +279,7 @@ FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
         // the provided writer fails with code 666
         // therefore, anytime we get 666, this means that lua_dump() attempted a dump
         // all other cases mean this is either a C or LuaJIT-fast function
-        dumpres = lua504_dump( L, dummy_writer, NULL, 0);
+        dumpres = lua504_dump(L, dummy_writer, nullptr, 0);
         lua_pop( L, mustpush);
         if( dumpres == 666)
         {
@@ -326,7 +289,9 @@ FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
     return FST_FastJIT;
 }
 
-static lua_CFunction luaG_tocfunction( lua_State *L, int _i, FuncSubType *_out)
+// #################################################################################################
+
+[[nodiscard]] static lua_CFunction luaG_tocfunction(lua_State* L, int _i, FuncSubType* _out)
 {
     lua_CFunction p = lua_tocfunction( L, _i);
     *_out = luaG_getfuncsubtype( L, _i);
@@ -334,14 +299,16 @@ static lua_CFunction luaG_tocfunction( lua_State *L, int _i, FuncSubType *_out)
 }
 
 // crc64/we of string "LOOKUPCACHE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( LOOKUPCACHE_REGKEY, 0x837a68dfc6fcb716);
+static constexpr UniqueKey LOOKUPCACHE_REGKEY{ 0x837a68dfc6fcb716ull };
+
+// #################################################################################################
 
 // inspired from tconcat() in ltablib.c
-static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
+[[nodiscard]] static char const* luaG_pushFQN(lua_State* L, int t, int last, size_t* length)
 {
     int i = 1;
     luaL_Buffer b;
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // Lua 5.4 pushes &b as light userdata on the stack. be aware of it...
     luaL_buffinit( L, &b);                            // ... {} ... &b?
     for( ; i < last; ++ i)
@@ -357,10 +324,12 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
     }
     // &b is popped at that point (-> replaced by the result)
     luaL_pushresult( &b);                             // ... {} ... "<result>"
-    STACK_END( L, 1);
+    STACK_CHECK( L, 1);
     return lua_tolstring( L, -1, length);
 }
 
+// #################################################################################################
+
 /*
  * receives 2 arguments: a name k and an object o
  * add two entries ["fully.qualified.name"] = o
@@ -369,7 +338,7 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
  * if we already had an entry of type [o] = ..., replace the name if the new one is shorter
  * pops the processed object from the stack
  */
-static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
+static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
 {
     // slot 1 in the stack contains the table that receives everything we found
     int const dest = _ctx_base;
@@ -378,22 +347,22 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
 
     size_t prevNameLength, newNameLength;
     char const* prevName;
-    DEBUGSPEW_CODE( char const *newName);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "update_lookup_entry()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(char const *newName);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "update_lookup_entry()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // first, raise an error if the function is already known
     lua_pushvalue( L, -1);                                                                // ... {bfc} k o o
     lua_rawget( L, dest);                                                                 // ... {bfc} k o name?
-    prevName = lua_tolstring( L, -1, &prevNameLength); // NULL if we got nil (first encounter of this object)
+    prevName = lua_tolstring( L, -1, &prevNameLength); // 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);                                                                // ... {bfc} k o name? k
     ASSERT_L( lua_type( L, -1) == LUA_TNUMBER || lua_type( L, -1) == LUA_TSTRING);
     ++ _depth;
     lua_rawseti( L, fqn, _depth);                                                         // ... {bfc} k o name?
     // generate name
-    DEBUGSPEW_CODE( newName =) luaG_pushFQN( L, fqn, _depth, &newNameLength);             // ... {bfc} k o name? "f.q.n"
+    DEBUGSPEW_OR_NOT(newName, std::ignore) = luaG_pushFQN(L, fqn, _depth, &newNameLength);// ... {bfc} k o name? "f.q.n"
     // Lua 5.2 introduced a hash randomizer seed which causes table iteration to yield a different key order
     // on different VMs even when the tables are populated the exact same way.
     // When Lua is built with compatibility options (such as LUA_COMPAT_ALL),
@@ -403,7 +372,7 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
     // Also, nothing prevents any external module from exposing a given object under several names, so...
     // 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 != NULL && (prevNameLength < newNameLength || lua_lessthan( L, -2, -1)))
+    if (prevName != nullptr && (prevNameLength < newNameLength || lua_lessthan(L, -2, -1)))
     {
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s '%s' remained named '%s'\n" INDENT_END, lua_typename( L, lua_type( L, -3)), newName, prevName));
         // the previous name is 'smaller' than the one we just generated: keep it!
@@ -439,11 +408,13 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
         lua_rawseti( L, fqn, _depth);                                                       // ... {bfc} k
     }
     -- _depth;
-    STACK_END( L, -1);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    STACK_CHECK(L, -1);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
-static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _i, int _depth)
+// #################################################################################################
+
+static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L, int _ctx_base, int _i, int _depth)
 {
     lua_Integer visit_count;
     // slot 2 contains a table that, when concatenated, produces the fully qualified name of scanned elements in the table provided at slot _i
@@ -452,18 +423,18 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     int const cache = _ctx_base + 2;
     // we need to remember subtables to process them after functions encountered at the current depth (breadth-first search)
     int const breadth_first_cache = lua_gettop( L) + 1;
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "populate_func_lookup_table_recur()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "populate_func_lookup_table_recur()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
     STACK_GROW( L, 6);
     // slot _i contains a table where we search for functions (or a full userdata with a metatable)
-    STACK_CHECK( L, 0);                                                                       // ... {_i}
+    STACK_CHECK_START_REL(L, 0);                                                              // ... {_i}
 
     // if object is a userdata, replace it by its metatable
     if( lua_type( L, _i) == LUA_TUSERDATA)
     {
-        lua_getmetatable( L, _i);                                                               // ... {_i} mt
-        lua_replace( L, _i);                                                                    // ... {_i}
+        lua_getmetatable( L, _i);                                                             // ... {_i} mt
+        lua_replace( L, _i);                                                                  // ... {_i}
     }
 
     // if table is already visited, we are done
@@ -471,11 +442,11 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     lua_rawget( L, cache);                                                                    // ... {_i} nil|n
     visit_count = lua_tointeger( L, -1); // 0 if nil, else n
     lua_pop( L, 1);                                                                           // ... {_i}
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
     if( visit_count > 0)
     {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "already visited\n" INDENT_END));
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "already visited\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
         return;
     }
 
@@ -483,7 +454,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     lua_pushvalue( L, _i);                                                                    // ... {_i} {}
     lua_pushinteger( L, visit_count + 1);                                                     // ... {_i} {} 1
     lua_rawset( L, cache);                                                                    // ... {_i}
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
 
     // this table is at breadth_first_cache index
     lua_newtable( L);                                                                         // ... {_i} {bfc}
@@ -521,7 +492,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
         {
             lua_pop( L, 1);                                                                       // ... {_i} {bfc} k
         }
-        STACK_MID( L, 2);
+        STACK_CHECK( L, 2);
     }
     // now process the tables we encountered at that depth
     ++ _depth;
@@ -530,7 +501,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     {
         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, key));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
         // un-visit this table in case we do need to process it
         lua_pushvalue( L, -1);                                                                  // ... {_i} {bfc} k {} {}
         lua_rawget( L, cache);                                                                  // ... {_i} {bfc} k {} n
@@ -552,8 +523,8 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
         lua_rawseti( L, fqn, _depth);                                                           // ... {_i} {bfc} k {}
         populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( U) L, _ctx_base, lua_gettop( L), _depth);
         lua_pop( L, 1);                                                                         // ... {_i} {bfc} k
-        STACK_MID( L, 2);
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        STACK_CHECK( L, 2);
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
     }
     // remove table name from fqn stack
     lua_pushnil( L);                                                                          // ... {_i} {bfc} nil
@@ -561,30 +532,32 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     -- _depth;
     // we are done with our cache
     lua_pop( L, 1);                                                                           // ... {_i}
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
     // we are done                                                                            // ... {_i} {bfc}
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
+// #################################################################################################
+
 /*
  * 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* L, int i_, char const* name_)
 {
-    int const ctx_base = lua_gettop( L) + 1;
-    int const in_base = lua_absindex( L, _i);
+    int const ctx_base = lua_gettop(L) + 1;
+    int const in_base = lua_absindex(L, i_);
     int start_depth = 0;
     DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "NULL"));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "nullptr"));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
     STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
-    REGISTRY_GET( L, LOOKUP_REGKEY);                                               // {}
-    STACK_MID( L, 1);
+    STACK_CHECK_START_REL(L, 0);
+    LOOKUP_REGKEY.pushValue(L);                                                      // {}
+    STACK_CHECK( L, 1);
     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_ : "NULL";
+        name_ = name_ ? name_ : "nullptr";
         lua_pushvalue( L, in_base);                                                  // {} f
         lua_pushstring( L, name_);                                                   // {} f _name
         lua_rawset( L, -3);                                                          // {}
@@ -595,10 +568,10 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
     }
     else if( lua_type( L, in_base) == LUA_TTABLE)
     {
-        lua_newtable( L);                                                            // {} {fqn}
+        lua_newtable(L);                                                             // {} {fqn}
         if( name_)
         {
-            STACK_MID( L, 2);
+            STACK_CHECK( L, 2);
             lua_pushstring( L, name_);                                                 // {} {fqn} "name"
             // generate a name, and if we already had one name, keep whichever is the shorter
             lua_pushvalue( L, in_base);                                           // {} {fqn} "name" t
@@ -606,16 +579,16 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
             // don't forget to store the name at the bottom of the fqn stack
             ++ start_depth;
             lua_rawseti( L, -2, start_depth);                                          // {} {fqn}
-            STACK_MID( L, 2);
+            STACK_CHECK( L, 2);
         }
         // retrieve the cache, create it if we haven't done it yet
-        REGISTRY_GET( L, LOOKUPCACHE_REGKEY);                                        // {} {fqn} {cache}?
+        LOOKUPCACHE_REGKEY.pushValue(L);                                               // {} {fqn} {cache}?
         if( lua_isnil( L, -1))
         {
             lua_pop( L, 1);                                                            // {} {fqn}
             lua_newtable( L);                                                          // {} {fqn} {cache}
-            REGISTRY_SET( L, LOOKUPCACHE_REGKEY, lua_pushvalue( L, -2));
-            STACK_MID( L, 3);
+            LOOKUPCACHE_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+            STACK_CHECK( L, 3);
         }
         // process everything we find in that table, filling in lookup data for all functions and tables we see there
         populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( U) L, ctx_base, in_base, start_depth);
@@ -626,19 +599,21 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
         lua_pop( L, 1);                                                         //
         (void) luaL_error( L, "unsupported module type %s", lua_typename( L, lua_type( L, in_base)));
     }
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    STACK_CHECK( L, 0);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
+// #################################################################################################
+
 /*---=== Inter-state copying ===---*/
 
 // crc64/we of string "REG_MTID" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( REG_MTID, 0x2e68f9b4751584dc);
+static constexpr UniqueKey REG_MTID{ 0x2e68f9b4751584dcull };
 
 /*
 * Get a unique ID for metatable at [i].
 */
-static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
+[[nodiscard]] static lua_Integer get_mt_id(Universe* U, lua_State* L, int i)
 {
     lua_Integer id;
 
@@ -646,20 +621,18 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
 
     STACK_GROW( L, 3);
 
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     push_registry_subtable( L, REG_MTID);        // ... _R[REG_MTID]
     lua_pushvalue( L, i);                        // ... _R[REG_MTID] {mt}
     lua_rawget( L, -2);                          // ... _R[REG_MTID] mtk?
 
-    id = lua_tointeger( L, -1);    // 0 for nil
+    id = lua_tointeger( L, -1); // 0 for nil
     lua_pop( L, 1);                              // ... _R[REG_MTID]
-    STACK_MID( L, 1);
+    STACK_CHECK( L, 1);
 
     if( id == 0)
     {
-        MUTEX_LOCK( &U->mtid_lock);
-        id = ++ U->last_mt_id;
-        MUTEX_UNLOCK( &U->mtid_lock);
+        id = U->next_mt_id.fetch_add(1, std::memory_order_relaxed);
 
         /* Create two-way references: id_uint <-> table
         */
@@ -673,41 +646,48 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
     }
     lua_pop( L, 1);                              // ...
 
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
 
     return id;
 }
 
+// #################################################################################################
+
 // function sentinel used to transfer native functions from/to keeper states
-static int func_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int func_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "function lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "function lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
 
 // function sentinel used to transfer native table from/to keeper states
-static int table_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int table_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "table lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "table lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
+
 // function sentinel used to transfer cloned full userdata from/to keeper states
-static int userdata_clone_sentinel( lua_State* L)
+[[nodiscard]] static int userdata_clone_sentinel(lua_State* L)
 {
-    return luaL_error( L, "userdata clone sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "userdata clone sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
+
 /*
  * retrieve the name of a function/table in the lookup database
  */
-static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, char const* upName_, size_t* len_)
+[[nodiscard]] static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char const* upName_, size_t* len_)
 {
     DEBUGSPEW_CODE( Universe* const U = universe_get( L));
     char const* fqn;
     ASSERT_L( lua_isfunction( L, i) || lua_istable( L, i));  // ... v ...
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     STACK_GROW( L, 3); // up to 3 slots are necessary on error
-    if( mode_ == eLM_FromKeeper)
+    if (mode_ == LookupMode::FromKeeper)
     {
         lua_CFunction f = lua_tocfunction( L, i); // should *always* be func_lookup_sentinel or table_lookup_sentinel!
         if( f == func_lookup_sentinel || f == table_lookup_sentinel || f == userdata_clone_sentinel)
@@ -717,16 +697,16 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
         else
         {
             // if this is not a sentinel, this is some user-created table we wanted to lookup
-            ASSERT_L( NULL == f && lua_istable( L, i));
-            // push anything that will convert to NULL string
+            ASSERT_L(nullptr == f && lua_istable(L, i));
+            // push anything that will convert to nullptr string
             lua_pushnil( L);                                     // ... v ... nil
         }
     }
     else
     {
         // fetch the name from the source state's lookup table
-        REGISTRY_GET( L, LOOKUP_REGKEY);                       // ... v ... {}
-        STACK_MID( L, 1);
+        LOOKUP_REGKEY.pushValue(L);                            // ... v ... {}
+        STACK_CHECK( L, 1);
         ASSERT_L( lua_istable( L, -1));
         lua_pushvalue( L, i);                                  // ... v ... {} v
         lua_rawget( L, -2);                                    // ... v ... {} "f.q.n"
@@ -734,9 +714,9 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
     fqn = lua_tolstring( L, -1, len_);
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function [C] %s \n" INDENT_END, fqn));
     // popping doesn't invalidate the pointer since this is an interned string gotten from the lookup database
-    lua_pop( L, (mode_ == eLM_FromKeeper) ? 1 : 2);          // ... v ...
-    STACK_MID( L, 0);
-    if( NULL == fqn && !lua_istable( L, i)) // raise an error if we try to send an unknown function (but not for tables)
+    lua_pop( L, (mode_ == LookupMode::FromKeeper) ? 1 : 2);    // ... v ...
+    STACK_CHECK( L, 0);
+    if (nullptr == fqn && !lua_istable(L, i)) // raise an error if we try to send an unknown function (but not for tables)
     {
         char const *from, *typewhat, *what, *gotchaA, *gotchaB;
         // try to discover the name of the function we want to send
@@ -762,81 +742,83 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
         }
         (void) luaL_error( L, "%s%s '%s' not found in %s origin transfer database.%s", typewhat, gotchaA, what, from ? from : "main", gotchaB);
         *len_ = 0;
-        return NULL;
+        return nullptr;
     }
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
     return fqn;
 }
 
+// #################################################################################################
 
 /*
  * Push a looked-up table, or nothing if we found nothing
  */
-static bool_t lookup_table( lua_State* L2, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const* upName_)
 {
     // get the name of the table we want to send
     size_t len;
     char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
-    if( NULL == fqn) // name not found, it is some user-created table
+    if (nullptr == fqn) // name not found, it is some user-created table
     {
-        return FALSE;
+        return false;
     }
     // push the equivalent table in the destination's stack, retrieved from the lookup table
-    STACK_CHECK( L2, 0);                                     // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                // L                       // L2
     STACK_GROW( L2, 3); // up to 3 slots are necessary on error
     switch( mode_)
     {
         default: // shouldn't happen, in theory...
         (void) luaL_error( L, "internal error: unknown lookup mode");
-        return FALSE;
+        return false;
 
-        case eLM_ToKeeper:
+        case LookupMode::ToKeeper:
         // push a sentinel closure that holds the lookup name as upvalue
-        lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
-        lua_pushcclosure( L2, table_lookup_sentinel, 1);                                     // f
+        lua_pushlstring(L2, fqn, len);                                                      // "f.q.n"
+        lua_pushcclosure(L2, table_lookup_sentinel, 1);                                     // f
         break;
 
-        case eLM_LaneBody:
-        case eLM_FromKeeper:
-        REGISTRY_GET( L2, LOOKUP_REGKEY);                                                    // {}
-        STACK_MID( L2, 1);
-        ASSERT_L( lua_istable( L2, -1));
-        lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
-        lua_rawget( L2, -2);                                                                 // {} t
+        case LookupMode::LaneBody:
+        case LookupMode::FromKeeper:
+        LOOKUP_REGKEY.pushValue(L2);                                                        // {}
+        STACK_CHECK(L2, 1);
+        ASSERT_L(lua_istable(L2, -1));
+        lua_pushlstring(L2, fqn, len);                                                      // {} "f.q.n"
+        lua_rawget(L2, -2);                                                                 // {} t
         // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead)
         // but not when we extract something out of a keeper, as there is nothing to clone!
-        if( lua_isnil( L2, -1) && mode_ == eLM_LaneBody)
+        if (lua_isnil(L2, -1) && mode_ == LookupMode::LaneBody)
         {
-            lua_pop( L2, 2);                                                                   //
-            STACK_MID( L2, 0);
-            return FALSE;
+            lua_pop(L2, 2);                                                                 //
+            STACK_CHECK(L2, 0);
+            return false;
         }
-        else if( !lua_istable( L2, -1))
+        else if( !lua_istable(L2, -1))
         {
             char const* from, *to;
-            lua_getglobal( L, "decoda_name");                    // ... t ... decoda_name
-            from = lua_tostring( L, -1);
-            lua_pop( L, 1);                                      // ... t ...
-            lua_getglobal( L2, "decoda_name");                                                 // {} t decoda_name
+            lua_getglobal(L, "decoda_name");                     // ... t ... decoda_name
+            from = lua_tostring(L, -1);
+            lua_pop(L, 1);                                       // ... t ...
+            lua_getglobal(L2, "decoda_name");                                               // {} t decoda_name
             to = lua_tostring( L2, -1);
-            lua_pop( L2, 1);                                                                   // {} t
-            // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
+            lua_pop(L2, 1);                                                                 // {} t
+            // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
             (void) luaL_error(
-                (mode_ == eLM_FromKeeper) ? L2 : L
+                (mode_ == LookupMode::FromKeeper) ? L2 : L
                 , "INTERNAL ERROR IN %s: table '%s' not found in %s destination transfer database."
                 , from ? from : "main"
                 , fqn
                 , to ? to : "main"
             );
-            return FALSE;
+            return false;
         }
-        lua_remove( L2, -2);                                                                 // t
+        lua_remove(L2, -2);                                                                 // t
         break;
     }
-    STACK_END( L2, 1);
-    return TRUE;
+    STACK_CHECK( L2, 1);
+    return true;
 }
 
+// #################################################################################################
 
 /* 
  * Check if we've already copied the same table from 'L', and
@@ -845,121 +827,121 @@ static bool_t lookup_table( lua_State* L2, lua_State* L, uint_t i, LookupMode mo
  *
  * Always pushes a table to 'L2'.
  *
- * Returns TRUE if the table was cached (no need to fill it!); FALSE if
+ * Returns true if the table was cached (no need to fill it!); false if
  * it's a virgin.
  */
-static bool_t push_cached_table( lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i)
+[[nodiscard]] static bool push_cached_table(Dest L2, int L2_cache_i, Source L, int i)
 {
-    bool_t not_found_in_cache;                                                                       // L2
-    void const* p = lua_topointer( L, i);
+    void const* p{ lua_topointer(L, i) };
 
     ASSERT_L( L2_cache_i != 0);
-    STACK_GROW( L2, 3);
-    STACK_CHECK( L2, 0);
+    STACK_GROW( L2, 3);                                                                              // L2
+    STACK_CHECK_START_REL(L2, 0);
 
     // We don't need to use the from state ('L') in ID since the life span
     // is only for the duration of a copy (both states are locked).
     // push a light userdata uniquely representing the table
-    lua_pushlightuserdata( L2, (void*) p);                                                           // ... p
+    lua_pushlightuserdata(L2, const_cast<void*>(p));                                                 // ... p
 
     //fprintf( stderr, "<< ID: %s >>\n", lua_tostring( L2, -1));
 
     lua_rawget( L2, L2_cache_i);                                                                     // ... {cached|nil}
-    not_found_in_cache = lua_isnil( L2, -1);
+    bool const not_found_in_cache{ lua_isnil(L2, -1) };
     if( not_found_in_cache)
     {
         lua_pop( L2, 1);                                                                             // ...
         lua_newtable( L2);                                                                           // ... {}
-        lua_pushlightuserdata( L2, (void*) p);                                                       // ... {} p
+        lua_pushlightuserdata(L2, const_cast<void*>(p));                                             // ... {} p
         lua_pushvalue( L2, -2);                                                                      // ... {} p {}
         lua_rawset( L2, L2_cache_i);                                                                 // ... {}
     }
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
     ASSERT_L( lua_istable( L2, -1));
     return !not_found_in_cache;
 }
 
+// #################################################################################################
 
 /*
  * Return some name helping to identify an object
  */
-static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
+[[nodiscard]] static int discover_object_name_recur(lua_State* L, int shortest_, int depth_)
 {
     int const what = 1;                                     // o "r" {c} {fqn} ... {?}
     int const result = 2;
     int const cache = 3;
     int const fqn = 4;
     // no need to scan this table if the name we will discover is longer than one we already know
-    if( shortest_ <= depth_ + 1)
+    if (shortest_ <= depth_ + 1)
     {
         return shortest_;
     }
-    STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
     // stack top contains the table to search in
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_rawget( L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_rawget(L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
     // if table is already visited, we are done
-    if( !lua_isnil( L, -1))
+    if( !lua_isnil(L, -1))
     {
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?}
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?}
         return shortest_;
     }
     // examined table is not in the cache, add it now
-    lua_pop( L, 1);                                         // o "r" {c} {fqn} ... {?}
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushinteger( L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
+    lua_pop(L, 1);                                         // o "r" {c} {fqn} ... {?}
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushinteger(L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
     // scan table contents
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} nil
-    while( lua_next( L, -2))                                // o "r" {c} {fqn} ... {?} k v
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} nil
+    while (lua_next(L, -2))                                // o "r" {c} {fqn} ... {?} k v
     {
-        //char const *const strKey = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : NULL; // only for debugging
-        //lua_Number const numKey = (lua_type( L, -2) == LUA_TNUMBER) ? lua_tonumber( L, -2) : -6666; // only for debugging
-        STACK_MID( L, 2);
+        //char const *const strKey = (lua_type(L, -2) == LUA_TSTRING) ? lua_tostring(L, -2) : nullptr; // only for debugging
+        //lua_Number const numKey = (lua_type(L, -2) == LUA_TNUMBER) ? lua_tonumber(L, -2) : -6666; // only for debugging
+        STACK_CHECK(L, 2);
         // append key name to fqn stack
         ++ depth_;
-        lua_pushvalue( L, -2);                                // o "r" {c} {fqn} ... {?} k v k
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
-        if( lua_rawequal( L, -1, what)) // is it what we are looking for?
+        lua_pushvalue(L, -2);                                // o "r" {c} {fqn} ... {?} k v k
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
+        if (lua_rawequal(L, -1, what)) // is it what we are looking for?
         {
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // update shortest name
             if( depth_ < shortest_)
             {
                 shortest_ = depth_;
-                luaG_pushFQN( L, fqn, depth_, NULL);              // o "r" {c} {fqn} ... {?} k v "fqn"
-                lua_replace( L, result);                          // o "r" {c} {fqn} ... {?} k v
+                std::ignore = luaG_pushFQN(L, fqn, depth_, nullptr); // o "r" {c} {fqn} ... {?} k v "fqn"
+                lua_replace(L, result);                          // o "r" {c} {fqn} ... {?} k v
             }
             // no need to search further at this level
-            lua_pop( L, 2);                                     // o "r" {c} {fqn} ... {?}
-            STACK_MID( L, 0);
+            lua_pop(L, 2);                                     // o "r" {c} {fqn} ... {?}
+            STACK_CHECK(L, 0);
             break;
         }
-        switch( lua_type( L, -1))                             // o "r" {c} {fqn} ... {?} k v
+        switch (lua_type(L, -1))                             // o "r" {c} {fqn} ... {?} k v
         {
             default: // nil, boolean, light userdata, number and string aren't identifiable
             break;
 
             case LUA_TTABLE:                                    // o "r" {c} {fqn} ... {?} k {}
-            STACK_MID( L, 2);
-            shortest_ = discover_object_name_recur( L, shortest_, depth_);
+            STACK_CHECK(L, 2);
+            shortest_ = discover_object_name_recur(L, shortest_, depth_);
             // search in the table's metatable too
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
             {
-                if( lua_istable( L, -1))
+                if( lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             break;
 
             case LUA_TTHREAD:                                   // o "r" {c} {fqn} ... {?} k T
@@ -967,64 +949,65 @@ static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
             break;
 
             case LUA_TUSERDATA:                                 // o "r" {c} {fqn} ... {?} k U
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's metatable (some modules are built that way)
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
             {
-                if( lua_istable( L, -1))
+                if (lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's uservalues
             {
                 int uvi = 1;
-                while( lua_getiuservalue( L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
+                while (lua_getiuservalue(L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
                 {
-                    if( lua_istable( L, -1)) // if it is a table, look inside
+                    if( lua_istable(L, -1)) // if it is a table, look inside
                     {
                         ++ depth_;
-                        lua_pushliteral( L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
-                        shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                        lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        lua_pushliteral(L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                        lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
                         -- depth_;
                     }
-                    lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                    lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
                     ++ uvi;
                 }
                 // when lua_getiuservalue() returned LUA_TNONE, it pushed a nil. pop it now
-                lua_pop( L, 1);                                     // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                     // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             break;
         }
         // make ready for next iteration
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?} k
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?} k
         // remove name from fqn stack
-        lua_pushnil( L);                                      // o "r" {c} {fqn} ... {?} k nil
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
-        STACK_MID( L, 1);
+        lua_pushnil(L);                                      // o "r" {c} {fqn} ... {?} k nil
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
+        STACK_CHECK(L, 1);
         -- depth_;
     }                                                       // o "r" {c} {fqn} ... {?}
-    STACK_MID( L, 0);
+    STACK_CHECK(L, 0);
     // remove the visited table from the cache, in case a shorter path to the searched object exists
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} {?} nil
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
-    STACK_END( L, 0);
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} {?} nil
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
+    STACK_CHECK(L, 0);
     return shortest_;
 }
 
+// #################################################################################################
 
 /*
  * "type", "name" = lanes.nameof( o)
@@ -1046,7 +1029,7 @@ int luaG_nameof( lua_State* L)
     }
 
     STACK_GROW( L, 4);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // this slot will contain the shortest name we found when we are done
     lua_pushnil( L);                                        // o nil
     // push a cache that will contain all already visited tables
@@ -1067,23 +1050,24 @@ int luaG_nameof( lua_State* L)
         (void) discover_object_name_recur( L, 6666, 1);
     }
     lua_pop( L, 3);                                         // o "result"
-    STACK_END( L, 1);
+    STACK_CHECK( L, 1);
     lua_pushstring( L, luaL_typename( L, 1));               // o "result" "type"
     lua_replace( L, -3);                                    // "type" "result"
     return 2;
 }
 
+// #################################################################################################
 
 /*
  * Push a looked-up native/LuaJIT function.
  */
-static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+static void lookup_native_func(lua_State* L2, lua_State* L, int i, LookupMode mode_, char const* upName_)
 {
     // get the name of the function we want to send
     size_t len;
     char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
     // push the equivalent function in the destination's stack, retrieved from the lookup table
-    STACK_CHECK( L2, 0);                                     // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                // L                        // L2
     STACK_GROW( L2, 3); // up to 3 slots are necessary on error
     switch( mode_)
     {
@@ -1091,16 +1075,16 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         (void) luaL_error( L, "internal error: unknown lookup mode");
         return;
 
-        case eLM_ToKeeper:
+        case LookupMode::ToKeeper:
         // push a sentinel closure that holds the lookup name as upvalue
         lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
         lua_pushcclosure( L2, func_lookup_sentinel, 1);                                      // f
         break;
 
-        case eLM_LaneBody:
-        case eLM_FromKeeper:
-        REGISTRY_GET( L2, LOOKUP_REGKEY);                                                    // {}
-        STACK_MID( L2, 1);
+        case LookupMode::LaneBody:
+        case LookupMode::FromKeeper:
+        LOOKUP_REGKEY.pushValue(L2);                                                         // {}
+        STACK_CHECK( L2, 1);
         ASSERT_L( lua_istable( L2, -1));
         lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
         lua_rawget( L2, -2);                                                                 // {} f
@@ -1115,9 +1099,9 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
             lua_getglobal( L2, "decoda_name");                                                 // {} f decoda_name
             to = lua_tostring( L2, -1);
             lua_pop( L2, 1);                                                                   // {} f
-            // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
+            // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
             (void) luaL_error(
-                (mode_ == eLM_FromKeeper) ? L2 : L
+                (mode_ == LookupMode::FromKeeper) ? L2 : L
                 , "%s%s: function '%s' not found in %s destination transfer database."
                 , lua_isnil( L2, -1) ? "" : "INTERNAL ERROR IN "
                 , from ? from : "main"
@@ -1130,13 +1114,13 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         break;
 
         /* keep it in case I need it someday, who knows...
-        case eLM_RawFunctions:
+        case LookupMode::RawFunctions:
         {
             int n;
             char const* upname;
             lua_CFunction f = lua_tocfunction( L, i);
             // copy upvalues
-            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != NULL; ++ n)
+            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != nullptr; ++ n)
             {
                 luaG_inter_move( U, L, L2, 1, mode_);                                            // [up[,up ...]]
             }
@@ -1145,9 +1129,10 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         break;
         */
     }
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
 }
 
+// #################################################################################################
 
 /*
  * Copy a function over, which has not been found in the cache.
@@ -1171,17 +1156,19 @@ static char const* lua_type_names[] =
 };
 static char const* vt_names[] =
 {
-    "VT_NORMAL"
-    , "VT_KEY"
-    , "VT_METATABLE"
+    "VT::NORMAL"
+    , "VT::KEY"
+    , "VT::METATABLE"
 };
 #endif // USE_DEBUG_SPEW()
 
+// #################################################################################################
+
 // Lua 5.4.3 style of dumping (see lstrlib.c)
 // we have to do it that way because we can't unbalance the stack between buffer operations
 // namely, this means we can't push a function on top of the stack *after* we initialize the buffer!
 // luckily, this also works with earlier Lua versions
-static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
+[[nodiscard]] static int buf_writer(lua_State* L, void const* b, size_t size, void* ud)
 {
     luaL_Buffer* B = (luaL_Buffer*) ud;
     if( !B->L)
@@ -1192,20 +1179,22 @@ static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
     return 0;
 }
 
-static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+static void copy_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     int n, needToPush;
     luaL_Buffer B;
-    B.L = NULL;
+    B.L = nullptr;
 
     ASSERT_L( L2_cache_i != 0);                                                       // ... {cache} ... p
     STACK_GROW( L, 2);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
 
 
     // 'lua_dump()' needs the function at top of stack
     // if already on top of the stack, no need to push again
-    needToPush = (i != (uint_t)lua_gettop( L));
+    needToPush = (i != lua_gettop( L));
     if( needToPush)
     {
         lua_pushvalue( L, i);                                // ... f
@@ -1232,7 +1221,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 
     // transfer the bytecode, then the upvalues, to create a similar closure
     {
-        char const* name = NULL;
+        char const* name = nullptr;
 
         #if LOG_FUNC_INFO
         // "To get information about a function you push it onto the 
@@ -1244,7 +1233,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // fills 'name' 'namewhat' and 'linedefined', pops function
             lua_getinfo( L, ">nS", &ar);                       // ... b
             name = ar.namewhat;
-            fprintf( stderr, INDENT_BEGIN "FNAME: %s @ %d\n", i, s_indent, ar.short_src, ar.linedefined);  // just gives NULL
+            fprintf( stderr, INDENT_BEGIN "FNAME: %s @ %d\n", i, s_indent, ar.short_src, ar.linedefined);  // just gives nullptr
         }
         #endif // LOG_FUNC_INFO
         {
@@ -1276,7 +1265,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // cache[p] = function
             lua_rawset( L2, L2_cache_i);                                                               // ... {cache} ... function
         }
-        STACK_MID( L, 0);
+        STACK_CHECK( L, 0);
 
         /* push over any upvalues; references to this function will come from
         * cache so we don't end up in eternal loop.
@@ -1291,7 +1280,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // -> if we encounter an upvalue equal to the global table in the source, bind it to the destination's global table
             lua_pushglobaltable( L);                           // ... _G
 #endif // LUA_VERSION_NUM
-            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != NULL; ++ n)
+            for (n = 0; (upname = lua_getupvalue(L, i, 1 + n)) != nullptr; ++n)
             {                                                  // ... _G up[n]
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "UPNAME[%d]: %s -> " INDENT_END, n, upname));
 #if LUA_VERSION_NUM >= 502
@@ -1304,7 +1293,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 #endif // LUA_VERSION_NUM
                 {
                     DEBUGSPEW_CODE( fprintf( stderr, "copying value\n"));
-                    if( !inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT_NORMAL, mode_, upname))  // ... {cache} ... function <upvalues>
+                    if( !inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT::NORMAL, mode_, upname)) // ... {cache} ... function <upvalues>
                     {
                         luaL_error( L, "Cannot copy upvalue type '%s'", luaL_typename( L, -1));
                     }
@@ -1317,7 +1306,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         // L2: function + 'n' upvalues (>=0)
 
-        STACK_MID( L, 0);
+        STACK_CHECK( L, 0);
 
         // Set upvalues (originally set to 'nil' by 'lua_load')
         {
@@ -1335,19 +1324,21 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // with the function at the top of the stack                                               // ... {cache} ... function
         }
     }
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
 }
 
+// #################################################################################################
+
 /* 
  * Check if we've already copied the same function from 'L', and reuse the old
  * copy.
  *
  * Always pushes a function to 'L2'.
  */
-static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+static void copy_cached_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     FuncSubType funcSubType;
-    /*lua_CFunction cfunc =*/ luaG_tocfunction( L, i, &funcSubType); // NULL for LuaJIT-fast && bytecode functions
+    std::ignore = luaG_tocfunction(L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions
     if( funcSubType == FST_Bytecode)
     {
         void* const aspointer = (void*)lua_topointer( L, i);
@@ -1358,7 +1349,7 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
 
         // L2_cache[id_str]= function
         //
-        STACK_CHECK( L2, 0);
+        STACK_CHECK_START_REL(L2, 0);
 
         // We don't need to use the from state ('L') in ID since the life span
         // is only for the duration of a copy (both states are locked).
@@ -1386,7 +1377,7 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
         {
             lua_remove( L2, -2);                                      // ... {cache} ... function
         }
-        STACK_END( L2, 1);
+        STACK_CHECK( L2, 1);
         ASSERT_L( lua_isfunction( L2, -1));
     }
     else // function is native/LuaJIT: no need to cache
@@ -1397,62 +1388,65 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
     }
 }
 
-static bool_t push_cached_metatable( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
-    STACK_CHECK( L, 0);
-    if( lua_getmetatable( L, i))                                                 // ... mt
+    STACK_CHECK_START_REL(L, 0);
+    if (!lua_getmetatable(L, i))                                                // ... mt
     {
-        lua_Integer const mt_id = get_mt_id( U, L, -1);    // Unique id for the metatable
+        STACK_CHECK( L, 0);
+        return false;
+    }
+    STACK_CHECK(L, 1);
 
-        STACK_CHECK( L2, 0);
-        STACK_GROW( L2, 4);
-        // do we already know this metatable?
-        push_registry_subtable( L2, REG_MTID);                                                                   // _R[REG_MTID]
-        lua_pushinteger( L2, mt_id);                                                                             // _R[REG_MTID] id
-        lua_rawget( L2, -2);                                                                                     // _R[REG_MTID] mt?
+    lua_Integer const mt_id{ get_mt_id(U, L, -1) }; // Unique id for the metatable
 
-        STACK_MID( L2, 2);
+    STACK_CHECK_START_REL(L2, 0);
+    STACK_GROW(L2, 4);
+    // do we already know this metatable?
+    push_registry_subtable(L2, REG_MTID);                                                               // _R[REG_MTID]
+    lua_pushinteger(L2, mt_id);                                                                         // _R[REG_MTID] id
+    lua_rawget(L2, -2);                                                                                 // _R[REG_MTID] mt|nil
+    STACK_CHECK(L2, 2);
 
-        if( lua_isnil( L2, -1))
-        {   // L2 did not know the metatable
-            lua_pop( L2, 1);                                                                                       // _R[REG_MTID]
-            if( inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT_METATABLE, mode_, upName_))               // _R[REG_MTID] mt
-            {
-                STACK_MID( L2, 2);
-                // mt_id -> metatable
-                lua_pushinteger( L2, mt_id);                                                                         // _R[REG_MTID] mt id
-                lua_pushvalue( L2, -2);                                                                              // _R[REG_MTID] mt id mt
-                lua_rawset( L2, -4);                                                                                 // _R[REG_MTID] mt
-
-                // metatable -> mt_id
-                lua_pushvalue( L2, -1);                                                                              // _R[REG_MTID] mt mt
-                lua_pushinteger( L2, mt_id);                                                                         // _R[REG_MTID] mt mt id
-                lua_rawset( L2, -4);                                                                                 // _R[REG_MTID] mt
-            }
-            else
-            {
-                (void) luaL_error( L, "Error copying a metatable");
-            }
-            STACK_MID( L2, 2);
+    if (lua_isnil(L2, -1))
+    {   // L2 did not know the metatable
+        lua_pop(L2, 1);                                                                                 // _R[REG_MTID]
+        if (!inter_copy_one(U, L2, L2_cache_i, L, lua_gettop(L), VT::METATABLE, mode_, upName_))        // _R[REG_MTID] mt?
+        {
+            luaL_error(L, "Error copying a metatable"); // doesn't return
         }
-        lua_remove( L2, -2);                                                                                     // mt
 
-        lua_pop( L, 1);                                                            // ...
-        STACK_END( L2, 1);
-        STACK_MID( L, 0);
-        return TRUE;
+        STACK_CHECK(L2, 2);                                                                             // _R[REG_MTID] mt
+        // mt_id -> metatable
+        lua_pushinteger(L2, mt_id);                                                                     // _R[REG_MTID] mt id
+        lua_pushvalue(L2, -2);                                                                          // _R[REG_MTID] mt id mt
+        lua_rawset(L2, -4);                                                                             // _R[REG_MTID] mt
+
+        // metatable -> mt_id
+        lua_pushvalue(L2, -1);                                                                          // _R[REG_MTID] mt mt
+        lua_pushinteger(L2, mt_id);                                                                     // _R[REG_MTID] mt mt id
+        lua_rawset(L2, -4);                                                                             // _R[REG_MTID] mt
+        STACK_CHECK(L2, 2);
     }
-    STACK_END( L, 0);
-    return FALSE;
+    lua_remove(L2, -2);                                                                                 // mt
+
+    lua_pop(L, 1);                                                          // ...
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source L, VT vt_, LookupMode mode_, char const* upName_)
 {
-    uint_t val_i = lua_gettop( L);
-    uint_t key_i = val_i - 1;
+    int val_i = lua_gettop(L);
+    int key_i = val_i - 1;
 
     // Only basic key types are copied over; others ignored
-    if( inter_copy_one( U, L2, L2_cache_i, L, key_i, VT_KEY, mode_, upName_))
+    if (inter_copy_one(U, L2, L2_cache_i, L, key_i, VT::KEY, mode_, upName_))
     {
         char* valPath = (char*) upName_;
         if( U->verboseErrors)
@@ -1465,7 +1459,7 @@ static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache
                 size_t const bufLen = strlen( upName_) + keyRawLen + 2;
                 valPath = (char*) alloca( bufLen);
                 sprintf( valPath, "%s.%*s", upName_, (int) keyRawLen, key);
-                key = NULL;
+                key = nullptr;
             }
 #if defined LUA_LNUM || LUA_VERSION_NUM >= 503
             else if( lua_isinteger( L, key_i))
@@ -1498,51 +1492,53 @@ static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache
         * Contents of metatables are copied with cache checking;
         * important to detect loops.
         */
-        if( inter_copy_one( U, L2, L2_cache_i, L, val_i, VT_NORMAL, mode_, valPath))
+        if (inter_copy_one(U, L2, L2_cache_i, L, val_i, VT::NORMAL, mode_, valPath))
         {
             ASSERT_L( lua_istable( L2, -3));
             lua_rawset( L2, -3);    // add to table (pops key & val)
         }
         else
         {
-            luaL_error( L, "Unable to copy %s entry '%s' because of value is of type '%s'", (vt == VT_NORMAL) ? "table" : "metatable", valPath, luaL_typename( L, val_i));
+            luaL_error(L, "Unable to copy %s entry '%s' because of value is of type '%s'", (vt_ == VT::NORMAL) ? "table" : "metatable", valPath, luaL_typename(L, val_i));
         }
     }
 }
 
+// #################################################################################################
+
 /*
 * The clone cache is a weak valued table listing all clones, indexed by their userdatapointer
 * fnv164 of string "CLONABLES_CACHE_KEY" generated at https://www.pelock.com/products/hash-calculator
 */
-static DECLARE_CONST_UNIQUE_KEY( CLONABLES_CACHE_KEY, 0xD04EE018B3DEE8F5);
+static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
 
-static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t source_i_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, LookupMode mode_, char const* upName_)
 {
     void* const source = lua_touserdata( L, source_i_);
     source_i_ = lua_absindex( L, source_i_);
 
-    STACK_CHECK( L, 0);                                                          // L (source)               // L2 (destination)
-    STACK_CHECK( L2, 0);
+    STACK_CHECK_START_REL(L, 0);                                                 // L (source)               // L2 (destination)
+    STACK_CHECK_START_REL(L2, 0);
 
     // Check if the source was already cloned during this copy
     lua_pushlightuserdata( L2, source);                                                                      // ... source
     lua_rawget( L2, L2_cache_i);                                                                             // ... clone?
     if ( !lua_isnil( L2, -1))
     {
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK( L2, 1);
+        return true;
     }
     else
     {
         lua_pop( L2, 1);                                                                                     // ...
     }
-    STACK_MID( L2, 0);
+    STACK_CHECK( L2, 0);
 
     // no metatable? -> not clonable
     if( !lua_getmetatable( L, source_i_))                                        // ... mt?
     {
-        STACK_MID( L, 0);
-        return FALSE;
+        STACK_CHECK( L, 0);
+        return false;
     }
 
     // no __lanesclone? -> not clonable
@@ -1550,15 +1546,15 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
     if( lua_isnil( L, -1))
     {
         lua_pop( L, 2);                                                          // ...
-        STACK_MID( L, 0);
-        return FALSE;
+        STACK_CHECK( L, 0);
+        return false;
     }
 
     // we need to copy over the uservalues of the userdata as well
     {
         int const mt = lua_absindex( L, -2);                                     // ... mt __lanesclone
         size_t const userdata_size = (size_t) lua_rawlen( L, source_i_);
-        void* clone = NULL;
+        void* clone = nullptr;
         // extract all the uservalues, but don't transfer them yet
         int uvi = 0;
         while( lua_getiuservalue( L, source_i_, ++ uvi) != LUA_TNONE) {}         // ... mt __lanesclone [uv]+ nil
@@ -1568,9 +1564,9 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
         // create the clone userdata with the required number of uservalue slots
         clone = lua_newuserdatauv( L2, userdata_size, uvi);                                                  // ... u
         // copy the metatable in the target state, and give it to the clone we put there
-        if( inter_copy_one( U, L2, L2_cache_i, L, mt, VT_NORMAL, mode_, upName_))                            // ... u mt|sentinel
+        if (inter_copy_one(U, L2, L2_cache_i, L, mt, VT::NORMAL, mode_, upName_))                            // ... u mt|sentinel
         {
-            if( eLM_ToKeeper == mode_)                                                                       // ... u sentinel
+            if( LookupMode::ToKeeper == mode_)                                                               // ... u sentinel
             {
                 ASSERT_L( lua_tocfunction( L2, -1) == table_lookup_sentinel);
                 // we want to create a new closure with a 'clone sentinel' function, where the upvalues are the userdata and the metatable fqn
@@ -1584,7 +1580,7 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
                 ASSERT_L( lua_istable( L2, -1));
                 lua_setmetatable( L2, -2);                                                                   // ... u
             }
-            STACK_MID( L2, 1);
+            STACK_CHECK( L2, 1);
         }
         else
         {
@@ -1595,206 +1591,210 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
         lua_pushvalue( L2, -2);                                                                              // ... u source u
         lua_rawset( L2, L2_cache_i);                                                                         // ... u
         // make sure we have the userdata now
-        if( eLM_ToKeeper == mode_)                                                                           // ... userdata_clone_sentinel
+        if( LookupMode::ToKeeper == mode_)                                                                   // ... userdata_clone_sentinel
         {
             lua_getupvalue( L2, -1, 2);                                                                      // ... userdata_clone_sentinel u
         }
         // assign uservalues
         while( uvi > 0)
         {
-            if(!inter_copy_one( U, L2, L2_cache_i, L, lua_absindex( L, -1), VT_NORMAL, mode_, upName_))      // ... u uv
+            if (!inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), VT::NORMAL, mode_, upName_))      // ... u uv
             {
-                (void) luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1));
+                luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1)); // doesn't return
             }
-            lua_pop( L, 1);                                                  // ... mt __lanesclone [uv]*
+            lua_pop( L, 1);                                                      // ... mt __lanesclone [uv]*
             // this pops the value from the stack
             lua_setiuservalue( L2, -2, uvi);                                                                 // ... u
             -- uvi;
         }
         // when we are done, all uservalues are popped from the source stack, and we want only the single transferred value in the destination
-        if( eLM_ToKeeper == mode_)                                                                           // ... userdata_clone_sentinel u
+        if( LookupMode::ToKeeper == mode_)                                                                   // ... userdata_clone_sentinel u
         {
             lua_pop( L2, 1);                                                                                 // ... userdata_clone_sentinel
         }
-        STACK_MID( L2, 1);
-        STACK_MID( L, 2);
+        STACK_CHECK( L2, 1);
+        STACK_CHECK( L, 2);
         // call cloning function in source state to perform the actual memory cloning
         lua_pushlightuserdata( L, clone);                                        // ... mt __lanesclone clone
         lua_pushlightuserdata( L, source);                                       // ... mt __lanesclone clone source
         lua_pushinteger( L, userdata_size);                                      // ... mt __lanesclone clone source size
         lua_call( L, 3, 0);                                                      // ... mt
-        STACK_MID( L, 1);
+        STACK_CHECK( L, 1);
     }
 
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
     lua_pop( L, 1);                                                              // ...
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK( L, 0);
+    return true;
 }
 
-static bool_t inter_copy_userdata( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    if( vt == VT_KEY)
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
     // try clonable userdata first
     if( copyclone( U, L2, L2_cache_i, L, i, mode_, upName_))
     {
-        STACK_MID( L, 0);
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK(L, 0);
+        STACK_CHECK(L2, 1);
+        return true;
     }
 
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);
 
     // Allow only deep userdata entities to be copied across
-    DEBUGSPEW_CODE( fprintf( stderr, "USERDATA\n"));
-    if( copydeep( U, L2, L2_cache_i, L, i, mode_, upName_))
+    DEBUGSPEW_CODE(fprintf(stderr, "USERDATA\n"));
+    if (copydeep(U, L2, L2_cache_i, L, i, mode_, upName_))
     {
-        STACK_MID( L, 0);
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK(L, 0);
+        STACK_CHECK(L2, 1);
+        return true;
     }
 
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);
 
     // Not a deep or clonable full userdata
-    if( U->demoteFullUserdata) // attempt demotion to light userdata
+    if (U->demoteFullUserdata) // attempt demotion to light userdata
     {
-        void* lud = lua_touserdata( L, i);
-        lua_pushlightuserdata( L2, lud);
+        void* lud = lua_touserdata(L, i);
+        lua_pushlightuserdata(L2, lud);
     }
     else // raise an error
     {
-        (void) luaL_error( L, "can't copy non-deep full userdata across lanes");
+        luaL_error(L, "can't copy non-deep full userdata across lanes"); // doesn't return
     }
 
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static bool_t inter_copy_function( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t source_i_, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, VT vt_, LookupMode mode_, char const* upName_)
 {
-    if( vt == VT_KEY)
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
-    STACK_CHECK( L, 0);                                                            // L (source)                 // L2 (destination)
-    STACK_CHECK( L2, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, "FUNCTION %s\n", upName_));
+    STACK_CHECK_START_REL(L, 0);                                                  // L (source)                 // L2 (destination)
+    STACK_CHECK_START_REL(L2, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, "FUNCTION %s\n", upName_));
 
-    if( lua_tocfunction( L, source_i_) == userdata_clone_sentinel) // we are actually copying a clonable full userdata from a keeper
+    if (lua_tocfunction(L, source_i_) == userdata_clone_sentinel) // we are actually copying a clonable full userdata from a keeper
     {
         // clone the full userdata again
-        size_t userdata_size = 0;
-        void* source;
-        void* clone;
 
         // let's see if we already restored this userdata
-        lua_getupvalue( L, source_i_, 2);                                          // ... u
-        source = lua_touserdata( L, -1);
-        lua_pushlightuserdata( L2, source);                                                                      // ... source
-        lua_rawget( L2, L2_cache_i);                                                                             // ... u?
-        if( !lua_isnil( L2, -1))
+        lua_getupvalue(L, source_i_, 2);                                          // ... u
+        void* source = lua_touserdata(L, -1);
+        lua_pushlightuserdata(L2, source);                                                                      // ... source
+        lua_rawget(L2, L2_cache_i);                                                                             // ... u?
+        if (!lua_isnil(L2, -1))
         {
-            lua_pop( L, 1);                                                        // ...
-            STACK_MID( L, 0);
-            STACK_MID( L2, 1);
-            return TRUE;
+            lua_pop(L, 1);                                                        // ...
+            STACK_CHECK(L, 0);
+            STACK_CHECK(L2, 1);
+            return true;
         }
-        lua_pop( L2, 1);                                                                                         // ...
+        lua_pop(L2, 1);                                                                                         // ...
 
         // this function has 2 upvalues: the fqn of its metatable, and the userdata itself
-        lookup_table( L2, L, source_i_, mode_, upName_);                                                         // ... mt
+        std::ignore = lookup_table(L2, L, source_i_, mode_, upName_);                                           // ... mt
         // originally 'source_i_' slot was the proxy closure, but from now on it indexes the actual userdata we extracted from it
-        source_i_ = lua_gettop( L);
-        source = lua_touserdata( L, -1);
+        source_i_ = lua_gettop(L);
+        source = lua_touserdata(L, -1);
+        void* clone{ nullptr };
         // get the number of bytes to allocate for the clone
-        userdata_size = (size_t) lua_rawlen( L, -1);
+        size_t const userdata_size{ lua_rawlen(L, -1) };
         {
             // extract uservalues (don't transfer them yet)
             int uvi = 0;
-            while( lua_getiuservalue( L, source_i_, ++ uvi) != LUA_TNONE) {}       // ... u uv
+            while (lua_getiuservalue(L, source_i_, ++uvi) != LUA_TNONE) {}        // ... u uv
             // when lua_getiuservalue() returned LUA_TNONE, it pushed a nil. pop it now
-            lua_pop( L, 1);                                                        // ... u [uv]*
-            -- uvi;
-            STACK_MID( L, uvi + 1);
+            lua_pop(L, 1);                                                        // ... u [uv]*
+            --uvi;
+            STACK_CHECK(L, uvi + 1);
             // create the clone userdata with the required number of uservalue slots
-            clone = lua_newuserdatauv( L2, userdata_size, uvi);                                                  // ... mt u
+            clone = lua_newuserdatauv(L2, userdata_size, uvi);                                                  // ... mt u
             // add it in the cache
-            lua_pushlightuserdata( L2, source);                                                                  // ... mt u source
-            lua_pushvalue( L2, -2);                                                                              // ... mt u source u
-            lua_rawset( L2, L2_cache_i);                                                                         // ... mt u
+            lua_pushlightuserdata(L2, source);                                                                  // ... mt u source
+            lua_pushvalue(L2, -2);                                                                              // ... mt u source u
+            lua_rawset(L2, L2_cache_i);                                                                         // ... mt u
             // set metatable
-            lua_pushvalue( L2, -2);                                                                              // ... mt u mt
-            lua_setmetatable( L2, -2);                                                                           // ... mt u
+            lua_pushvalue(L2, -2);                                                                              // ... mt u mt
+            lua_setmetatable(L2, -2);                                                                           // ... mt u
             // transfer and assign uservalues
-            while( uvi > 0)
+            while (uvi > 0)
             {
-                if(!inter_copy_one( U, L2, L2_cache_i, L, lua_absindex( L, -1), vt, mode_, upName_))             // ... mt u uv
+                if (!inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), vt_, mode_, upName_))            // ... mt u uv
                 {
-                    (void) luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1));
+                    luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1)); // doesn't return
                 }
-                lua_pop( L, 1);                                                    // ... u [uv]*
+                lua_pop(L, 1);                                                    // ... u [uv]*
                 // this pops the value from the stack
-                lua_setiuservalue( L2, -2, uvi);                                                                 // ... mt u
+                lua_setiuservalue(L2, -2, uvi);                                                                 // ... mt u
                 -- uvi;
             }
             // when we are done, all uservalues are popped from the stack, we can pop the source as well
-            lua_pop( L, 1);                                                        // ...
-            STACK_MID( L, 0);
-            STACK_MID( L2, 2);                                                                                   // ... mt u
+            lua_pop(L, 1);                                                        // ...
+            STACK_CHECK(L, 0);
+            STACK_CHECK(L2, 2);                                                                                 // ... mt u
         }
         // perform the custom cloning part
-        lua_insert( L2, -2);                                                                                     // ... u mt
+        lua_insert(L2, -2);                                                                                     // ... u mt
         // __lanesclone should always exist because we wouldn't be restoring data from a userdata_clone_sentinel closure to begin with
-        lua_getfield(L2, -1, "__lanesclone");                                                                    // ... u mt __lanesclone
-        lua_remove( L2, -2);                                                                                     // ... u __lanesclone
-        lua_pushlightuserdata( L2, clone);                                                                       // ... u __lanesclone clone
-        lua_pushlightuserdata( L2, source);                                                                      // ... u __lanesclone clone source
-        lua_pushinteger( L2, userdata_size);                                                                     // ... u __lanesclone clone source size
+        lua_getfield(L2, -1, "__lanesclone");                                                                   // ... u mt __lanesclone
+        lua_remove(L2, -2);                                                                                     // ... u __lanesclone
+        lua_pushlightuserdata(L2, clone);                                                                       // ... u __lanesclone clone
+        lua_pushlightuserdata(L2, source);                                                                      // ... u __lanesclone clone source
+        lua_pushinteger(L2, userdata_size);                                                                     // ... u __lanesclone clone source size
         // clone:__lanesclone(dest, source, size)
-        lua_call( L2, 3, 0);                                                                                     // ... u
+        lua_call(L2, 3, 0);                                                                                     // ... u
     }
     else // regular function
     {
-        DEBUGSPEW_CODE( fprintf( stderr, "FUNCTION %s\n", upName_));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        copy_cached_func( U, L2, L2_cache_i, L, source_i_, mode_, upName_);                                      // ... f
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(fprintf( stderr, "FUNCTION %s\n", upName_));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        copy_cached_func(U, L2, L2_cache_i, L, source_i_, mode_, upName_);                                      // ... f
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
     }
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    if( vt == VT_KEY)
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, "TABLE %s\n", upName_));
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, "TABLE %s\n", upName_));
 
     /*
-        * First, let's try to see if this table is special (aka is it some table that we registered in our lookup databases during module registration?)
-        * Note that this table CAN be a module table, but we just didn't register it, in which case we'll send it through the table cloning mechanism
-        */
-    if( lookup_table( L2, L, i, mode_, upName_))
+     * First, let's try to see if this table is special (aka is it some table that we registered in our lookup databases during module registration?)
+     * Note that this table CAN be a module table, but we just didn't register it, in which case we'll send it through the table cloning mechanism
+     */
+    if (lookup_table(L2, L, i, mode_, upName_))
     {
-        ASSERT_L( lua_istable( L2, -1) || (lua_tocfunction( L2, -1) == table_lookup_sentinel));    // from lookup datables // can also be table_lookup_sentinel if this is a table we know
-        return TRUE;
+        ASSERT_L(lua_istable(L2, -1) || (lua_tocfunction(L2, -1) == table_lookup_sentinel));  // from lookup data. can also be table_lookup_sentinel if this is a table we know
+        return true;
     }
 
     /* Check if we've already copied the same table from 'L' (during this transmission), and
@@ -1806,36 +1806,38 @@ static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, l
     * Note: Even metatables need to go through this test; to detect
     *       loops such as those in required module tables (getmetatable(lanes).lanes == lanes)
     */
-    if( push_cached_table( L2, L2_cache_i, L, i))
+    if (push_cached_table(L2, L2_cache_i, L, i))
     {
-        ASSERT_L( lua_istable( L2, -1));    // from cache
-        return TRUE;
+        ASSERT_L(lua_istable(L2, -1));    // from cache
+        return true;
     }
-    ASSERT_L( lua_istable( L2, -1));
+    ASSERT_L(lua_istable(L2, -1));
 
-    STACK_GROW( L, 2);
-    STACK_GROW( L2, 2);
+    STACK_GROW(L, 2);
+    STACK_GROW(L2, 2);
 
-    lua_pushnil( L);    // start iteration
-    while( lua_next( L, i))
+    lua_pushnil(L); // start iteration
+    while (lua_next(L, i))
     {
         // need a function to prevent overflowing the stack with verboseErrors-induced alloca()
-        inter_copy_keyvaluepair( U, L2, L2_cache_i, L, vt, mode_, upName_);
-        lua_pop( L, 1);    // pop value (next round)
+        inter_copy_keyvaluepair(U, L2, L2_cache_i, L, vt_, mode_, upName_);
+        lua_pop(L, 1);    // pop value (next round)
     }
-    STACK_MID( L, 0);
-    STACK_MID( L2, 1);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 1);
 
     // Metatables are expected to be immutable, and copied only once.
-    if( push_cached_metatable( U, L2, L2_cache_i, L, i, mode_, upName_))                                   // ... t mt?
+    if (push_cached_metatable(U, L2, L2_cache_i, L, i, mode_, upName_))                                   // ... t mt?
     {
-        lua_setmetatable( L2, -2);                                                                           // ... t
+        lua_setmetatable(L2, -2);                                                                         // ... t
     }
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
+// #################################################################################################
+
 /*
 * Copies a value from 'L' state (at index 'i') to 'L2' state. Does not remove
 * the original value.
@@ -1844,23 +1846,23 @@ static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, l
 *
 * 'i' is an absolute index (no -1, ...)
 *
-* Returns TRUE if value was pushed, FALSE if its type is non-supported.
+* Returns true if value was pushed, false if its type is non-supported.
 */
-bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+[[nodiscard]] bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    bool_t ret = TRUE;
-    int val_type = lua_type( L, i);
-    static int const pod_mask = (1 << LUA_TNIL) | (1 << LUA_TBOOLEAN) | (1 << LUA_TLIGHTUSERDATA) | (1 << LUA_TNUMBER) | (1 << LUA_TSTRING);
+    bool ret{ true };
+    LuaType val_type{ lua_type_as_enum(L, i) };
+    static constexpr int pod_mask = (1 << LUA_TNIL) | (1 << LUA_TBOOLEAN) | (1 << LUA_TLIGHTUSERDATA) | (1 << LUA_TNUMBER) | (1 << LUA_TSTRING);
     STACK_GROW( L2, 1);
-    STACK_CHECK( L, 0);                                                          // L                          // L2
-    STACK_CHECK( L2, 0);                                                         // L                          // L2
+    STACK_CHECK_START_REL(L, 0);                                                       // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                                      // L                          // L2
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "inter_copy_one()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s %s: " INDENT_END, lua_type_names[val_type], vt_names[vt]));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s %s: " INDENT_END, lua_type_names[val_type], vt_names[static_cast<int>(vt_)]));
 
     // Non-POD can be skipped if its metatable contains { __lanesignore = true }
-    if( ((1 << val_type) & pod_mask) == 0)
+    if( ((1 << static_cast<int>(val_type)) & pod_mask) == 0)
     {
         if( lua_getmetatable( L, i))                                               // ... mt
         {
@@ -1868,27 +1870,27 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             if( lua_isboolean( L, -1) && lua_toboolean( L, -1))
             {
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "__lanesignore -> LUA_TNIL\n" INDENT_END));
-                val_type = LUA_TNIL;
+                val_type = LuaType::NIL;
             }
             lua_pop( L, 2);                                                          // ...
         }
     }
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
 
     /* Lets push nil to L2 if the object should be ignored */
     switch( val_type)
     {
         /* Basic types allowed both as values, and as table keys */
 
-        case LUA_TBOOLEAN:
+        case LuaType::BOOLEAN:
         {
-            bool_t v = lua_toboolean( L, i);
+            int const v{ lua_toboolean(L, i) };
             DEBUGSPEW_CODE( fprintf( stderr, "%s\n", v ? "true" : "false"));
             lua_pushboolean( L2, v);
         }
         break;
 
-        case LUA_TNUMBER:
+        case LuaType::NUMBER:
         /* LNUM patch support (keeping integer accuracy) */
 #if defined LUA_LNUM || LUA_VERSION_NUM >= 503
         if( lua_isinteger( L, i))
@@ -1907,7 +1909,7 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         break;
 
-        case LUA_TSTRING:
+        case LuaType::STRING:
         {
             size_t len;
             char const* s = lua_tolstring( L, i, &len);
@@ -1916,7 +1918,7 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         break;
 
-        case LUA_TLIGHTUSERDATA:
+        case LuaType::LIGHTUSERDATA:
         {
             void* p = lua_touserdata( L, i);
             DEBUGSPEW_CODE( fprintf( stderr, "%p\n", p));
@@ -1926,42 +1928,44 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 
         /* The following types are not allowed as table keys */
 
-        case LUA_TUSERDATA:
-        ret = inter_copy_userdata( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::USERDATA:
+        ret = inter_copy_userdata(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
-        case LUA_TNIL:
-        if( vt == VT_KEY)
+        case LuaType::NIL:
+        if (vt_ == VT::KEY)
         {
-            ret = FALSE;
+            ret = false;
             break;
         }
         lua_pushnil( L2);
         break;
 
-        case LUA_TFUNCTION:
-        ret = inter_copy_function( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::FUNCTION:
+        ret = inter_copy_function(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
-        case LUA_TTABLE:
-        ret = inter_copy_table( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::TABLE:
+        ret = inter_copy_table(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
         /* The following types cannot be copied */
 
-        case 10: // LuaJIT CDATA
-        case LUA_TTHREAD:
-        ret = FALSE;
+        case LuaType::CDATA:
+        case LuaType::THREAD:
+        ret = false;
         break;
     }
 
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 
-    STACK_END( L2, ret ? 1 : 0);
-    STACK_END( L, 0);
+    STACK_CHECK( L2, ret ? 1 : 0);
+    STACK_CHECK( L, 0);
     return ret;
 }
 
+// #################################################################################################
+
 /*
 * Akin to 'lua_xmove' but copies values between _any_ Lua states.
 *
@@ -1969,128 +1973,137 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 *
 * Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'.
 */
-InterCopyResult luaG_inter_copy( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_)
+[[nodiscard]] InterCopyResult luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
 {
-    uint_t top_L = lua_gettop( L);                                    // ... {}n
-    uint_t top_L2 = lua_gettop( L2);                                                               // ...
-    uint_t i, j;
+    int const top_L{ lua_gettop(L) };                             // ... {}n
+    int const top_L2{ lua_gettop(L2) };                                                             // ...
     char tmpBuf[16];
-    char const* pBuf = U->verboseErrors ? tmpBuf : "?";
-    bool_t copyok = TRUE;
+    char const* pBuf{ U->verboseErrors ? tmpBuf : "?" };
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    if( n > top_L)
+    if (n > top_L)
     {
         // requesting to copy more than is available?
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-        return eICR_NotEnoughValues;
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+        return InterCopyResult::NotEnoughValues;
     }
 
-    STACK_CHECK( L2, 0);
-    STACK_GROW( L2, n + 1);
+    STACK_CHECK_START_REL(L2, 0);
+    STACK_GROW(L2, n + 1);
 
     /*
     * Make a cache table for the duration of this copy. Collects tables and
     * function entries, avoiding the same entries to be passed on as multiple
     * copies. ESSENTIAL i.e. for handling upvalue tables in the right manner!
     */
-    lua_newtable( L2);                                                                              // ... cache
+    lua_newtable(L2);                                                                               // ... cache
 
-    STACK_CHECK( L, 0);
-    for( i = top_L - n + 1, j = 1; i <= top_L; ++ i, ++ j)
+    STACK_CHECK_START_REL(L, 0);
+    bool copyok{ true };
+    for (int i = top_L - n + 1, j = 1; i <= top_L; ++i, ++j)
     {
-        if( U->verboseErrors)
+        if (U->verboseErrors)
         {
-            sprintf( tmpBuf, "arg_%d", j);
+            sprintf(tmpBuf, "arg_%d", j);
         }
-        copyok = inter_copy_one( U, L2, top_L2 + 1, L, i, VT_NORMAL, mode_, pBuf);                    // ... cache {}n
-        if( !copyok)
+        copyok = inter_copy_one(U, L2, top_L2 + 1, L, i, VT::NORMAL, mode_, pBuf);                  // ... cache {}n
+        if (!copyok)
         {
             break;
         }
     }
-    STACK_END( L, 0);
+    STACK_CHECK(L, 0);
 
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 
-    if( copyok)
+    if (copyok)
     {
-        STACK_MID( L2, n + 1);
+        STACK_CHECK(L2, n + 1);
         // Remove the cache table. Persistent caching would cause i.e. multiple
         // messages passed in the same table to use the same table also in receiving end.
-        lua_remove( L2, top_L2 + 1);
-        return eICR_Success;
+        lua_remove(L2, top_L2 + 1);
+        return InterCopyResult::Success;
     }
 
     // error -> pop everything from the target state stack
-    lua_settop( L2, top_L2);
-    STACK_END( L2, 0);
-    return eICR_Error;
+    lua_settop(L2, top_L2);
+    STACK_CHECK(L2, 0);
+    return InterCopyResult::Error;
 }
 
+// #################################################################################################
 
-InterCopyResult luaG_inter_move( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_)
+[[nodiscard]] InterCopyResult luaG_inter_move(Universe* U, Source L, Dest L2, int n_, LookupMode mode_)
 {
-    InterCopyResult ret = luaG_inter_copy( U, L, L2, n, mode_);
-    lua_pop( L, (int) n);
+    InterCopyResult const ret{ luaG_inter_copy(U, L, L2, n_, mode_) };
+    lua_pop( L, n_);
     return ret;
 }
 
-InterCopyResult luaG_inter_copy_package( Universe* U, lua_State* L, lua_State* L2, int package_idx_, LookupMode mode_)
+// #################################################################################################
+
+// transfers stuff from L->_G["package"] to L2->_G["package"]
+// returns InterCopyResult::Success if everything is fine
+// returns InterCopyResult::Error if pushed an error message in L
+// else raise an error in L
+[[nodiscard]] InterCopyResult luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_)
 {
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
     // package
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    package_idx_ = lua_absindex( L, package_idx_);
-    if( lua_type( L, package_idx_) != LUA_TTABLE)
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    package_idx_ = lua_absindex(L, package_idx_);
+    if (lua_type(L, package_idx_) != LUA_TTABLE)
     {
-        lua_pushfstring( L, "expected package as table, got %s", luaL_typename( L, package_idx_));
-        STACK_MID( L, 1);
+        lua_pushfstring(L, "expected package as table, got %s", luaL_typename(L, package_idx_));
+        STACK_CHECK(L, 1);
         // raise the error when copying from lane to lane, else just leave it on the stack to be raised later
-        if (mode_ == eLM_LaneBody)
+        if (mode_ == LookupMode::LaneBody)
         {
             lua_error(L); // doesn't return
         }
-        return eICR_Error;
+        return InterCopyResult::Error;
     }
-    lua_getglobal( L2, "package");
-    if( !lua_isnil( L2, -1)) // package library not loaded: do nothing
+    lua_getglobal(L2, "package");
+    if (!lua_isnil(L2, -1)) // package library not loaded: do nothing
     {
-        int i;
         // package.loaders is renamed package.searchers in Lua 5.2
         // but don't copy it anyway, as the function names change depending on the slot index!
         // users should provide an on_state_create function to setup custom loaders instead
         // don't copy package.preload in keeper states (they don't know how to translate functions)
-        char const* entries[] = { "path", "cpath", (mode_ == eLM_LaneBody) ? "preload" : NULL/*, (LUA_VERSION_NUM == 501) ? "loaders" : "searchers"*/, NULL};
-        for( i = 0; entries[i]; ++ i)
+        char const* entries[] = { "path", "cpath", (mode_ == LookupMode::LaneBody) ? "preload" : nullptr /*, (LUA_VERSION_NUM == 501) ? "loaders" : "searchers"*/, nullptr };
+        for (char const* const entry : entries)
         {
-            DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "package.%s\n" INDENT_END, entries[i]));
-            lua_getfield( L, package_idx_, entries[i]);
-            if( lua_isnil( L, -1))
+            if (!entry)
+            {
+                continue;
+            }
+            DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "package.%s\n" INDENT_END, entry));
+            lua_getfield(L, package_idx_, entry);
+            if (lua_isnil(L, -1))
             {
-                lua_pop( L, 1);
+                lua_pop(L, 1);
             }
             else
             {
-                DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-                luaG_inter_move( U, L, L2, 1, mode_); // moves the entry to L2
-                DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-                lua_setfield( L2, -2, entries[i]); // set package[entries[i]]
+                DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+                std::ignore = luaG_inter_move(U, L, L2, 1, mode_); // moves the entry to L2
+                DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+                lua_setfield(L2, -2, entry); // set package[entry]
             }
         }
     }
     else
     {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "'package' not loaded, nothing to do\n" INDENT_END));
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "'package' not loaded, nothing to do\n" INDENT_END));
     }
-    lua_pop( L2, 1);
-    STACK_END( L2, 0);
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    return eICR_Success;
+    lua_pop(L2, 1);
+    STACK_CHECK(L2, 0);
+    STACK_CHECK(L, 0);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    return InterCopyResult::Success;
 }