15 files changed, 126 insertions, 131 deletions

diff --git a/deep_test/deep_test.cpp b/deep_test/deep_test.cpp
index 77ecefb..35a2e56 100644
--- a/deep_test/deep_test.cpp
+++ b/deep_test/deep_test.cpp
@@ -13,13 +13,13 @@ class MyDeepFactory : public DeepFactory
 
     private:
 
-    DeepPrelude* newDeepObjectInternal(lua_State* L) const override;
+    [[nodiscard]] DeepPrelude* newDeepObjectInternal(lua_State* L) const override;
     void deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const override;
     void createMetatable(lua_State* L_) const override
     {
         luaL_getmetatable(L_, "deep");
     }
-    char const* moduleName() const override { return "deep_test"; }
+    [[nodiscard]] char const* moduleName() const override { return "deep_test"; }
 };
 /*static*/ MyDeepFactory MyDeepFactory::Instance{};
 
diff --git a/src/cancel.h b/src/cancel.h
index bbc7787..8c8063f 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
@@ -24,7 +25,7 @@ enum class CancelRequest
 {
     None, // no pending cancel request
     Soft, // user wants the lane to cancel itself manually on cancel_test()
-    Hard  // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
+    Hard // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
 };
 
 enum class CancelResult
diff --git a/src/compat.h b/src/compat.h
index 8d10e78..037a3ba 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
@@ -22,16 +23,15 @@ extern "C" {
 #define LUAJIT_FLAVOR() 0
 #endif // LUA_JITLIBNAME
 
-
 // code is now preferring Lua 5.4 API
 
 // add some Lua 5.3-style API when building for Lua 5.1
 #if LUA_VERSION_NUM == 501
 
 #define lua501_equal lua_equal
-#define lua_absindex( L, idx) (((idx) >= 0 || (idx) <= LUA_REGISTRYINDEX) ? (idx) : lua_gettop(L) + (idx) +1)
+#define lua_absindex(L, idx) (((idx) >= 0 || (idx) <= LUA_REGISTRYINDEX) ? (idx) : lua_gettop(L) + (idx) + 1)
 #if LUAJIT_VERSION_NUM < 20200 // moonjit is 5.1 plus bits of 5.2 that we don't need to wrap
-#define lua_pushglobaltable(L) lua_pushvalue( L, LUA_GLOBALSINDEX)
+#define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
 #endif // LUAJIT_VERSION_NUM
 #define lua_setuservalue lua_setfenv
 #define lua_getuservalue lua_getfenv
@@ -39,8 +39,8 @@ extern "C" {
 #define luaG_registerlibfuncs(L, _funcs) luaL_register(L, nullptr, _funcs)
 #define LUA_OK 0
 #define LUA_ERRGCMM 666 // doesn't exist in Lua 5.1, we don't care about the actual value
-void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int glb); // implementation copied from Lua 5.2 sources
-#define lua504_dump( L, writer, data, strip) lua_dump( L, writer, data)
+void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb); // implementation copied from Lua 5.2 sources
+#define lua504_dump(L, writer, data, strip) lua_dump(L, writer, data)
 #define LUA_LOADED_TABLE "_LOADED" // // doesn't exist in Lua 5.1
 
 #endif // LUA_VERSION_NUM == 501
@@ -49,13 +49,13 @@ void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int
 #if LUA_VERSION_NUM == 502
 
 #ifndef lua501_equal // already defined when compatibility is active in luaconf.h
-#define lua501_equal( L, a, b) lua_compare( L, a, b, LUA_OPEQ)
+#define lua501_equal(L, a, b) lua_compare(L, a, b, LUA_OPEQ)
 #endif // lua501_equal
 #ifndef lua_lessthan // already defined when compatibility is active in luaconf.h
-#define lua_lessthan( L, a, b) lua_compare( L, a, b, LUA_OPLT)
+#define lua_lessthan(L, a, b) lua_compare(L, a, b, LUA_OPLT)
 #endif // lua_lessthan
-#define luaG_registerlibfuncs( L, _funcs) luaL_setfuncs( L, _funcs, 0)
-#define lua504_dump( L, writer, data, strip) lua_dump( L, writer, data)
+#define luaG_registerlibfuncs(L, _funcs) luaL_setfuncs(L, _funcs, 0)
+#define lua504_dump(L, writer, data, strip) lua_dump(L, writer, data)
 #define LUA_LOADED_TABLE "_LOADED" // // doesn't exist in Lua 5.2
 
 #endif // LUA_VERSION_NUM == 502
@@ -64,22 +64,22 @@ void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int
 #if LUA_VERSION_NUM == 503
 
 #ifndef lua501_equal // already defined when compatibility is active in luaconf.h
-#define lua501_equal( L, a, b) lua_compare( L, a, b, LUA_OPEQ)
+#define lua501_equal(L, a, b) lua_compare(L, a, b, LUA_OPEQ)
 #endif // lua501_equal
 #ifndef lua_lessthan // already defined when compatibility is active in luaconf.h
-#define lua_lessthan( L, a, b) lua_compare( L, a, b, LUA_OPLT)
+#define lua_lessthan(L, a, b) lua_compare(L, a, b, LUA_OPLT)
 #endif // lua_lessthan
-#define luaG_registerlibfuncs( L, _funcs) luaL_setfuncs( L, _funcs, 0)
+#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 luaL_optint(L, n, d) ((int) luaL_optinteger(L, (n), (d)))
 
 #endif // LUA_VERSION_NUM == 503
 
 #if LUA_VERSION_NUM < 504
 
-void *lua_newuserdatauv( lua_State* L, size_t sz, int nuvalue);
-int lua_getiuservalue( lua_State* L, int idx, int n);
-int lua_setiuservalue( lua_State* L, int idx, int n);
+void* lua_newuserdatauv(lua_State* L, size_t sz, int nuvalue);
+int lua_getiuservalue(lua_State* L, int idx, int n);
+int lua_setiuservalue(lua_State* L, int idx, int n);
 
 #endif // LUA_VERSION_NUM < 504
 
@@ -87,14 +87,14 @@ int lua_setiuservalue( lua_State* L, int idx, int n);
 #if LUA_VERSION_NUM == 504
 
 #ifndef lua501_equal // already defined when compatibility is active in luaconf.h
-#define lua501_equal( L, a, b) lua_compare( L, a, b, LUA_OPEQ)
+#define lua501_equal(L, a, b) lua_compare(L, a, b, LUA_OPEQ)
 #endif // lua501_equal
 #ifndef lua_lessthan // already defined when compatibility is active in luaconf.h
-#define lua_lessthan( L, a, b) lua_compare( L, a, b, LUA_OPLT)
+#define lua_lessthan(L, a, b) lua_compare(L, a, b, LUA_OPLT)
 #endif // lua_lessthan
-#define luaG_registerlibfuncs( L, _funcs) luaL_setfuncs( L, _funcs, 0)
+#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 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/deep.h b/src/deep.h
index 45f7841..6f6e99d 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -6,7 +6,8 @@
  */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #ifdef __cplusplus
@@ -53,13 +54,11 @@ struct DeepPrelude
 class DeepFactory
 {
     protected:
-
     // protected non-virtual destructor: Lanes won't manage the Factory's lifetime
     DeepFactory() = default;
     ~DeepFactory() = default;
 
     public:
-
     // non-copyable, non-movable
     DeepFactory(DeepFactory const&) = delete;
     DeepFactory(DeepFactory const&&) = delete;
@@ -67,18 +66,16 @@ class DeepFactory
     DeepFactory& operator=(DeepFactory const&&) = delete;
 
     private:
-
     // NVI: private overrides
-    virtual DeepPrelude* newDeepObjectInternal(lua_State* L_) const = 0;
+    [[nodiscard]] virtual DeepPrelude* newDeepObjectInternal(lua_State* L_) const = 0;
     virtual void deleteDeepObjectInternal(lua_State* L_, DeepPrelude* o_) const = 0;
     virtual void createMetatable(lua_State* L_) const = 0;
-    virtual char const* moduleName() const = 0;
+    [[nodiscard]] virtual char const* moduleName() const = 0;
 
     public:
-
     // NVI: public interface
-    int pushDeepUserdata(DestState L_, int nuv_) const;
-    DeepPrelude* toDeep(lua_State* L_, int index_) const;
+    [[nodiscard]] int pushDeepUserdata(DestState L_, int nuv_) const;
+    [[nodiscard]] DeepPrelude* toDeep(lua_State* L_, int index_) const;
     static void DeleteDeepObject(lua_State* L_, DeepPrelude* o_);
-    static char const* PushDeepProxy(DestState L_, DeepPrelude* o_, int nuv_, LookupMode mode_);
+    [[nodiscard]] static char const* PushDeepProxy(DestState L_, DeepPrelude* o_, int nuv_, LookupMode mode_);
 };
