base_macros.h

Go to the documentation of this file.

 
#ifndef BASE_MACROS_H
#define BASE_MACROS_H
 
#if defined(_WIN32)
#   ifndef WIN32_LEAN_AND_MEAN
#       define WIN32_LEAN_AND_MEAN
#   endif
// Note: We don't include <windows.h> here to prevent namespace pollution.
// Include it manually in the specific .c files that need it.
#elif defined(__linux__) || (defined(__APPLE__) && defined(__MACH__))
#   include <unistd.h>
#endif
 
#if defined(__clang__)
#   define COMPILER_CLANG 1
#   define COMPILER_NAME "Clang"
#elif defined(__GNUC__)
#   define COMPILER_GCC  1
#   define COMPILER_NAME "GCC"
#elif defined(_MSC_VER)
#   define COMPILER_MSVC 1
#   define COMPILER_NAME "MSVC"
#else
#   error "Compiler not supported"
#endif
 
#if defined(_WIN32)
#   define OS_WINDOWS 1
#   define OS_NAME "Windows"
#elif defined(__linux__)
#   define OS_LINUX 1
#   define OS_NAME   "Linux"
#elif defined(__APPLE__) && defined(__MACH__)
#   define OS_MAC   1
#   define OS_NAME "macOS"
#else
#   error "Operating system not supported"
#endif
 
#if defined(_M_X64) || defined(__x86_64__)
#   define ARCH_X64 1
#   define ARCH_NAME "x86_64"
#elif defined(_M_IX86) || defined(__i386__)
#   define ARCH_X86  1
#   define ARCH_NAME "x86"
#elif defined(_M_ARM64) || defined(__aarch64__)
#   define ARCH_ARM64 1
#   define ARCH_NAME  "ARM64"
#elif defined(_M_ARM) || defined(__arm__)
#   define ARCH_ARM  1
#   define ARCH_NAME "ARM"
#else
#   error "Architecture not supported"
#endif
 
#if defined(NDEBUG)
#   define BUILD_RELEASE 1
#   define BUILD_NAME "Release"
#else
#   define BUILD_DEBUG 1
#   define BUILD_NAME  "Debug"
#endif
 
#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || defined(_M_IX86) ||  \
    defined(_M_X64) || defined(__i386__) || defined(__x86_64__) || defined(_M_ARM) ||          \
    defined(_M_ARM64)
#   define ENDIAN_LITTLE 1
#   define ENDIAN_NAME "Little Endian"
#elif (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__)
#   define ENDIAN_BIG  1
#   define ENDIAN_NAME "Big Endian"
#else
#   error "Could not determine endianness"
#endif
 
#if defined(__STDC_VERSION__)
#   if __STDC_VERSION__ >= 202311L
#       define C_STANDARD 23
#       define C_STANDARD_NAME "C23"
#   elif __STDC_VERSION__ >= 201710L
#       define C_STANDARD   17
#       define C_STANDARD_NAME "C17"
#   elif __STDC_VERSION__ >= 201112L
#       define C_STANDARD   11
#       define C_STANDARD_NAME "C11"
#   elif __STDC_VERSION__ >= 199901L
#       define C_STANDARD   99
#       define C_STANDARD_NAME "C99"
#   else
#       define C_STANDARD   89
#       define C_STANDARD_NAME "C89"
#   endif
#else
#   define C_STANDARD   89
#   define C_STANDARD_NAME "C89/Default"
#endif
 
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>


#define function static

#define global static

#define local_persist static

#define external extern

#if defined(COMPILER_MSVC)
#   define thread_local __declspec(thread)
#elif defined(COMPILER_CLANG) || defined(COMPILER_GCC)
#   define thread_local __thread
#elif C_STANDARD >= 11
#   define thread_local _Thread_local
#else
#   error "Thread local storage not supported on this compiler!"
#endif
 
#if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
#   define API_EXPORT __attribute__((visibility("default")))
#   define API_LOCAL __attribute__((visibility("hidden")))
#elif defined(COMPILER_MSVC)
#   define API_EXPORT __declspec(dllexport)
#   define API_LOCAL
#else
#   define API_EXPORT
#   define API_LOCAL
#endif
 
#ifdef __cplusplus
#   define C_LINKAGE_BEGIN extern "C" {
#   define C_LINKAGE_END }
#else
#   define C_LINKAGE_BEGIN
#   define C_LINKAGE_END
#endif


#define STRINGIFY_DETAIL(x) #x
#define STRINGIFY(x) STRINGIFY_DETAIL(x)

#define GLUE_DETAIL(x, y) x##y
#define GLUE(x, y) GLUE_DETAIL(x, y)

#define INT_FROM_PTR(ptr) ((uintptr_t)(ptr))

#define PTR_FROM_INT(type, val) ((type *)(uintptr_t)(val))

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
#if defined(__GNUC__) || defined(__clang__) ||                                                     \
    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
 
#   if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
#       define _TYPEOF(x) typeof(x)
#   else
#       define _TYPEOF(x) __typeof__(x)
#   endif

#   define MIN(a, b)                                                                          \
        ({                                                                                 \
            _TYPEOF(a) _a = (a);                                                       \
            _TYPEOF(b) _b = (b);                                                       \
            _a < _b ? _a : _b;                                                         \
        })

#   define MAX(a, b)                                                                          \
        ({                                                                                 \
            _TYPEOF(a) _a = (a);                                                       \
            _TYPEOF(b) _b = (b);                                                       \
            _a > _b ? _a : _b;                                                         \
        })

