1 files changed, 153 insertions, 67 deletions

diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index e184476..e8d5ab5 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -1,107 +1,193 @@
-/*
- * MACROS_AND_UTILS.H
- */
-#ifndef MACROS_AND_UTILS_H
-#define MACROS_AND_UTILS_H
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#include <cassert>
+#include <chrono>
+#include <tuple>
+#include <type_traits>
 
- // M$ compiler doesn't support 'inline' keyword in C files...
-#if defined( _MSC_VER)
-#define inline __inline
-#endif
+using namespace std::chrono_literals;
 
 #define USE_DEBUG_SPEW() 0
 #if USE_DEBUG_SPEW()
 extern char const* debugspew_indent;
 #define INDENT_BEGIN "%.*s "
-#define INDENT_END , (U ? U->debugspew_indent_depth : 0), debugspew_indent
+#define INDENT_END , (U ? U->debugspew_indent_depth.load(std::memory_order_relaxed) : 0), debugspew_indent
 #define DEBUGSPEW_CODE(_code) _code
-#define DEBUGSPEW_PARAM_COMMA( param_) param_,
+#define DEBUGSPEW_OR_NOT(a_, b_) a_
+#define DEBUGSPEW_PARAM_COMMA(param_) param_,
 #define DEBUGSPEW_COMMA_PARAM( param_) , param_
 #else // USE_DEBUG_SPEW()
 #define DEBUGSPEW_CODE(_code)
-#define DEBUGSPEW_PARAM_COMMA( param_)
+#define DEBUGSPEW_OR_NOT(a_, b_) b_
+#define DEBUGSPEW_PARAM_COMMA(param_)
 #define DEBUGSPEW_COMMA_PARAM( param_)
 #endif // USE_DEBUG_SPEW()
 
 #ifdef NDEBUG
 
 #define _ASSERT_L(lua,c)     //nothing
-#define STACK_CHECK(L,o)     //nothing
-#define STACK_CHECK_ABS(L,o) //nothing
-#define STACK_MID(L,c)       //nothing
-#define STACK_END(L,c)       //nothing
 #define STACK_DUMP(L)        //nothing
 
+#define STACK_CHECK_START_REL(L, offset_)
+#define STACK_CHECK_START_ABS(L, offset_)
+#define STACK_CHECK_RESET_REL(L, offset_)
+#define STACK_CHECK_RESET_ABS(L, offset_)
+#define STACK_CHECK(L, offset_)
+
 #else // NDEBUG
 