diff --git a/src/keeper.h b/src/keeper.h
index 27a4cff..6688fe0 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #ifdef __cplusplus
diff --git a/src/lanes.h b/src/lanes.h
index 6f8a084..287e405 100644
--- a/src/lanes.h
+++ b/src/lanes.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #ifdef __cplusplus
@@ -16,11 +17,11 @@ extern "C" {
 #define LANES_VERSION_MINOR 0
 #define LANES_VERSION_PATCH 0
 
-#define LANES_MIN_VERSION_REQUIRED(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
-#define LANES_VERSION_LESS_THAN(MAJOR, MINOR, PATCH)        ((LANES_VERSION_MAJOR<MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR<MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH<PATCH))))
-#define LANES_VERSION_LESS_OR_EQUAL(MAJOR, MINOR, PATCH)    ((LANES_VERSION_MAJOR<MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR<MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH<=PATCH))))
-#define LANES_VERSION_GREATER_THAN(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>PATCH))))
-#define LANES_VERSION_GREATER_OR_EQUAL(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
+#define LANES_MIN_VERSION_REQUIRED(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR > MAJOR) || (LANES_VERSION_MAJOR == MAJOR && (LANES_VERSION_MINOR > MINOR || (LANES_VERSION_MINOR == MINOR && LANES_VERSION_PATCH >= PATCH))))
+#define LANES_VERSION_LESS_THAN(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR < MAJOR) || (LANES_VERSION_MAJOR == MAJOR && (LANES_VERSION_MINOR < MINOR || (LANES_VERSION_MINOR == MINOR && LANES_VERSION_PATCH < PATCH))))
+#define LANES_VERSION_LESS_OR_EQUAL(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR < MAJOR) || (LANES_VERSION_MAJOR == MAJOR && (LANES_VERSION_MINOR < MINOR || (LANES_VERSION_MINOR == MINOR && LANES_VERSION_PATCH <= PATCH))))
+#define LANES_VERSION_GREATER_THAN(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR > MAJOR) || (LANES_VERSION_MAJOR == MAJOR && (LANES_VERSION_MINOR > MINOR || (LANES_VERSION_MINOR == MINOR && LANES_VERSION_PATCH > PATCH))))
+#define LANES_VERSION_GREATER_OR_EQUAL(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR > MAJOR) || (LANES_VERSION_MAJOR == MAJOR && (LANES_VERSION_MINOR > MINOR || (LANES_VERSION_MINOR == MINOR && LANES_VERSION_PATCH >= PATCH))))
 
 LANES_API [[nodiscard]] int luaopen_lanes_core(lua_State* L);
 
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 7ecb9a7..859c8a2 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -16,7 +16,6 @@
 class Lane
 {
     public:
-
     /*
       Pending: The Lua VM hasn't done anything yet.
       Running, Waiting: Thread is inside the Lua VM. If the thread is forcefully stopped, we can't lua_close() the Lua State.
@@ -53,7 +52,7 @@ class Lane
     // S: while S is running, M must keep out of modifying the state
 
     Status volatile m_status{ Pending };
-    // 
+    //
     // M: sets to Pending (before launching)
     // S: updates -> Running/Waiting -> Done/Error/Cancelled
 
diff --git a/src/linda.h b/src/linda.h
index 21b6ecc..dbf48b3 100644
--- a/src/linda.h
+++ b/src/linda.h
@@ -20,10 +20,10 @@ static constexpr UniqueKey kLindaBatched{ 0xB8234DF772646567ull, "linda.batched"
 
 using LindaGroup = Unique<int>;
 
-class Linda : public DeepPrelude // Deep userdata MUST start with this header
+class Linda
+: public DeepPrelude // Deep userdata MUST start with this header
 {
     private:
-
     static constexpr size_t kEmbeddedNameLength = 24;
     using EmbeddedName = std::array<char, kEmbeddedNameLength>;
     struct AllocatedName
@@ -35,7 +35,6 @@ class Linda : public DeepPrelude // Deep userdata MUST start with this header
     std::variant<AllocatedName, EmbeddedName> m_name;
 
     public:
-
     std::condition_variable m_read_happened;
     std::condition_variable m_write_happened;
     Universe* const U{ nullptr }; // the universe this linda belongs to
@@ -43,7 +42,6 @@ class Linda : public DeepPrelude // Deep userdata MUST start with this header
     CancelRequest simulate_cancel{ CancelRequest::None };
 
     public:
-
     // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
     [[nodiscard]] static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
@@ -61,14 +59,12 @@ class Linda : public DeepPrelude // Deep userdata MUST start with this header
     Linda& operator=(Linda const&) = delete;
     Linda& operator=(Linda const&&) = delete;
 
-    static int ProtectedCall(lua_State* L, lua_CFunction f_);
-
-    private :
+    [[nodiscard]] static int ProtectedCall(lua_State* L, lua_CFunction f_);
 
+    private:
     void setName(char const* name_, size_t len_);
 
     public:
-
     [[nodiscard]] char const* getName() const;
     [[nodiscard]] Keeper* whichKeeper() const { return U->keepers->nb_keepers ? &U->keepers->keeper_array[m_keeper_index] : nullptr; }
     [[nodiscard]] Keeper* acquireKeeper() const;
diff --git a/src/lindafactory.h b/src/lindafactory.h
index d31af1f..271f9a7 100644
--- a/src/lindafactory.h
+++ b/src/lindafactory.h
@@ -8,7 +8,6 @@ class LindaFactory
 : public DeepFactory
 {
     public:
-
     // I'm not totally happy with having a 'global' variable. Maybe it should be dynamically created and stored somewhere in the universe?
     static LindaFactory Instance;
 
@@ -18,11 +17,10 @@ class LindaFactory
     }
 
     private:
-
     luaL_Reg const* const mLindaMT{ nullptr };
 
     void createMetatable(lua_State* L_) const override;
     void deleteDeepObjectInternal(lua_State* L_, DeepPrelude* o_) const override;
-    char const* moduleName() const override;
-    DeepPrelude* newDeepObjectInternal(lua_State* L_) const override;
+    [[nodiscard]] char const* moduleName() const override;
+    [[nodiscard]] DeepPrelude* newDeepObjectInternal(lua_State* L_) const override;
 };
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index 9bc71e1..be331a1 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
@@ -65,17 +66,17 @@ template <typename... ARGS>
 #define DEBUGSPEW_CODE(_code) _code
 #define DEBUGSPEW_OR_NOT(a_, b_) a_
 #define DEBUGSPEW_PARAM_COMMA(param_) param_,
-#define DEBUGSPEW_COMMA_PARAM( param_) , param_
+#define DEBUGSPEW_COMMA_PARAM(param_) , param_
 #else // USE_DEBUG_SPEW()
 #define DEBUGSPEW_CODE(_code)
 #define DEBUGSPEW_OR_NOT(a_, b_) b_
 #define DEBUGSPEW_PARAM_COMMA(param_)
-#define DEBUGSPEW_COMMA_PARAM( param_)
+#define DEBUGSPEW_COMMA_PARAM(param_)
 #endif // USE_DEBUG_SPEW()
 
 #ifdef NDEBUG
 
-#define LUA_ASSERT(L,c) ; //nothing
+#define LUA_ASSERT(L, c) ; // nothing
 
 #define STACK_CHECK_START_REL(L, offset_)
 #define STACK_CHECK_START_ABS(L, offset_)
@@ -87,8 +88,7 @@ template <typename... ARGS>
 
 inline void LUA_ASSERT_IMPL(lua_State* L_, bool cond_, char const* file_, size_t const line_, char const* txt_)
 {
-    if (!cond_)
-    {
+    if (!cond_) {
         raise_luaL_error(L_, "LUA_ASSERT %s:%llu '%s'", file_, line_, txt_);
     }
 }
@@ -120,8 +120,7 @@ class StackChecker
     : m_L{ L_ }
     , m_oldtop{ lua_gettop(L_) - offset_ }
     {
-        if ((offset_ < 0) || (m_oldtop < 0))
-        {
+        if ((offset_ < 0) || (m_oldtop < 0)) {
             assert(false);
             raise_luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), offset_, file_, line_);
         }
@@ -131,8 +130,7 @@ class StackChecker
     : m_L{ L_ }
     , m_oldtop{ 0 }
     {
-        if (lua_gettop(m_L) != pos_)
-        {
+        if (lua_gettop(m_L) != pos_) {
             assert(false);
             raise_luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), pos_, file_, line_);
         }
@@ -148,11 +146,9 @@ class StackChecker
     // verify if the distance between the current top and the initial one is what we expect
     void check(int expected_, char const* file_, size_t const line_)
     {
-        if (expected_ != LUA_MULTRET)
-        {
+        if (expected_ != LUA_MULTRET) {
             int const actual{ lua_gettop(m_L) - m_oldtop };
-            if (actual != expected_)
-            {
+            if (actual != expected_) {
                 assert(false);
                 raise_luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%llu", actual, expected_, file_, line_);
             }
@@ -160,10 +156,26 @@ class StackChecker
     }
 };
 
-#define STACK_CHECK_START_REL(L, offset_) StackChecker stackChecker_##L{L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_START_ABS(L, offset_) StackChecker stackChecker_##L{L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_RESET_REL(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_RESET_ABS(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__}
+#define STACK_CHECK_START_REL(L, offset_) \
+    StackChecker stackChecker_##L \
+    { \
+        L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_START_ABS(L, offset_) \
+    StackChecker stackChecker_##L \
+    { \
+        L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_RESET_REL(L, offset_) \
+    stackChecker_##L = StackChecker \
+    { \
+        L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_RESET_ABS(L, offset_) \
+    stackChecker_##L = StackChecker \
+    { \
+        L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__ \
+    }
 #define STACK_CHECK(L, offset_) stackChecker_##L.check(offset_, __FILE__, __LINE__)
 
 #endif // NDEBUG
@@ -172,8 +184,7 @@ class StackChecker
 
 inline void STACK_GROW(lua_State* L, int n_)
 {
-    if (!lua_checkstack(L, n_))
-    {
+    if (!lua_checkstack(L, n_)) {
         raise_luaL_error(L, "Cannot grow stack!");
     }
 }
@@ -185,23 +196,20 @@ inline void STACK_GROW(lua_State* L, int n_)
 // #################################################################################################
 
 // a small helper to extract a full userdata pointer from the stack in a safe way
-template<typename T>
+template <typename T>
 [[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
 {
     LUA_ASSERT(L, lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
     return static_cast<T*>(lua_touserdata(L, index_));
 }
 
-template<typename T>
+template <typename T>
 [[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
 {
     LUA_ASSERT(L, lua_isnil(L, index_) || lua_islightuserdata(L, index_));
-    if constexpr (std::is_pointer_v<T>)
-    {
+    if constexpr (std::is_pointer_v<T>) {
         return static_cast<T>(lua_touserdata(L, index_));
-    }
-    else
-    {
+    } else {
         return static_cast<T*>(lua_touserdata(L, index_));
     }
 }
@@ -223,23 +231,27 @@ template <typename T, auto = [] {}, typename specialization = void>
 class Unique
 {
     private:
-
     T m_val;
 
     public:
-
     Unique() = default;
     operator T() const { return m_val; }
-    explicit Unique(T b_) : m_val{ b_ } {}
+    explicit Unique(T b_)
+    : m_val{ b_ }
+    {
+    }
 };
 
 template <typename T, auto lambda>
-class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>> : public T
+class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>>
+: public T
 {
     public:
-
     using T::T;
-    explicit Unique(T const& b_) : T{ b_ } {}
+    explicit Unique(T const& b_)
+    : T{ b_ }
+    {
+    }
 };
 
 // #################################################################################################
@@ -252,14 +264,16 @@ using DestState = Unique<lua_State*>;
 // A helper to issue an error if the provided optional doesn't contain a value
 // we can't use std::optional::value_or(luaL_error(...)), because the 'or' value is always evaluated
 template <typename T>
-concept IsOptional = requires(T x){ x.value_or(T{}); };
+concept IsOptional = requires(T x)
+{
+    x.value_or(T{});
+};
 
-template<typename T, typename ...Ts>
+template <typename T, typename... Ts>
 requires IsOptional<T>
 typename T::value_type const& OptionalValue(T const& x_, Ts... args_)
 {
-    if (!x_.has_value())
-    {
+    if (!x_.has_value()) {
         raise_luaL_error(std::forward<Ts>(args_)...);
     }
     return x_.value();
diff --git a/src/platform.h b/src/platform.h
index b10f0ad..5a740e5 100644
--- a/src/platform.h
+++ b/src/platform.h
@@ -1,22 +1,22 @@
 #pragma once
 
 #ifdef _WIN32_WCE
-  #define PLATFORM_POCKETPC
+#define PLATFORM_POCKETPC
 #elif defined(_XBOX)
-  #define PLATFORM_XBOX
+#define PLATFORM_XBOX
 #elif (defined _WIN32)
-  #define PLATFORM_WIN32
-  #define NOMINMAX
+#define PLATFORM_WIN32
+#define NOMINMAX
 #elif (defined __linux__)
-  #define PLATFORM_LINUX
+#define PLATFORM_LINUX
 #elif (defined __APPLE__) && (defined __MACH__)
-  #define PLATFORM_OSX
+#define PLATFORM_OSX
 #elif (defined __NetBSD__) || (defined __FreeBSD__) || (defined BSD)
-  #define PLATFORM_BSD
+#define PLATFORM_BSD
 #elif (defined __QNX__)
-  #define PLATFORM_QNX
+#define PLATFORM_QNX
 #elif (defined __CYGWIN__)
-  #define PLATFORM_CYGWIN
+#define PLATFORM_CYGWIN
 #else
-  #error "Unknown platform!"
+#error "Unknown platform!"
 #endif
diff --git a/src/threading.h b/src/threading.h
index 7d24ef0..d88d308 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -7,11 +7,11 @@
 #define THREADAPI_WINDOWS 1
 #define THREADAPI_PTHREAD 2
 
-#if (defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
-//#pragma message ( "THREADAPI_WINDOWS" )
+#if (defined(PLATFORM_XBOX) || defined(PLATFORM_WIN32) || defined(PLATFORM_POCKETPC))
+// #pragma message ( "THREADAPI_WINDOWS" )
 #define THREADAPI THREADAPI_WINDOWS
 #else // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-//#pragma message ( "THREADAPI_PTHREAD" )
+// #pragma message ( "THREADAPI_PTHREAD" )
 #define THREADAPI THREADAPI_PTHREAD
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
diff --git a/src/tools.h b/src/tools.h
index 53edbe2..f83a01c 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -32,7 +32,6 @@ using SourceIndex = Unique<int>;
 class InterCopyContext
 {
     public:
-
     Universe* const U;
     DestState const L2;
     SourceState const L1;
@@ -43,7 +42,6 @@ class InterCopyContext
     char const* name; // that one can change when we reuse the context
 
     private:
-
     // for use in copy_cached_func
     void copy_func() const;
     void lookup_native_func() const;
@@ -71,7 +69,6 @@ class InterCopyContext
     [[nodiscard]] bool inter_copy_userdata() const;
 
     public:
-
     [[nodiscard]] bool inter_copy_one() const;
     [[nodiscard]] InterCopyResult inter_copy_package() const;
     [[nodiscard]] InterCopyResult inter_copy(int n_) const;
diff --git a/src/uniquekey.h b/src/uniquekey.h
index 738cb51..984ef50 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -10,11 +10,9 @@
 class UniqueKey
 {
     protected:
-
     uintptr_t const m_storage{ 0 };
 
     public:
-
     char const* m_debugName{ nullptr };
 
     // ---------------------------------------------------------------------------------------------
@@ -45,10 +43,10 @@ class UniqueKey
 
 // #################################################################################################
 
-class RegistryUniqueKey : public UniqueKey
+class RegistryUniqueKey
+: public UniqueKey
 {
     public:
-
     using UniqueKey::UniqueKey;
 
     // ---------------------------------------------------------------------------------------------
@@ -64,9 +62,9 @@ class RegistryUniqueKey : public UniqueKey
     void setValue(lua_State* L_, OP operation_) const
     {
         // Note we can't check stack consistency because operation is not always a push (could be insert, replace, whatever)
-        pushKey(L_);                           // ... key
-        operation_(L_);                        // ... key value
-        lua_rawset(L_, LUA_REGISTRYINDEX);     // ...
+        pushKey(L_); // ... key
+        operation_(L_); // ... key value
+        lua_rawset(L_, LUA_REGISTRYINDEX); // ...
     }
     // ---------------------------------------------------------------------------------------------
     template <typename T>
@@ -86,7 +84,7 @@ class RegistryUniqueKey : public UniqueKey
         STACK_GROW(L_, 1);
         STACK_CHECK_START_REL(L_, 0);
         pushValue(L_);
-        bool const value{ lua_toboolean(L_, -1) ? true : false}; // bool/nil
+        bool const value{ lua_toboolean(L_, -1) ? true : false }; // bool/nil
         lua_pop(L_, 1);
         STACK_CHECK(L_, 0);
         return value;
diff --git a/src/universe.h b/src/universe.h
index bdc871d..128c4d9 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #ifdef __cplusplus
@@ -20,9 +21,7 @@ struct DeepPrelude;
 struct Keepers;
 class Lane;
 
-/*
-* Do we want to activate full lane tracking feature? (EXPERIMENTAL)
-*/
+// Do we want to activate full lane tracking feature?
 #define HAVE_LANE_TRACKING() 1
 
 // #################################################################################################
@@ -31,7 +30,6 @@ class Lane;
 class AllocatorDefinition
 {
     public:
-
     lua_Alloc m_allocF{ nullptr };
     void* m_allocUD{ nullptr };
 
@@ -76,10 +74,10 @@ class AllocatorDefinition
 // #################################################################################################
 
 // mutex-protected allocator for use with Lua states that share a non-threadsafe allocator
-class ProtectedAllocator : public AllocatorDefinition
+class ProtectedAllocator
+: public AllocatorDefinition
 {
     private:
-
     std::mutex m_lock;
 
     [[nodiscard]] static void* protected_lua_Alloc(void* ud_, void* ptr_, size_t osize_, size_t nsize_)
@@ -90,14 +88,13 @@ class ProtectedAllocator : public AllocatorDefinition
     }
 
     public:
-
     // we are not like our base class: we can't be created inside a full userdata (or we would have to install a metatable and __gc handler to destroy ourselves properly)
     [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept = delete;
     static void operator delete(void* p_, lua_State* L) = delete;
 
     AllocatorDefinition makeDefinition()
     {
-        return AllocatorDefinition{ protected_lua_Alloc, this};
+        return AllocatorDefinition{ protected_lua_Alloc, this };
     }
 
     void installIn(lua_State* L)
@@ -108,8 +105,7 @@ class ProtectedAllocator : public AllocatorDefinition
     void removeFrom(lua_State* L)
     {
         // remove the protected allocator, if any
-        if (m_allocF != nullptr)
-        {
+        if (m_allocF != nullptr) {
             // install the non-protected allocator
             lua_setallocf(L, m_allocF, m_allocUD);
         }
@@ -123,7 +119,6 @@ class ProtectedAllocator : public AllocatorDefinition
 class Universe
 {
     public:
-
 #ifdef PLATFORM_LINUX
     // Linux needs to check, whether it's been run as root
     bool const m_sudo{ geteuid() == 0 };
@@ -197,11 +192,9 @@ void universe_store(lua_State* L, Universe* U);
 class DebugSpewIndentScope
 {
     private:
-
     Universe* const U;
 
     public:
-
     static char const* const debugspew_indent;
 
     DebugSpewIndentScope(Universe* U_)