#   define CLAMP(val, min, max)                                                               \
        ({                                                                                 \
            _TYPEOF(val) _v  = (val);                                                  \
            _TYPEOF(min) _mn = (min);                                                  \
            _TYPEOF(max) _mx = (max);                                                  \
            (_v < _mn) ? _mn : ((_v > _mx) ? _mx : _v);                                \
        })
 
#else
// Fallbacks for standard C89/C11 (MSVC)
#   define MIN(a, b)         (((a) < (b)) ? (a) : (b))
#   define MAX(a, b)         (((a) > (b)) ? (a) : (b))
#   define CLAMP(val, min, max) (((val) < (min)) ? (min) : ((val) > (max)) ? (max) : (val))
#endif

#define SWAP(type, a, b)                                                                           \
    do {                                                                                       \
        type _tmp = (a);                                                                   \
        (a)   = (b);                                                                   \
        (b)   = _tmp;                                                                  \
    } while (0)

#define Boolify(x) ((x) != 0)

#define AsciiID4(a, b, c, d)                                                                       \
    (((u32)(u8)(d) << 24) | ((u32)(u8)(c) << 16) | ((u32)(u8)(b) << 8) | (u32)(u8)(a))

#define ExpandAsciiID(x) (int)(sizeof(x)), (char *)(&(x))


#define ALIGN_UP_POW2(x, p) (((x) + (p) - 1) & ~((p) - 1))

#define ALIGN_DOWN_POW2(x, p) ((x) & ~((p) - 1))

#define IS_POW2_OR_ZERO(x) (((x) & ((x) - 1)) == 0)

#define IS_POW2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))

#define SHIFT8(T, x, s) ((T)(x) << (s))

#define PACK_U32_LE(a, b, c, d)                                                                    \
    (SHIFT8(U32, a, 0) | SHIFT8(U32, b, 8) | SHIFT8(U32, c, 16) | SHIFT8(U32, d, 24))



#define MEM_ZERO(ptr, size) memset((ptr), 0, (size))

#define MEM_ZERO_STRUCT(ptr) MEM_ZERO((ptr), sizeof(*(ptr)))

#define MEM_ZERO_ARRAY(arr) MEM_ZERO((arr), sizeof(arr))

#define MEM_COPY(dst, src, size) memmove((dst), (src), (size))

#define MEM_COPY_STRUCT(dst, src) MEM_COPY((dst), (src), MIN(sizeof(*(dst)), sizeof(*(src))))

#define MEM_COPY_ARRAY(dst, src) MEM_COPY((dst), (src), MIN(sizeof(dst), sizeof(src)))


#define DLL_PUSH_BACK_NP(f, l, n, next, prev)                                                      \
    ((f) == 0 ? ((f) = (l) = (n), (n)->next = (n)->prev = 0)                                   \
          : ((n)->prev = (l), (l)->next = (n), (l) = (n), (n)->next = 0))

#define DLL_PUSH_BACK(f, l, n) DLL_PUSH_BACK_NP(f, l, n, next, prev)

#define DLL_PUSH_FRONT(f, l, n) DLL_PUSH_BACK_NP(l, f, n, prev, next)

#define DLL_REMOVE_NP(f, l, n, next, prev)                                                         \
    ((f) == (n)   ? ((f) == (l) ? ((f) = (l) = (0)) : ((f) = (f)->next, (f)->prev = 0))        \
     : (l) == (n) ? ((l) = (l)->prev, (l)->next = 0)                                           \
              : ((n)->next->prev = (n)->prev, (n)->prev->next = (n)->next))

#define DLL_REMOVE(f, l, n) DLL_REMOVE_NP(f, l, n, next, prev)

#define SLL_QUEUE_PUSH_N(f, l, n, next)                                                            \
    (((f) == 0 ? (f) = (l) = (n) : ((l)->next = (n), (l) = (n))), (n)->next = 0)

#define SLL_QUEUE_PUSH(f, l, n) SLL_QUEUE_PUSH_N(f, l, n, next)

#define SLL_STACK_PUSH_N(f, n, next) ((n)->next = (f), (f) = (n))

#define SLL_STACK_PUSH(f, n) SLL_STACK_PUSH_N(f, n, next)

#define SLL_STACK_POP_N(f, next) ((f) == 0 ? 0 : ((f) = (f)->next))

#define SLL_STACK_POP(f) SLL_STACK_POP_N(f, next)

 
#if defined(COMPILER_MSVC)
#   define debug_break() __debugbreak()
#elif defined(COMPILER_GCC) || defined(COMPILER_CLANG)
#   define debug_break() __builtin_trap()
#else
#   define debug_break() (*(volatile int *)0 = 0)
#endif
 
#if BUILD_DEBUG
#   define ASSERT(expr)                                                                       \
        do {                                                                               \
            if (!(expr)) {                                                             \
                fputs("Assertion failed: " #expr "\n", stderr);                    \
                fputs("File: " __FILE__ "\n", stderr);                             \
                fputs("Line: " STRINGIFY(__LINE__) "\n", stderr);                  \
                debug_break();                                                     \
            }                                                                          \
        } while (0)

#   define ASSERT_NOT_NULL(ptr)                                                               \
        do {                                                                               \
            if ((ptr) == NULL) {                                                       \
                fputs("Assertion failed: " #ptr " is NULL\n", stderr);             \
                fputs("File: " __FILE__ "\n", stderr);                             \
                fputs("Line: " STRINGIFY(__LINE__) "\n", stderr);                  \
                debug_break();                                                     \
            }                                                                          \
        } while (0)
#else
// Compile assertions out completely in Release builds for zero overhead
#   define ASSERT(expr)      ((void)0)
#   define ASSERT_NOT_NULL(ptr) ((void)0)
#endif
 
#endif // BASE_MACROS_H