C++ migration: lots of noise, but it's only some minor code cleanup

6 files changed, 773 insertions, 746 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index c0867a9..8b8977b 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -55,9 +55,9 @@ THE SOFTWARE.
 */
 static inline CancelRequest cancel_test(lua_State* L)
 {
-    Lane* const s = get_lane_from_registry( L);
+    Lane* const lane{ get_lane_from_registry(L) };
     // 's' is nullptr for the original main state (and no-one can cancel that)
-    return s ? s->cancel_request : CancelRequest::None;
+    return lane ? lane->cancel_request : CancelRequest::None;
 }
 
 // ################################################################################################
@@ -111,38 +111,36 @@ static void cancel_hook(lua_State* L, [[maybe_unused]] lua_Debug* ar)
 
 // ################################################################################################
 
-static CancelResult thread_cancel_soft(Lane* s, double secs_, bool wake_lindas_)
+static CancelResult thread_cancel_soft(Lane* lane_, double secs_, bool wake_lindas_)
 {
-    s->cancel_request = CancelRequest::Soft; // it's now signaled to stop
+    lane_->cancel_request = CancelRequest::Soft; // it's now signaled to stop
     // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
-    if( wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
+    if (wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
     {
-        SIGNAL_T* waiting_on = s->waiting_on;
-        if( s->status == WAITING && waiting_on != nullptr)
+        SIGNAL_T* const waiting_on{ lane_->waiting_on };
+        if (lane_->status == WAITING && waiting_on != nullptr)
         {
             SIGNAL_ALL( waiting_on);
         }
     }
 
-    return THREAD_WAIT(&s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CancelResult::Cancelled : CancelResult::Timeout;
+    return THREAD_WAIT(&lane_->thread, secs_, &lane_->done_signal, &lane_->done_lock, &lane_->status) ? CancelResult::Cancelled : CancelResult::Timeout;
 }
 
 // ################################################################################################
 
-static CancelResult thread_cancel_hard(lua_State* L, Lane* s, double secs_, bool force_, double waitkill_timeout_)
+static CancelResult thread_cancel_hard(lua_State* L, Lane* lane_, double secs_, bool force_, double waitkill_timeout_)
 {
-    CancelResult result;
-
-    s->cancel_request = CancelRequest::Hard; // it's now signaled to stop
+    lane_->cancel_request = CancelRequest::Hard; // it's now signaled to stop
     {
-        SIGNAL_T* waiting_on = s->waiting_on;
-        if( s->status == WAITING && waiting_on != nullptr)
+        SIGNAL_T* waiting_on = lane_->waiting_on;
+        if (lane_->status == WAITING && waiting_on != nullptr)
         {
             SIGNAL_ALL( waiting_on);
         }
     }
 
-    result = THREAD_WAIT(&s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CancelResult::Cancelled : CancelResult::Timeout;
+    CancelResult result{ THREAD_WAIT(&lane_->thread, secs_, &lane_->done_signal, &lane_->done_lock, &lane_->status) ? CancelResult::Cancelled : CancelResult::Timeout };
 
     if ((result == CancelResult::Timeout) && force_)
     {
@@ -151,11 +149,11 @@ static CancelResult thread_cancel_hard(lua_State* L, Lane* s, double secs_, bool
         // would be use of "cancellation cleanup handlers" that at least
         // PThread seems to have).
         //
-        THREAD_KILL( &s->thread);
+        THREAD_KILL(&lane_->thread);
 #if THREADAPI == THREADAPI_PTHREAD
         // pthread: make sure the thread is really stopped!
         // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
-        result = THREAD_WAIT(&s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status) ? CancelResult::Killed : CancelResult::Timeout;
+        result = THREAD_WAIT(&lane_->thread, waitkill_timeout_, &lane_->done_signal, &lane_->done_lock, &lane_->status) ? CancelResult::Killed : CancelResult::Timeout;
         if (result == CancelResult::Timeout)
         {
             std::ignore = luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
@@ -164,8 +162,8 @@ static CancelResult thread_cancel_hard(lua_State* L, Lane* s, double secs_, bool
         (void) waitkill_timeout_; // unused
         (void) L; // unused
 #endif // THREADAPI == THREADAPI_PTHREAD
-        s->mstatus = ThreadStatus::Killed; // mark 'gc' to wait for it
-        // note that s->status value must remain to whatever it was at the time of the kill
+        lane_->mstatus = ThreadStatus::Killed; // mark 'gc' to wait for it
+        // note that lane_->status value must remain to whatever it was at the time of the kill
         // because we need to know if we can lua_close() the Lua State or not.
         result = CancelResult::Killed;
     }
@@ -174,16 +172,16 @@ static CancelResult thread_cancel_hard(lua_State* L, Lane* s, double secs_, bool
 
 // ################################################################################################
 
-CancelResult thread_cancel(lua_State* L, Lane* s, CancelOp op_, double secs_, bool force_, double waitkill_timeout_)
+CancelResult thread_cancel(lua_State* L, Lane* lane_, CancelOp op_, double secs_, bool force_, double waitkill_timeout_)
 {
     // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
-    // We can read 's->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
-    if (s->mstatus == ThreadStatus::Killed)
+    // We can read 'lane_->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
+    if (lane_->mstatus == ThreadStatus::Killed)
     {
         return CancelResult::Killed;
     }
 
-    if( s->status >= DONE)
+    if (lane_->status >= DONE)
     {
         // say "ok" by default, including when lane is already done
         return CancelResult::Cancelled;
@@ -191,12 +189,12 @@ CancelResult thread_cancel(lua_State* L, Lane* s, CancelOp op_, double secs_, bo
 
     // signal the linda the wake up the thread so that it can react to the cancel query
     // let us hope we never land here with a pointer on a linda that has been destroyed...
-    if( op_ == CO_Soft)
+    if (op_ == CO_Soft)
     {
-        return thread_cancel_soft( s, secs_, force_);
+        return thread_cancel_soft(lane_, secs_, force_);
     }
 
-    return thread_cancel_hard( L, s, secs_, force_, waitkill_timeout_);
+    return thread_cancel_hard(L, lane_, secs_, force_, waitkill_timeout_);
 }
 
 // ################################################################################################
@@ -247,54 +245,51 @@ static CancelOp which_op( lua_State* L, int idx_)
 // ################################################################################################
 
 // bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, force [, forcekill_timeout]])
-LUAG_FUNC( thread_cancel)
+LUAG_FUNC(thread_cancel)
 {
-    Lane* s = lua_toLane( L, 1);
-    double secs = 0.0;
-    CancelOp op = which_op( L, 2); // this removes the op string from the stack
+    Lane* const lane{ lua_toLane(L, 1) };
+    CancelOp const op{ which_op(L, 2) }; // this removes the op string from the stack
 
-    if( op > 0) // hook is requested
+    if (op > 0) // hook is requested
     {
-        int hook_count = (int) lua_tointeger( L, 2);
-        lua_remove( L, 2); // argument is processed, remove it
-        if( hook_count < 1)
+        int hook_count = (int) lua_tointeger(L, 2);
+        lua_remove(L, 2); // argument is processed, remove it
+        if (hook_count < 1)
         {
-            return luaL_error( L, "hook count cannot be < 1");
+            return luaL_error(L, "hook count cannot be < 1");
         }
-        lua_sethook( s->L, cancel_hook, op, hook_count);
+        lua_sethook(lane->L, cancel_hook, op, hook_count);
     }
 
-    if( lua_type( L, 2) == LUA_TNUMBER)
+    double secs{ 0.0 };
+    if (lua_type(L, 2) == LUA_TNUMBER)
     {
-        secs = lua_tonumber( L, 2);
-        lua_remove( L, 2); // argument is processed, remove it
-        if( secs < 0.0)
+        secs = lua_tonumber(L, 2);
+        lua_remove(L, 2); // argument is processed, remove it
+        if (secs < 0.0)
         {
-            return luaL_error( L, "cancel timeout cannot be < 0");
+            return luaL_error(L, "cancel timeout cannot be < 0");
         }
     }
 
+    bool const force{ lua_toboolean(L, 2) ? true : false }; // false if nothing there
+    double const forcekill_timeout{ luaL_optnumber(L, 3, 0.0) };
+    switch (thread_cancel(L, lane, op, secs, force, forcekill_timeout))
     {
-        bool const force = lua_toboolean( L, 2) ? true : false;     // false if nothing there
-        double forcekill_timeout = luaL_optnumber( L, 3, 0.0);
-
-        switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
-        {
-            case CancelResult::Timeout:
-            lua_pushboolean( L, 0);
-            lua_pushstring( L, "timeout");
-            return 2;
-
-            case CancelResult::Cancelled:
-            lua_pushboolean( L, 1);
-            push_thread_status( L, s);
-            return 2;
-
-            case CancelResult::Killed:
-            lua_pushboolean( L, 1);
-            push_thread_status( L, s);
-            return 2;
-        }
+        case CancelResult::Timeout:
+        lua_pushboolean(L, 0);
+        lua_pushstring(L, "timeout");
+        return 2;
+
+        case CancelResult::Cancelled:
+        lua_pushboolean(L, 1);
+        push_thread_status(L, lane);
+        return 2;
+
+        case CancelResult::Killed:
+        lua_pushboolean(L, 1);
+        push_thread_status(L, lane);
+        return 2;
     }
     // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
     return 0;
diff --git a/src/cancel.h b/src/cancel.h
index 9299ae1..9cd7d5b 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -51,7 +51,7 @@ static constexpr UniqueKey CANCEL_ERROR{ 0xe97d41626cc97577ull }; // 'raise_canc
 // crc64/we of string "CANCEL_TEST_KEY" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey CANCEL_TEST_KEY{ 0xe66f5960c57d133aull }; // used as registry key
 
-CancelResult thread_cancel(lua_State* L, Lane* s, CancelOp op_, double secs_, bool force_, double waitkill_timeout_);
+CancelResult thread_cancel(lua_State* L, Lane* lane_, CancelOp op_, double secs_, bool force_, double waitkill_timeout_);
 
 [[noreturn]] static inline void raise_cancel_error(lua_State* L)
 {
@@ -63,7 +63,7 @@ CancelResult thread_cancel(lua_State* L, Lane* s, CancelOp op_, double secs_, bo
 // ################################################################################################
 // ################################################################################################
 
-LUAG_FUNC( cancel_test);
-LUAG_FUNC( thread_cancel);
+LUAG_FUNC(cancel_test);
+LUAG_FUNC(thread_cancel);
 
 // ################################################################################################
diff --git a/src/compat.h b/src/compat.h
index 46c31cf..8ef1b6c 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -95,5 +95,6 @@ int lua_setiuservalue( lua_State* L, int idx, int n);
 #define luaG_registerlibfuncs( L, _funcs) luaL_setfuncs( L, _funcs, 0)
 #define lua504_dump lua_dump
 #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
+#define LUA_ERRGCMM 666 // doesn't exist in Lua 5.4, we don't care about the actual value
 
 #endif // LUA_VERSION_NUM == 504
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 9c41b1c..f88d0ab 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -64,7 +64,7 @@ class keeper_fifo
     static void* operator new(size_t size_, lua_State* L) noexcept { return lua_newuserdatauv<keeper_fifo>(L, 1); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
-    static void operator delete(void* p_, lua_State* L){ ASSERT_L(!"should never be called") };
+    static void operator delete(void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
 
     static keeper_fifo* getPtr(lua_State* L, int idx_)
     {
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 2f17e6e..86972f7 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -111,18 +111,18 @@ THE SOFTWARE.
 #define ERROR_FULL_STACK 1 // must be either 0 or 1 as we do some index arithmetics with it!
 
 // intern the debug name in the specified lua state so that the pointer remains valid when the lane's state is closed
-static void securize_debug_threadname( lua_State* L, Lane* s)
+static void securize_debug_threadname(lua_State* L, Lane* lane_)
 {
     STACK_CHECK_START_REL(L, 0);
-    STACK_GROW( L, 3);
-    lua_getiuservalue( L, 1, 1);
-    lua_newtable( L);
-    // Lua 5.1 can't do 's->debug_name = lua_pushstring( L, s->debug_name);'
-    lua_pushstring( L, s->debug_name);
-    s->debug_name = lua_tostring( L, -1);
-    lua_rawset( L, -3);
-    lua_pop( L, 1);
-    STACK_CHECK( L, 0);
+    STACK_GROW(L, 3);
+    lua_getiuservalue(L, 1, 1);
+    lua_newtable(L);
+    // Lua 5.1 can't do 'lane_->debug_name = lua_pushstring(L, lane_->debug_name);'
+    lua_pushstring(L, lane_->debug_name);
+    lane_->debug_name = lua_tostring(L, -1);
+    lua_rawset(L, -3);
+    lua_pop(L, 1);
+    STACK_CHECK(L, 0);
 }
 
 #if ERROR_FULL_STACK
@@ -142,6 +142,8 @@ static constexpr UniqueKey STACKTRACE_REGKEY{ 0x534af7d3226a429full };
 // crc64/we of string "FINALIZER_REGKEY" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey FINALIZER_REGKEY{ 0x188fccb8bf348e09ull };
 
+// #################################################################################################
+
 /*
 * Push a table stored in registry onto Lua stack.
 *
@@ -152,16 +154,16 @@ static constexpr UniqueKey FINALIZER_REGKEY{ 0x188fccb8bf348e09ull };
 */
 static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
 {
-    STACK_GROW( L, 3);
+    STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
 
     key.query_registry(L);                                                       // ?
-    if( lua_isnil( L, -1))                                                       // nil?
+    if (lua_isnil(L, -1))                                                       // nil?
     {
-        lua_pop( L, 1);                                                            //
+        lua_pop(L, 1);                                                            //
         STACK_CHECK(L, 0);
 
-        if( !create)
+        if (!create)
         {
             return false;
         }
@@ -169,10 +171,12 @@ static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
         lua_newtable( L);                                                          // t
         key.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
     }
-    STACK_CHECK( L, 1);
+    STACK_CHECK(L, 1);
     return true;    // table pushed
 }
 
+// #################################################################################################
+
 #if HAVE_LANE_TRACKING()
 
 // The chain is ended by '(Lane*)(-1)', not nullptr:
@@ -183,76 +187,73 @@ static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
  * Add the lane to tracking chain; the ones still running at the end of the
  * whole process will be cancelled.
  */
-static void tracking_add(Lane* s)
+static void tracking_add(Lane* lane_)
 {
+    std::lock_guard<std::mutex> guard{ lane_->U->tracking_cs };
+    assert(lane_->tracking_next == nullptr);
 
-    s->U->tracking_cs.lock();
-    {
-        assert( s->tracking_next == nullptr);
-
-        s->tracking_next = s->U->tracking_first;
-        s->U->tracking_first = s;
-    }
-    s->U->tracking_cs.unlock();
+    lane_->tracking_next = lane_->U->tracking_first;
+    lane_->U->tracking_first = lane_;
 }
 
+// #################################################################################################
+
 /*
  * A free-running lane has ended; remove it from tracking chain
  */
-static bool tracking_remove(Lane* s)
+static bool tracking_remove(Lane* lane_)
 {
     bool found{ false };
-    s->U->tracking_cs.lock();
+    std::lock_guard<std::mutex> guard{ lane_->U->tracking_cs };
+    // Make sure (within the MUTEX) that we actually are in the chain
+    // still (at process exit they will remove us from chain and then
+    // cancel/kill).
+    //
+    if (lane_->tracking_next != nullptr)
     {
-        // Make sure (within the MUTEX) that we actually are in the chain
-        // still (at process exit they will remove us from chain and then
-        // cancel/kill).
-        //
-        if( s->tracking_next != nullptr)
-        {
-            Lane** ref = (Lane**) &s->U->tracking_first;
+        Lane** ref = (Lane**) &lane_->U->tracking_first;
 
-            while( *ref != TRACKING_END)
+        while( *ref != TRACKING_END)
+        {
+            if (*ref == lane_)
             {
-                if( *ref == s)
-                {
-                    *ref = s->tracking_next;
-                    s->tracking_next = nullptr;
-                    found = true;
-                    break;
-                }
-                ref = (Lane**) &((*ref)->tracking_next);
+                *ref = lane_->tracking_next;
+                lane_->tracking_next = nullptr;
+                found = true;
+                break;
             }
-            assert( found);
+            ref = (Lane**) &((*ref)->tracking_next);
         }
+        assert( found);
     }
-    s->U->tracking_cs.unlock();
     return found;
 }
 
 #endif // HAVE_LANE_TRACKING()
 
+// #################################################################################################
+
 //---
 // low-level cleanup
 
-static void lane_cleanup( Lane* s)
+static void lane_cleanup(Lane* lane_)
 {
     // Clean up after a (finished) thread
     //
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    SIGNAL_FREE( &s->done_signal);
-    MUTEX_FREE( &s->done_lock);
+    SIGNAL_FREE(&lane_->done_signal);
+    MUTEX_FREE(&lane_->done_lock);
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
 
 #if HAVE_LANE_TRACKING()
-    if( s->U->tracking_first != nullptr)
+    if (lane_->U->tracking_first != nullptr)
     {
         // Lane was cleaned up, no need to handle at process termination
-        tracking_remove( s);
+        tracking_remove(lane_);
     }
 #endif // HAVE_LANE_TRACKING()
 
-    s->U->internal_allocator.free(s, sizeof(Lane));
+    lane_->U->internal_allocator.free(lane_, sizeof(Lane));
 }
 
 /*
@@ -271,15 +272,15 @@ static void lane_cleanup( Lane* s)
 //
 LUAG_FUNC( set_finalizer)
 {
-    luaL_argcheck( L, lua_isfunction( L, 1), 1, "finalizer should be a function");
-    luaL_argcheck( L, lua_gettop( L) == 1, 1, "too many arguments");
+    luaL_argcheck(L, lua_isfunction(L, 1), 1, "finalizer should be a function");
+    luaL_argcheck(L, lua_gettop( L) == 1, 1, "too many arguments");
     // Get the current finalizer table (if any)
-    push_registry_table( L, FINALIZER_REGKEY, true /*do create if none*/);      // finalizer {finalisers}
-    STACK_GROW( L, 2);
-    lua_pushinteger( L, lua_rawlen( L, -1) + 1);                                 // finalizer {finalisers} idx
-    lua_pushvalue( L, 1);                                                        // finalizer {finalisers} idx finalizer
-    lua_rawset( L, -3);                                                          // finalizer {finalisers}
-    lua_pop( L, 2);                                                              //
+    push_registry_table(L, FINALIZER_REGKEY, true /*do create if none*/);      // finalizer {finalisers}
+    STACK_GROW(L, 2);
+    lua_pushinteger(L, lua_rawlen(L, -1) + 1);                                 // finalizer {finalisers} idx
+    lua_pushvalue(L, 1);                                                        // finalizer {finalisers} idx finalizer
+    lua_rawset(L, -3);                                                          // finalizer {finalisers}
+    lua_pop(L, 2);                                                              //
     return 0;
 }
 
@@ -305,44 +306,44 @@ static int run_finalizers( lua_State* L, int lua_rc)
     int n;
     int err_handler_index = 0;
     int rc = LUA_OK;                                                                // ...
-    if( !push_registry_table( L, FINALIZER_REGKEY, false))                          // ... finalizers?
+    if (!push_registry_table(L, FINALIZER_REGKEY, false))                          // ... finalizers?
     {
         return 0;   // no finalizers
     }
 
-    STACK_GROW( L, 5);
+    STACK_GROW(L, 5);
 
     finalizers_index = lua_gettop( L);
 
 #if ERROR_FULL_STACK
-    lua_pushcfunction( L, lane_error);                                              // ... finalizers lane_error
+    lua_pushcfunction(L, lane_error);                                              // ... finalizers lane_error
     err_handler_index = lua_gettop( L);
 #endif // ERROR_FULL_STACK
 
-    for( n = (int) lua_rawlen( L, finalizers_index); n > 0; -- n)
+    for( n = (int) lua_rawlen(L, finalizers_index); n > 0; -- n)
     {
         int args = 0;
-        lua_pushinteger( L, n);                                                       // ... finalizers lane_error n
-        lua_rawget( L, finalizers_index);                                             // ... finalizers lane_error finalizer
-        ASSERT_L( lua_isfunction( L, -1));
-        if( lua_rc != LUA_OK) // we have an error message and an optional stack trace at the bottom of the stack
+        lua_pushinteger(L, n);                                                       // ... finalizers lane_error n
+        lua_rawget(L, finalizers_index);                                             // ... finalizers lane_error finalizer
+        ASSERT_L( lua_isfunction(L, -1));
+        if (lua_rc != LUA_OK) // we have an error message and an optional stack trace at the bottom of the stack
         {
             ASSERT_L( finalizers_index == 2 || finalizers_index == 3);
-            //char const* err_msg = lua_tostring( L, 1);
-            lua_pushvalue( L, 1);                                                       // ... finalizers lane_error finalizer err_msg
+            //char const* err_msg = lua_tostring(L, 1);
+            lua_pushvalue(L, 1);                                                       // ... finalizers lane_error finalizer err_msg
             // note we don't always have a stack trace for example when CANCEL_ERROR, or when we got an error that doesn't call our handler, such as LUA_ERRMEM
-            if( finalizers_index == 3)
+            if (finalizers_index == 3)
             {
-                lua_pushvalue( L, 2);                                                     // ... finalizers lane_error finalizer err_msg stack_trace
+                lua_pushvalue(L, 2);                                                     // ... finalizers lane_error finalizer err_msg stack_trace
             }
             args = finalizers_index - 1;
         }
 
         // if no error from the main body, finalizer doesn't receive any argument, else it gets the error message and optional stack trace
-        rc = lua_pcall( L, args, 0, err_handler_index);                               // ... finalizers lane_error err_msg2?
-        if( rc != LUA_OK)
+        rc = lua_pcall(L, args, 0, err_handler_index);                               // ... finalizers lane_error err_msg2?
+        if (rc != LUA_OK)
         {
-            push_stack_trace( L, rc, lua_gettop( L));
+            push_stack_trace(L, rc, lua_gettop( L));
             // If one finalizer fails, don't run the others. Return this
             // as the 'real' error, replacing what we could have had (or not)
             // from the actual code.
@@ -351,21 +352,21 @@ static int run_finalizers( lua_State* L, int lua_rc)
         // no error, proceed to next finalizer                                        // ... finalizers lane_error
     }
 
-    if( rc != LUA_OK)
+    if (rc != LUA_OK)
     {
         // ERROR_FULL_STACK accounts for the presence of lane_error on the stack
         int nb_err_slots = lua_gettop( L) - finalizers_index - ERROR_FULL_STACK;
         // a finalizer generated an error, this is what we leave of the stack
         for( n = nb_err_slots; n > 0; -- n)
         {
-            lua_replace( L, n);
+            lua_replace(L, n);
         }
         // leave on the stack only the error and optional stack trace produced by the error in the finalizer
-        lua_settop( L, nb_err_slots);
+        lua_settop(L, nb_err_slots);
     }
     else // no error from the finalizers, make sure only the original return values from the lane body remain on the stack
     {
-        lua_settop( L, finalizers_index - 1);
+        lua_settop(L, finalizers_index - 1);
     }
 
     return rc;
@@ -389,49 +390,45 @@ static int run_finalizers( lua_State* L, int lua_rc)
  * Add the lane to selfdestruct chain; the ones still running at the end of the
  * whole process will be cancelled.
  */
-static void selfdestruct_add( Lane* s)
+static void selfdestruct_add(Lane* lane_)
 {
-    s->U->selfdestruct_cs.lock();
-    assert( s->selfdestruct_next == nullptr);
+    std::lock_guard<std::mutex> guard{ lane_->U->selfdestruct_cs };
+    assert(lane_->selfdestruct_next == nullptr);
 
-    s->selfdestruct_next = s->U->selfdestruct_first;
-    s->U->selfdestruct_first= s;
-    s->U->selfdestruct_cs.unlock();
+    lane_->selfdestruct_next = lane_->U->selfdestruct_first;
+    lane_->U->selfdestruct_first = lane_;
 }
 
 /*
  * A free-running lane has ended; remove it from selfdestruct chain
  */
-static bool selfdestruct_remove( Lane* s)
+static bool selfdestruct_remove(Lane* lane_)
 {
     bool found{ false };
-    s->U->selfdestruct_cs.lock();
+    std::lock_guard<std::mutex> guard{ lane_->U->selfdestruct_cs };
+    // Make sure (within the MUTEX) that we actually are in the chain
+    // still (at process exit they will remove us from chain and then
+    // cancel/kill).
+    //
+    if (lane_->selfdestruct_next != nullptr)
     {
-        // Make sure (within the MUTEX) that we actually are in the chain
-        // still (at process exit they will remove us from chain and then
-        // cancel/kill).
-        //
-        if( s->selfdestruct_next != nullptr)
-        {
-            Lane** ref = (Lane**) &s->U->selfdestruct_first;
+        Lane** ref = (Lane**) &lane_->U->selfdestruct_first;
 
-            while( *ref != SELFDESTRUCT_END )
+        while (*ref != SELFDESTRUCT_END)
+        {
+            if (*ref == lane_)
             {
-                if( *ref == s)
-                {
-                    *ref = s->selfdestruct_next;
-                    s->selfdestruct_next = nullptr;
-                    // the terminal shutdown should wait until the lane is done with its lua_close()
-                    ++ s->U->selfdestructing_count;
-                    found = true;
-                    break;
-                }
-                ref = (Lane**) &((*ref)->selfdestruct_next);
+                *ref = lane_->selfdestruct_next;
+                lane_->selfdestruct_next = nullptr;
+                // the terminal shutdown should wait until the lane is done with its lua_close()
+                ++lane_->U->selfdestructing_count;
+                found = true;
+                break;
             }
-            assert( found);
+            ref = (Lane**) &((*ref)->selfdestruct_next);
         }
+        assert(found);
     }
-    s->U->selfdestruct_cs.unlock();
     return found;
 }
 
@@ -442,30 +439,29 @@ static int selfdestruct_gc( lua_State* L)
 {
     Universe* const U{ lua_tofulluserdata<Universe>(L, 1) };
 
-    while( U->selfdestruct_first != SELFDESTRUCT_END) // true at most once!
+    while (U->selfdestruct_first != SELFDESTRUCT_END) // true at most once!
     {
         // Signal _all_ still running threads to exit (including the timer thread)
         //
-        U->selfdestruct_cs.lock();
         {
-            Lane* s = U->selfdestruct_first;
-            while( s != SELFDESTRUCT_END)
+            std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+            Lane* lane{ U->selfdestruct_first };
+            while (lane != SELFDESTRUCT_END)
             {
                 // attempt a regular unforced hard cancel with a small timeout
-                bool const cancelled = THREAD_ISNULL( s->thread) || thread_cancel( L, s, CO_Hard, 0.0001, false, 0.0) != CancelResult::Timeout;
+                bool const cancelled = THREAD_ISNULL(lane->thread) || thread_cancel(L, lane, CO_Hard, 0.0001, false, 0.0) != CancelResult::Timeout;
                 // if we failed, and we know the thread is waiting on a linda
-                if( cancelled == false && s->status == WAITING && s->waiting_on != nullptr)
+                if (cancelled == false && lane->status == WAITING && lane->waiting_on != nullptr)
                 {
                     // signal the linda to wake up the thread so that it can react to the cancel query
                     // let us hope we never land here with a pointer on a linda that has been destroyed...
-                    SIGNAL_T* waiting_on = s->waiting_on;
-                    //s->waiting_on = nullptr; // useful, or not?
-                    SIGNAL_ALL( waiting_on);
+                    SIGNAL_T* const waiting_on{ lane->waiting_on };
+                    // lane->waiting_on = nullptr; // useful, or not?
+                    SIGNAL_ALL(waiting_on);
                 }
-                s = s->selfdestruct_next;
+                lane = lane->selfdestruct_next;
             }
         }
-        U->selfdestruct_cs.unlock();
 
         // When noticing their cancel, the lanes will remove themselves from
         // the selfdestruct chain.
@@ -482,32 +478,31 @@ static int selfdestruct_gc( lua_State* L)
         //  -- AKa 25-Oct-2008
         //
         {
-            lua_Number const shutdown_timeout = lua_tonumber( L, lua_upvalueindex( 1));
+            lua_Number const shutdown_timeout = lua_tonumber(L, lua_upvalueindex(1));
             double const t_until = now_secs() + shutdown_timeout;
 
-            while( U->selfdestruct_first != SELFDESTRUCT_END)
+            while (U->selfdestruct_first != SELFDESTRUCT_END)
             {
-                YIELD();    // give threads time to act on their cancel
+                YIELD(); // give threads time to act on their cancel
                 {
                     // count the number of cancelled thread that didn't have the time to act yet
                     int n = 0;
                     double t_now = 0.0;
-                    U->selfdestruct_cs.lock();
                     {
-                        Lane* s = U->selfdestruct_first;
-                        while( s != SELFDESTRUCT_END)
+                        std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+                        Lane* lane{ U->selfdestruct_first };
+                        while (lane != SELFDESTRUCT_END)
                         {
-                            if (s->cancel_request == CancelRequest::Hard)
-                                ++ n;
-                            s = s->selfdestruct_next;
+                            if (lane->cancel_request == CancelRequest::Hard)
+                                ++n;
+                            lane = lane->selfdestruct_next;
                         }
                     }
-                    U->selfdestruct_cs.unlock();
                     // if timeout elapsed, or we know all threads have acted, stop waiting
                     t_now = now_secs();
-                    if( n == 0 || (t_now >= t_until))
+                    if (n == 0 || (t_now >= t_until))
                     {
-                        DEBUGSPEW_CODE( fprintf( stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdown_timeout - (t_until - t_now)));
+                        DEBUGSPEW_CODE(fprintf(stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdown_timeout - (t_until - t_now)));
                         break;
                     }
                 }
@@ -516,7 +511,7 @@ static int selfdestruct_gc( lua_State* L)
 
         // If some lanes are currently cleaning after themselves, wait until they are done.
         // They are no longer listed in the selfdestruct chain, but they still have to lua_close().
-        while( U->selfdestructing_count > 0)
+        while (U->selfdestructing_count > 0)
         {
             YIELD();
         }
@@ -524,37 +519,36 @@ static int selfdestruct_gc( lua_State* L)
         //---
         // Kill the still free running threads
         //
-        if( U->selfdestruct_first != SELFDESTRUCT_END)
+        if (U->selfdestruct_first != SELFDESTRUCT_END)
         {
             unsigned int n = 0;
             // first thing we did was to raise the linda signals the threads were waiting on (if any)
             // therefore, any well-behaved thread should be in CANCELLED state
             // these are not running, and the state can be closed
-            U->selfdestruct_cs.lock();
             {
-                Lane* s = U->selfdestruct_first;
-                while( s != SELFDESTRUCT_END)
+                std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+                Lane* lane{ U->selfdestruct_first };
+                while (lane != SELFDESTRUCT_END)
                 {
-                    Lane* next_s = s->selfdestruct_next;
-                    s->selfdestruct_next = nullptr;     // detach from selfdestruct chain
-                    if( !THREAD_ISNULL( s->thread)) // can be nullptr if previous 'soft' termination succeeded
+                    Lane* const next_s{ lane->selfdestruct_next };
+                    lane->selfdestruct_next = nullptr; // detach from selfdestruct chain
+                    if (!THREAD_ISNULL(lane->thread)) // can be nullptr if previous 'soft' termination succeeded
                     {
-                        THREAD_KILL( &s->thread);
+                        THREAD_KILL(&lane->thread);
 #if THREADAPI == THREADAPI_PTHREAD
                         // pthread: make sure the thread is really stopped!
-                        THREAD_WAIT( &s->thread, -1, &s->done_signal, &s->done_lock, &s->status);
+                        THREAD_WAIT(&lane->thread, -1, &lane->done_signal, &lane->done_lock, &lane->status);
 #endif // THREADAPI == THREADAPI_PTHREAD
                     }
                     // NO lua_close() in this case because we don't know where execution of the state was interrupted
-                    lane_cleanup( s);
-                    s = next_s;
-                    ++ n;
+                    lane_cleanup(lane);
+                    lane = next_s;
+                    ++n;
                 }
                 U->selfdestruct_first = SELFDESTRUCT_END;
             }
-            U->selfdestruct_cs.unlock();
 
-            DEBUGSPEW_CODE( fprintf( stderr, "Killed %d lane(s) at process end.\n", n));
+            DEBUGSPEW_CODE(fprintf(stderr, "Killed %d lane(s) at process end.\n", n));
         }
     }
 
@@ -566,9 +560,9 @@ static int selfdestruct_gc( lua_State* L)
     }
 
     // necessary so that calling free_deep_prelude doesn't crash because linda_id expects a linda lightuserdata at absolute slot 1
-    lua_settop( L, 0);
+    lua_settop(L, 0);
     // no need to mutex-protect this as all threads in the universe are gone at that point
-    if( U->timer_deep != nullptr) // test ins case some early internal error prevented Lanes from creating the deep timer
+    if (U->timer_deep != nullptr) // test ins case some early internal error prevented Lanes from creating the deep timer
     {
         [[maybe_unused]] int const prev_ref_count{ U->timer_deep->m_refcount.fetch_sub(1, std::memory_order_relaxed) };
         ASSERT_L(prev_ref_count == 1); // this should be the last reference
@@ -586,7 +580,7 @@ static int selfdestruct_gc( lua_State* L)
     // universe is no longer available (nor necessary)
     // we need to do this in case some deep userdata objects were created before Lanes was initialized,
     // as potentially they will be garbage collected after Lanes at application shutdown
-    universe_store( L, nullptr);
+    universe_store(L, nullptr);
     return 0;
 }
 
@@ -604,18 +598,18 @@ LUAG_FUNC( set_singlethreaded)
 
 #ifdef PLATFORM_OSX
 #ifdef _UTILBINDTHREADTOCPU
-    if( cores > 1)
+    if (cores > 1)
     {
-        return luaL_error( L, "Limiting to N>1 cores not possible");
+        return luaL_error(L, "Limiting to N>1 cores not possible");
     }
     // requires 'chudInitialize()'
     utilBindThreadToCPU(0);     // # of CPU to run on (we cannot limit to 2..N CPUs?)
     return 0;
 #else
-    return luaL_error( L, "Not available: compile with _UTILBINDTHREADTOCPU");
+    return luaL_error(L, "Not available: compile with _UTILBINDTHREADTOCPU");
 #endif
 #else
-    return luaL_error( L, "not implemented");
+    return luaL_error(L, "not implemented");
 #endif
 }
 
@@ -643,20 +637,20 @@ static constexpr UniqueKey EXTENDED_STACKTRACE_REGKEY{ 0x2357c69a7c92c936ull };
 
 LUAG_FUNC( set_error_reporting)
 {
-    luaL_checktype( L, 1, LUA_TSTRING);
-    lua_pushliteral( L, "extended");
-    int equal = lua_rawequal( L, -1, 1);
-    lua_pop( L, 1);
-    if( equal)
+    luaL_checktype(L, 1, LUA_TSTRING);
+    lua_pushliteral(L, "extended");
+    int equal = lua_rawequal(L, -1, 1);
+    lua_pop(L, 1);
+    if (equal)
     {
         goto done;
     }
-    lua_pushliteral( L, "basic");
-    equal = !lua_rawequal( L, -1, 1);
-    lua_pop( L, 1);
-    if( equal)
+    lua_pushliteral(L, "basic");
+    equal = !lua_rawequal(L, -1, 1);
+    lua_pop(L, 1);
+    if (equal)
     {
-        return luaL_error( L, "unsupported error reporting model");
+        return luaL_error(L, "unsupported error reporting model");
     }
 done:
     EXTENDED_STACKTRACE_REGKEY.set_registry(L, [equal](lua_State* L) { lua_pushboolean(L, equal); });
@@ -675,10 +669,10 @@ static int lane_error( lua_State* L)
         return 1;   // just pass on
     }
 
-    STACK_GROW( L, 3);
+    STACK_GROW(L, 3);
     EXTENDED_STACKTRACE_REGKEY.query_registry(L);                                       // some_error basic|extended
     bool const extended{ lua_toboolean(L, -1) ? true : false};
-    lua_pop( L, 1);                                                                     // some_error
+    lua_pop(L, 1);                                                                     // some_error
     STACK_CHECK(L, 1);
 
     // Place stack trace at 'registry[STACKTRACE_REGKEY]' for the 'lua_pcall()'
@@ -700,35 +694,35 @@ static int lane_error( lua_State* L)
     lua_Debug ar;
     for (int n = 1; lua_getstack(L, n, &ar); ++n)
     {
-        lua_getinfo( L, extended ? "Sln" : "Sl", &ar);
-        if( extended)
+        lua_getinfo(L, extended ? "Sln" : "Sl", &ar);
+        if (extended)
         {
             lua_newtable( L);                                                           // some_error {} {}
 
-            lua_pushstring( L, ar.source);                                              // some_error {} {} source
-            lua_setfield( L, -2, "source");                                             // some_error {} {}
+            lua_pushstring(L, ar.source);                                              // some_error {} {} source
+            lua_setfield(L, -2, "source");                                             // some_error {} {}
 
-            lua_pushinteger( L, ar.currentline);                                        // some_error {} {} currentline
-            lua_setfield( L, -2, "currentline");                                        // some_error {} {}
+            lua_pushinteger(L, ar.currentline);                                        // some_error {} {} currentline
+            lua_setfield(L, -2, "currentline");                                        // some_error {} {}
 
-            lua_pushstring( L, ar.name);                                                // some_error {} {} name
-            lua_setfield( L, -2, "name");                                               // some_error {} {}
+            lua_pushstring(L, ar.name);                                                // some_error {} {} name
+            lua_setfield(L, -2, "name");                                               // some_error {} {}
 
-            lua_pushstring( L, ar.namewhat);                                            // some_error {} {} namewhat
-            lua_setfield( L, -2, "namewhat");                                           // some_error {} {}
+            lua_pushstring(L, ar.namewhat);                                            // some_error {} {} namewhat
+            lua_setfield(L, -2, "namewhat");                                           // some_error {} {}
 
-            lua_pushstring( L, ar.what);                                                // some_error {} {} what
-            lua_setfield( L, -2, "what");                                               // some_error {} {}
+            lua_pushstring(L, ar.what);                                                // some_error {} {} what
+            lua_setfield(L, -2, "what");                                               // some_error {} {}
         }
-        else if( ar.currentline > 0)
+        else if (ar.currentline > 0)
         {
-            lua_pushfstring( L, "%s:%d", ar.short_src, ar.currentline);                 // some_error {} "blah:blah"
+            lua_pushfstring(L, "%s:%d", ar.short_src, ar.currentline);                 // some_error {} "blah:blah"
         }
         else
         {
-            lua_pushfstring( L, "%s:?", ar.short_src);                                  // some_error {} "blah"
+            lua_pushfstring(L, "%s:?", ar.short_src);                                  // some_error {} "blah"
         }
-        lua_rawseti( L, -2, (lua_Integer) n);                                           // some_error {}
+        lua_rawseti(L, -2, (lua_Integer) n);                                           // some_error {}
     }
 
     // store the stack trace table in the registry
@@ -752,10 +746,10 @@ static void push_stack_trace( lua_State* L, int rc_, int stk_base_)
         {
             STACK_CHECK_START_REL(L, 0);
             // fetch the call stack table from the registry where the handler stored it
-            STACK_GROW( L, 1);
+            STACK_GROW(L, 1);
             // yields nil if no stack was generated (in case of cancellation for example)
             STACKTRACE_REGKEY.query_registry(L);                                       // err trace|nil
-            STACK_CHECK( L, 1);
+            STACK_CHECK(L, 1);
 
             // For cancellation the error message is CANCEL_ERROR, and a stack trace isn't placed
             // For other errors, the message can be whatever was thrown, and we should have a stack trace table
@@ -774,57 +768,65 @@ static void push_stack_trace( lua_State* L, int rc_, int stk_base_)
     }
 }
 
-LUAG_FUNC( set_debug_threadname)
+// #################################################################################################
+
+LUAG_FUNC(set_debug_threadname)
 {
     // fnv164 of string "debug_threadname" generated at https://www.pelock.com/products/hash-calculator
     constexpr UniqueKey hidden_regkey{ 0x79C0669AAAE04440ull };
     // C s_lane structure is a light userdata upvalue
-    Lane* const s{ lua_tolightuserdata<Lane>(L, lua_upvalueindex(1)) };
-    luaL_checktype( L, -1, LUA_TSTRING);                           // "name"
-    lua_settop( L, 1);
-    STACK_CHECK_START_ABS( L, 1);
+    Lane* const lane{ lua_tolightuserdata<Lane>(L, lua_upvalueindex(1)) };
+    luaL_checktype(L, -1, LUA_TSTRING); // "name"
+    lua_settop(L, 1);
+    STACK_CHECK_START_ABS(L, 1);
     // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
     hidden_regkey.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
-    STACK_CHECK( L, 1);
-    s->debug_name = lua_tostring( L, -1);
+    STACK_CHECK(L, 1);
+    lane->debug_name = lua_tostring(L, -1);
     // keep a direct pointer on the string
-    THREAD_SETNAME( s->debug_name);
+    THREAD_SETNAME(lane->debug_name);
     // to see VM name in Decoda debugger Virtual Machine window
-    lua_setglobal( L, "decoda_name");                              //
-    STACK_CHECK( L, 0);
+    lua_setglobal(L, "decoda_name"); //
+    STACK_CHECK(L, 0);
     return 0;
 }
 
-LUAG_FUNC( get_debug_threadname)
+// #################################################################################################
+
+LUAG_FUNC(get_debug_threadname)
 {
-    Lane* const s = lua_toLane( L, 1);
-    luaL_argcheck( L, lua_gettop( L) == 1, 2, "too many arguments");
-    lua_pushstring( L, s->debug_name);
+    Lane* const lane{ lua_toLane(L, 1) };
+    luaL_argcheck(L, lua_gettop(L) == 1, 2, "too many arguments");
+    lua_pushstring(L, lane->debug_name);
     return 1;
 }
 
-LUAG_FUNC( set_thread_priority)
+// #################################################################################################
+
+LUAG_FUNC(set_thread_priority)
 {
-    int const prio = (int) luaL_checkinteger( L, 1);
+    int const prio{ (int) luaL_checkinteger(L, 1) };
     // public Lanes API accepts a generic range -3/+3
     // that will be remapped into the platform-specific scheduler priority scheme
     // On some platforms, -3 is equivalent to -2 and +3 to +2
-    if( prio < THREAD_PRIO_MIN || prio > THREAD_PRIO_MAX)
+    if (prio < THREAD_PRIO_MIN || prio > THREAD_PRIO_MAX)
     {
-        return luaL_error( L, "priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, prio);
+        return luaL_error(L, "priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, prio);
     }
-    THREAD_SET_PRIORITY( prio);
+    THREAD_SET_PRIORITY(prio);
     return 0;
 }
 
-LUAG_FUNC( set_thread_affinity)
+// #################################################################################################
+
+LUAG_FUNC(set_thread_affinity)
 {
-    lua_Integer affinity = luaL_checkinteger( L, 1);
-    if( affinity <= 0)
+    lua_Integer const affinity{ luaL_checkinteger(L, 1) };
+    if (affinity <= 0)
     {
-        return luaL_error( L, "invalid affinity (%d)", affinity);
+        return luaL_error(L, "invalid affinity (%d)", affinity);
     }
-    THREAD_SET_AFFINITY( (unsigned int) affinity);
+    THREAD_SET_AFFINITY( static_cast<unsigned int>(affinity));
     return 0;
 }
 
@@ -852,7 +854,7 @@ static char const* get_errcode_name( int _code)
     int i;
     for( i = 0; i < 7; ++ i)
     {
-        if( s_errcodes[i].code == _code)
+        if (s_errcodes[i].code == _code)
         {
             return s_errcodes[i].name;
         }
@@ -862,89 +864,88 @@ static char const* get_errcode_name( int _code)
 #endif // USE_DEBUG_SPEW()
 
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR // implies THREADAPI == THREADAPI_PTHREAD
-static void thread_cleanup_handler( void* opaque)
+static void thread_cleanup_handler(void* opaque)
 {
-    Lane* s= (Lane*) opaque;
-    MUTEX_LOCK( &s->done_lock);
-    s->status = CANCELLED;
-    SIGNAL_ONE( &s->done_signal);   // wake up master (while 's->done_lock' is on)
-    MUTEX_UNLOCK( &s->done_lock);
+    Lane* lane{ (Lane*) opaque };
+    MUTEX_LOCK(&lane->done_lock);
+    lane->status = CANCELLED;
+    SIGNAL_ONE(&lane->done_signal); // wake up master (while 'lane->done_lock' is on)
+    MUTEX_UNLOCK(&lane->done_lock);
 }
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
 
-static THREAD_RETURN_T THREAD_CALLCONV lane_main( void* vs)
+static THREAD_RETURN_T THREAD_CALLCONV lane_main(void* vs)
 {
-    Lane* s = (Lane*) vs;
-    int rc, rc2;
-    lua_State* L = s->L;
+    Lane* const lane{ (Lane*) vs };
+    lua_State* const L{ lane->L };
     // Called with the lane function and arguments on the stack
-    int const nargs = lua_gettop( L) - 1;
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
+    int const nargs{ lua_gettop(L) - 1 };
+    DEBUGSPEW_CODE(Universe* U = universe_get(L));
     THREAD_MAKE_ASYNCH_CANCELLABLE();
-    THREAD_CLEANUP_PUSH( thread_cleanup_handler, s);
-    s->status = RUNNING;  // PENDING -> RUNNING
+    THREAD_CLEANUP_PUSH(thread_cleanup_handler, lane);
+    lane->status = RUNNING; // PENDING -> RUNNING
 
     // Tie "set_finalizer()" to the state
-    lua_pushcfunction( L, LG_set_finalizer);
-    populate_func_lookup_table( L, -1, "set_finalizer");
-    lua_setglobal( L, "set_finalizer");
+    lua_pushcfunction(L, LG_set_finalizer);
+    populate_func_lookup_table(L, -1, "set_finalizer");
+    lua_setglobal(L, "set_finalizer");
 
     // Tie "set_debug_threadname()" to the state
     // But don't register it in the lookup database because of the Lane pointer upvalue
-    lua_pushlightuserdata( L, s);
-    lua_pushcclosure( L, LG_set_debug_threadname, 1);
-    lua_setglobal( L, "set_debug_threadname");
+    lua_pushlightuserdata(L, lane);
+    lua_pushcclosure(L, LG_set_debug_threadname, 1);
+    lua_setglobal(L, "set_debug_threadname");
 
     // Tie "cancel_test()" to the state
-    lua_pushcfunction( L, LG_cancel_test);
-    populate_func_lookup_table( L, -1, "cancel_test");
-    lua_setglobal( L, "cancel_test");
+    lua_pushcfunction(L, LG_cancel_test);
+    populate_func_lookup_table(L, -1, "cancel_test");
+    lua_setglobal(L, "cancel_test");
 
     // this could be done in lane_new before the lane body function is pushed on the stack to avoid unnecessary stack slot shifting around
 #if ERROR_FULL_STACK
     // Tie "set_error_reporting()" to the state
-    lua_pushcfunction( L, LG_set_error_reporting);
-    populate_func_lookup_table( L, -1, "set_error_reporting");
-    lua_setglobal( L, "set_error_reporting");
+    lua_pushcfunction(L, LG_set_error_reporting);
+    populate_func_lookup_table(L, -1, "set_error_reporting");
+    lua_setglobal(L, "set_error_reporting");
 
-    STACK_GROW( L, 1);
-    lua_pushcfunction( L, lane_error);                                           // func args handler
-    lua_insert( L, 1);                                                           // handler func args
+    STACK_GROW(L, 1);
+    lua_pushcfunction(L, lane_error);                                            // func args handler
+    lua_insert(L, 1);                                                            // handler func args
 #endif // ERROR_FULL_STACK
 
-    rc = lua_pcall( L, nargs, LUA_MULTRET, ERROR_FULL_STACK);                    // retvals|err
+    int rc{ lua_pcall(L, nargs, LUA_MULTRET, ERROR_FULL_STACK) };                // retvals|err
 
 #if ERROR_FULL_STACK
-    lua_remove( L, 1);                                                           // retvals|error
+    lua_remove(L, 1);                                                            // retvals|error
 #       endif // ERROR_FULL_STACK
 
     // in case of error and if it exists, fetch stack trace from registry and push it
-    push_stack_trace( L, rc, 1);                                                 // retvals|error [trace]
+    push_stack_trace(L, rc, 1);                                                  // retvals|error [trace]
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p body: %s (%s)\n" INDENT_END, L, get_errcode_name( rc), equal_unique_key( L, 1, CANCEL_ERROR) ? "cancelled" : lua_typename( L, lua_type( L, 1))));
-    //STACK_DUMP(L);
-    // Call finalizers, if the script has set them up.
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "Lane %p body: %s (%s)\n" INDENT_END, L, get_errcode_name(rc), CANCEL_ERROR.equals(L, 1) ? "cancelled" : lua_typename(L, lua_type(L, 1))));
+    // STACK_DUMP(L);
+    //  Call finalizers, if the script has set them up.
     //
-    rc2 = run_finalizers( L, rc);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p finalizer: %s\n" INDENT_END, L, get_errcode_name( rc2)));
-    if( rc2 != LUA_OK) // Error within a finalizer!
+    int rc2 = run_finalizers(L, rc);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "Lane %p finalizer: %s\n" INDENT_END, L, get_errcode_name(rc2)));
+    if (rc2 != LUA_OK) // Error within a finalizer!
     {
         // the finalizer generated an error, and left its own error message [and stack trace] on the stack
-        rc = rc2;    // we're overruling the earlier script error or normal return
+        rc = rc2; // we're overruling the earlier script error or normal return
     }
-    s->waiting_on = nullptr; // just in case
-    if( selfdestruct_remove( s)) // check and remove (under lock!)
+    lane->waiting_on = nullptr; // just in case
+    if (selfdestruct_remove(lane)) // check and remove (under lock!)
     {
         // We're a free-running thread and no-one's there to clean us up.
         //
-        lua_close( s->L);
+        lua_close(lane->L);
 
-        s->U->selfdestruct_cs.lock();
+        lane->U->selfdestruct_cs.lock();
         // done with lua_close(), terminal shutdown sequence may proceed
-        -- s->U->selfdestructing_count;
-        s->U->selfdestruct_cs.unlock();
+        --lane->U->selfdestructing_count;
+        lane->U->selfdestruct_cs.unlock();
 
-        lane_cleanup( s); // s is freed at this point
+        lane_cleanup(lane); // s is freed at this point
     }
     else
     {
@@ -956,64 +957,69 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void* vs)
         // 'done_lock' protects the -> DONE|ERROR_ST|CANCELLED state change
         //
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-        MUTEX_LOCK( &s->done_lock);
+        MUTEX_LOCK(&lane->done_lock);
         {
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-            s->status = st;
+            lane->status = st;
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-            SIGNAL_ONE( &s->done_signal);   // wake up master (while 's->done_lock' is on)
+            SIGNAL_ONE(&lane->done_signal); // wake up master (while 'lane->done_lock' is on)
         }
-        MUTEX_UNLOCK( &s->done_lock);
+        MUTEX_UNLOCK(&lane->done_lock);
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
     }
-    THREAD_CLEANUP_POP( false);
-    return 0;   // ignored
+    THREAD_CLEANUP_POP(false);
+    return 0; // ignored
 }
 
+// #################################################################################################
+
 // --- If a client wants to transfer stuff of a given module from the current state to another Lane, the module must be required
 // with lanes.require, that will call the regular 'require', then populate the lookup database in the source lane
 // module = lanes.require( "modname")
 // upvalue[1]: _G.require
-LUAG_FUNC( require)
+LUAG_FUNC(require)
 {
-    char const* name = lua_tostring( L, 1);
-    int const nargs = lua_gettop( L);
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
+    char const* name = lua_tostring(L, 1);
+    int const nargs = lua_gettop(L);
+    DEBUGSPEW_CODE(Universe* U = universe_get(L));
     STACK_CHECK_START_REL(L, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s BEGIN\n" INDENT_END, name));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    lua_pushvalue( L, lua_upvalueindex(1));   // "name" require
-    lua_insert( L, 1);                        // require "name"
-    lua_call( L, nargs, 1);                   // module
-    populate_func_lookup_table( L, -1, name);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s END\n" INDENT_END, name));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    STACK_CHECK( L, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.require %s BEGIN\n" INDENT_END, name));
+    DEBUGSPEW_CODE(++U->debugspew_indent_depth);
+    lua_pushvalue(L, lua_upvalueindex(1)); // "name" require
+    lua_insert(L, 1); // require "name"
+    lua_call(L, nargs, 1); // module
+    populate_func_lookup_table(L, -1, name);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.require %s END\n" INDENT_END, name));
+    DEBUGSPEW_CODE(--U->debugspew_indent_depth);
+    STACK_CHECK(L, 0);
     return 1;
 }
 
+// #################################################################################################
 
 // --- If a client wants to transfer stuff of a previously required module from the current state to another Lane, the module must be registered
 // to populate the lookup database in the source lane (and in the destination too, of course)
 // lanes.register( "modname", module)
-LUAG_FUNC( register)
+LUAG_FUNC(register)
 {
-    char const* name = luaL_checkstring( L, 1);
-    int const mod_type = lua_type( L, 2);
+    char const* name = luaL_checkstring(L, 1);
+    int const mod_type = lua_type(L, 2);
     // ignore extra parameters, just in case
-    lua_settop( L, 2);
-    luaL_argcheck( L, (mod_type == LUA_TTABLE) || (mod_type == LUA_TFUNCTION), 2, "unexpected module type");
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    STACK_CHECK_START_REL(L, 0);                             // "name" mod_table
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.register %s BEGIN\n" INDENT_END, name));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    populate_func_lookup_table( L, -1, name);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.register %s END\n" INDENT_END, name));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    STACK_CHECK( L, 0);
+    lua_settop(L, 2);
+    luaL_argcheck(L, (mod_type == LUA_TTABLE) || (mod_type == LUA_TFUNCTION), 2, "unexpected module type");
+    DEBUGSPEW_CODE(Universe* U = universe_get(L));
+    STACK_CHECK_START_REL(L, 0); // "name" mod_table
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.register %s BEGIN\n" INDENT_END, name));
+    DEBUGSPEW_CODE(++U->debugspew_indent_depth);
+    populate_func_lookup_table(L, -1, name);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.register %s END\n" INDENT_END, name));
+    DEBUGSPEW_CODE(--U->debugspew_indent_depth);
+    STACK_CHECK(L, 0);
     return 0;
 }
 
+// #################################################################################################
+
 // crc64/we of string "GCCB_KEY" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey GCCB_KEY{ 0xcfb1f046ef074e88ull };
 
@@ -1031,10 +1037,10 @@ static constexpr UniqueKey GCCB_KEY{ 0xcfb1f046ef074e88ull };
 //
 LUAG_FUNC( lane_new)
 {
-    char const* libs_str = lua_tostring( L, 2);
+    char const* libs_str = lua_tostring(L, 2);
     bool const have_priority{ !lua_isnoneornil(L, 3) };
-    int const priority = have_priority ? (int) lua_tointeger( L, 3) : THREAD_PRIO_DEFAULT;
-    int const globals_idx = lua_isnoneornil( L, 4) ? 0 : 4;
+    int const priority = have_priority ? (int) lua_tointeger(L, 3) : THREAD_PRIO_DEFAULT;
+    int const globals_idx = lua_isnoneornil(L, 4) ? 0 : 4;
     int const package_idx = lua_isnoneornil(L, 5) ? 0 : 5;
     int const required_idx = lua_isnoneornil(L, 6) ? 0 : 6;
     int const gc_cb_idx = lua_isnoneornil(L, 7) ? 0 : 7;
@@ -1047,9 +1053,9 @@ LUAG_FUNC( lane_new)
     // public Lanes API accepts a generic range -3/+3
     // that will be remapped into the platform-specific scheduler priority scheme
     // On some platforms, -3 is equivalent to -2 and +3 to +2
-    if( have_priority && (priority < THREAD_PRIO_MIN || priority > THREAD_PRIO_MAX))
+    if (have_priority && (priority < THREAD_PRIO_MIN || priority > THREAD_PRIO_MAX))
     {
-        return luaL_error( L, "Priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, priority);
+        return luaL_error(L, "Priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, priority);
     }
 
     /* --- Create and prepare the sub state --- */
@@ -1062,7 +1068,7 @@ LUAG_FUNC( lane_new)
     STACK_GROW( L2, nargs + 3);                                                                                                                //
     STACK_CHECK_START_REL(L2, 0);
 
-    STACK_GROW( L, 3);                                               // func libs priority globals package required gc_cb [... args ...]
+    STACK_GROW(L, 3);                                               // func libs priority globals package required gc_cb [... args ...]
     STACK_CHECK_START_REL(L, 0);
 
     // give a default "Lua" name to the thread to see VM name in Decoda debugger
@@ -1072,7 +1078,7 @@ LUAG_FUNC( lane_new)
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END));
     // package
-    if( package_idx != 0)
+    if (package_idx != 0)
     {
         // when copying with mode eLM_LaneBody, should raise an error in case of problem, not leave it one the stack
         (void) luaG_inter_copy_package( U, L, L2, package_idx, eLM_LaneBody);
@@ -1080,42 +1086,42 @@ LUAG_FUNC( lane_new)
 
     // modules to require in the target lane *before* the function is transfered!
 
-    if( required_idx != 0)
+    if (required_idx != 0)
     {
         int nbRequired = 1;
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require 'required' list\n" INDENT_END));
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
         // should not happen, was checked in lanes.lua before calling lane_new()
-        if( lua_type( L, required_idx) != LUA_TTABLE)
+        if (lua_type(L, required_idx) != LUA_TTABLE)
         {
-            return luaL_error( L, "expected required module list as a table, got %s", luaL_typename( L, required_idx));
+            return luaL_error(L, "expected required module list as a table, got %s", luaL_typename(L, required_idx));
         }
 
         lua_pushnil( L);                                             // func libs priority globals package required gc_cb [... args ...] nil
-        while( lua_next( L, required_idx) != 0)                      // func libs priority globals package required gc_cb [... args ...] n "modname"
+        while( lua_next(L, required_idx) != 0)                      // func libs priority globals package required gc_cb [... args ...] n "modname"
         {
-            if( lua_type( L, -1) != LUA_TSTRING || lua_type( L, -2) != LUA_TNUMBER || lua_tonumber( L, -2) != nbRequired)
+            if (lua_type(L, -1) != LUA_TSTRING || lua_type(L, -2) != LUA_TNUMBER || lua_tonumber(L, -2) != nbRequired)
             {
-                return luaL_error( L, "required module list should be a list of strings");
+                return luaL_error(L, "required module list should be a list of strings");
             }
             else
             {
                 // require the module in the target state, and populate the lookup table there too
                 size_t len;
-                char const* name = lua_tolstring( L, -1, &len);
+                char const* name = lua_tolstring(L, -1, &len);
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require '%s'\n" INDENT_END, name));
 
                 // require the module in the target lane
                 lua_getglobal( L2, "require");                                                                                                 // require()?
-                if( lua_isnil( L2, -1))
+                if (lua_isnil( L2, -1))
                 {
                     lua_pop( L2, 1);                                                                                                           //
-                    return luaL_error( L, "cannot pre-require modules without loading 'package' library first");
+                    return luaL_error(L, "cannot pre-require modules without loading 'package' library first");
                 }
                 else
                 {
                     lua_pushlstring( L2, name, len);                                                                                           // require() name
-                    if( lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                     // ret/errcode
+                    if (lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                     // ret/errcode
                     {
                         // propagate error to main state if any
                         luaG_inter_move( U, L2, L, 1, eLM_LaneBody); // func libs priority globals package required gc_cb [... args ...] n "modname" error
@@ -1126,83 +1132,83 @@ LUAG_FUNC( lane_new)
                     lua_pop( L2, 1);                                                                                                           //
                 }
             }
-            lua_pop( L, 1);                                          // func libs priority globals package required gc_cb [... args ...] n
+            lua_pop(L, 1);                                          // func libs priority globals package required gc_cb [... args ...] n
             ++ nbRequired;
         }                                                            // func libs priority globals package required gc_cb [... args ...]
         DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
     }
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
     STACK_CHECK( L2, 0);                                                                                                                         //
 
     // Appending the specified globals to the global environment
     // *after* stdlibs have been loaded and modules required, in case we transfer references to native functions they exposed...
     //
-    if( globals_idx != 0)
+    if (globals_idx != 0)
     {
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer globals\n" INDENT_END));
-        if( !lua_istable( L, globals_idx))
+        if (!lua_istable(L, globals_idx))
         {
-            return luaL_error( L, "Expected table, got %s", luaL_typename( L, globals_idx));
+            return luaL_error(L, "Expected table, got %s", luaL_typename(L, globals_idx));
         }
 
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
         lua_pushnil( L);                                             // func libs priority globals package required gc_cb [... args ...] nil
         // Lua 5.2 wants us to push the globals table on the stack
         lua_pushglobaltable( L2);                                                                                                              // _G
-        while( lua_next( L, globals_idx))                            // func libs priority globals package required gc_cb [... args ...] k v
+        while( lua_next(L, globals_idx))                            // func libs priority globals package required gc_cb [... args ...] k v
         {
             luaG_inter_copy( U, L, L2, 2, eLM_LaneBody);                                                                                       // _G k v
             // assign it in L2's globals table
             lua_rawset( L2, -3);                                                                                                               // _G
-            lua_pop( L, 1);                                          // func libs priority globals package required gc_cb [... args ...] k
+            lua_pop(L, 1);                                          // func libs priority globals package required gc_cb [... args ...] k
         }                                                            // func libs priority globals package required gc_cb [... args ...]
         lua_pop( L2, 1);                                                                                                                       //
 
         DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
     }
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
     STACK_CHECK( L2, 0);
 
     // Lane main function
-    if( lua_type( L, 1) == LUA_TFUNCTION)
+    if (lua_type(L, 1) == LUA_TFUNCTION)
     {
         int res;
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END));
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        lua_pushvalue( L, 1);                                        // func libs priority globals package required gc_cb [... args ...] func
+        lua_pushvalue(L, 1);                                        // func libs priority globals package required gc_cb [... args ...] func
         res = luaG_inter_move( U, L, L2, 1, eLM_LaneBody);           // func libs priority globals package required gc_cb [... args ...]       // func
         DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-        if( res != 0)
+        if (res != 0)
         {
-            return luaL_error( L, "tried to copy unsupported types");
+            return luaL_error(L, "tried to copy unsupported types");
         }
     }
-    else if( lua_type( L, 1) == LUA_TSTRING)
+    else if (lua_type(L, 1) == LUA_TSTRING)
     {
         // compile the string
-        if( luaL_loadstring( L2, lua_tostring( L, 1)) != 0)                                                                                    // func
+        if (luaL_loadstring( L2, lua_tostring(L, 1)) != 0)                                                                                    // func
         {
-            return luaL_error( L, "error when parsing lane function code");
+            return luaL_error(L, "error when parsing lane function code");
         }
     }
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
     STACK_CHECK( L2, 1);
     ASSERT_L( lua_isfunction( L2, 1));
 
     // revive arguments
-    if( nargs > 0)
+    if (nargs > 0)
     {
         int res;
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END));
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        res = luaG_inter_move( U, L, L2, nargs, eLM_LaneBody);       // func libs priority globals package required gc_cb                      // func [... args ...]
+        res = luaG_inter_move(U, L, L2, nargs, eLM_LaneBody);        // func libs priority globals package required gc_cb                      // func [... args ...]
         DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-        if( res != 0)
+        if (res != 0)
         {
-            return luaL_error( L, "tried to copy unsupported types");
+            return luaL_error(L, "tried to copy unsupported types");
         }
     }
-    STACK_CHECK( L, -nargs);
+    STACK_CHECK(L, -nargs);
     ASSERT_L( lua_gettop( L) == FIXED_ARGS);
     STACK_CHECK_RESET_REL(L, 0);
     STACK_CHECK( L2, 1 + nargs);
@@ -1211,66 +1217,67 @@ LUAG_FUNC( lane_new)
     //
     // a Lane full userdata needs a single uservalue
     Lane** const ud{ lua_newuserdatauv<Lane*>(L, 1) };               // func libs priority globals package required gc_cb lane
-    Lane* const s{ *ud = static_cast<Lane*>(U->internal_allocator.alloc(sizeof(Lane))) }; // don't forget to store the pointer in the userdata!
-    if( s == nullptr)
+    Lane* const lane{ *ud = static_cast<Lane*>(U->internal_allocator.alloc(sizeof(Lane))) }; // don't forget to store the pointer in the userdata!
+    if (lane == nullptr)
     {
-        return luaL_error( L, "could not create lane: out of memory");
+        return luaL_error(L, "could not create lane: out of memory");
     }
 
-    s->L = L2;
-    s->U = U;
-    s->status = PENDING;
-    s->waiting_on = nullptr;
-    s->debug_name = "<unnamed>";
-    s->cancel_request = CancelRequest::None;
+    lane->L = L2;
+    lane->U = U;
+    lane->status = PENDING;
+    lane->waiting_on = nullptr;
+    lane->debug_name = "<unnamed>";
+    lane->cancel_request = CancelRequest::None;
 
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    MUTEX_INIT( &s->done_lock);
-    SIGNAL_INIT( &s->done_signal);
+    MUTEX_INIT(&lane->done_lock);
+    SIGNAL_INIT(&lane->done_signal);
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    s->mstatus = ThreadStatus::Normal;
-    s->selfdestruct_next = nullptr;
+    lane->mstatus = ThreadStatus::Normal;
+    lane->selfdestruct_next = nullptr;
 #if HAVE_LANE_TRACKING()
-    s->tracking_next = nullptr;
-    if( s->U->tracking_first)
+    lane->tracking_next = nullptr;
+    if (lane->U->tracking_first)
     {
-        tracking_add( s);
+        tracking_add(lane);
     }
 #endif // HAVE_LANE_TRACKING()
 
     // Set metatable for the userdata
     //
-    lua_pushvalue( L, lua_upvalueindex( 1));                         // func libs priority globals package required gc_cb lane mt
-    lua_setmetatable( L, -2);                                        // func libs priority globals package required gc_cb lane
-    STACK_CHECK( L, 1);
+    lua_pushvalue(L, lua_upvalueindex( 1));                         // func libs priority globals package required gc_cb lane mt
+    lua_setmetatable(L, -2);                                        // func libs priority globals package required gc_cb lane
+    STACK_CHECK(L, 1);
 
     // Create uservalue for the userdata
     // (this is where lane body return values will be stored when the handle is indexed by a numeric key)
     lua_newtable( L);                                                // func libs cancelstep priority globals package required gc_cb lane uv
 
     // Store the gc_cb callback in the uservalue
-    if( gc_cb_idx > 0)
+    if (gc_cb_idx > 0)
     {
         GCCB_KEY.push(L);                                            // func libs priority globals package required gc_cb lane uv k
-        lua_pushvalue( L, gc_cb_idx);                                // func libs priority globals package required gc_cb lane uv k gc_cb
-        lua_rawset( L, -3);                                          // func libs priority globals package required gc_cb lane uv
+        lua_pushvalue(L, gc_cb_idx);                                // func libs priority globals package required gc_cb lane uv k gc_cb
+        lua_rawset(L, -3);                                          // func libs priority globals package required gc_cb lane uv
     }
 
-    lua_setiuservalue( L, -2, 1);                                    // func libs priority globals package required gc_cb lane
+    lua_setiuservalue(L, -2, 1);                                    // func libs priority globals package required gc_cb lane
 
     // Store 's' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
-    CANCEL_TEST_KEY.set_registry(L2, [s](lua_State* L) { lua_pushlightuserdata(L, s); });                                                      // func [... args ...]
+    CANCEL_TEST_KEY.set_registry(L2, [lane](lua_State* L) { lua_pushlightuserdata(L, lane); });                                                // func [... args ...]
 
-    STACK_CHECK( L, 1);
+    STACK_CHECK(L, 1);
     STACK_CHECK( L2, 1 + nargs);
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: launching thread\n" INDENT_END));
-    THREAD_CREATE( &s->thread, lane_main, s, priority);
+    THREAD_CREATE(&lane->thread, lane_main, lane, priority);
 
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(--U->debugspew_indent_depth);
     return 1;
 }
 
+// #################################################################################################
 
 //---
 // = thread_gc( lane_ud )
@@ -1284,83 +1291,85 @@ LUAG_FUNC( lane_new)
 // and the issue of canceling/killing threads at gc is not very nice, either
 // (would easily cause waits at gc cycle, which we don't want).
 //
-LUAG_FUNC( thread_gc)
+LUAG_FUNC(thread_gc)
 {
     bool have_gc_cb{ false };
-    Lane* s = lua_toLane( L, 1);                                        // ud
+    Lane* lane{ lua_toLane(L, 1) };                                      // ud
 
     // if there a gc callback?
-    lua_getiuservalue( L, 1, 1);                                        // ud uservalue
-    GCCB_KEY.push(L);                                                   // ud uservalue __gc
-    lua_rawget( L, -2);                                                 // ud uservalue gc_cb|nil
-    if( !lua_isnil( L, -1))
+    lua_getiuservalue(L, 1, 1);                                          // ud uservalue
+    GCCB_KEY.push(L);                                                    // ud uservalue __gc
+    lua_rawget(L, -2);                                                   // ud uservalue gc_cb|nil
+    if (!lua_isnil(L, -1))
     {
-        lua_remove( L, -2);                                               // ud gc_cb|nil
-        lua_pushstring( L, s->debug_name);                                // ud gc_cb name
+        lua_remove(L, -2);                                               // ud gc_cb|nil
+        lua_pushstring(L, lane->debug_name);                             // ud gc_cb name
         have_gc_cb = true;
     }
     else
     {
-        lua_pop( L, 2);                                                   // ud
+        lua_pop(L, 2);                                                   // ud
     }
 
-    // We can read 's->status' without locks, but not wait for it
+    // We can read 'lane->status' without locks, but not wait for it
     // test Killed state first, as it doesn't need to enter the selfdestruct chain
-    if (s->mstatus == ThreadStatus::Killed)
+    if (lane->mstatus == ThreadStatus::Killed)
     {
         // Make sure a kill has proceeded, before cleaning up the data structure.
         //
         // NO lua_close() in this case because we don't know where execution of the state was interrupted
-        DEBUGSPEW_CODE( fprintf( stderr, "** Joining with a killed thread (needs testing) **"));
+        DEBUGSPEW_CODE(fprintf(stderr, "** Joining with a killed thread (needs testing) **"));
         // make sure the thread is no longer running, just like thread_join()
-        if(! THREAD_ISNULL( s->thread))
+        if (!THREAD_ISNULL(lane->thread))
         {
-            THREAD_WAIT( &s->thread, -1, &s->done_signal, &s->done_lock, &s->status);
+            THREAD_WAIT(&lane->thread, -1, &lane->done_signal, &lane->done_lock, &lane->status);
         }
-        if( s->status >= DONE && s->L)
+        if (lane->status >= DONE && lane->L)
         {
             // we know the thread was killed while the Lua VM was not doing anything: we should be able to close it without crashing
-            // now, thread_cancel() will not forcefully kill a lane with s->status >= DONE, so I am not sure it can ever happen
-            lua_close( s->L);
-            s->L = 0;
+            // now, thread_cancel() will not forcefully kill a lane with lane->status >= DONE, so I am not sure it can ever happen
+            lua_close(lane->L);
+            lane->L = nullptr;
             // just in case, but s will be freed soon so...
-            s->debug_name = "<gc>";
+            lane->debug_name = "<gc>";
         }
-        DEBUGSPEW_CODE( fprintf( stderr, "** Joined ok **"));
+        DEBUGSPEW_CODE(fprintf(stderr, "** Joined ok **"));
     }
-    else if( s->status < DONE)
+    else if (lane->status < DONE)
     {
         // still running: will have to be cleaned up later
-        selfdestruct_add( s);
-        assert( s->selfdestruct_next);
-        if( have_gc_cb)
+        selfdestruct_add(lane);
+        assert(lane->selfdestruct_next);
+        if (have_gc_cb)
         {
-            lua_pushliteral( L, "selfdestruct");                            // ud gc_cb name status
-            lua_call( L, 2, 0);                                             // ud
+            lua_pushliteral(L, "selfdestruct");                          // ud gc_cb name status
+            lua_call(L, 2, 0);                                           // ud
         }
         return 0;
     }
-    else if( s->L)
+    else if (lane->L)
     {
         // no longer accessing the Lua VM: we can close right now
-        lua_close( s->L);
-        s->L = 0;
+        lua_close(lane->L);
+        lane->L = nullptr;
         // just in case, but s will be freed soon so...
-        s->debug_name = "<gc>";
+        lane->debug_name = "<gc>";
     }
 
     // Clean up after a (finished) thread
-    lane_cleanup( s);
+    lane_cleanup(lane);
 
     // do this after lane cleanup in case the callback triggers an error
-    if( have_gc_cb)
+    if (have_gc_cb)
     {
-        lua_pushliteral( L, "closed");                                    // ud gc_cb name status
-        lua_call( L, 2, 0);                                               // ud
+        lua_pushliteral(L, "closed");                                    // ud gc_cb name status
+        lua_call(L, 2, 0);                                               // ud
     }
     return 0;
 }
 
+// #################################################################################################
+
 //---
 // str= thread_status( lane )
 //
@@ -1371,11 +1380,11 @@ LUAG_FUNC( thread_gc)
 //                   / "error"     finished at an error, error value is there
 //                   / "cancelled"   execution cancelled by M (state gone)
 //
-static char const * thread_status_string( Lane* s)
+static char const * thread_status_string(Lane* lane_)
 {
-    enum e_status st = s->status;    // read just once (volatile)
+    enum e_status const st{ lane_->status }; // read just once (volatile)
     char const* str =
-        (s->mstatus == ThreadStatus::Killed) ? "killed" : // new to v3.3.0!
+        (lane_->mstatus == ThreadStatus::Killed) ? "killed" : // new to v3.3.0!
         (st == PENDING) ? "pending" :
         (st == RUNNING) ? "running" :    // like in 'co.status()'
         (st == WAITING) ? "waiting" :
@@ -1385,15 +1394,18 @@ static char const * thread_status_string( Lane* s)
     return str;
 }
 
-int push_thread_status( lua_State* L, Lane* s)
+// #################################################################################################
+
+int push_thread_status(lua_State* L, Lane* lane_)
 {
-    char const* const str = thread_status_string( s);
-    ASSERT_L( str);
+    char const* const str{ thread_status_string(lane_) };
+    ASSERT_L(str);
 
-    lua_pushstring( L, str);
+    lua_pushstring(L, str);
     return 1;
 }
 
+// #################################################################################################
 
 //---
 // [...] | [nil, err_any, stack_tbl]= thread_join( lane_ud [, wait_secs=-1] )
@@ -1403,46 +1415,46 @@ int push_thread_status( lua_State* L, Lane* s)
 //  error:     returns nil + error value [+ stack table]
 //  cancelled: returns nil
 //
-LUAG_FUNC( thread_join)
+LUAG_FUNC(thread_join)
 {
-    Lane* const s = lua_toLane( L, 1);
-    double wait_secs = luaL_optnumber( L, 2, -1.0);
-    lua_State* L2 = s->L;
+    Lane* const lane{ lua_toLane(L, 1) };
+    lua_Number const wait_secs{ luaL_optnumber(L, 2, -1.0) };
+    lua_State* const L2{ lane->L };
     int ret;
-    bool const done{ THREAD_ISNULL(s->thread) || THREAD_WAIT(&s->thread, wait_secs, &s->done_signal, &s->done_lock, &s->status) };
-    if( !done || !L2)
+    bool const done{ THREAD_ISNULL(lane->thread) || THREAD_WAIT(&lane->thread, wait_secs, &lane->done_signal, &lane->done_lock, &lane->status) };
+    if (!done || !L2)
     {
-        STACK_GROW( L, 2);
-        lua_pushnil( L);
-        lua_pushliteral( L, "timeout");
+        STACK_GROW(L, 2);
+        lua_pushnil(L);
+        lua_pushliteral(L, "timeout");
         return 2;
     }
 
     STACK_CHECK_START_REL(L, 0);
     // Thread is DONE/ERROR_ST/CANCELLED; all ours now
 
-    if (s->mstatus == ThreadStatus::Killed) // OS thread was killed if thread_cancel was forced
+    if (lane->mstatus == ThreadStatus::Killed) // OS thread was killed if thread_cancel was forced
     {
         // in that case, even if the thread was killed while DONE/ERROR_ST/CANCELLED, ignore regular return values
-        STACK_GROW( L, 2);
-        lua_pushnil( L);
-        lua_pushliteral( L, "killed");
+        STACK_GROW(L, 2);
+        lua_pushnil(L);
+        lua_pushliteral(L, "killed");
         ret = 2;
     }
     else
     {
-        Universe* U = universe_get( L);
+        Universe* const U{ lane->U };
         // debug_name is a pointer to string possibly interned in the lane's state, that no longer exists when the state is closed
         // so store it in the userdata uservalue at a key that can't possibly collide
-        securize_debug_threadname( L, s);
-        switch( s->status)
+        securize_debug_threadname(L, lane);
+        switch (lane->status)
         {
             case DONE:
             {
-                int n = lua_gettop( L2);       // whole L2 stack
-                if( (n > 0) && (luaG_inter_move( U, L2, L, n, eLM_LaneBody) != 0))
+                int const n{ lua_gettop(L2) }; // whole L2 stack
+                if ((n > 0) && (luaG_inter_move(U, L2, L, n, eLM_LaneBody) != 0))
                 {
-                    return luaL_error( L, "tried to copy unsupported types");
+                    return luaL_error(L, "tried to copy unsupported types");
                 }
                 ret = n;
             }
@@ -1450,13 +1462,13 @@ LUAG_FUNC( thread_join)
 
             case ERROR_ST:
             {
-                int const n = lua_gettop( L2);
-                STACK_GROW( L, 3);
-                lua_pushnil( L);
+                int const n{ lua_gettop(L2) };
+                STACK_GROW(L, 3);
+                lua_pushnil(L);
                 // even when ERROR_FULL_STACK, if the error is not LUA_ERRRUN, the handler wasn't called, and we only have 1 error message on the stack ...
-                if( luaG_inter_move( U, L2, L, n, eLM_LaneBody) != 0)  // nil "err" [trace]
+                if (luaG_inter_move(U, L2, L, n, eLM_LaneBody) != 0) // nil "err" [trace]
                 {
-                    return luaL_error( L, "tried to copy unsupported types: %s", lua_tostring( L, -n));
+                    return luaL_error(L, "tried to copy unsupported types: %s", lua_tostring(L, -n));
                 }
                 ret = 1 + n;
             }
@@ -1467,14 +1479,14 @@ LUAG_FUNC( thread_join)
             break;
 
             default:
-            DEBUGSPEW_CODE( fprintf( stderr, "Status: %d\n", s->status));
-            ASSERT_L( false);
+            DEBUGSPEW_CODE(fprintf(stderr, "Status: %d\n", lane->status));
+            ASSERT_L(false);
             ret = 0;
         }
-        lua_close( L2);
+        lua_close(L2);
     }
-    s->L = 0;
-    STACK_CHECK( L, ret);
+    lane->L = nullptr;
+    STACK_CHECK(L, ret);
     return ret;
 }
 
@@ -1487,57 +1499,57 @@ LUAG_FUNC( thread_join)
 // If the return values signal an error, propagate it
 // If key is "status" return the thread status
 // Else raise an error
-LUAG_FUNC( thread_index)
+LUAG_FUNC(thread_index)
 {
-    int const UD = 1;
-    int const KEY = 2;
-    int const USR = 3;
-    Lane* const s = lua_toLane( L, UD);
-    ASSERT_L( lua_gettop( L) == 2);
+    static constexpr int UD{ 1 };
+    static constexpr int KEY{ 2 };
+    static constexpr int USR{ 3 };
+    Lane* const lane{ lua_toLane(L, UD) };
+    ASSERT_L(lua_gettop(L) == 2);
 
-    STACK_GROW( L, 8); // up to 8 positions are needed in case of error propagation
+    STACK_GROW(L, 8); // up to 8 positions are needed in case of error propagation
 
     // If key is numeric, wait until the thread returns and populate the environment with the return values
-    if( lua_type( L, KEY) == LUA_TNUMBER)
+    if (lua_type(L, KEY) == LUA_TNUMBER)
     {
         // first, check that we don't already have an environment that holds the requested value
         {
             // If key is found in the uservalue, return it
-            lua_getiuservalue( L, UD, 1);
-            lua_pushvalue( L, KEY);
-            lua_rawget( L, USR);
-            if( !lua_isnil( L, -1))
+            lua_getiuservalue(L, UD, 1);
+            lua_pushvalue(L, KEY);
+            lua_rawget(L, USR);
+            if (!lua_isnil(L, -1))
             {
-                return 1;
+            return 1;
             }
-            lua_pop( L, 1);
+            lua_pop(L, 1);
         }
         {
             // check if we already fetched the values from the thread or not
-            lua_Integer key = lua_tointeger( L, KEY);
-            lua_pushinteger( L, 0);
-            lua_rawget( L, USR);
+            lua_Integer key = lua_tointeger(L, KEY);
+            lua_pushinteger(L, 0);
+            lua_rawget(L, USR);
             bool const fetched{ !lua_isnil(L, -1) };
-            lua_pop( L, 1); // back to our 2 args + uservalue on the stack
-            if( !fetched)
+            lua_pop(L, 1); // back to our 2 args + uservalue on the stack
+            if (!fetched)
             {
-                lua_pushinteger( L, 0);
-                lua_pushboolean( L, 1);
-                lua_rawset( L, USR);
+                lua_pushinteger(L, 0);
+                lua_pushboolean(L, 1);
+                lua_rawset(L, USR);
                 // wait until thread has completed
-                lua_pushcfunction( L, LG_thread_join);
-                lua_pushvalue( L, UD);
-                lua_call( L, 1, LUA_MULTRET); // all return values are on the stack, at slots 4+
-                switch( s->status)
+                lua_pushcfunction(L, LG_thread_join);
+                lua_pushvalue(L, UD);
+                lua_call(L, 1, LUA_MULTRET); // all return values are on the stack, at slots 4+
+                switch (lane->status)
                 {
                     default:
-                    if (s->mstatus != ThreadStatus::Killed)
+                    if (lane->mstatus != ThreadStatus::Killed)
                     {
                         // this is an internal error, we probably never get here
-                        lua_settop( L, 0);
-                        lua_pushliteral( L, "Unexpected status: ");
-                        lua_pushstring( L, thread_status_string( s));
-                        lua_concat( L, 2);
+                        lua_settop(L, 0);
+                        lua_pushliteral(L, "Unexpected status: ");
+                        lua_pushstring(L, thread_status_string(lane));
+                        lua_concat(L, 2);
                         raise_lua_error(L);
                     }
                     [[fallthrough]]; // fall through if we are killed, as we got nil, "killed" on the stack
@@ -1545,23 +1557,23 @@ LUAG_FUNC( thread_index)
                     case DONE: // got regular return values
                     {
                         int const nvalues{ lua_gettop(L) - 3 };
-                        for( int i = nvalues; i > 0; -- i)
+                        for (int i = nvalues; i > 0; --i)
                         {
                             // pop the last element of the stack, to store it in the uservalue at its proper index
-                            lua_rawseti( L, USR, i);
+                            lua_rawseti(L, USR, i);
                         }
                     }
                     break;
 
                     case ERROR_ST: // got 3 values: nil, errstring, callstack table
-                    // me[-2] could carry the stack table, but even 
+                    // me[-2] could carry the stack table, but even
                     // me[-1] is rather unnecessary (and undocumented);
                     // use ':join()' instead.   --AKa 22-Jan-2009
-                    ASSERT_L( lua_isnil( L, 4) && !lua_isnil( L, 5) && lua_istable( L, 6));
+                    ASSERT_L(lua_isnil(L, 4) && !lua_isnil(L, 5) && lua_istable(L, 6));
                     // store errstring at key -1
-                    lua_pushnumber( L, -1);
-                    lua_pushvalue( L, 5);
-                    lua_rawset( L, USR);
+                    lua_pushnumber(L, -1);
+                    lua_pushvalue(L, 5);
+                    lua_rawset(L, USR);
                     break;
 
                     case CANCELLED:
@@ -1569,12 +1581,12 @@ LUAG_FUNC( thread_index)
                     break;
                 }
             }
-            lua_settop( L, 3);                                                // UD KEY ENV
-            if( key != -1)
+            lua_settop(L, 3);                                                    // UD KEY ENV
+            if (key != -1)
             {
-                lua_pushnumber( L, -1);                                         // UD KEY ENV -1
-                lua_rawget( L, USR);                                            // UD KEY ENV "error"
-                if( !lua_isnil( L, -1)) // an error was stored
+                lua_pushnumber(L, -1);                                           // UD KEY ENV -1
+                lua_rawget(L, USR);                                              // UD KEY ENV "error"
+                if (!lua_isnil(L, -1)) // an error was stored
                 {
                     // Note: Lua 5.1 interpreter is not prepared to show
                     //       non-string errors, so we use 'tostring()' here
@@ -1587,49 +1599,49 @@ LUAG_FUNC( thread_index)
                     // Level 3 should show the line where 'h[x]' was read
                     // but this only seems to work for string messages
                     // (Lua 5.1.4). No idea, why.   --AKa 22-Jan-2009
-                    lua_getmetatable( L, UD);                                     // UD KEY ENV "error" mt
-                    lua_getfield( L, -1, "cached_error");                         // UD KEY ENV "error" mt error()
-                    lua_getfield( L, -2, "cached_tostring");                      // UD KEY ENV "error" mt error() tostring()
-                    lua_pushvalue( L, 4);                                         // UD KEY ENV "error" mt error() tostring() "error"
-                    lua_call( L, 1, 1); // tostring( errstring) -- just in case   // UD KEY ENV "error" mt error() "error"
-                    lua_pushinteger( L, 3);                                       // UD KEY ENV "error" mt error() "error" 3
-                    lua_call( L, 2, 0); // error( tostring( errstring), 3)        // UD KEY ENV "error" mt
+                    lua_getmetatable(L, UD);                                     // UD KEY ENV "error" mt
+                    lua_getfield(L, -1, "cached_error");                         // UD KEY ENV "error" mt error()
+                    lua_getfield(L, -2, "cached_tostring");                      // UD KEY ENV "error" mt error() tostring()
+                    lua_pushvalue(L, 4);                                         // UD KEY ENV "error" mt error() tostring() "error"
+                    lua_call(L, 1, 1); // tostring( errstring) -- just in case   // UD KEY ENV "error" mt error() "error"
+                    lua_pushinteger(L, 3);                                       // UD KEY ENV "error" mt error() "error" 3
+                    lua_call(L, 2, 0); // error( tostring( errstring), 3)        // UD KEY ENV "error" mt
                 }
                 else
                 {
-                    lua_pop( L, 1); // back to our 3 arguments on the stack
+                    lua_pop(L, 1); // back to our 3 arguments on the stack
                 }
             }
-            lua_rawgeti( L, USR, (int)key);
+            lua_rawgeti(L, USR, (int)key);
         }
         return 1;
     }
-    if( lua_type( L, KEY) == LUA_TSTRING)
+    if (lua_type(L, KEY) == LUA_TSTRING)
     {
-        char const * const keystr = lua_tostring( L, KEY);
-        lua_settop( L, 2); // keep only our original arguments on the stack
-        if( strcmp( keystr, "status") == 0)
+        char const * const keystr = lua_tostring(L, KEY);
+        lua_settop(L, 2); // keep only our original arguments on the stack
+        if (strcmp( keystr, "status") == 0)
         {
-            return push_thread_status( L, s); // push the string representing the status
+            return push_thread_status(L, lane); // push the string representing the status
         }
         // return UD.metatable[key]
-        lua_getmetatable( L, UD); // UD KEY mt
-        lua_replace( L, -3);      // mt KEY
-        lua_rawget( L, -2);       // mt value
+        lua_getmetatable(L, UD); // UD KEY mt
+        lua_replace(L, -3);      // mt KEY
+        lua_rawget(L, -2);       // mt value
         // only "cancel" and "join" are registered as functions, any other string will raise an error
-        if( lua_iscfunction( L, -1))
+        if (lua_iscfunction(L, -1))
         {
             return 1;
         }
-        return luaL_error( L, "can't index a lane with '%s'", keystr);
+        return luaL_error(L, "can't index a lane with '%s'", keystr);
     }
     // unknown key
-    lua_getmetatable( L, UD);
-    lua_getfield( L, -1, "cached_error");
-    lua_pushliteral( L, "Unknown key: ");
-    lua_pushvalue( L, KEY);
-    lua_concat( L, 2);
-    lua_call( L, 1, 0); // error( "Unknown key: " .. key) -> doesn't return
+    lua_getmetatable(L, UD);
+    lua_getfield(L, -1, "cached_error");
+    lua_pushliteral(L, "Unknown key: ");
+    lua_pushvalue(L, KEY);
+    lua_concat(L, 2);
+    lua_call(L, 1, 0); // error( "Unknown key: " .. key) -> doesn't return
     return 0;
 }
 
@@ -1638,33 +1650,32 @@ LUAG_FUNC( thread_index)
 // threads() -> {}|nil
 //
 // Return a list of all known lanes
-LUAG_FUNC( threads)
+LUAG_FUNC(threads)
 {
-  int const top = lua_gettop( L);
-  Universe* U = universe_get( L);
-
-  // List _all_ still running threads
-  //
-  U->tracking_cs.lock();
-  if( U->tracking_first && U->tracking_first != TRACKING_END)
-  {
-    Lane* s = U->tracking_first;
-    int index = 0;
-    lua_newtable( L);                                          // {}
-    while( s != TRACKING_END)
+    int const top{ lua_gettop(L) };
+    Universe* const U{ universe_get(L) };
+
+    // List _all_ still running threads
+    //
+    std::lock_guard<std::mutex> guard{ U->tracking_cs };
+    if (U->tracking_first && U->tracking_first != TRACKING_END)
     {
-      // insert a { name, status } tuple, so that several lanes with the same name can't clobber each other
-      lua_newtable( L);                                        // {} {}
-      lua_pushstring( L, s->debug_name);                       // {} {} "name"
-      lua_setfield( L, -2, "name");                            // {} {}
-      push_thread_status( L, s);                               // {} {} "status"
-      lua_setfield( L, -2, "status");                          // {} {}
-      lua_rawseti( L, -2, ++ index);                           // {}
-      s = s->tracking_next;
+        Lane* lane{ U->tracking_first };
+        int index = 0;
+        lua_newtable(L);                         // {}
+        while (lane != TRACKING_END)
+        {
+            // insert a { name, status } tuple, so that several lanes with the same name can't clobber each other
+            lua_newtable(L);                     // {} {}
+            lua_pushstring(L, lane->debug_name); // {} {} "name"
+            lua_setfield(L, -2, "name");         // {} {}
+            push_thread_status(L, lane);         // {} {} "status"
+            lua_setfield(L, -2, "status");       // {} {}
+            lua_rawseti(L, -2, ++index);         // {}
+            lane = lane->tracking_next;
+        }
     }
-  }
-  U->tracking_cs.unlock();
-  return lua_gettop( L) - top; // 0 or 1
+    return lua_gettop(L) - top;                  // 0 or 1
 }
 #endif // HAVE_LANE_TRACKING()
 
@@ -1679,47 +1690,56 @@ LUAG_FUNC( threads)
 *
 * Returns the current time, as seconds (millisecond resolution).
 */
-LUAG_FUNC( now_secs )
+LUAG_FUNC(now_secs)
 {
-    lua_pushnumber( L, now_secs() );
+    lua_pushnumber(L, now_secs());
     return 1;
 }
 
+// #################################################################################################
+
 /*
-* wakeup_at_secs= wakeup_conv( date_tbl )
+* wakeup_at_secs= wakeup_conv(date_tbl)
 */
-LUAG_FUNC( wakeup_conv )
+LUAG_FUNC(wakeup_conv)
 {
-    int year, month, day, hour, min, sec, isdst;
-    struct tm t;
-    memset( &t, 0, sizeof( t));
-        //
-        // .year (four digits)
-        // .month (1..12)
-        // .day (1..31)
-        // .hour (0..23)
-        // .min (0..59)
-        // .sec (0..61)
-        // .yday (day of the year)
-        // .isdst (daylight saving on/off)
+    // date_tbl
+    // .year (four digits)
+    // .month (1..12)
+    // .day (1..31)
+    // .hour (0..23)
+    // .min (0..59)
+    // .sec (0..61)
+    // .yday (day of the year)
+    // .isdst (daylight saving on/off)
 
     STACK_CHECK_START_REL(L, 0);
-    lua_getfield( L, 1, "year" ); year= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "month" ); month= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "day" ); day= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "hour" ); hour= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "min" ); min= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "sec" ); sec= (int)lua_tointeger(L,-1); lua_pop(L,1);
+    auto readInteger = [L](char const* name_)
+    {
+        lua_getfield(L, 1, name_);
+        lua_Integer const val{ lua_tointeger(L, -1) };
+        lua_pop(L, 1);
+        return static_cast<int>(val);
+    };
+    int const year{ readInteger("year") };
+    int const month{ readInteger("month") };
+    int const day{ readInteger("day") };
+    int const hour{ readInteger("hour") };
+    int const min{ readInteger("min") };
+    int const sec{ readInteger("sec") };
+    STACK_CHECK(L, 0);
 
     // If Lua table has '.isdst' we trust that. If it does not, we'll let
     // 'mktime' decide on whether the time is within DST or not (value -1).
     //
-    lua_getfield( L, 1, "isdst" );
-    isdst= lua_isboolean(L,-1) ? lua_toboolean(L,-1) : -1;
+    lua_getfield(L, 1, "isdst" );
+    int const isdst{ lua_isboolean(L, -1) ? lua_toboolean(L, -1) : -1 };
     lua_pop(L,1);
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
 
-    t.tm_year= year-1900;
+    struct tm t;
+    memset(&t, 0, sizeof(t));
+    t.tm_year = year - 1900;
     t.tm_mon= month-1;     // 0..11
     t.tm_mday= day;        // 1..31
     t.tm_hour= hour;       // 0..23
@@ -1727,7 +1747,7 @@ LUAG_FUNC( wakeup_conv )
     t.tm_sec= sec;         // 0..60
     t.tm_isdst= isdst;     // 0/1/negative
 
-    lua_pushnumber( L, (double) mktime( &t));   // ms=0
+    lua_pushnumber(L, static_cast<lua_Number>(mktime(&t))); // ms=0
     return 1;
 }
 
@@ -1737,17 +1757,18 @@ LUAG_FUNC( wakeup_conv )
  * ###############################################################################################
  */
 
-extern int LG_linda( lua_State* L);
-static const struct luaL_Reg lanes_functions [] = {
-    {"linda", LG_linda},
-    {"now_secs", LG_now_secs},
-    {"wakeup_conv", LG_wakeup_conv},
-    {"set_thread_priority", LG_set_thread_priority},
-    {"set_thread_affinity", LG_set_thread_affinity},
-    {"nameof", luaG_nameof},
-    {"register", LG_register},
-    {"set_singlethreaded", LG_set_singlethreaded},
-    {nullptr, nullptr}
+extern int LG_linda(lua_State* L);
+static const struct luaL_Reg lanes_functions[] =
+{
+    { "linda", LG_linda },
+    { "now_secs", LG_now_secs },
+    { "wakeup_conv", LG_wakeup_conv },
+    { "set_thread_priority", LG_set_thread_priority },
+    { "set_thread_affinity", LG_set_thread_affinity },
+    { "nameof", luaG_nameof },
+    { "register", LG_register },
+    { "set_singlethreaded", LG_set_singlethreaded },
+    { nullptr, nullptr }
 };
 
 /*
@@ -1778,31 +1799,33 @@ static void init_once_LOCKED( void)
     sudo = (geteuid() == 0); // we are root?
 
     // If lower priorities (-2..-1) are wanted, we need to lift the main
-    // thread to SCHED_RR and 50 (medium) level. Otherwise, we're always below 
+    // thread to SCHED_RR and 50 (medium) level. Otherwise, we're always below
     // the launched threads (even -2).
     //
 #ifdef LINUX_SCHED_RR
-    if( sudo)
+    if (sudo)
     {
         struct sched_param sp;
         sp.sched_priority = _PRIO_0;
-        PT_CALL( pthread_setschedparam( pthread_self(), SCHED_RR, &sp));
+        PT_CALL(pthread_setschedparam(pthread_self(), SCHED_RR, &sp));
     }
 #endif // LINUX_SCHED_RR
 #endif // PLATFORM_LINUX
 }
 
+// #################################################################################################
+
 static volatile long s_initCount = 0;
 
 // upvalue 1: module name
 // upvalue 2: module table
 // param 1: settings table
-LUAG_FUNC( configure)
+LUAG_FUNC(configure)
 {
-    Universe* U = universe_get( L);
+    Universe* U = universe_get(L);
     bool const from_master_state{ U == nullptr };
-    char const* name = luaL_checkstring( L, lua_upvalueindex( 1));
-    _ASSERT_L( L, lua_type( L, 1) == LUA_TTABLE);
+    char const* name = luaL_checkstring(L, lua_upvalueindex(1));
+    ASSERT_L(lua_type(L, 1) == LUA_TTABLE);
 
     /*
     ** Making one-time initializations.
@@ -1814,199 +1837,204 @@ LUAG_FUNC( configure)
 #if THREADAPI == THREADAPI_WINDOWS
     {
         static volatile int /*bool*/ go_ahead; // = 0
-        if( InterlockedCompareExchange( &s_initCount, 1, 0) == 0)
+        if (InterlockedCompareExchange(&s_initCount, 1, 0) == 0)
         {
             init_once_LOCKED();
             go_ahead = 1; // let others pass
         }
         else
         {
-            while( !go_ahead) { Sleep(1); } // changes threads
+            while (!go_ahead)
+            {
+                Sleep(1);
+            } // changes threads
         }
     }
 #else // THREADAPI == THREADAPI_PTHREAD
-    if( s_initCount == 0)
+    if (s_initCount == 0)
     {
         static pthread_mutex_t my_lock = PTHREAD_MUTEX_INITIALIZER;
-        pthread_mutex_lock( &my_lock);
+        pthread_mutex_lock(&my_lock);
         {
             // Recheck now that we're within the lock
             //
-            if( s_initCount == 0)
+            if (s_initCount == 0)
             {
                 init_once_LOCKED();
                 s_initCount = 1;
             }
         }
-        pthread_mutex_unlock( &my_lock);
+        pthread_mutex_unlock(&my_lock);
     }
 #endif // THREADAPI == THREADAPI_PTHREAD
 
-    STACK_GROW( L, 4);
-    STACK_CHECK_START_ABS( L, 1);                                                          // settings
+    STACK_GROW(L, 4);
+    STACK_CHECK_START_ABS(L, 1);                                                          // settings
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() BEGIN\n" INDENT_END, L));
-    DEBUGSPEW_CODE( if( U) ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE( if (U) ++ U->debugspew_indent_depth);
 
     if(U == nullptr)
     {
-        U = universe_create( L);                                                           // settings universe
+        U = universe_create( L);                                                          // settings universe
         DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        lua_newtable( L);                                                                  // settings universe mt
-        lua_getfield( L, 1, "shutdown_timeout");                                           // settings universe mt shutdown_timeout
-        lua_pushcclosure( L, selfdestruct_gc, 1);                                          // settings universe mt selfdestruct_gc
-        lua_setfield( L, -2, "__gc");                                                      // settings universe mt
-        lua_setmetatable( L, -2);                                                          // settings universe
-        lua_pop( L, 1);                                                                    // settings
-        lua_getfield( L, 1, "verbose_errors");                                             // settings verbose_errors
-        U->verboseErrors = lua_toboolean( L, -1) ? true : false;
-        lua_pop( L, 1);                                                                    // settings
-        lua_getfield( L, 1, "demote_full_userdata");                                       // settings demote_full_userdata
-        U->demoteFullUserdata = lua_toboolean( L, -1) ? true : false;
-        lua_pop( L, 1);                                                                    // settings
+        lua_newtable( L);                                                                 // settings universe mt
+        lua_getfield(L, 1, "shutdown_timeout");                                           // settings universe mt shutdown_timeout
+        lua_pushcclosure(L, selfdestruct_gc, 1);                                          // settings universe mt selfdestruct_gc
+        lua_setfield(L, -2, "__gc");                                                      // settings universe mt
+        lua_setmetatable(L, -2);                                                          // settings universe
+        lua_pop(L, 1);                                                                    // settings
+        lua_getfield(L, 1, "verbose_errors");                                             // settings verbose_errors
+        U->verboseErrors = lua_toboolean(L, -1) ? true : false;
+        lua_pop(L, 1);                                                                    // settings
+        lua_getfield(L, 1, "demote_full_userdata");                                       // settings demote_full_userdata
+        U->demoteFullUserdata = lua_toboolean(L, -1) ? true : false;
+        lua_pop(L, 1);                                                                    // settings
 #if HAVE_LANE_TRACKING()
-        lua_getfield( L, 1, "track_lanes");                                                // settings track_lanes
-        U->tracking_first = lua_toboolean( L, -1) ? TRACKING_END : nullptr;
-        lua_pop( L, 1);                                                                    // settings
+        lua_getfield(L, 1, "track_lanes");                                                // settings track_lanes
+        U->tracking_first = lua_toboolean(L, -1) ? TRACKING_END : nullptr;
+        lua_pop(L, 1);                                                                    // settings
 #endif // HAVE_LANE_TRACKING()
         // Linked chains handling
         U->selfdestruct_first = SELFDESTRUCT_END;
         initialize_allocator_function( U, L);
         initialize_on_state_create( U, L);
         init_keepers( U, L);
-        STACK_CHECK( L, 1);
+        STACK_CHECK(L, 1);
 
         // Initialize 'timer_deep'; a common Linda object shared by all states
-        lua_pushcfunction( L, LG_linda);                                                   // settings lanes.linda
-        lua_pushliteral( L, "lanes-timer");                                                // settings lanes.linda "lanes-timer"
-        lua_call( L, 1, 1);                                                                // settings linda
-        STACK_CHECK( L, 2);
+        lua_pushcfunction(L, LG_linda);                                                   // settings lanes.linda
+        lua_pushliteral(L, "lanes-timer");                                                // settings lanes.linda "lanes-timer"
+        lua_call(L, 1, 1);                                                                // settings linda
+        STACK_CHECK(L, 2);
 
         // Proxy userdata contents is only a 'DeepPrelude*' pointer
         U->timer_deep = *lua_tofulluserdata<DeepPrelude*>(L, -1);
         // increment refcount so that this linda remains alive as long as the universe exists.
         U->timer_deep->m_refcount.fetch_add(1, std::memory_order_relaxed);
-        lua_pop( L, 1);                                                                    // settings
+        lua_pop(L, 1);                                                                    // settings
     }
-    STACK_CHECK( L, 1);
+    STACK_CHECK(L, 1);
 
     // Serialize calls to 'require' from now on, also in the primary state
     serialize_require( DEBUGSPEW_PARAM_COMMA( U) L);
 
     // Retrieve main module interface table
-    lua_pushvalue( L, lua_upvalueindex( 2));                                               // settings M
+    lua_pushvalue(L, lua_upvalueindex( 2));                                               // settings M
     // remove configure() (this function) from the module interface
-    lua_pushnil( L);                                                                       // settings M nil
-    lua_setfield( L, -2, "configure");                                                     // settings M
+    lua_pushnil( L);                                                                      // settings M nil
+    lua_setfield(L, -2, "configure");                                                     // settings M
     // add functions to the module's table
-    luaG_registerlibfuncs( L, lanes_functions);
+    luaG_registerlibfuncs(L, lanes_functions);
 #if HAVE_LANE_TRACKING()
     // register core.threads() only if settings say it should be available
-    if( U->tracking_first != nullptr)
+    if (U->tracking_first != nullptr)
     {
-        lua_pushcfunction( L, LG_threads);                                                 // settings M LG_threads()
-        lua_setfield( L, -2, "threads");                                                   // settings M
+        lua_pushcfunction(L, LG_threads);                                                 // settings M LG_threads()
+        lua_setfield(L, -2, "threads");                                                   // settings M
     }
 #endif // HAVE_LANE_TRACKING()
-    STACK_CHECK( L, 2);
+    STACK_CHECK(L, 2);
 
     {
-        char const* errmsg{ push_deep_proxy(L, U->timer_deep, 0, eLM_LaneBody) };          // settings M timer_deep
-        if( errmsg != nullptr)
+        char const* errmsg{ push_deep_proxy(L, U->timer_deep, 0, eLM_LaneBody) };         // settings M timer_deep
+        if (errmsg != nullptr)
         {
-            return luaL_error( L, errmsg);
+            return luaL_error(L, errmsg);
         }
-        lua_setfield( L, -2, "timer_gateway");                                             // settings M
+        lua_setfield(L, -2, "timer_gateway");                                             // settings M
     }
-    STACK_CHECK( L, 2);
+    STACK_CHECK(L, 2);
 
     // prepare the metatable for threads
     // contains keys: { __gc, __index, cached_error, cached_tostring, cancel, join, get_debug_threadname }
     //
-    if( luaL_newmetatable( L, "Lane"))                                                     // settings M mt
+    if (luaL_newmetatable(L, "Lane"))                                                     // settings M mt
     {
-        lua_pushcfunction( L, LG_thread_gc);                                               // settings M mt LG_thread_gc
-        lua_setfield( L, -2, "__gc");                                                      // settings M mt
-        lua_pushcfunction( L, LG_thread_index);                                            // settings M mt LG_thread_index
-        lua_setfield( L, -2, "__index");                                                   // settings M mt
-        lua_getglobal( L, "error");                                                        // settings M mt error
-        ASSERT_L( lua_isfunction( L, -1));
-        lua_setfield( L, -2, "cached_error");                                              // settings M mt
-        lua_getglobal( L, "tostring");                                                     // settings M mt tostring
-        ASSERT_L( lua_isfunction( L, -1));
-        lua_setfield( L, -2, "cached_tostring");                                           // settings M mt
-        lua_pushcfunction( L, LG_thread_join);                                             // settings M mt LG_thread_join
-        lua_setfield( L, -2, "join");                                                      // settings M mt
-        lua_pushcfunction( L, LG_get_debug_threadname);                                    // settings M mt LG_get_debug_threadname
-        lua_setfield( L, -2, "get_debug_threadname");                                      // settings M mt
-        lua_pushcfunction( L, LG_thread_cancel);                                           // settings M mt LG_thread_cancel
-        lua_setfield( L, -2, "cancel");                                                    // settings M mt
-        lua_pushliteral( L, "Lane");                                                       // settings M mt "Lane"
-        lua_setfield( L, -2, "__metatable");                                               // settings M mt
+        lua_pushcfunction(L, LG_thread_gc);                                               // settings M mt LG_thread_gc
+        lua_setfield(L, -2, "__gc");                                                      // settings M mt
+        lua_pushcfunction(L, LG_thread_index);                                            // settings M mt LG_thread_index
+        lua_setfield(L, -2, "__index");                                                   // settings M mt
+        lua_getglobal(L, "error");                                                        // settings M mt error
+        ASSERT_L( lua_isfunction(L, -1));
+        lua_setfield(L, -2, "cached_error");                                              // settings M mt
+        lua_getglobal(L, "tostring");                                                     // settings M mt tostring
+        ASSERT_L( lua_isfunction(L, -1));
+        lua_setfield(L, -2, "cached_tostring");                                           // settings M mt
+        lua_pushcfunction(L, LG_thread_join);                                             // settings M mt LG_thread_join
+        lua_setfield(L, -2, "join");                                                      // settings M mt
+        lua_pushcfunction(L, LG_get_debug_threadname);                                    // settings M mt LG_get_debug_threadname
+        lua_setfield(L, -2, "get_debug_threadname");                                      // settings M mt
+        lua_pushcfunction(L, LG_thread_cancel);                                           // settings M mt LG_thread_cancel
+        lua_setfield(L, -2, "cancel");                                                    // settings M mt
+        lua_pushliteral(L, "Lane");                                                       // settings M mt "Lane"
+        lua_setfield(L, -2, "__metatable");                                               // settings M mt
     }
 
-    lua_pushcclosure( L, LG_lane_new, 1);                                                  // settings M lane_new
-    lua_setfield( L, -2, "lane_new");                                                      // settings M
+    lua_pushcclosure(L, LG_lane_new, 1);                                                  // settings M lane_new
+    lua_setfield(L, -2, "lane_new");                                                      // settings M
 
     // we can't register 'lanes.require' normally because we want to create an upvalued closure
-    lua_getglobal( L, "require");                                                          // settings M require
-    lua_pushcclosure( L, LG_require, 1);                                                   // settings M lanes.require
-    lua_setfield( L, -2, "require");                                                       // settings M
+    lua_getglobal(L, "require");                                                          // settings M require
+    lua_pushcclosure(L, LG_require, 1);                                                   // settings M lanes.require
+    lua_setfield(L, -2, "require");                                                       // settings M
 
     lua_pushfstring(
         L, "%d.%d.%d"
         , LANES_VERSION_MAJOR, LANES_VERSION_MINOR, LANES_VERSION_PATCH
-    );                                                                                     // settings M VERSION
-    lua_setfield( L, -2, "version");                                                       // settings M
+    );                                                                                    // settings M VERSION
+    lua_setfield(L, -2, "version");                                                       // settings M
 
-    lua_pushinteger(L, THREAD_PRIO_MAX);                                                   // settings M THREAD_PRIO_MAX
-    lua_setfield( L, -2, "max_prio");                                                      // settings M
+    lua_pushinteger(L, THREAD_PRIO_MAX);                                                  // settings M THREAD_PRIO_MAX
+    lua_setfield(L, -2, "max_prio");                                                      // settings M
 
-    CANCEL_ERROR.push(L);                                                                  // settings M CANCEL_ERROR
-    lua_setfield( L, -2, "cancel_error");                                                  // settings M
+    CANCEL_ERROR.push(L);                                                                 // settings M CANCEL_ERROR
+    lua_setfield(L, -2, "cancel_error");                                                  // settings M
 
-    STACK_CHECK( L, 2); // reference stack contains only the function argument 'settings'
+    STACK_CHECK(L, 2); // reference stack contains only the function argument 'settings'
     // we'll need this every time we transfer some C function from/to this state
-    LOOKUP_REGKEY.set_registry(L, [](lua_State* L) { lua_newtable(L); });                  // settings M
-    STACK_CHECK( L, 2);
+    LOOKUP_REGKEY.set_registry(L, [](lua_State* L) { lua_newtable(L); });                 // settings M
+    STACK_CHECK(L, 2);
 
     // register all native functions found in that module in the transferable functions database
     // we process it before _G because we don't want to find the module when scanning _G (this would generate longer names)
     // for example in package.loaded["lanes.core"].*
-    populate_func_lookup_table( L, -1, name);
-    STACK_CHECK( L, 2);
+    populate_func_lookup_table(L, -1, name);
+    STACK_CHECK(L, 2);
 
     // record all existing C/JIT-fast functions
     // Lua 5.2 no longer has LUA_GLOBALSINDEX: we must push globals table on the stack
-    if( from_master_state)
+    if (from_master_state)
     {
         // don't do this when called during the initialization of a new lane,
         // because we will do it after on_state_create() is called,
         // and we don't want to skip _G because of caching in case globals are created then
-        lua_pushglobaltable( L);                                                           // settings M _G
-        populate_func_lookup_table( L, -1, nullptr);
-        lua_pop( L, 1);                                                                    // settings M
+        lua_pushglobaltable( L);                                                          // settings M _G
+        populate_func_lookup_table(L, -1, nullptr);
+        lua_pop(L, 1);                                                                    // settings M
     }
-    lua_pop( L, 1);                                                                        // settings
+    lua_pop(L, 1);                                                                        // settings
 
     // set _R[CONFIG_REGKEY] = settings
     CONFIG_REGKEY.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
-    STACK_CHECK( L, 1);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() END\n" INDENT_END, L));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    STACK_CHECK(L, 1);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "%p: lanes.configure() END\n" INDENT_END, L));
+    DEBUGSPEW_CODE(--U->debugspew_indent_depth);
     // Return the settings table
     return 1;
 }
 
+// #################################################################################################
+
 #if defined PLATFORM_WIN32 && !defined NDEBUG
 #include <signal.h>
 #include <conio.h>
 
-void signal_handler( int signal)
+void signal_handler(int signal)
 {
-    if( signal == SIGABRT)
+    if (signal == SIGABRT)
     {
-        _cprintf( "caught abnormal termination!");
+        _cprintf("caught abnormal termination!");
         abort();
     }
 }
@@ -2015,12 +2043,12 @@ void signal_handler( int signal)
 // don't forget to toggle Debug/Exceptions/Win32 in visual Studio too!
 static volatile long s_ecoc_initCount = 0;
 static volatile int s_ecoc_go_ahead = 0;
-static void EnableCrashingOnCrashes( void)
+static void EnableCrashingOnCrashes(void)
 {
-    if( InterlockedCompareExchange( &s_ecoc_initCount, 1, 0) == 0)
+    if (InterlockedCompareExchange(&s_ecoc_initCount, 1, 0) == 0)
     {
-        typedef BOOL (WINAPI* tGetPolicy)( LPDWORD lpFlags);
-        typedef BOOL (WINAPI* tSetPolicy)( DWORD dwFlags);
+        typedef BOOL(WINAPI * tGetPolicy)(LPDWORD lpFlags);
+        typedef BOOL(WINAPI * tSetPolicy)(DWORD dwFlags);
         const DWORD EXCEPTION_SWALLOWING = 0x1;
 
         HMODULE kernel32 = LoadLibraryA("kernel32.dll");
@@ -2039,14 +2067,17 @@ static void EnableCrashingOnCrashes( void)
             }
             FreeLibrary(kernel32);
         }
-        //typedef void (* SignalHandlerPointer)( int);
-        /*SignalHandlerPointer previousHandler =*/ signal( SIGABRT, signal_handler);
+        // typedef void (* SignalHandlerPointer)( int);
+        /*SignalHandlerPointer previousHandler =*/signal(SIGABRT, signal_handler);
 
         s_ecoc_go_ahead = 1; // let others pass
     }
     else
     {
-        while( !s_ecoc_go_ahead) { Sleep(1); } // changes threads
+        while (!s_ecoc_go_ahead)
+        {
+            Sleep(1);
+        } // changes threads
     }
 }
 #endif // PLATFORM_WIN32 && !defined NDEBUG
@@ -2057,51 +2088,51 @@ LANES_API int luaopen_lanes_core( lua_State* L)
     EnableCrashingOnCrashes();
 #endif // defined PLATFORM_WIN32 && !defined NDEBUG
 
-    STACK_GROW( L, 4);
+    STACK_GROW(L, 4);
     STACK_CHECK_START_REL(L, 0);
 
     // Prevent PUC-Lua/LuaJIT mismatch. Hopefully this works for MoonJIT too
-    lua_getglobal( L, "jit");                           // {jit?}
+    lua_getglobal(L, "jit");                           // {jit?}
 #if LUAJIT_FLAVOR() == 0
-    if (!lua_isnil( L, -1))
-        return luaL_error( L, "Lanes is built for PUC-Lua, don't run from LuaJIT");
+    if (!lua_isnil(L, -1))
+        return luaL_error(L, "Lanes is built for PUC-Lua, don't run from LuaJIT");
 #else
-    if (lua_isnil( L, -1))
-        return luaL_error( L, "Lanes is built for LuaJIT, don't run from PUC-Lua");
+    if (lua_isnil(L, -1))
+        return luaL_error(L, "Lanes is built for LuaJIT, don't run from PUC-Lua");
 #endif
-    lua_pop( L, 1);                                     //
+    lua_pop(L, 1);                                     //
     STACK_CHECK(L, 0);
 
     // Create main module interface table
     // we only have 1 closure, which must be called to configure Lanes
     lua_newtable( L);                                   // M
-    lua_pushvalue( L, 1);                               // M "lanes.core"
-    lua_pushvalue( L, -2);                              // M "lanes.core" M
-    lua_pushcclosure( L, LG_configure, 2);              // M LG_configure()
+    lua_pushvalue(L, 1);                               // M "lanes.core"
+    lua_pushvalue(L, -2);                              // M "lanes.core" M
+    lua_pushcclosure(L, LG_configure, 2);              // M LG_configure()
     CONFIG_REGKEY.query_registry(L);                    // M LG_configure() settings
-    if( !lua_isnil( L, -1)) // this is not the first require "lanes.core": call configure() immediately
+    if (!lua_isnil(L, -1)) // this is not the first require "lanes.core": call configure() immediately
     {
-        lua_pushvalue( L, -1);                          // M LG_configure() settings settings
-        lua_setfield( L, -4, "settings");               // M LG_configure() settings
-        lua_call( L, 1, 0);                             // M
+        lua_pushvalue(L, -1);                          // M LG_configure() settings settings
+        lua_setfield(L, -4, "settings");               // M LG_configure() settings
+        lua_call(L, 1, 0);                             // M
     }
     else
     {
         // will do nothing on first invocation, as we haven't stored settings in the registry yet
-        lua_setfield( L, -3, "settings");               // M LG_configure()
-        lua_setfield( L, -2, "configure");              // M
+        lua_setfield(L, -3, "settings");               // M LG_configure()
+        lua_setfield(L, -2, "configure");              // M
     }
 
-    STACK_CHECK( L, 1);
+    STACK_CHECK(L, 1);
     return 1;
 }
 
 static int default_luaopen_lanes( lua_State* L)
 {
-    int rc = luaL_loadfile( L, "lanes.lua") || lua_pcall( L, 0, 1, 0);
-    if( rc != LUA_OK)
+    int rc = luaL_loadfile(L, "lanes.lua") || lua_pcall(L, 0, 1, 0);
+    if (rc != LUA_OK)
     {
-        return luaL_error( L, "failed to initialize embedded Lanes");
+        return luaL_error(L, "failed to initialize embedded Lanes");
     }
     return 1;
 }
@@ -2111,10 +2142,10 @@ LANES_API void luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lane
 {
     STACK_CHECK_START_REL(L, 0);
     // pre-require lanes.core so that when lanes.lua calls require "lanes.core" it finds it is already loaded
-    luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);                                       // ... lanes.core
-    lua_pop( L, 1);                                                                               // ...
-    STACK_CHECK( L, 0);
+    luaL_requiref(L, "lanes.core", luaopen_lanes_core, 0);                                       // ... lanes.core
+    lua_pop(L, 1);                                                                               // ...
+    STACK_CHECK(L, 0);
     // call user-provided function that runs the chunk "lanes.lua" from wherever they stored it
-    luaL_requiref( L, "lanes", _luaopen_lanes ? _luaopen_lanes : default_luaopen_lanes, 0);       // ... lanes
-    STACK_CHECK( L, 1);
+    luaL_requiref(L, "lanes", _luaopen_lanes ? _luaopen_lanes : default_luaopen_lanes, 0);       // ... lanes
+    STACK_CHECK(L, 1);
 }
diff --git a/src/universe.h b/src/universe.h
index a31e6c2..1079915 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -83,9 +83,9 @@ class ProtectedAllocator : public AllocatorDefinition
 
     static void* protected_lua_Alloc(void* ud_, void* ptr_, size_t osize_, size_t nsize_)
     {
-        ProtectedAllocator* const s{ static_cast<ProtectedAllocator*>(ud_) };
-        std::lock_guard<std::mutex> guard{ s->m_lock };
-        return s->m_allocF(s->m_allocUD, ptr_, osize_, nsize_);
+        ProtectedAllocator* const allocator{ static_cast<ProtectedAllocator*>(ud_) };
+        std::lock_guard<std::mutex> guard{ allocator->m_lock };
+        return allocator->m_allocF(allocator->m_allocUD, ptr_, osize_, nsize_);
     }
 
     public: