2023-08-28 20:46:50 -07:00
# ifdef GEN_INTELLISENSE_DIRECTIVES
2024-10-27 15:58:37 -07:00
# pragma once
2024-12-10 17:45:00 -08:00
# include "platform.hpp"
2023-08-28 20:46:50 -07:00
# endif
2023-08-21 17:30:13 -07:00
2023-07-25 20:00:57 -07:00
# pragma region Macros
2024-10-27 15:58:37 -07:00
# ifndef global
2023-07-24 15:19:37 -07:00
# define global static // Global variables
2024-10-27 15:58:37 -07:00
# endif
# ifndef internal
2023-07-24 15:19:37 -07:00
# define internal static // Internal linkage
2023-08-09 15:47:59 -07:00
# endif
2024-10-27 15:58:37 -07:00
# ifndef local_persist
# define local_persist static // Local Persisting variables
2023-08-09 15:47:59 -07:00
# endif
2024-10-24 22:04:17 -07:00
# ifndef bit
2023-07-24 15:19:37 -07:00
# define bit( Value ) ( 1 << Value )
2024-12-08 22:33:37 -08:00
# define bitfield_is_equal( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) )
2024-10-24 22:04:17 -07:00
# endif
2023-07-24 15:19:37 -07:00
2024-12-06 21:21:09 -08:00
// Mainly intended for forcing the base library to utilize only C-valid constructs or type coercion
# ifndef GEN_C_LIKE_CPP
# define GEN_C_LIKE_CPP 0
# endif
2024-12-04 08:01:53 -08:00
# if GEN_COMPILER_CPP
2024-12-01 15:50:37 -08:00
# ifndef cast
# define cast( type, value ) (tmpl_cast<type>( value ))
# endif
2024-12-06 21:21:09 -08:00
# else
# ifndef cast
# define cast( type, value ) ( (type)(value) )
# endif
# endif
# if GEN_COMPILER_CPP
2024-11-30 14:18:49 -08:00
# ifndef ccast
# define ccast( type, value ) ( const_cast< type >( (value) ) )
# endif
# ifndef pcast
# define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
# endif
# ifndef rcast
# define rcast( type, value ) reinterpret_cast< type >( value )
# endif
# ifndef scast
# define scast( type, value ) static_cast< type >( value )
# endif
# else
# ifndef ccast
# define ccast( type, value ) ( (type)(value) )
# endif
# ifndef pcast
2024-12-09 11:55:02 -08:00
# define pcast( type, value ) ( * (type*)(& value) )
2024-11-30 14:18:49 -08:00
# endif
# ifndef rcast
# define rcast( type, value ) ( (type)(value) )
# endif
# ifndef scast
# define scast( type, value ) ( (type)(value) )
# endif
2024-10-27 15:58:37 -07:00
# endif
# ifndef stringize
# define stringize_va( ... ) #__VA_ARGS__
# define stringize( ... ) stringize_va( __VA_ARGS__ )
# endif
# ifndef do_once
# define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
# define do_once_start \
do \
{ \
local_persist \
bool done = false ; \
if ( done ) \
break ; \
done = true ;
# define do_once_end \
} \
while ( 0 ) ;
# endif
# ifndef labeled_scope_start
# define labeled_scope_start if ( false ) {
# define labeled_scope_end }
2024-10-24 22:04:17 -07:00
# endif
2023-07-24 15:19:37 -07:00
2024-10-27 15:58:37 -07:00
# ifndef compiler_decorated_func_name
# ifdef COMPILER_CLANG
# define compiler_decorated_func_name __PRETTY_NAME__
# elif defined(COMPILER_MSVC)
# define compiler_decorated_func_name __FUNCDNAME__
# endif
# endif
# ifndef num_args_impl
2024-12-05 14:04:17 -08:00
// This is essentially an arg couneter version of GEN_SELECT_ARG macros
// See section : _Generic function overloading for that usage (explains this heavier case)
2023-08-06 11:58:43 -07:00
# define num_args_impl( _0, \
_1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9 , _10 , \
_11 , _12 , _13 , _14 , _15 , _16 , _17 , _18 , _19 , _20 , \
_21 , _22 , _23 , _24 , _25 , _26 , _27 , _28 , _29 , _30 , \
_31 , _32 , _33 , _34 , _35 , _36 , _37 , _38 , _39 , _40 , \
_41 , _42 , _43 , _44 , _45 , _46 , _47 , _48 , _49 , _50 , \
_51 , _52 , _53 , _54 , _55 , _56 , _57 , _58 , _59 , _60 , \
_61 , _62 , _63 , _64 , _65 , _66 , _67 , _68 , _69 , _70 , \
_71 , _72 , _73 , _74 , _75 , _76 , _77 , _78 , _79 , _80 , \
_81 , _82 , _83 , _84 , _85 , _86 , _87 , _88 , _89 , _90 , \
_91 , _92 , _93 , _94 , _95 , _96 , _97 , _98 , _99 , _100 , \
N , . . . \
2023-07-24 15:19:37 -07:00
) N
2024-10-27 15:58:37 -07:00
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
2023-08-06 11:58:43 -07:00
# define num_args(...) \
num_args_impl ( _ , # # __VA_ARGS__ , \
100 , 99 , 98 , 97 , 96 , 95 , 94 , 93 , 92 , 91 , \
90 , 89 , 88 , 87 , 86 , 85 , 84 , 83 , 82 , 81 , \
80 , 79 , 78 , 77 , 76 , 75 , 74 , 73 , 72 , 71 , \
70 , 69 , 68 , 67 , 66 , 65 , 64 , 63 , 62 , 61 , \
60 , 59 , 58 , 57 , 56 , 55 , 54 , 53 , 52 , 51 , \
50 , 49 , 48 , 47 , 46 , 45 , 44 , 43 , 42 , 41 , \
40 , 39 , 38 , 37 , 36 , 35 , 34 , 33 , 32 , 31 , \
30 , 29 , 28 , 27 , 26 , 25 , 24 , 23 , 22 , 21 , \
20 , 19 , 18 , 17 , 16 , 15 , 14 , 13 , 12 , 11 , \
10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , \
0 \
2023-07-24 15:19:37 -07:00
)
2024-10-27 15:58:37 -07:00
# endif
2023-08-03 08:01:43 -07:00
2024-10-27 15:58:37 -07:00
# ifndef clamp
2023-07-24 15:19:37 -07:00
# define clamp( x, lower, upper ) min( max( ( x ), ( lower ) ), ( upper ) )
2024-10-27 15:58:37 -07:00
# endif
# ifndef count_of
# define count_of( x ) ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( ssize )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
# endif
# ifndef is_between
2023-07-24 15:19:37 -07:00
# define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
2024-10-27 15:58:37 -07:00
# endif
# ifndef size_of
# define size_of( x ) ( ssize )( sizeof( x ) )
# endif
# ifndef max
# define max( a, b ) ( (a > b) ? (a) : (b) )
# endif
# ifndef min
# define min( a, b ) ( (a < b) ? (a) : (b) )
# endif
2023-07-24 15:19:37 -07:00
2024-11-30 14:18:49 -08:00
# if GEN_COMPILER_MSVC || GEN_COMPILER_TINYC
2024-10-27 15:58:37 -07:00
# define offset_of( Type, element ) ( ( GEN_NS( ssize ) ) & ( ( ( Type* )0 )->element ) )
2023-08-09 15:47:59 -07:00
# else
# define offset_of( Type, element ) __builtin_offsetof( Type, element )
# endif
2024-10-27 15:58:37 -07:00
# ifndef forceinline
2024-11-30 14:18:49 -08:00
# if GEN_COMPILER_MSVC
2024-10-27 15:58:37 -07:00
# define forceinline __forceinline
# define neverinline __declspec( noinline )
2024-11-30 14:18:49 -08:00
# elif GEN_COMPILER_GCC
2024-10-27 15:58:37 -07:00
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
2024-11-30 14:18:49 -08:00
# elif GEN_COMPILER_CLANG
2024-10-27 15:58:37 -07:00
# if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
# else
# define forceinline
# define neverinline
# endif
# else
# define forceinline
# define neverinline
# endif
# endif
2023-07-25 20:00:57 -07:00
2024-10-27 18:18:41 -07:00
# ifndef neverinline
2024-11-30 14:18:49 -08:00
# if GEN_COMPILER_MSVC
2024-10-27 18:18:41 -07:00
# define neverinline __declspec( noinline )
2024-11-30 14:18:49 -08:00
# elif GEN_COMPILER_GCC
2024-10-27 18:18:41 -07:00
# define neverinline __attribute__( ( __noinline__ ) )
2024-11-30 14:18:49 -08:00
# elif GEN_COMPILER_CLANG
2024-10-27 18:18:41 -07:00
# if __has_attribute(__always_inline__)
# define neverinline __attribute__( ( __noinline__ ) )
# else
# define neverinline
# endif
# else
# define neverinline
# endif
# endif
2024-12-05 20:02:26 -08:00
# if GEN_COMPILER_C
# ifndef static_assert
# undef static_assert
# if GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
# define static_assert(condition, message) _Static_assert(condition, message)
# else
# define static_assert(condition, message) typedef char static_assertion_##__LINE__[(condition)?1:-1]
# endif
# endif
# endif
2024-12-04 23:53:14 -08:00
# if GEN_COMPILER_CPP
// Already Defined
# elif GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
# define thread_local _Thread_local
# elif GEN_COMPILER_MSVC
# define thread_local __declspec(thread)
# elif GEN_COMPILER_CLANG
# define thread_local __thread
# else
# error "No thread local support"
# endif
2024-12-04 08:01:53 -08:00
# if ! defined(typeof) && (!GEN_COMPILER_C || __STDC_VERSION__ < 202311L)
2024-11-30 14:18:49 -08:00
# if ! GEN_COMPILER_C
2024-11-30 15:54:19 -08:00
# define typeof decltype
2024-11-30 14:18:49 -08:00
# elif defined(_MSC_VER)
2024-12-04 23:53:14 -08:00
# define typeof(x) __typeof__(x)
2024-11-30 14:18:49 -08:00
# elif defined(__GNUC__) || defined(__clang__)
# define typeof(x) __typeof__(x)
# else
# error "Compiler not supported"
# endif
# endif
2024-12-04 08:01:53 -08:00
# ifndef GEN_API_C_BEGIN
2024-12-06 21:21:09 -08:00
# if GEN_COMPILER_C
2024-12-04 08:01:53 -08:00
# define GEN_API_C_BEGIN
# define GEN_API_C_END
# else
# define GEN_API_C_BEGIN extern "C" {
2024-12-06 21:21:09 -08:00
# define GEN_API_C_END }
2024-12-04 08:01:53 -08:00
# endif
# endif
2024-11-30 15:54:19 -08:00
2024-12-01 09:48:58 -08:00
# if GEN_COMPILER_C
2024-12-01 02:30:37 -08:00
# if __STDC_VERSION__ >= 202311L
# define enum_underlying(type) : type
# else
# define enum_underlying(type)
# endif
# else
# define enum_underlying(type) : type
# endif
2024-12-01 15:50:37 -08:00
# if GEN_COMPILER_C
# ifndef nullptr
# define nullptr NULL
# endif
2024-12-04 21:40:51 -08:00
# ifndef GEN_REMOVE_PTR
# define GEN_REMOVE_PTR(type) typeof(* ( (type) NULL) )
# endif
2024-12-01 15:50:37 -08:00
# endif
2024-12-04 08:01:53 -08:00
# if ! defined(GEN_PARAM_DEFAULT) && GEN_COMPILER_CPP
2024-12-02 21:45:30 -08:00
# define GEN_PARAM_DEFAULT = {}
# else
# define GEN_PARAM_DEFAULT
# endif
2024-12-04 23:53:14 -08:00
# if GEN_COMPILER_CPP
# define struct_init(type, value) {value}
# else
# define struct_init(type, value) {value}
# endif
2024-12-06 21:21:09 -08:00
#if 0
# ifndef GEN_OPTIMIZE_MAPPINGS_BEGIN
# define GEN_OPTIMIZE_MAPPINGS_BEGIN _pragma(optimize("gt", on))
# define GEN_OPITMIZE_MAPPINGS_END _pragma(optimize("", on))
# endif
# else
# define GEN_OPTIMIZE_MAPPINGS_BEGIN
# define GEN_OPITMIZE_MAPPINGS_END
# endif
2024-12-05 14:04:17 -08:00
# if GEN_COMPILER_C
2024-12-08 13:37:04 -08:00
// ____ _ ______ _ _ ____ _ __ _
// / ___} (_) | ____} | | (_) / __ \ | | | |(_)
// | | ___ ___ _ __ ___ _ __ _ ___ | |__ _ _ _ __ ___| |_ _ ___ _ __ | | | |_ _____ _ __ | | ___ __ _ __| | _ _ __ __ _
// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ \| |/ _ \ / _` |/ _` || | '_ \ / _` |
// | |__j | __/ | | | __/ | | | (__ | | | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V / __/ | | | | (_) | (_| | (_| || | | | | (_| |
// \____/ \___}_l l_l\___}_l l_l\___| l_l \__,_l_l l_l\___}\__}_l\___/l_l l_l \____/ \_/ \___}_l l_l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
// This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in: __| |
// https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md {___/
// Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible.
2024-12-05 18:01:04 -08:00
2024-12-05 14:04:17 -08:00
# define GEN_COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly.
// Helper macros for argument selection
# define GEN_SELECT_ARG_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
# define GEN_SELECT_ARG_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
2024-12-06 21:21:09 -08:00
# define GEN_SELECT_ARG_3( _1, _2, _3, ... ) _3 // etc..
2024-12-05 14:04:17 -08:00
# define GEN_GENERIC_SEL_ENTRY_TYPE GEN_SELECT_ARG_1 // Use the arg expansion macro to select arg 1 which should have the type.
# define GEN_GENERIC_SEL_ENTRY_FUNCTION GEN_SELECT_ARG_2 // Use the arg expansion macro to select arg 2 which should have the function.
# define GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER GEN_SELECT_ARG_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','.
# define GEN_RESOLVED_FUNCTION_CALL // Just used to indicate where the call "occurs"
// ----------------------------------------------------------------------------------------------------------------------------------
// GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name).
// It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma.
// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
2024-12-05 18:01:04 -08:00
# define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , )
2024-12-06 21:21:09 -08:00
// ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
// The slot won't exist if that comma is not found. |
2024-12-08 13:37:04 -08:00
2024-12-10 23:04:22 -08:00
// For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to:
2024-12-08 20:10:10 -08:00
typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION ;
struct GENCPP_NO_RESOLVED_GENERIC_SELECTION {
void * _THE_VOID_SLOT_ ;
2024-12-08 13:37:04 -08:00
} ;
2024-12-08 20:10:10 -08:00
GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = { 0 } ;
2024-12-08 13:37:04 -08:00
// Which will provide the message: error: called object type 'struct NO_RESOLVED_GENERIC_SELECTION' is not a function or function pointer
2024-12-05 14:04:17 -08:00
// ----------------------------------------------------------------------------------------------------------------------------------
2024-12-05 18:01:04 -08:00
// Below are generated on demand for an overlaod depdendent on a type:
2024-12-10 23:04:22 -08:00
// ----------------------------------------------------------------------------------------------------------------------------------
2024-12-08 13:37:04 -08:00
# define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
( selector_arg ) , /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_1 ) \
default : gen_generic_selection_fail \
2024-12-05 18:01:04 -08:00
) GEN_RESOLVED_FUNCTION_CALL ( selector_arg )
2024-12-05 14:04:17 -08:00
// ----------------------------------------------------------------------------------------------------------------------------------
// Then each definiton of a function has an associated define:
2024-12-10 23:04:22 -08:00
# // #define GENERIC_SLOT_<#>_<generic identifier> <typename>, <function_to_resolve>
2024-12-05 14:04:17 -08:00
// Then somehwere later on
// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
// Concrete example:
// To add support for long:
2024-12-10 23:04:22 -08:00
# define GENERIC_SLOT_1_gen_example_hash long, gen_example_hash__P_long
2024-12-05 18:01:04 -08:00
size_t gen_example_hash__P_long ( long val ) { return val * 2654435761ull ; }
2024-12-05 14:04:17 -08:00
// To add support for long long:
2024-12-10 23:04:22 -08:00
# define GENERIC_SLOT_2_gen_example_hash long long, gen_example_hash__P_long_long
2024-12-05 18:01:04 -08:00
size_t gen_example_hash__P_long_long ( long long val ) { return val * 2654435761ull ; }
2024-12-05 14:04:17 -08:00
// If using an Editor with support for syntax hightlighting macros: HASH__ARGS_SIG_1 and HASH_ARGS_SIG_2 should show color highlighting indicating the slot is enabled,
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
2024-12-10 10:56:56 -08:00
# define gen_hash_example( function_arguments ) _Generic( \
2024-12-08 13:37:04 -08:00
( function_arguments ) , /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_2 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_3 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_4 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_5 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_6 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_7 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( HASH__ARGS_SIG_8 ) \
default : gen_generic_selection_fail \
2024-12-05 14:04:17 -08:00
) GEN_RESOLVED_FUNCTION_CALL ( function_arguments )
2024-12-05 18:01:04 -08:00
// Additional Variations:
// If the function takes more than one argument the following is used:
# define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
( selector_arg ) , \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_2 ) \
2024-12-09 12:23:47 -08:00
/* ... */ \
2024-12-08 13:37:04 -08:00
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_N ) \
default : gen_generic_selection_fail \
2024-12-05 18:01:04 -08:00
) GEN_RESOLVED_FUNCTION_CALL ( selector_arg , __VA_ARG__ )
// If the function does not take the arugment as a parameter:
# define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
( GEN_TYPE_TO_EXP ( selector_arg ) ) , \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_2 ) \
/* ... */ \
2024-12-08 13:37:04 -08:00
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT ( FunctionID__ARGS_SIG_N ) \
default : gen_generic_selection_fail \
2024-12-05 18:01:04 -08:00
) GEN_RESOLVED_FUNCTION_CALL ( )
2024-12-08 13:37:04 -08:00
// Used to keep the _Generic keyword happy as bare types are not considered "expressions"
# define GEN_TYPE_TO_EXP(type) (* (type*)NULL)
2024-12-10 23:04:22 -08:00
// Instead of using this macro, you'll see it directly expanded by the code generation.
2024-12-08 13:37:04 -08:00
2024-12-05 18:01:04 -08:00
// typedef void* GEN_GenericExampleType;
// GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( GEN_GenericExampleType );
2024-12-06 21:21:09 -08:00
2024-12-05 14:04:17 -08:00
// END OF ------------------------ _Generic function overloading ----------------------------------------- END OF
# endif
2023-07-25 20:00:57 -07:00
# pragma endregion Macros