10 files changed, 90 insertions, 84 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index fe1f3e6..a7dc0ec 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -264,7 +264,7 @@ LUAG_FUNC(thread_cancel)
     switch (thread_cancel(lane, op, hook_count, wait_timeout, wake_lane))
     {
         default: // should never happen unless we added a case and forgot to handle it
-        ASSERT_L(false);
+        LUA_ASSERT(L, false);
         break;
 
         case CancelResult::Timeout:
diff --git a/src/compat.cpp b/src/compat.cpp
index 9f652a7..712aa23 100644
--- a/src/compat.cpp
+++ b/src/compat.cpp
@@ -55,7 +55,7 @@ void luaL_requiref(lua_State *L, const char *modname, lua_CFunction openf, int g
 
 void* lua_newuserdatauv( lua_State* L, size_t sz, int nuvalue)
 {
-    ASSERT_L( nuvalue <= 1);
+    LUA_ASSERT(L, nuvalue <= 1);
     return lua_newuserdata(L, sz);
 }
 
diff --git a/src/deep.cpp b/src/deep.cpp
index 3e1d90a..e4d090f 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -212,7 +212,7 @@ char const* DeepFactory::PushDeepProxy(Dest L, DeepPrelude* prelude, int nuv_, L
 
     // a new full userdata, fitted with the specified number of uservalue slots (always 1 for Lua < 5.4)
     DeepPrelude** const proxy{ lua_newuserdatauv<DeepPrelude*>(L, nuv_) };                             // DPC proxy
-    ASSERT_L(proxy);
+    LUA_ASSERT(L, proxy);
     *proxy = prelude;
     prelude->m_refcount.fetch_add(1, std::memory_order_relaxed); // one more proxy pointing to this deep data
 
@@ -312,8 +312,8 @@ char const* DeepFactory::PushDeepProxy(Dest L, DeepPrelude* prelude, int nuv_, L
         }
     }
     STACK_CHECK(L, 2);                                                                                 // DPC proxy metatable
-    ASSERT_L(lua_type_as_enum(L, -2) == LuaType::USERDATA);
-    ASSERT_L(lua_istable( L, -1));
+    LUA_ASSERT(L, lua_type_as_enum(L, -2) == LuaType::USERDATA);
+    LUA_ASSERT(L, lua_istable( L, -1));
     lua_setmetatable( L, -2);                                                                          // DPC proxy
 
     // If we're here, we obviously had to create a new proxy, so cache it.
@@ -321,7 +321,7 @@ char const* DeepFactory::PushDeepProxy(Dest L, DeepPrelude* prelude, int nuv_, L
     lua_pushvalue( L, -2);                                                                             // DPC proxy deep proxy
     lua_rawset( L, -4);                                                                                // DPC proxy
     lua_remove( L, -2);                                                                                // proxy
-    ASSERT_L(lua_type_as_enum(L, -1) == LuaType::USERDATA);
+    LUA_ASSERT(L, lua_type_as_enum(L, -1) == LuaType::USERDATA);
     STACK_CHECK(L, 0);
     return nullptr;
 }
@@ -361,8 +361,8 @@ int DeepFactory::pushDeepUserdata(Dest L, int nuv_) const
         return luaL_error( L, "Bad Deep Factory: DEEP_VERSION is incorrect, rebuild your implementation with the latest deep implementation");
     }
 
-    ASSERT_L(prelude->m_refcount.load(std::memory_order_relaxed) == 0); // 'DeepFactory::PushDeepProxy' will lift it to 1
-    ASSERT_L(&prelude->m_factory == this);
+    LUA_ASSERT(L, prelude->m_refcount.load(std::memory_order_relaxed) == 0); // 'DeepFactory::PushDeepProxy' will lift it to 1
+    LUA_ASSERT(L, &prelude->m_factory == this);
 
     if (lua_gettop( L) - oldtop != 0)
     {
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 0875b87..48f0166 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -64,7 +64,7 @@ class keeper_fifo
     [[nodiscard]] static void* operator new([[maybe_unused]] 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([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
+    static void operator delete([[maybe_unused]] void* p_, lua_State* L_) { LUA_ASSERT(L_, !"should never be called"); }
 
     [[nodiscard]] static keeper_fifo* getPtr(lua_State* L, int idx_)
     {
@@ -146,7 +146,7 @@ static void fifo_peek(lua_State* L, keeper_fifo* fifo_, int count_)
 // out: remove the fifo from the stack, push as many items as required on the stack (function assumes they exist in sufficient number)
 static void fifo_pop( lua_State* L, keeper_fifo* fifo_, int count_)
 {
-    ASSERT_L(lua_istable(L, -1));
+    LUA_ASSERT(L, lua_istable(L, -1));
     int const fifo_idx{ lua_gettop(L) };       // ... fifotbl
     // each iteration pushes a value on the stack!
     STACK_GROW(L, count_ + 2);
@@ -582,7 +582,7 @@ int keepercall_count(lua_State* L)
         } // all keys are exhausted                                // out fifos
         lua_pop(L, 1);                                             // out
     }
-    ASSERT_L(lua_gettop(L) == 1);
+    LUA_ASSERT(L, lua_gettop(L) == 1);
     return 1;
 }
 
@@ -651,7 +651,7 @@ void close_keepers(Universe* U)
  */
 void init_keepers(Universe* U, lua_State* L)
 {
-    ASSERT_L(lua_gettop(L) == 1 && lua_istable(L, 1));
+    LUA_ASSERT(L, lua_gettop(L) == 1 && lua_istable(L, 1));
     STACK_CHECK_START_REL(L, 0);                                   // L                            K
     lua_getfield(L, 1, "nb_keepers");                              // settings nb_keepers
     int const nb_keepers{ static_cast<int>(lua_tointeger(L, -1)) };
@@ -838,7 +838,7 @@ KeeperCallResult keeper_call(Universe* U, lua_State* K, keeper_api_t func_, lua_
     int const args{ starting_index ? (lua_gettop(L) - starting_index + 1) : 0 };
     int const top_K{ lua_gettop(K) };
     // if we didn't do anything wrong, the keeper stack should be clean
-    ASSERT_L(lua_gettop(K) == 0);
+    LUA_ASSERT(L, lua_gettop(K) == 0);
 
     STACK_GROW(K, 2);
     PUSH_KEEPER_FUNC(K, func_);                                                                                       // func_
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 6b3a9a1..1f938d4 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -317,7 +317,7 @@ static void push_stack_trace(lua_State* L, int rc_, int stk_base_)
 
             // 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
-            ASSERT_L(lua_type(L, 1 + stk_base_) == (CANCEL_ERROR.equals(L, stk_base_) ? LUA_TNIL : LUA_TTABLE));
+            LUA_ASSERT(L, lua_type(L, 1 + stk_base_) == (CANCEL_ERROR.equals(L, stk_base_) ? LUA_TNIL : LUA_TTABLE));
             // Just leaving the stack trace table on the stack is enough to get it through to the master.
             break;
         }
@@ -327,7 +327,7 @@ static void push_stack_trace(lua_State* L, int rc_, int stk_base_)
         case LUA_ERRERR: // error while running the error handler (if any, for example an out-of-memory condition)
         default:
         // we should have a single value which is either a string (the error message) or CANCEL_ERROR
-        ASSERT_L((lua_gettop(L) == stk_base_) && ((lua_type(L, stk_base_) == LUA_TSTRING) || CANCEL_ERROR.equals(L, stk_base_)));
+        LUA_ASSERT(L, (lua_gettop(L) == stk_base_) && ((lua_type(L, stk_base_) == LUA_TSTRING) || CANCEL_ERROR.equals(L, stk_base_)));
         break;
     }
 }
@@ -367,10 +367,10 @@ static void push_stack_trace(lua_State* L, int rc_, int stk_base_)
         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));
+        LUA_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);
+            LUA_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
             // 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
@@ -564,7 +564,7 @@ static void selfdestruct_add(Lane* lane_)
     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
+        LUA_ASSERT(L, prev_ref_count == 1); // this should be the last reference
         DeepFactory::DeleteDeepObject(L, U->timer_deep);
         U->timer_deep = nullptr;
     }
@@ -987,7 +987,7 @@ LUAG_FUNC(lane_new)
     static constexpr int FIXED_ARGS{ 7 };
     int const nargs{ lua_gettop(L) - FIXED_ARGS };
     Universe* const U{ universe_get(L) };
-    ASSERT_L( nargs >= 0);
+    LUA_ASSERT(L, nargs >= 0);
 
     // public Lanes API accepts a generic range -3/+3
     // that will be remapped into the platform-specific scheduler priority scheme
@@ -1104,7 +1104,7 @@ LUAG_FUNC(lane_new)
     // give a default "Lua" name to the thread to see VM name in Decoda debugger
     lua_pushfstring( L2, "Lane #%p", L2);                                                                                                           // "..."
     lua_setglobal( L2, "decoda_name");                                                                                                              //
-    ASSERT_L( lua_gettop( L2) == 0);
+    LUA_ASSERT(L, lua_gettop( L2) == 0);
 
     // package
     if (package_idx != 0)
@@ -1113,7 +1113,7 @@ LUAG_FUNC(lane_new)
         // when copying with mode LookupMode::LaneBody, should raise an error in case of problem, not leave it one the stack
         InterCopyContext c{ U, Dest{ L2 }, Source{ L }, {}, SourceIndex{ package_idx }, {}, {}, {} };
         [[maybe_unused]] InterCopyResult const ret{ c.inter_copy_package() };
-        ASSERT_L(ret == InterCopyResult::Success); // either all went well, or we should not even get here
+        LUA_ASSERT(L, ret == InterCopyResult::Success); // either all went well, or we should not even get here
     }
 
     // modules to require in the target lane *before* the function is transfered!
@@ -1228,7 +1228,7 @@ LUAG_FUNC(lane_new)
     }
     STACK_CHECK(L, 0);
     STACK_CHECK(L2, 1);
-    ASSERT_L(lua_isfunction(L2, 1));
+    LUA_ASSERT(L, lua_isfunction(L2, 1));
 
     // revive arguments
     if (nargs > 0)
@@ -1243,7 +1243,7 @@ LUAG_FUNC(lane_new)
         }
     }
     STACK_CHECK(L, -nargs);
-    ASSERT_L(lua_gettop( L) == FIXED_ARGS);
+    LUA_ASSERT(L, lua_gettop( L) == FIXED_ARGS);
 
     // Store 'lane' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
     LANE_POINTER_REGKEY.setValue(L2, [lane](lua_State* L) { lua_pushlightuserdata(L, lane); });                                                     // func [... args ...]
@@ -1355,7 +1355,7 @@ LUAG_FUNC(lane_new)
 void push_thread_status(lua_State* L, Lane* lane_)
 {
     char const* const str{ thread_status_string(lane_) };
-    ASSERT_L(str);
+    LUA_ASSERT(L, str);
 
     lua_pushstring(L, str);
 }
@@ -1430,7 +1430,7 @@ LUAG_FUNC(thread_join)
 
         default:
         DEBUGSPEW_CODE(fprintf(stderr, "Status: %d\n", lane->m_status));
-        ASSERT_L(false);
+        LUA_ASSERT(L, false);
         ret = 0;
     }
     lua_close(L2);
@@ -1454,7 +1454,7 @@ LUAG_FUNC(thread_index)
     static constexpr int KEY{ 2 };
     static constexpr int USR{ 3 };
     Lane* const lane{ ToLane(L, UD) };
-    ASSERT_L(lua_gettop(L) == 2);
+    LUA_ASSERT(L, lua_gettop(L) == 2);
 
     STACK_GROW(L, 8); // up to 8 positions are needed in case of error propagation
 
@@ -1515,7 +1515,7 @@ LUAG_FUNC(thread_index)
                     // 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));
+                    LUA_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);
@@ -1741,7 +1741,7 @@ LUAG_FUNC(configure)
     Universe* U = universe_get(L);
     bool const from_master_state{ U == nullptr };
     char const* name = luaL_checkstring(L, lua_upvalueindex(1));
-    ASSERT_L(lua_type(L, 1) == LUA_TTABLE);
+    LUA_ASSERT(L, lua_type(L, 1) == LUA_TTABLE);
 
     STACK_GROW(L, 4);
     STACK_CHECK_START_ABS(L, 1);                                                          // settings
@@ -1832,10 +1832,10 @@ LUAG_FUNC(configure)
         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_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_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
diff --git a/src/linda.cpp b/src/linda.cpp
index 7b3973d..4635d75 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -168,7 +168,7 @@ template <bool OPT>
     if constexpr (!OPT)
     {
         luaL_argcheck(L, linda != nullptr, idx_, "expecting a linda object");
-        ASSERT_L(linda->U == universe_get(L));
+        LUA_ASSERT(L, linda->U == universe_get(L));
     }
     return linda;
 }
@@ -218,7 +218,7 @@ int Linda::ProtectedCall(lua_State* L, lua_CFunction f_)
     if (KL == nullptr)
         return 0;
     // if we didn't do anything wrong, the keeper stack should be clean
-    ASSERT_L(lua_gettop(KL) == 0);
+    LUA_ASSERT(L, lua_gettop(KL) == 0);
 
     // push the function to be called and move it before the arguments
     lua_pushcfunction(L, f_);
@@ -332,7 +332,7 @@ LUAG_FUNC(linda_send)
                 {
                     break;
                 }
-                ASSERT_L(pushed.value() == 1);
+                LUA_ASSERT(L, pushed.value() == 1);
 
                 ret = lua_toboolean(L, -1) ? true : false;
                 lua_pop(L, 1);
@@ -357,9 +357,9 @@ LUAG_FUNC(linda_send)
                     {
                         // change status of lane to "waiting"
                         prev_status = lane->m_status; // Running, most likely
-                        ASSERT_L(prev_status == Lane::Running); // but check, just in case
+                        LUA_ASSERT(L, prev_status == Lane::Running); // but check, just in case
                         lane->m_status = Lane::Waiting;
-                        ASSERT_L(lane->m_waiting_on == nullptr);
+                        LUA_ASSERT(L, lane->m_waiting_on == nullptr);
                         lane->m_waiting_on = &linda->m_read_happened;
                     }
                     // could not send because no room: wait until some data was read before trying again, or until timeout is reached
@@ -502,7 +502,7 @@ LUAG_FUNC(linda_receive)
             }
             if (pushed.value() > 0)
             {
-                ASSERT_L(pushed.value() >= expected_pushed_min && pushed.value() <= expected_pushed_max);
+                LUA_ASSERT(L, pushed.value() >= expected_pushed_min && pushed.value() <= expected_pushed_max);
                 // replace sentinels with real nils
                 keeper_toggle_nil_sentinels(L, lua_gettop(L) - pushed.value(), LookupMode::FromKeeper);
                 // To be done from within the 'K' locking area
@@ -523,9 +523,9 @@ LUAG_FUNC(linda_receive)
                 {
                     // change status of lane to "waiting"
                     prev_status = lane->m_status; // Running, most likely
-                    ASSERT_L(prev_status == Lane::Running); // but check, just in case
+                    LUA_ASSERT(L, prev_status == Lane::Running); // but check, just in case
                     lane->m_status = Lane::Waiting;
-                    ASSERT_L(lane->m_waiting_on == nullptr);
+                    LUA_ASSERT(L, lane->m_waiting_on == nullptr);
                     lane->m_waiting_on = &linda->m_write_happened;
                 }
                 // not enough data to read: wakeup when data was sent, or when timeout is reached
@@ -596,7 +596,7 @@ LUAG_FUNC(linda_set)
             pushed = keeper_call(linda->U, K->L, KEEPER_API(set), L, linda, 2);
             if (pushed.has_value()) // no error?
             {
-                ASSERT_L(pushed.value() == 0 || pushed.value() == 1);
+                LUA_ASSERT(L, pushed.value() == 0 || pushed.value() == 1);
 
                 if (has_value)
                 {
@@ -606,7 +606,7 @@ LUAG_FUNC(linda_set)
                 if (pushed.value() == 1)
                 {
                     // the key was full, but it is no longer the case, tell writers they should wake
-                    ASSERT_L(lua_type(L, -1) == LUA_TBOOLEAN && lua_toboolean(L, -1) == 1);
+                    LUA_ASSERT(L, lua_type(L, -1) == LUA_TBOOLEAN && lua_toboolean(L, -1) == 1);
                     linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
                 }
             }
@@ -711,10 +711,10 @@ LUAG_FUNC(linda_limit)
         {
             Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
             pushed = keeper_call(linda->U, K->L, KEEPER_API(limit), L, linda, 2);
-            ASSERT_L( pushed.has_value() && (pushed.value() == 0 || pushed.value() == 1)); // no error, optional boolean value saying if we should wake blocked writer threads
+            LUA_ASSERT(L, pushed.has_value() && (pushed.value() == 0 || pushed.value() == 1)); // no error, optional boolean value saying if we should wake blocked writer threads
             if (pushed.value() == 1)
             {
-                ASSERT_L( lua_type( L, -1) == LUA_TBOOLEAN && lua_toboolean( L, -1) == 1);
+                LUA_ASSERT(L, lua_type( L, -1) == LUA_TBOOLEAN && lua_toboolean( L, -1) == 1);
                 linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
             }
         }
@@ -931,7 +931,7 @@ DeepPrelude* LindaFactory::newDeepObjectInternal(lua_State* L) const
 void LindaFactory::deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const
 {
     Linda* const linda{ static_cast<Linda*>(o_) };
-    ASSERT_L(linda);
+    LUA_ASSERT(L, linda);
     Keeper* const myK{ which_keeper(linda->U->keepers, linda->hashSeed()) };
     // if collected after the universe, keepers are already destroyed, and there is nothing to clear
     if (myK)
@@ -943,7 +943,7 @@ void LindaFactory::deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const
         Keeper* const K{ need_acquire_release ? keeper_acquire(linda->U->keepers, linda->hashSeed()) : myK };
         // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
         [[maybe_unused]] KeeperCallResult const result{ keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0) };
-        ASSERT_L(result.has_value() && result.value() == 0);
+        LUA_ASSERT(L, result.has_value() && result.value() == 0);
         if (need_acquire_release)
         {
             keeper_release(K);
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index c01363a..edda76e 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -34,7 +34,7 @@ using namespace std::chrono_literals;
 
 #ifdef NDEBUG
 
-#define _ASSERT_L(lua,c)     //nothing
+#define LUA_ASSERT(L,c) ; //nothing
 
 #define STACK_CHECK_START_REL(L, offset_)
 #define STACK_CHECK_START_ABS(L, offset_)
@@ -44,7 +44,15 @@ using namespace std::chrono_literals;
 
 #else // NDEBUG
 
-#define _ASSERT_L(L, cond_) if ((cond_) == 0) { (void) luaL_error(L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
+inline void LUA_ASSERT_IMPL(lua_State* L_, bool cond_, char const* file_, size_t const line_, char const* txt_)
+{
+    if (!cond_)
+    {
+        luaL_error(L_, "LUA_ASSERT %s:%llu '%s'", file_, line_, txt_); // doesn't return
+    }
+}
+
+#define LUA_ASSERT(L_, cond_) LUA_ASSERT_IMPL(L_, cond_, __FILE__, __LINE__, #cond_)
 
 class StackChecker
 {
@@ -74,7 +82,7 @@ class StackChecker
         if ((offset_ < 0) || (m_oldtop < 0))
         {
             assert(false);
-            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop(m_L), offset_, file_, line_); // doesn't return
+            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), offset_, file_, line_); // doesn't return
         }
     }
 
@@ -85,7 +93,7 @@ class StackChecker
         if (lua_gettop(m_L) != pos_)
         {
             assert(false);
-            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop(m_L), pos_, file_, line_); // doesn't return
+            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), pos_, file_, line_); // doesn't return
         }
     }
 
@@ -105,7 +113,7 @@ class StackChecker
             if (actual != expected_)
             {
                 assert(false);
-                luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%d", actual, expected_, file_, line_); // doesn't return
+                luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%llu", actual, expected_, file_, line_); // doesn't return
             }
         }
     }
@@ -119,8 +127,6 @@ class StackChecker
 
 #endif // NDEBUG
 
-#define ASSERT_L(c) _ASSERT_L(L,c)
-
 inline void STACK_GROW(lua_State* L, int n_)
 {
     if (!lua_checkstack(L, n_))
@@ -137,14 +143,14 @@ inline void STACK_GROW(lua_State* L, int n_)
 template<typename T>
 [[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
 {
-    ASSERT_L(lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
+    LUA_ASSERT(L, lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
     return static_cast<T*>(lua_touserdata(L, index_));
 }
 
 template<typename T>
 [[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
 {
-    ASSERT_L(lua_isnil(L, index_) || lua_islightuserdata(L, index_));
+    LUA_ASSERT(L, lua_isnil(L, index_) || lua_islightuserdata(L, index_));
     if constexpr (std::is_pointer_v<T>)
     {
         return static_cast<T>(lua_touserdata(L, index_));
diff --git a/src/tools.cpp b/src/tools.cpp
index 98cbf27..3410f4b 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -72,7 +72,7 @@ void push_registry_subtable_mode(lua_State* L, RegistryUniqueKey key_, const cha
         }
     }
     STACK_CHECK(L, 1);
-    ASSERT_L(lua_istable(L, -1));
+    LUA_ASSERT(L, lua_istable(L, -1));
 }
 
 // #################################################################################################
@@ -139,7 +139,7 @@ void initialize_allocator_function(Universe* U, lua_State* L)
         }
         else if (lua_type(L, -1) == LUA_TSTRING) // should be "protected"
         {
-            ASSERT_L(strcmp(lua_tostring(L, -1), "protected") == 0);
+            LUA_ASSERT(L, strcmp(lua_tostring(L, -1), "protected") == 0);
             // set the original allocator to call from inside protection by the mutex
             U->protected_allocator.initFrom(L);
             U->protected_allocator.installIn(L);
@@ -290,7 +290,7 @@ static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L,
     prevName = lua_tolstring( L, -1, &prevNameLength); // nullptr if we got nil (first encounter of this object)
     // push name in fqn stack (note that concatenation will crash if name is a not string or a number)
     lua_pushvalue(L, -3);                                                                    // ... {bfc} k o name? k
-    ASSERT_L(lua_type(L, -1) == LUA_TNUMBER || lua_type(L, -1) == LUA_TSTRING);
+    LUA_ASSERT(L, lua_type(L, -1) == LUA_TNUMBER || lua_type(L, -1) == LUA_TSTRING);
     ++_depth;
     lua_rawseti(L, fqn, _depth);                                                             // ... {bfc} k o name?
     // generate name
@@ -329,8 +329,8 @@ static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L,
         // prepare the stack for database feed
         lua_pushvalue(L, -1);                                                                // ... {bfc} k o "f.q.n" "f.q.n"
         lua_pushvalue(L, -3);                                                                // ... {bfc} k o "f.q.n" "f.q.n" o
-        ASSERT_L(lua_rawequal(L, -1, -4));
-        ASSERT_L(lua_rawequal(L, -2, -3));
+        LUA_ASSERT(L, lua_rawequal(L, -1, -4));
+        LUA_ASSERT(L, lua_rawequal(L, -2, -3));
         // t["f.q.n"] = o
         lua_rawset(L, dest);                                                                 // ... {bfc} k o "f.q.n"
         // t[o] = "f.q.n"
@@ -387,7 +387,7 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U)
 
     // this table is at breadth_first_cache index
     lua_newtable(L);                                                                         // ... {_i} {bfc}
-    ASSERT_L( lua_gettop(L) == breadth_first_cache);
+    LUA_ASSERT(L,  lua_gettop(L) == breadth_first_cache);
     // iterate over all entries in the processed table
     lua_pushnil(L);                                                                          // ... {_i} {bfc} nil
     while( lua_next(L, _i) != 0)                                                             // ... {_i} {bfc} k v
@@ -434,7 +434,7 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U)
         // un-visit this table in case we do need to process it
         lua_pushvalue(L, -1);                                                                // ... {_i} {bfc} k {} {}
         lua_rawget(L, cache);                                                                // ... {_i} {bfc} k {} n
-        ASSERT_L(lua_type(L, -1) == LUA_TNUMBER);
+        LUA_ASSERT(L, lua_type(L, -1) == LUA_TNUMBER);
         visit_count = lua_tointeger(L, -1) - 1;
         lua_pop(L, 1);                                                                       // ... {_i} {bfc} k {}
         lua_pushvalue(L, -1);                                                                // ... {_i} {bfc} k {} {}
@@ -481,7 +481,7 @@ void populate_func_lookup_table(lua_State* L, int i_, char const* name_)
     STACK_CHECK_START_REL(L, 0);
     LOOKUP_REGKEY.pushValue(L);                                                        // {}
     STACK_CHECK(L, 1);
-    ASSERT_L(lua_istable(L, -1));
+    LUA_ASSERT(L, lua_istable(L, -1));
     if (lua_type(L, in_base) == LUA_TFUNCTION) // for example when a module is a simple function
     {
         name_ = name_ ? name_ : "nullptr";
@@ -606,7 +606,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
 {
     DEBUGSPEW_CODE( Universe* const U = universe_get( L));
     char const* fqn;
-    ASSERT_L( lua_isfunction( L, i) || lua_istable( L, i));  // ... v ...
+    LUA_ASSERT(L, lua_isfunction( L, i) || lua_istable( L, i));  // ... v ...
     STACK_CHECK_START_REL(L, 0);
     STACK_GROW( L, 3); // up to 3 slots are necessary on error
     if (mode_ == LookupMode::FromKeeper)
@@ -619,7 +619,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
         else
         {
             // if this is not a sentinel, this is some user-created table we wanted to lookup
-            ASSERT_L(nullptr == f && lua_istable(L, i));
+            LUA_ASSERT(L, nullptr == f && lua_istable(L, i));
             // push anything that will convert to nullptr string
             lua_pushnil( L);                                     // ... v ... nil
         }
@@ -629,7 +629,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
         // fetch the name from the source state's lookup table
         LOOKUP_REGKEY.pushValue(L);                            // ... v ... {}
         STACK_CHECK( L, 1);
-        ASSERT_L( lua_istable( L, -1));
+        LUA_ASSERT(L, lua_istable( L, -1));
         lua_pushvalue( L, i);                                  // ... v ... {} v
         lua_rawget( L, -2);                                    // ... v ... {} "f.q.n"
     }
@@ -701,7 +701,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
         case LookupMode::FromKeeper:
         LOOKUP_REGKEY.pushValue(L2);                                                        // {}
         STACK_CHECK(L2, 1);
-        _ASSERT_L(L1, lua_istable(L2, -1));
+        LUA_ASSERT(L1, lua_istable(L2, -1));
         lua_pushlstring(L2, fqn, len);                                                      // {} "f.q.n"
         lua_rawget(L2, -2);                                                                 // {} t
         // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead)
@@ -754,7 +754,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
 {
     void const* p{ lua_topointer(L1, i) };
 
-    _ASSERT_L(L1, L2_cache_i != 0);
+    LUA_ASSERT(L1, L2_cache_i != 0);
     STACK_GROW(L2, 3);                                                                              // L2
     STACK_CHECK_START_REL(L2, 0);
 
@@ -777,7 +777,7 @@ static constexpr RegistryUniqueKey REG_MTID{ 0x2E68F9B4751584DCull };
         lua_rawset(L2, L2_cache_i);                                                                 // ... {}
     }
     STACK_CHECK(L2, 1);
-    _ASSERT_L(L1, lua_istable( L2, -1));
+    LUA_ASSERT(L1, lua_istable( L2, -1));
     return !not_found_in_cache;
 }
 
@@ -1006,7 +1006,7 @@ void InterCopyContext::lookup_native_func() const
         case LookupMode::FromKeeper:
         LOOKUP_REGKEY.pushValue(L2);                                                         // {}
         STACK_CHECK(L2, 1);
-        _ASSERT_L(L1, lua_istable(L2, -1));
+        LUA_ASSERT(L1, lua_istable(L2, -1));
         lua_pushlstring(L2, fqn, len);                                                       // {} "f.q.n"
         lua_rawget(L2, -2);                                                                  // {} f
         // nil means we don't know how to transfer stuff: user should do something
@@ -1104,7 +1104,7 @@ static char const* vt_names[] =
 
 void InterCopyContext::copy_func() const
 {
-    _ASSERT_L(L1, L2_cache_i != 0);                                                                    // ... {cache} ... p
+    LUA_ASSERT(L1, L2_cache_i != 0);                                                                    // ... {cache} ... p
     STACK_GROW(L1, 2);
     STACK_CHECK_START_REL(L1, 0);
 
@@ -1158,7 +1158,7 @@ void InterCopyContext::copy_func() const
         {
             size_t sz;
             char const* s = lua_tolstring(L1, -1, &sz);        // ... b
-            _ASSERT_L(L1, s && sz);
+            LUA_ASSERT(L1, s && sz);
             STACK_GROW(L2, 2);
             // Note: Line numbers seem to be taken precisely from the 
             //       original function. 'name' is not used since the chunk
@@ -1238,7 +1238,7 @@ void InterCopyContext::copy_func() const
                 // "assigns the value at the top of the stack to the upvalue and returns its name.
                 // It also pops the value from the stack."
 
-                _ASSERT_L(L1, rc);      // not having enough slots?
+                LUA_ASSERT(L1, rc);      // not having enough slots?
             }
             // once all upvalues have been set we are left
             // with the function at the top of the stack                                               // ... {cache} ... function
@@ -1262,7 +1262,7 @@ void InterCopyContext::copy_cached_func() const
     {
         void* const aspointer = const_cast<void*>(lua_topointer(L1, L1_i));
         // TBD: Merge this and same code for tables
-        _ASSERT_L(L1, L2_cache_i != 0);
+        LUA_ASSERT(L1, L2_cache_i != 0);
 
         STACK_GROW(L2, 2);
 
@@ -1297,13 +1297,13 @@ void InterCopyContext::copy_cached_func() const
             lua_remove(L2, -2);                                       // ... {cache} ... function
         }
         STACK_CHECK(L2, 1);
-        _ASSERT_L(L1, lua_isfunction(L2, -1));
+        LUA_ASSERT(L1, lua_isfunction(L2, -1));
     }
     else // function is native/LuaJIT: no need to cache
     {
         lookup_native_func();                                         // ... {cache} ... function
         // if the function was in fact a lookup sentinel, we can either get a function or a table here
-        _ASSERT_L(L1, lua_isfunction(L2, -1) || lua_istable(L2, -1));
+        LUA_ASSERT(L1, lua_isfunction(L2, -1) || lua_istable(L2, -1));
     }
 }
 
@@ -1421,7 +1421,7 @@ void InterCopyContext::inter_copy_keyvaluepair() const
     c.name = valPath ? valPath : name;
     if (c.inter_copy_one())
     {
-        _ASSERT_L(L1, lua_istable( L2, -3));
+        LUA_ASSERT(L1, lua_istable( L2, -3));
         lua_rawset(L2, -3);    // add to table (pops key & val)
     }
     else
@@ -1494,7 +1494,7 @@ static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
         {
             if (LookupMode::ToKeeper == mode)                                                                // ... u sentinel
             {
-                _ASSERT_L(L1, lua_tocfunction(L2, -1) == table_lookup_sentinel);
+                LUA_ASSERT(L1, lua_tocfunction(L2, -1) == table_lookup_sentinel);
                 // we want to create a new closure with a 'clone sentinel' function, where the upvalues are the userdata and the metatable fqn
                 lua_getupvalue(L2, -1, 1);                                                                   // ... u sentinel fqn
                 lua_remove(L2, -2);                                                                          // ... u fqn
@@ -1503,7 +1503,7 @@ static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
             }
             else // from keeper or direct                                                                    // ... u mt
             {
-                _ASSERT_L(L1, lua_istable(L2, -1));
+                LUA_ASSERT(L1, lua_istable(L2, -1));
                 lua_setmetatable(L2, -2);                                                                    // ... u
             }
             STACK_CHECK(L2, 1);
@@ -1726,7 +1726,7 @@ static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
      */
     if (lookup_table())
     {
-        _ASSERT_L(L1, lua_istable(L2, -1) || (lua_tocfunction(L2, -1) == table_lookup_sentinel)); // from lookup data. can also be table_lookup_sentinel if this is a table we know
+        LUA_ASSERT(L1, lua_istable(L2, -1) || (lua_tocfunction(L2, -1) == table_lookup_sentinel)); // from lookup data. can also be table_lookup_sentinel if this is a table we know
         return true;
     }
 
@@ -1741,10 +1741,10 @@ static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
     */
     if (push_cached_table(L2, L2_cache_i, L1, L1_i))
     {
-        _ASSERT_L(L1, lua_istable(L2, -1));    // from cache
+        LUA_ASSERT(L1, lua_istable(L2, -1));    // from cache
         return true;
     }
-    _ASSERT_L(L1, lua_istable(L2, -1));
+    LUA_ASSERT(L1, lua_istable(L2, -1));
 
     STACK_GROW(L1, 2);
     STACK_GROW(L2, 2);
@@ -1907,7 +1907,7 @@ static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
 // NOTE: Both the states must be solely in the current OS thread's possession.
 [[nodiscard]] InterCopyResult InterCopyContext::inter_copy(int n_) const
 {
-    _ASSERT_L(L1, vt == VT::NORMAL);
+    LUA_ASSERT(L1, vt == VT::NORMAL);
 
     DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "InterCopyContext::inter_copy()\n" INDENT_END));
     DEBUGSPEW_CODE(DebugSpewIndentScope scope{ U });
diff --git a/src/universe.cpp b/src/universe.cpp
index 112c840..fb10067 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -75,7 +75,7 @@ Universe::Universe()
 // only called from the master state
 Universe* universe_create(lua_State* L)
 {
-    ASSERT_L(universe_get(L) == nullptr);
+    LUA_ASSERT(L, universe_get(L) == nullptr);
     Universe* const U{ lua_newuserdatauv<Universe>(L, 0) }; // universe
     U->Universe::Universe();
     STACK_CHECK_START_REL(L, 1);
@@ -89,7 +89,7 @@ Universe* universe_create(lua_State* L)
 
 void universe_store(lua_State* L, Universe* U)
 {
-    ASSERT_L(!U || universe_get(L) == nullptr);
+    LUA_ASSERT(L, !U || universe_get(L) == nullptr);
     STACK_CHECK_START_REL(L, 0);
     UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { U ? lua_pushlightuserdata(L, U) : lua_pushnil(L); });
     STACK_CHECK(L, 0);
diff --git a/src/universe.h b/src/universe.h
index 320c400..d0d7864 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -39,7 +39,7 @@ class AllocatorDefinition
     [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept { return lua_newuserdatauv(L, size_, 0); }
     // 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([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
+    static void operator delete([[maybe_unused]] void* p_, lua_State* L_) { LUA_ASSERT(L_, !"should never be called"); }
 
     AllocatorDefinition(lua_Alloc allocF_, void* allocUD_) noexcept
     : m_allocF{ allocF_ }