docs/WinTer/base__macros_8h_source.html

#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

 // end context_detection


#include <stddef.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>


#define INTERNAL static


#define EXTERNAL extern


#if defined(__GNUC__) || defined(__clang__)

#   define API_EXPORT __attribute__((visibility("default")))

#   define API_LOCAL __attribute__((visibility("hidden")))

#elif defined(_MSC_VER)

#   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 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 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)


INTERNAL inline void


print_context_info(void)

{

    printf("Compilation Context:\n");

    printf("    - Compiler: " COMPILER_NAME "\n");

    printf("    - OS: " OS_NAME "\n");

    printf("    - Architecture: " ARCH_NAME "\n");

    printf("    - Endianness: " ENDIAN_NAME "\n");

    printf("    - Build: " BUILD_NAME "\n");

    printf("    - C Standard: " C_STANDARD_NAME "\n");

}


#if COMPILER_MSVC

#   define debug_break() __debugbreak()

#elif COMPILER_GCC || 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

OS_NAME
#define OS_NAME
Human-readable string name of the operating system.
Definition base_macros.h:66

BUILD_NAME
#define BUILD_NAME
Human-readable string name of the build configuration.
Definition base_macros.h:114

C_STANDARD_NAME
#define C_STANDARD_NAME
Human-readable string of the detected C standard.
Definition base_macros.h:156

print_context_info
static void print_context_info(void)
Prints OS, architecture, compiler, endianness, build, and C standard to stdout.
Definition base_macros.h:554

INTERNAL
#define INTERNAL
Marks a function or variable as strictly internal to its translation unit (static).
Definition base_macros.h:173