ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2024-12-22 07:44:45 -08:00
Code Issues Packages Projects Releases Wiki Activity

Finished draft pass verifying containers.array.hpp is equivalent to container.hpp's array.

Browse Source 
gen_generic_selection_function_macro now works generically
Imprvoed _Generic function overloading examples
This commit is contained in:
Edward R. Gonzalez 2024-12-05 21:01:04 -05:00
parent 8bb2bc7b1b
commit 266163557f
8 changed files with 251 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
gen_c_library/components/containers.array.hpp
View File

@ -34,15 +34,19 @@ CodeBody gen_array( StrC type, StrC array_name )
#pragma push_macro( "GEN_ASSERT" ) #pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "rcast" ) #pragma push_macro( "rcast" )
#pragma push_macro( "cast" ) #pragma push_macro( "cast" )
#pragma push_macro( "typeof" )
#pragma push_macro( "forceinline" )
#undef GEN_ASSERT #undef GEN_ASSERT
#undef rcast #undef rcast
#undef cast #undef cast
#undef typeof
#undef forceinline
CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
, stringize( , stringize(
typedef <type>* <array_type>; typedef <type>* <array_type>;
void <fn>_init ( <array_type>* self, AllocatorInfo allocator ); <array_type> <fn>_init ( AllocatorInfo allocator );
void <fn>_init_reserve ( <array_type>* self, AllocatorInfo allocator, usize capacity ); <array_type> <fn>_init_reserve ( AllocatorInfo allocator, usize capacity );
bool <fn>_append_array ( <array_type>* self, <array_type> other ); bool <fn>_append_array ( <array_type>* self, <array_type> other );
bool <fn>_append ( <array_type>* self, <type> value ); bool <fn>_append ( <array_type>* self, <type> value );
bool <fn>_append_items ( <array_type>* self, <type>* items, usize item_num ); bool <fn>_append_items ( <array_type>* self, <type>* items, usize item_num );
@ -60,33 +64,40 @@ CodeBody gen_array( StrC type, StrC array_name )
bool <fn>_resize ( <array_type>* self, usize num ); bool <fn>_resize ( <array_type>* self, usize num );
bool <fn>_set_capacity ( <array_type>* self, usize new_capacity ); bool <fn>_set_capacity ( <array_type>* self, usize new_capacity );
void <fn>_init( <array_type>* self, AllocatorInfo allocator ) forceinline
<array_type> <fn>_init( AllocatorInfo allocator )
{ {
size_t initial_size = array_grow_formula(0); size_t initial_size = array_grow_formula(0);
array_init_reserve( * self, allocator, initial_size ); return array_init_reserve( <array_type>, allocator, initial_size );
} }
void <fn>_init_reserve( <array_type>* self, AllocatorInfo allocator, usize capacity ) inline
<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
{ {
GEN_ASSERT(capacity > 0);
ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity)); ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity));
if (header == nullptr) if (header == nullptr)
self = nullptr; return nullptr;
header->Allocator = allocator; header->Allocator = allocator;
header->Capacity = capacity; header->Capacity = capacity;
header->Num = 0; header->Num = 0;
self = rcast(<array_type>*, header + 1); return rcast(<type>*, header + 1);
} }
forceinline
bool <fn>_append_array( <array_type>* self, <array_type> other ) bool <fn>_append_array( <array_type>* self, <array_type> other )
{ {
return array_append_items( * self, (<array_type>)other, <fn>_num(other)); return array_append_items( * self, (<array_type>)other, <fn>_num(other));
} }
inline
bool <fn>_append( <array_type>* self, <type> value ) bool <fn>_append( <array_type>* self, <type> value )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( header->Num == header->Capacity ) if ( header->Num == header->Capacity )
@ -103,8 +114,13 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num ) bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(items != nullptr);
GEN_ASSERT(item_num > 0);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( header->Num + item_num > header->Capacity ) if ( header->Num + item_num > header->Capacity )
@ -121,8 +137,11 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
bool <fn>_append_at( <array_type>* self, <type> item, usize idx ) bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( idx >= header->Num ) if ( idx >= header->Num )
@ -147,8 +166,11 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx ) bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( idx >= header->Num ) if ( idx >= header->Num )
@ -174,8 +196,10 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
<type>* <fn>_back( <array_type> self ) <type>* <fn>_back( <array_type> self )
{ {
GEN_ASSERT(self != nullptr);
ArrayHeader* header = array_get_header( self ); ArrayHeader* header = array_get_header( self );
if ( header->Num == 0 ) if ( header->Num == 0 )
@ -184,14 +208,19 @@ CodeBody gen_array( StrC type, StrC array_name )
return self + header->Num - 1; return self + header->Num - 1;
} }
inline
void <fn>_clear( <array_type> self ) void <fn>_clear( <array_type> self )
{ {
GEN_ASSERT(self != nullptr);
ArrayHeader* header = array_get_header( self ); ArrayHeader* header = array_get_header( self );
header->Num = 0; header->Num = 0;
} }
inline
bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value ) bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
{ {
GEN_ASSERT(self != nullptr);
GEN_ASSERT(begin <= end);
ArrayHeader* header = array_get_header( self ); ArrayHeader* header = array_get_header( self );
if ( begin < 0 || end >= header->Num ) if ( begin < 0 || end >= header->Num )
@ -203,17 +232,24 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
void <fn>_free( <array_type>* self ) void <fn>_free( <array_type>* self )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
allocator_free( header->Allocator, header ); allocator_free( header->Allocator, header );
self = NULL; self = NULL;
} }
inline
bool <fn>_grow( <array_type>* self, usize min_capacity ) bool <fn>_grow( <array_type>* self, usize min_capacity )
{ {
ArrayHeader* header = array_get_header( *self ); GEN_ASSERT( self != nullptr);
usize new_capacity = array_grow_formula( header->Capacity ); GEN_ASSERT(* self != nullptr);
GEN_ASSERT( min_capacity > 0 );
ArrayHeader* header = array_get_header( *self );
usize new_capacity = array_grow_formula( header->Capacity );
if ( new_capacity < min_capacity ) if ( new_capacity < min_capacity )
new_capacity = min_capacity; new_capacity = min_capacity;
@ -221,13 +257,17 @@ CodeBody gen_array( StrC type, StrC array_name )
return array_set_capacity( self, new_capacity ); return array_set_capacity( self, new_capacity );
} }
forceinline
usize <fn>_num( <array_type> self ) usize <fn>_num( <array_type> self )
{ {
GEN_ASSERT( self != nullptr);
return array_get_header(self)->Num; return array_get_header(self)->Num;
} }
inline
<type> <fn>_pop( <array_type> self ) <type> <fn>_pop( <array_type> self )
{ {
GEN_ASSERT( self != nullptr);
ArrayHeader* header = array_get_header( self ); ArrayHeader* header = array_get_header( self );
GEN_ASSERT( header->Num > 0 ); GEN_ASSERT( header->Num > 0 );
@ -236,8 +276,10 @@ CodeBody gen_array( StrC type, StrC array_name )
return result; return result;
} }
forceinline
void <fn>_remove_at( <array_type> self, usize idx ) void <fn>_remove_at( <array_type> self, usize idx )
{ {
GEN_ASSERT( self != nullptr);
ArrayHeader* header = array_get_header( self ); ArrayHeader* header = array_get_header( self );
GEN_ASSERT( idx < header->Num ); GEN_ASSERT( idx < header->Num );
@ -245,8 +287,12 @@ CodeBody gen_array( StrC type, StrC array_name )
header->Num--; header->Num--;
} }
inline
bool <fn>_reserve( <array_type>* self, usize new_capacity ) bool <fn>_reserve( <array_type>* self, usize new_capacity )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(new_capacity > 0);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( header->Capacity < new_capacity ) if ( header->Capacity < new_capacity )
@ -255,8 +301,12 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
bool <fn>_resize( <array_type>* self, usize num ) bool <fn>_resize( <array_type>* self, usize num )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(num > 0);
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( header->Capacity < num ) if ( header->Capacity < num )
@ -271,26 +321,34 @@ CodeBody gen_array( StrC type, StrC array_name )
return true; return true;
} }
inline
bool <fn>_set_capacity( <array_type>* self, usize new_capacity ) bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
{ {
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT( new_capacity > 0 );
ArrayHeader* header = array_get_header( * self ); ArrayHeader* header = array_get_header( * self );
if ( new_capacity == header->Capacity ) if ( new_capacity == header->Capacity )
return true; return true;
if ( new_capacity < header->Num ) if ( new_capacity < header->Num )
{
header->Num = new_capacity; header->Num = new_capacity;
return true;
}
usize size = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity; usize size = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity;
ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size )); ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size ));
if ( new_header == NULL ) if ( new_header == NULL )
return false; return false;
mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num ); mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
new_header->Capacity = new_capacity;
allocator_free( header->Allocator, & header ); allocator_free( header->Allocator, & header );
new_header->Capacity = new_capacity;
* self = cast( <type>*, new_header + 1 ); * self = cast( <type>*, new_header + 1 );
return true; return true;
} }
@ -298,6 +356,8 @@ CodeBody gen_array( StrC type, StrC array_name )
#pragma pop_macro( "GEN_ASSERT" ) #pragma pop_macro( "GEN_ASSERT" )
#pragma pop_macro( "rcast" ) #pragma pop_macro( "rcast" )
#pragma pop_macro( "cast" ) #pragma pop_macro( "cast" )
#pragma pop_macro( "typeof" )
#pragma pop_macro( "forceinline" )
++ ArrayDefinitionCounter; ++ ArrayDefinitionCounter;
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", ArrayDefinitionCounter).to_strc(); StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", ArrayDefinitionCounter).to_strc();
@ -335,67 +395,22 @@ R"(#define GENERIC_SLOT_<slot>__array_init <type_delimiter>, <type_deli
)); ));
}; };
constexpr bool array_by_ref = true;
Code gen_array_generic_selection_function_macro( StrC macro_name, bool by_ref = false )
{
local_persist
String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64));
define_builder.clear();
StrC macro_begin = token_fmt( "macro_name", (StrC)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( \
(selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \
)"
);
define_builder.append(macro_begin);
for ( s32 slot = 1; slot <= ArrayDefinitionCounter; ++ slot )
{
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
if (slot == ArrayDefinitionCounter)
{
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
continue;
}
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
}
if (by_ref)
define_builder.append(txt(")\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
else
define_builder.append(txt(")\tGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
// Add gap for next definition
define_builder.append(txt("\n\n"));
Code macro = untyped_str(define_builder.to_strc());
return macro;
}
CodeBody gen_array_generic_selection_interface() CodeBody gen_array_generic_selection_interface()
{ {
CodeBody interface_defines = def_body(CT_Global_Body); CodeBody interface_defines = def_body(CT_Global_Body);
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_init"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_init"), GenericSel_Direct_Type ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_init_reserve"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_init_reserve"), GenericSel_Direct_Type ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_append"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_append"), GenericSel_By_Ref ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_append_items"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_append_items"), GenericSel_By_Ref ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_back")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_back"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_clear")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_clear"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_fill")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_fill")) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_free"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_free"), GenericSel_By_Ref, GenericSel_One_Arg ) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_grow")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_grow")) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_num")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_num")) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("arary_pop")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_pop"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_remove_at")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_remove_at")) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("arary_reserve"), array_by_ref) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_reserve"), GenericSel_By_Ref) );
interface_defines.append( gen_array_generic_selection_function_macro(txt("array_set_capacity")) ); interface_defines.append( gen_generic_selection_function_macro( ArrayDefinitionCounter, txt("array_set_capacity")) );
return interface_defines; return interface_defines;
} }

