First compiling version of operator overloading for C! (on both msvc and clang using -std=c11 flag, using _Generic selection with some helper macros)

Extremely satsified with how unofuscated the generated code is for _Generic. Still fixing up the templated container code though in the c-codegen
2025-10-30 22:40:54 -07:00 · 2024-12-05 17:04:17 -05:00
parent 47b9c37e94
commit a3407c14d5
15 changed files with 424 additions and 263 deletions
--- a/gen_c_library/c_library.cpp
+++ b/gen_c_library/c_library.cpp
@@ -118,22 +118,33 @@ int gen_main()
 	{
 		header.print( c_library_header_start );

+#pragma region Scan, Parse, and Generate Components
+		Code types      = scan_file( project_dir "components/types.hpp" );
+		Code ast        = scan_file( project_dir "components/ast.hpp" );
+		Code ast_types  = scan_file( project_dir "components/ast_types.hpp" );
+		Code code_types = scan_file( project_dir "components/code_types.hpp" );
+		Code interface  = scan_file( project_dir "components/interface.hpp" );
+		Code inlines 	= scan_file( project_dir "components/inlines.hpp" );
+		Code header_end = scan_file( project_dir "components/header_end.hpp" );
+
+		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+#pragma endregion Scan, Parse, and Generate Components
+
+#pragma region Scan, Parse, and Generate Dependencies
 		Code platform     = scan_file( project_dir "dependencies/platform.hpp" );
 		Code macros       = scan_file( project_dir "dependencies/macros.hpp" );
 		Code basic_types  = scan_file( project_dir "dependencies/basic_types.hpp" );
 		Code debug        = scan_file( project_dir "dependencies/debug.hpp" );
-
-		header.print_fmt( roll_own_dependencies_guard_start );
-		header.print( platform );
-		header.print_fmt( "\nGEN_NS_BEGIN\n" );
-
-		header.print( macros );
-		header.print( basic_types );
-		header.print( debug );
+		Code string_ops   = scan_file( project_dir "dependencies/string_ops.hpp" );
+		Code hashing      = scan_file( project_dir "dependencies/hashing.hpp" );
+		Code filesystem   = scan_file( project_dir "dependencies/filesystem.hpp" );
+		Code timing       = scan_file( project_dir "dependencies/timing.hpp" );

 		CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" );
 		CodeBody memory        = def_body(CT_Global_Body);
-
 		for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
 		{
 			switch (entry->Type)
@@ -252,11 +263,6 @@ int gen_main()
 			}
 		}

-		header.print( dump_to_scratch_and_retireve(memory) );
-
-		Code string_ops = scan_file( project_dir "dependencies/string_ops.hpp" );
-		header.print( string_ops );
-
 		CodeBody printing_parsed = parse_file( project_dir "dependencies/printing.hpp" );
 		CodeBody printing        = def_body(CT_Global_Body);
 		for ( Code entry = printing_parsed.begin(); entry != printing_parsed.end(); ++ entry )
@@ -287,27 +293,6 @@ int gen_main()
 				break;
 			}
 		}
-		header.print(dump_to_scratch_and_retireve(printing));
-
-		CodeBody containers = def_body(CT_Global_Body);
-		{
-			containers.append( def_pragma(code(region Containers)));
-
-			containers.append( gen_array_base() );
-			containers.append( gen_hashtable_base() );
-
-			containers.append(fmt_newline);
-
-			CodeBody array_ssize = gen_array(txt("ssize"), txt("Array_ssize"));
-			containers.append(array_ssize);
-
-			containers.append( def_pragma(code(endregion Containers)));
-		}
-		header.print(fmt_newline);
-		header.print(dump_to_scratch_and_retireve(containers));
-
-		Code hashing = scan_file( project_dir "dependencies/hashing.hpp" );
-		header.print( hashing );

 		CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
 		CodeBody strings        = def_body(CT_Global_Body);
@@ -386,7 +371,7 @@ int gen_main()
 					CodeTypedef td = cast(CodeTypedef, entry);
 					if (td->Name.contains(name_string_table))
 					{
-						CodeBody ht = gen_hashtable(name_string_table, name_string_table);
+						CodeBody ht = gen_hashtable(txt("StrC"), name_string_table);
 						strings.append(ht);
 						strings.append(td);
 						break;
@@ -400,30 +385,49 @@ int gen_main()
 				break;
 			}
 		}
-		header.print(dump_to_scratch_and_retireve(strings));

-		Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" );
-		Code timing = scan_file( project_dir "dependencies/timing.hpp" );
+		CodeBody containers = def_body(CT_Global_Body);
+		{
+			CodeBody array_ssize = gen_array(txt("ssize"), txt("Array_ssize"));
+
+			containers.append( def_pragma(code(region Containers)));
+
+			// At this point all arrays required should have been defined so its safe to generate the generic selectors.
+			containers.append( gen_array_base() );
+			containers.append( gen_array_generic_selection_interface());
+			containers.append( gen_hashtable_base() );
+
+			containers.append(fmt_newline);
+			containers.append(array_ssize);
+
+			containers.append( def_pragma(code(endregion Containers)));
+			containers.append(fmt_newline);
+		}
+#pragma endregion Scan, Parse, and Generate Dependencies
+
+#pragma region Print Dependencies
+		header.print_fmt( roll_own_dependencies_guard_start );
+		header.print( platform );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		header.print( macros );
+		header.print( basic_types );
+		header.print( debug );
+		header.print( dump_to_scratch_and_retireve(memory) );
+		header.print( dump_to_scratch_and_retireve(printing));
+		header.print( string_ops );
+		header.print( dump_to_scratch_and_retireve(containers));
+		header.print( hashing );
+		header.print( dump_to_scratch_and_retireve(strings));
 		// header.print( filesystem );
 		// header.print( timing );
-
 		header.print_fmt( "\nGEN_NS_END\n" );
 		header.print_fmt( roll_own_dependencies_guard_end );
+#pragma endregion Print Dependencies

-		Code types      = scan_file( project_dir "components/types.hpp" );
-		Code ast        = scan_file( project_dir "components/ast.hpp" );
-		Code ast_types  = scan_file( project_dir "components/ast_types.hpp" );
-		Code code_types = scan_file( project_dir "components/code_types.hpp" );
-		Code interface  = scan_file( project_dir "components/interface.hpp" );
-		Code inlines 	= scan_file( project_dir "components/inlines.hpp" );
-		Code header_end = scan_file( project_dir "components/header_end.hpp" );

-		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
-		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
-		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
-		CodeBody ast_inlines = gen_ast_inlines();
-
-	#if 0
+#if 0
+#region region Print Components
 		header.print_fmt("#pragma region Types\n");
 		header.print( types );
 		header.print( fmt_newline );
@@ -434,7 +438,8 @@ int gen_main()
 		header.print( dump_to_scratch_and_retireve( especifier ));
 		header.print( fmt_newline );
 		header.print_fmt("#pragma endregion Types\n\n");
-	#endif
+#pragma endregion Print Compoennts
+#endif
 	}

 	header.print( pop_ignores );
--- a/gen_c_library/components/containers.array.hpp
+++ b/gen_c_library/components/containers.array.hpp
@@ -4,6 +4,9 @@

 using namespace gen;

+// Used to know what slot the array will be for generic selection
+global s32 ArrayDefinitionCounter = 0;
+
 CodeBody gen_array_base()
 {
 	CodeTypedef td_header = parse_typedef( code( typedef struct ArrayHeader ArrayHeader; ));
@@ -16,30 +19,35 @@ CodeBody gen_array_base()
 		};
 	));

-	// Code grow_formula = untyped_str( txt( "#define gen_array_grow_formula( value ) ( 2 * value + 8 )\n" ));
-	Code get_header   = untyped_str( txt( "#define array_get_header( Type, self ) ( (ArrayHeader*)( self ) - 1)\n" ));
+	Code grow_formula = untyped_str( txt( "#define array_grow_formula( value ) ( 2 * value + 8 )\n" ));
+	Code get_header   = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" ));