-#define _ASSERT_L( L, cond_) if( (cond_) == 0) { (void) luaL_error( L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
-
-#define STACK_CHECK( L, offset_) \
-    { \
-        int const L##_delta = offset_; \
-        if( (L##_delta < 0) || (lua_gettop( L) < L##_delta)) \
-        { \
-            assert( FALSE); \
-            (void) luaL_error( L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop( L), L##_delta, __FILE__, __LINE__); \
-        } \
-        int const L##_oldtop = lua_gettop( L) - L##_delta
-
-#define STACK_CHECK_ABS( L, offset_) \
-    { \
-        int const L##_pos = offset_; \
-        if( lua_gettop( L) < L##_pos) \
-        { \
-            assert( FALSE); \
-            (void) luaL_error( L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop( L), L##_pos, __FILE__, __LINE__); \
-        } \
-        int const L##_oldtop = 0
-
-#define STACK_MID( L, change) \
-        do if( change != LUA_MULTRET) \
-        { \
-            int stack_check_a = lua_gettop( L) - L##_oldtop; \
-            int stack_check_b = (change); \
-            if( stack_check_a != stack_check_b) \
-            { \
-                assert( FALSE); \
-                luaL_error( L, "STACK ASSERT failed (%d not %d): %s:%d", stack_check_a, stack_check_b, __FILE__, __LINE__); \
-            } \
-        } while( 0)
-
-#define STACK_END( L, change) \
-        STACK_MID( L, change); \
+#define _ASSERT_L(L, cond_) if( (cond_) == 0) { (void) luaL_error(L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
+#define STACK_DUMP(L)    luaG_dump(L)
+
+class StackChecker
+{
+    private:
+    lua_State* const m_L;
+    int m_oldtop;
+
+    public:
+    struct Relative
+    {
+        int const m_offset;
+
+        operator int() const { return m_offset; }
+    };
+
+    struct Absolute
+    {
+        int const m_offset;
+
+        operator int() const { return m_offset; }
+    };
+
+    StackChecker(lua_State* const L_, Relative offset_, char const* file_, size_t const line_)
+    : m_L{ L_ }
+    , m_oldtop{ lua_gettop(L_) - offset_ }
+    {
+        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
+        }
+    }
+
+    StackChecker(lua_State* const L_, Absolute pos_, char const* file_, size_t const line_)
+    : m_L{ L_ }
+    , m_oldtop{ 0 }
+    {
+        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
+        }
     }
 
-#define STACK_DUMP( L)    luaG_dump( L)
+    StackChecker& operator=(StackChecker const& rhs_)
+    {
+        assert(m_L == rhs_.m_L);
+        m_oldtop = rhs_.m_oldtop;
+        return *this;
+    }
+
+    // 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)
+        {
+            int const actual{ lua_gettop(m_L) - m_oldtop };
+            if (actual != expected_)
+            {
+                assert(false);
+                luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%d", actual, expected_, file_, line_); // doesn't return
+            }
+        }
+    }
+};
+
+#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
 
 #define ASSERT_L(c) _ASSERT_L(L,c)
 
-inline void STACK_GROW(lua_State * L, int n_)
+inline void STACK_GROW(lua_State* L, int n_)
 {
     if (!lua_checkstack(L, n_))
-        luaL_error(L, "Cannot grow stack!");
+    {
+        luaL_error(L, "Cannot grow stack!"); // doesn't return
+    }
 }
 
-// non-string keyed registry access
-#define REGISTRY_SET( L, key_, value_) \
-{ \
-    push_unique_key( L, key_); \
-    value_; \
-    lua_rawset( L, LUA_REGISTRYINDEX); \
+#define LUAG_FUNC(func_name) [[nodiscard]] int LG_##func_name(lua_State* L)
+
+// #################################################################################################
+
+// a small helper to extract a full userdata pointer from the stack in a safe way
+template<typename T>
+[[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
+{
+    ASSERT_L(lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
+    return static_cast<T*>(lua_touserdata(L, index_));
 }
 
-#define REGISTRY_GET( L, key_) \
-{ \
-    push_unique_key( L, key_); \
-    lua_rawget( L, LUA_REGISTRYINDEX); \
+template<typename T>
+[[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
+{
+    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_));
+    }
+    else
+    {
+        return static_cast<T*>(lua_touserdata(L, index_));
+    }
+}
+
+template <typename T>
+[[nodiscard]] T* lua_newuserdatauv(lua_State* L, int nuvalue_)
+{
+    return static_cast<T*>(lua_newuserdatauv(L, sizeof(T), nuvalue_));
+}
+
+// #################################################################################################
+
+// use this instead of Lua's lua_error if possible
+[[noreturn]] static inline void raise_lua_error(lua_State* L)
+{
+    std::ignore = lua_error(L); // doesn't return
+    assert(false); // we should never get here, but i'm paranoid
 }
 
-#define LUAG_FUNC( func_name) int LG_##func_name( lua_State* L)
+using lua_Duration = std::chrono::template duration<lua_Number>;
+
+// #################################################################################################
+
+// A unique type generator
+template <typename T, auto = []{}>
+struct Unique
+{
+    T m_val;
+    constexpr Unique() = default;
+    constexpr operator T() const { return m_val; }
+    constexpr explicit Unique(T b_) : m_val{ b_ } {}
+};
+
+// #################################################################################################
 
-#endif // MACROS_AND_UTILS_H
+using Source = Unique<lua_State*>;
+using Dest = Unique<lua_State*>;
\ No newline at end of file