12
gen_c_library/components/containers.hashtable.hpp
View File

@ -93,16 +93,16 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
void <fn>_set ( <tbl_type>* self, u64 key, <type> value ); void <fn>_set ( <tbl_type>* self, u64 key, <type> value );
ssize <fn>_slot ( <tbl_type> self, u64 key ); ssize <fn>_slot ( <tbl_type> self, u64 key );
ssize <fn>__add_entry( <tbl_type> self, u64 key ); ssize <fn>__add_entry( <tbl_type> self, u64 key );
HT_FindResult <fn>__find ( <tbl_type> self, u64 key ); HT_FindResult <fn>__find ( <tbl_type> self, u64 key );
b32 <fn>__full ( <tbl_type> self ); b32 <fn>__full ( <tbl_type> self );
<tbl_type> <fn>_make( AllocatorInfo allocator ) <tbl_type> <fn>_make( AllocatorInfo allocator )
{ {
<tbl_type> <tbl_type>
result = { NULL, NULL }; result = { NULL, NULL };
array_init(result.Hashes, allocator ); result.Hashes = array_init(Array_ssize, allocator );
array_init(result.Entries, allocator ); result.Entries = array_init(<array_entry>, allocator );
return result; return result;
} }
@ -111,8 +111,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
{ {
<tbl_type> <tbl_type>
result = { NULL, NULL }; result = { NULL, NULL };
array_init_reserve(result.Hashes, allocator, num ); result.Hashes = array_init_reserve(Array_ssize, allocator, num );
array_init_reserve(result.Entries, allocator, num ); result.Entries = array_init_reserve(<array_entry>, allocator, num );
return result; return result;
} }

84
gen_c_library/components/misc.hpp
View File

@ -1,9 +1,7 @@
// #pragma once #pragma once
// #include "../project/gen.hpp" #include "../project/gen.hpp"
// using namespace gen;
using namespace gen;
b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body ) b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
{ {
@ -57,6 +55,82 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& par
return found; return found;
} }
constexpr bool GenericSel_One_Arg = true;
enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
{
/* Implements:
#define GEN_FUNCTION_GENERIC_EXAMPLE( 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 ) \
... \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_N ) \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
*/
local_persist
String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64));
define_builder.clear();
StrC macro_begin;
if (opts == GenericSel_Direct_Type) {
macro_begin = token_fmt( "macro_name", (StrC)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \
)"
);
}
else {
macro_begin = token_fmt( "macro_name", (StrC)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
)"
);
}
define_builder.append(macro_begin);
for ( s32 slot = 1; slot <= num_slots; ++ slot )
{
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
if (slot == num_slots)
{
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
continue;
}
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
}
if ( ! one_arg )
{
if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
}
else
{
if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL()"));
else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
}
// Add gap for next definition
define_builder.append(txt("\n\n"));
Code macro = untyped_str(define_builder.to_strc());
return macro;
}
CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt("")) CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""))
{ {
// Get basic components for the name // Get basic components for the name

45
project/dependencies/containers.hpp
View File

@ -133,6 +133,7 @@ Array<Type> array_init(AllocatorInfo allocator) {
template<class Type> inline template<class Type> inline
Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity) Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity)
{ {
GEN_ASSERT(capacity > 0);
ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(Type) * capacity)); ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(Type) * capacity));
if (header == nullptr) if (header == nullptr)
@ -157,6 +158,8 @@ bool array_append_array(Array<Type>* array, Array<Type> other) {
template<class Type> inline template<class Type> inline
bool array_append(Array<Type>* array, Type value) bool array_append(Array<Type>* array, Type value)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
if (header->Num == header->Capacity) if (header->Num == header->Capacity)
@ -175,6 +178,10 @@ bool array_append(Array<Type>* array, Type value)
template<class Type> inline template<class Type> inline
bool array_append_items(Array<Type>* array, Type* items, usize item_num) bool array_append_items(Array<Type>* array, Type* items, usize item_num)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT(items != nullptr);
GEN_ASSERT(item_num > 0);
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
if (header->Num + item_num > header->Capacity) if (header->Num + item_num > header->Capacity)
@ -193,6 +200,8 @@ bool array_append_items(Array<Type>* array, Type* items, usize item_num)
template<class Type> inline template<class Type> inline
bool array_append_at(Array<Type>* array, Type item, usize idx) bool array_append_at(Array<Type>* array, Type item, usize idx)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
ssize slot = idx; ssize slot = idx;
@ -215,19 +224,19 @@ bool array_append_at(Array<Type>* array, Type item, usize idx)
mem_move(target + 1, target, (header->Num - slot) * sizeof(Type)); mem_move(target + 1, target, (header->Num - slot) * sizeof(Type));
header->Num++; header->Num++;
header = array_get_header(* array);
return true; return true;
} }
template<class Type> inline template<class Type> inline
bool array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx) bool array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = get_header(array); ArrayHeader* header = get_header(array);
if (idx >= header->Num) if (idx >= header->Num)
{ {
return append(array, items, item_num); return array_append_items(array, items, item_num);
} }
if (item_num > header->Capacity) if (item_num > header->Capacity)
@ -262,6 +271,7 @@ Type* array_back(Array<Type> array)
template<class Type> inline template<class Type> inline
void array_clear(Array<Type> array) { void array_clear(Array<Type> array) {
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
header->Num = 0; header->Num = 0;
} }
@ -269,6 +279,8 @@ void array_clear(Array<Type> array) {
template<class Type> inline template<class Type> inline
bool array_fill(Array<Type> array, usize begin, usize end, Type value) bool array_fill(Array<Type> array, usize begin, usize end, Type value)
{ {
GEN_ASSERT(array != nullptr);
GEN_ASSERT(begin <= end);
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
if (begin < 0 || end > header->Num) if (begin < 0 || end > header->Num)
@ -282,9 +294,10 @@ bool array_fill(Array<Type> array, usize begin, usize end, Type value)
return true; return true;
} }
template<class Type> inline template<class Type> forceinline
void array_free(Array<Type>* array) { void array_free(Array<Type>* array) {
GEN_ASSERT(array != nullptr); GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
allocator_free(header->Allocator, header); allocator_free(header->Allocator, header);
Type** Data = (Type**)array; Type** Data = (Type**)array;
@ -293,14 +306,18 @@ void array_free(Array<Type>* array) {
template<class Type> forceinline template<class Type> forceinline
ArrayHeader* array_get_header(Array<Type> array) { ArrayHeader* array_get_header(Array<Type> array) {
GEN_ASSERT(array != nullptr);
Type* Data = array; Type* Data = array;
using NonConstType = TRemoveConst<Type>; using NonConstType = TRemoveConst<Type>;
return rcast(ArrayHeader*, const_cast<NonConstType*>(Data)) - 1; return rcast(ArrayHeader*, const_cast<NonConstType*>(Data)) - 1;
} }
template<class Type> inline template<class Type> forceinline
bool array_grow(Array<Type>* array, usize min_capacity) bool array_grow(Array<Type>* array, usize min_capacity)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT( min_capacity > 0 );
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
usize new_capacity = array_grow_formula(header->Capacity); usize new_capacity = array_grow_formula(header->Capacity);
@ -310,13 +327,15 @@ bool array_grow(Array<Type>* array, usize min_capacity)
return array_set_capacity(array, new_capacity); return array_set_capacity(array, new_capacity);
} }
template<class Type> inline template<class Type> forceinline
usize array_num(Array<Type> array) { usize array_num(Array<Type> array) {
GEN_ASSERT(array != nullptr);
return array_get_header(array)->Num; return array_get_header(array)->Num;
} }
template<class Type> inline template<class Type> forceinline
void array_pop(Array<Type> array) { void array_pop(Array<Type> array) {
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
GEN_ASSERT(header->Num > 0); GEN_ASSERT(header->Num > 0);
header->Num--; header->Num--;
@ -325,6 +344,7 @@ void array_pop(Array<Type> array) {
template<class Type> inline template<class Type> inline
void array_remove_at(Array<Type> array, usize idx) void array_remove_at(Array<Type> array, usize idx)
{ {
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
GEN_ASSERT(idx < header->Num); GEN_ASSERT(idx < header->Num);
@ -335,6 +355,9 @@ void array_remove_at(Array<Type> array, usize idx)
template<class Type> inline template<class Type> inline
bool array_reserve(Array<Type>* array, usize new_capacity) bool array_reserve(Array<Type>* array, usize new_capacity)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT(num > 0)
ArrayHeader* header = array_get_header(array); ArrayHeader* header = array_get_header(array);
if (header->Capacity < new_capacity) if (header->Capacity < new_capacity)
@ -346,6 +369,8 @@ bool array_reserve(Array<Type>* array, usize new_capacity)
template<class Type> inline template<class Type> inline
bool array_resize(Array<Type>* array, usize num) bool array_resize(Array<Type>* array, usize num)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
if (header->Capacity < num) { if (header->Capacity < num) {
@ -361,10 +386,12 @@ bool array_resize(Array<Type>* array, usize num)
template<class Type> inline template<class Type> inline
bool array_set_capacity(Array<Type>* array, usize new_capacity) bool array_set_capacity(Array<Type>* array, usize new_capacity)
{ {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array); ArrayHeader* header = array_get_header(* array);
if (new_capacity == header->Capacity) if (new_capacity == header->Capacity)
return true; return true;
if (new_capacity < header->Num) if (new_capacity < header->Num)
{ {

53
project/dependencies/macros.hpp
View File

@ -269,13 +269,16 @@
#define struct_init(type, value) {value} #define struct_init(type, value) {value}
#endif #endif
// ------------------------ _Generic function overloading -----------------------------------------
#if GEN_COMPILER_C #if GEN_COMPILER_C
// ------------------------ _Generic function overloading -----------------------------------------
// This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in: // 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 // 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 unopaque as possible. // 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 unopaque as possible.
// Extensive effort was put in below to make this as easy as possible to understand what is going on with this mess of a preoprocessor. // Extensive effort was put in below to make this as easy as possible to understand what is going on with this mess of a preoprocessor.
// Where the signature would be defined using:
#define GEN_TYPE_TO_EXP(type) (type*)NULL
#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. #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 // Helper macros for argument selection
@ -299,19 +302,19 @@
// It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma. // 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: ',' > // Expands to ',' if it can find (type): (function) <comma_operator: ',' >
// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> , // Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_SELECT_ARG_3( slot_exp, GEN_SELECT_ARG_1( slot_exp, ): GEN_SELECT_ARG_2( slot_exp, ) GEN_COMMA_OPERATOR, , ) #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, , )
// ^Selects the comma ^ is the type ^ is the function ^ comma delimiter to select ^ Insert a comma // ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
// The slot won't exist if that comma is not found. // The slot won't exist if that comma is not found. |
// | // |
// This is the same as above but it does not insert a comma V no comma here. // This is the same as above but it does not insert a comma V no comma here.
#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ), , ) #define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ), , )
// Needed for the last slot as they don't allow trailing commas. // Needed for the last slot as they don't allow trailing commas.
// ---------------------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------------------
// Below are generated on demand for a generated function // Below are generated on demand for an overlaod depdendent on a type:
// ---------------------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------------------
#define GEN_FUNCTION_GENERIC_EXAMPLE( function_arguments ) _Generic( \ #define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
(function_arguments), /* Select Via Expression*/ \ (selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \ /* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
@ -320,8 +323,8 @@
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_1 ) \
) GEN_RESOLVED_FUNCTION_CALL( function_arguments ) ) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
// ---------------------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------------------
// Then each definiton of a function has an associated define: // Then each definiton of a function has an associated define:
@ -332,16 +335,14 @@
// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> } // <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
// Concrete example: // Concrete example:
#define ENABLE_GENERIC_EXAMPLE 0
#if ENABLE_GENERIC_EXAMPLE
// To add support for long: // To add support for long:
#define HASH__ARGS_SIG_1 GEN_GENERIC_FUNCTION_ARG_SIGNATURE( hash__P_long, long long ) #define GEN_EXAMPLE_HASH__ARGS_SIG_1 GEN_GENERIC_FUNCTION_ARG_SIGNATURE( hash__P_long, long long )
size_t hash__P_long ( long val ) { return val * 2654435761ull; } size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
// To add support for long long: // To add support for long long:
#define HASH__ARGS_SIG_2 GEN_GENERIC_FUNCTION_ARG_SIGNATURE( hash__P_long_long, long long ) #define GEN_EXAMPLE_HASH__ARGS_SIG_2 GEN_GENERIC_FUNCTION_ARG_SIGNATURE( hash__P_long_long, long long )
size_t hash__P_long_long( long long val ) { return val * 2654435761ull; } size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
// 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, // 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. // or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
@ -358,8 +359,28 @@ size_t hash__P_long_long( long long val ) { return val * 2654435761ull; }
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( HASH__ARGS_SIG_8 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( HASH__ARGS_SIG_8 ) \
) GEN_RESOLVED_FUNCTION_CALL( function_arguments ) ) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
#endif // ENABLE_GENERIC_EXAMPLE // 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 ) \
... \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_N ) \
) 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 ) \
/* ... */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_N ) \
) GEN_RESOLVED_FUNCTION_CALL()
// typedef void* GEN_GenericExampleType;
// GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( GEN_GenericExampleType );
// END OF ------------------------ _Generic function overloading ----------------------------------------- END OF // END OF ------------------------ _Generic function overloading ----------------------------------------- END OF
#endif #endif

2
project/dependencies/platform.hpp
View File

@ -123,7 +123,7 @@
#endif #endif
#if GEN_COMPILER_C #if GEN_COMPILER_C
#pragma message("Detected C") #pragma message("GENCPP: Detected C")
#endif #endif
#pragma endregion Platform Detection #pragma endregion Platform Detection

1
project/helpers/push_ignores.inline.hpp
View File

@ -8,6 +8,7 @@
# pragma clang diagnostic ignored "-Wvarargs" # pragma clang diagnostic ignored "-Wvarargs"
# pragma clang diagnostic ignored "-Wunused-function" # pragma clang diagnostic ignored "-Wunused-function"
# pragma clang diagnostic ignored "-Wbraced-scalar-init" # pragma clang diagnostic ignored "-Wbraced-scalar-init"
# pragma clang diagnostic ignored "-W#pragma-messages"
#endif #endif
#ifdef __GNUC__ #ifdef __GNUC__

12
scripts/build.ci.ps1
View File

@ -137,7 +137,7 @@ if ( $bootstrap )
$unit = join-path $path_project "bootstrap.cpp" $unit = join-path $path_project "bootstrap.cpp"
$executable = join-path $path_build "bootstrap.exe" $executable = join-path $path_build "bootstrap.exe"
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_project Push-Location $path_project
if ( Test-Path( $executable ) ) { if ( Test-Path( $executable ) ) {
@ -175,7 +175,7 @@ if ( $singleheader )
$flag_link_win_subsystem_console $flag_link_win_subsystem_console
) )
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_singleheader Push-Location $path_singleheader
if ( Test-Path( $executable ) ) { if ( Test-Path( $executable ) ) {
@ -213,7 +213,7 @@ if ( $c_library )
$flag_link_win_subsystem_console $flag_link_win_subsystem_console
) )
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_c_library Push-Location $path_c_library
if ( Test-Path( $executable ) ) { if ( Test-Path( $executable ) ) {
@ -240,7 +240,7 @@ if ( $c_library )
$compiler_args += "/std:c11" $compiler_args += "/std:c11"
} }
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_c_library Push-Location $path_c_library
if ( Test-Path( $executable ) ) { if ( Test-Path( $executable ) ) {
@ -278,7 +278,7 @@ if ( $unreal )
$flag_link_win_subsystem_console $flag_link_win_subsystem_console
) )
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_unreal Push-Location $path_unreal
if ( Test-Path( $executable ) ) { if ( Test-Path( $executable ) ) {
@ -340,7 +340,7 @@ if ( $test )
$flag_link_win_subsystem_console $flag_link_win_subsystem_console
) )
build-simple $path_build $includes $compiler_args $linker_args $unit $executable $result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
Push-Location $path_test Push-Location $path_test
Write-Host $path_test Write-Host $path_test