-	return def_global_body( args( fmt_newline, td_header, header, get_header, fmt_newline ) );
+	return def_global_body( args( fmt_newline, td_header, header, grow_formula, get_header, fmt_newline ) );
 };

 CodeBody gen_array( StrC type, StrC array_name )
 {
 	String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
 	String fn         = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
-	str_to_lower(fn.Data);
+	// str_to_lower(fn.Data);

 #pragma push_macro( "GEN_ASSERT" )
+#pragma push_macro( "rcast" )
+#pragma push_macro( "cast" )
 #undef GEN_ASSERT
+#undef rcast
+#undef cast
 	CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
 	, stringize(
 		typedef <type>* <array_type>;

-		<array_type> <fn>_init           ( AllocatorInfo allocator );
-		<array_type> <fn>_init_reserve   ( AllocatorInfo allocator, usize capacity );
-		bool         <fn>_append         ( <array_type>*  self, <type> value );
-		bool         <fn>_append_items   ( <array_type>*  self, <type>* items, usize item_num );
-		bool         <fn>_append_at      ( <array_type>*  self, <type> item, usize idx );
-		bool         <fn>_append_items_at( <array_type>*  self, <type>* items, usize item_num, usize idx );
+		void         <fn>_init           ( <array_type>* self, AllocatorInfo allocator );
+		void         <fn>_init_reserve   ( <array_type>* self, AllocatorInfo allocator, usize capacity );
+		bool         <fn>_append_array   ( <array_type>* self, <array_type> other );
+		bool         <fn>_append         ( <array_type>* self, <type> value );
+		bool         <fn>_append_items   ( <array_type>* self, <type>* items, usize item_num );
+		bool         <fn>_append_at      ( <array_type>* self, <type> item, usize idx );
+		bool         <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx );
 		<type>*      <fn>_back           ( <array_type>  self );
 		void         <fn>_clear          ( <array_type>  self );
 		bool         <fn>_fill		     ( <array_type>  self, usize begin, usize end, <type> value );
@@ -51,35 +59,41 @@ CodeBody gen_array( StrC type, StrC array_name )
 		bool         <fn>_resize         ( <array_type>* self, usize num );
 		bool         <fn>_set_capacity   ( <array_type>* self, usize new_capacity );

-		<array_type> <fn>_init( AllocatorInfo allocator )
+		void <fn>_init( <array_type>* self, AllocatorInfo allocator )
 		{
-			return <fn>_init_reserve( allocator, array_grow_formula( 0 ) );
+			size_t initial_size = array_grow_formula(0);
+			array_init_reserve( * self, allocator, initial_size );
 		}

-		<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
+		void <fn>_init_reserve( <array_type>* self, AllocatorInfo allocator, usize capacity )
 		{
-			ArrayHeader* header = cast(ArrayHeader*, alloc( allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity ) );
+			ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity));

-			if ( header == NULL )
-				return NULL;
+			if (header == nullptr)
+				self = nullptr;

 			header->Allocator = allocator;
 			header->Capacity  = capacity;
 			header->Num       = 0;

-			return cast( <type>*, header + 1 );
+			self = rcast(<array_type>*, header + 1);
+		}
+
+		bool <fn>_append_array( <array_type>* self, <array_type> other )
+		{
+			return array_append_items( * self, (<array_type>)other, <fn>_num(other));
 		}

 		bool <fn>_append( <array_type>* self, <type> value )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( header->Num == header->Capacity )
 			{
-				if ( ! <fn>_grow( self, header->Capacity))
+				if ( ! array_grow( self, header->Capacity))
 					return false;

-				header = get_header( * self );
+				header = array_get_header( * self );
 			}

 			(* self)[ header->Num ] = value;
@@ -90,14 +104,14 @@ CodeBody gen_array( StrC type, StrC array_name )

 		bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( header->Num + item_num > header->Capacity )
 			{
-				if ( ! <fn>_grow( self, header->Capacity + item_num ))
+				if ( ! array_grow( self, header->Capacity + item_num ))
 					return false;

-				header = get_header( * self );
+				header = array_get_header( * self );
 			}

 			mem_copy( (* self) + header->Num, items, sizeof(<type>) * item_num );
@@ -108,7 +122,7 @@ CodeBody gen_array( StrC type, StrC array_name )

 		bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( idx >= header->Num )
 				idx = header->Num - 1;
@@ -118,10 +132,10 @@ CodeBody gen_array( StrC type, StrC array_name )

 			if ( header->Capacity < header->Num + 1 )
 			{
-				if ( ! <fn>_grow( self, header->Capacity + 1 ) )
+				if ( ! array_grow( self, header->Capacity + 1 ) )
 					return false;

-				header = get_header( * self );
+				header = array_get_header( * self );
 			}

 			<array_type> target = (* self) + idx;
@@ -134,19 +148,19 @@ CodeBody gen_array( StrC type, StrC array_name )

 		bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( idx >= header->Num )
 			{
-				return <fn>_append_items( self, items, item_num );
+				return array_append_items( * self, items, item_num );
 			}

 			if ( item_num > header->Capacity )
 			{
-				if ( ! <fn>_grow( self, item_num + header->Capacity ) )
+				if ( ! array_grow( self, item_num + header->Capacity ) )
 					return false;

-				header = get_header( * self );
+				header = array_get_header( * self );
 			}

 			<type>* target = (* self) + idx + item_num;
@@ -161,7 +175,7 @@ CodeBody gen_array( StrC type, StrC array_name )

 		<type>* <fn>_back( <array_type> self )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( self );

 			if ( header->Num == 0 )
 				return NULL;
@@ -171,13 +185,13 @@ CodeBody gen_array( StrC type, StrC array_name )

 		void <fn>_clear( <array_type> self )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( self );
 			header->Num = 0;
 		}

 		bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( self );

 			if ( begin < 0 || end >= header->Num )
 				return false;
@@ -190,30 +204,30 @@ CodeBody gen_array( StrC type, StrC array_name )

 		void <fn>_free( <array_type> self )
 		{
-			ArrayHeader* header = get_header( self );
-			free( header->Allocator, header );
+			ArrayHeader* header = array_get_header( self );
+			allocator_free( header->Allocator, header );
 			self = NULL;
 		}

 		bool <fn>_grow( <array_type>* self, usize min_capacity )
 		{
-			ArrayHeader* header      = get_header( *self );
+			ArrayHeader* header      = array_get_header( *self );
 			usize       new_capacity = array_grow_formula( header->Capacity );

 			if ( new_capacity < min_capacity )
 				new_capacity = min_capacity;

-			return <fn>_set_capacity( self, new_capacity );
+			return array_set_capacity( * self, new_capacity );
 		}

 		usize <fn>_num( <array_type> self )
 		{
-			return get_header(self)->Num;
+			return array_get_header(self)->Num;
 		}

 		<type> <fn>_pop( <array_type> self )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( self );
 			GEN_ASSERT( header->Num > 0 );

 			<type> result = self[ header->Num - 1 ];
@@ -223,7 +237,7 @@ CodeBody gen_array( StrC type, StrC array_name )

 		void <fn>_remove_at( <array_type> self, usize idx )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( self );
 			GEN_ASSERT( idx < header->Num );

 			mem_move( self + idx, self + idx + 1, sizeof( <type> ) * ( header->Num - idx - 1 ) );
@@ -232,24 +246,24 @@ CodeBody gen_array( StrC type, StrC array_name )

 		bool <fn>_reserve( <array_type>* self, usize new_capacity )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( header->Capacity < new_capacity )
-				return <fn>_set_capacity( self, new_capacity );
+				return array_set_capacity( * self, new_capacity );

 			return true;
 		}

 		bool <fn>_resize( <array_type>* self, usize num )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( header->Capacity < num )
 			{
-				if ( ! <fn>_grow( self, num ) )
+				if ( ! array_grow( self, num ) )
 					return false;

-				header = get_header( * self );
+				header = array_get_header( * self );
 			}

 			header->Num = num;
@@ -258,7 +272,7 @@ CodeBody gen_array( StrC type, StrC array_name )

 		bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
 		{
-			ArrayHeader* header = get_header( * self );
+			ArrayHeader* header = array_get_header( * self );

 			if ( new_capacity == header->Capacity )
 				return true;
@@ -266,14 +280,14 @@ CodeBody gen_array( StrC type, StrC array_name )
 			if ( new_capacity < header->Num )
 				header->Num = new_capacity;

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

 			if ( new_header == NULL )
 				return false;

 			mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
-			free( header->Allocator, & header );
+			allocator_free( header->Allocator, & header );

 			new_header->Capacity = new_capacity;
 			* self = cast( <type>*, new_header + 1 );
@@ -281,10 +295,36 @@ CodeBody gen_array( StrC type, StrC array_name )
 		}
 	)));
 #pragma pop_macro( "GEN_ASSERT" )
+#pragma pop_macro( "rcast" )
+#pragma pop_macro( "cast" )
+
+	++ ArrayDefinitionCounter;
+	StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", ArrayDefinitionCounter).to_strc();
+
+	Code generic_interface_slot = untyped_str(token_fmt( "type_delimiter", (StrC)array_type, "slot", (StrC)slot_str,
+R"(#define GENERIC_SLOT_<slot>__array_init         <type_delimiter>,  <type_delimiter>_init
+#define GENERIC_SLOT_<slot>__array_init_reserve    <type_delimiter>,  <type_delimiter>_init_reserve
+#define GENERIC_SLOT_<slot>__array_append          <type_delimiter>,  <type_delimiter>_append
+#define GENERIC_SLOT_<slot>__array_append_items    <type_delimiter>,  <type_delimiter>_append_items
+#define GENERIC_SLOT_<slot>__array_append_at       <type_delimiter>,  <type_delimiter>_append_at
+#define GENERIC_SLOT_<slot>__array_append_items_at <type_delimiter>,  <type_delimiter>_append_items_at
+#define GENERIC_SLOT_<slot>__array_back            <type_delimiter>,  <type_delimiter>_back
+#define GENERIC_SLOT_<slot>__array_clear           <type_delimiter>,  <type_delimiter>_clear
+#define GENERIC_SLOT_<slot>__array_fill            <type_delimiter>,  <type_delimiter>_fill
+#define GENERIC_SLOT_<slot>__array_grow            <type_delimiter>*, <type_delimiter>_grow
+#define GENERIC_SLOT_<slot>__array_num             <type_delimiter>,  <type_delimiter>_num
+#define GENERIC_SLOT_<slot>__array_pop             <type_delimiter>,  <type_delimiter>_pop
+#define GENERIC_SLOT_<slot>__array_reserve         <type_delimiter>,  <type_delimiter>_reserve
+#define GENERIC_SLOT_<slot>__array_resize          <type_delimiter>,  <type_delimiter>_resize
+#define GENERIC_SLOT_<slot>__array_set_capacity    <type_delimiter>,  <type_delimiter>_set_capacity
+)"
+	));

 	return def_global_body( args(
 		def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", array_type ))),
 		fmt_newline,
+		generic_interface_slot,
+		fmt_newline,
 		result,
 		fmt_newline,
 		def_pragma( string_to_strc(string_fmt_buf( GlobalAllocator, "endregion %S", array_type ))),
@@ -292,4 +332,67 @@ CodeBody gen_array( StrC type, StrC array_name )
 	));
 };

-// CodeBody gen_
+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 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_array_generic_selection_function_macro(txt("array_init_reserve"), array_by_ref) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_append"), array_by_ref) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_append_items"), array_by_ref) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_back")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_clear")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_fill")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_free")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_grow")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_num")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("arary_pop")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("arary_remove_at")) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("arary_reserve"), array_by_ref) );
+	interface_defines.append( gen_array_generic_selection_function_macro(txt("array_set_capacity"), array_by_ref) );
+	return interface_defines;
+}
--- a/gen_c_library/components/containers.hashtable.hpp
+++ b/gen_c_library/components/containers.hashtable.hpp
@@ -30,10 +30,10 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )

 	String tbl_type = {(char*) hashtable_name.duplicate(GlobalAllocator).Ptr};
 	String fn       = tbl_type.duplicate(GlobalAllocator);
-	str_to_lower(fn.Data);
+	// str_to_lower(fn.Data);

 	String name_lower = String::make( GlobalAllocator, hashtable_name );
-	str_to_lower( name_lower.Data );
+	// str_to_lower( name_lower.Data );

 	String hashtable_entry   = String::fmt_buf( GlobalAllocator, "HTE_%.*s",     hashtable_name.Len, hashtable_name.Ptr );
 	String entry_array_name  = String::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
@@ -44,6 +44,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		"tbl_name",    (StrC) hashtable_name,
 		"tbl_type",    (StrC) tbl_type,
 	stringize(
+		typedef struct <tbl_type> <tbl_type>;
 		typedef struct HTE_<tbl_name> HTE_<tbl_name>;
 		struct HTE_<tbl_name>
 		{
@@ -101,8 +102,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			<tbl_type>
 			result        = { NULL, NULL };
-			result.Hashes  = array_ssize_make( allocator );
-			result.Entries = <fn_array>_make( allocator );
+			array_init(result.Hashes, allocator );
+			array_init(result.Entries, allocator );

 			return result;
 		}
@@ -111,8 +112,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			<tbl_type>
 			result         = { NULL, NULL };
-			result.Hashes  = array_ssize_make_reserve( allocator, num );
-			result.Entries = <fn_array>_make_reserve( allocator, num );
+			array_init_reserve(result.Hashes, allocator, num );
+			array_init_reserve(result.Entries, allocator, num );

 			return result;
 		}
--- a/gen_c_library/components/memory.fixed_arena.hpp
+++ b/gen_c_library/components/memory.fixed_arena.hpp
@@ -63,6 +63,7 @@ CodeBody gen_fixed_arenas()
 	result.append(arena_struct_8kb);
 	result.append(arena_struct_16kb);
 	result.append(arena_struct_32kb);
+	result.append(arena_struct_64kb);
 	result.append(arena_struct_128kb);
 	result.append(arena_struct_256kb);
 	result.append(arena_struct_512kb);
@@ -75,6 +76,7 @@ CodeBody gen_fixed_arenas()
 	result.append(arena_interface_8kb);
 	result.append(arena_interface_16kb);
 	result.append(arena_interface_32kb);
+	result.append(arena_interface_64kb);
 	result.append(arena_interface_128kb);
 	result.append(arena_interface_256kb);
 	result.append(arena_interface_512kb);
@@ -100,7 +102,7 @@ CodeBody gen_fixed_arenas()
    FixedArena_1MB*   : fixed_arena_init_1MB,   \
    FixedArena_2MB*   : fixed_arena_init_2MB,   \
    FixedArena_4MB*   : fixed_arena_init_4MB    \
-)(expr)
+) GEN_RESOLVED_FUNCTION_CALL(& expr)

 #define fixed_arena_size_remaining(expr, alignment) _Generic((expr), \
    FixedArena_1KB*   : fixed_arena_size_remaining_1KB,              \
@@ -115,7 +117,7 @@ CodeBody gen_fixed_arenas()
    FixedArena_1MB*   : fixed_arena_size_remaining_1MB,              \
    FixedArena_2MB*   : fixed_arena_size_remaining_2MB,              \
    FixedArena_4MB*   : fixed_arena_size_remaining_4MB               \
-)(expr, alignment)
+)	GEN_RESOLVED_FUNCTION_CALL(& expr, alignment)
 )"
 	)));