fixes on containers (compiles but still verifying parity with c++ templates

I'm going to have to change some c++ templates to match the init interfaces as they must not be in the return type

gen_c_library/c_library.cpp

@@ -9,7 +9,9 @@
 #include "helpers/helper.hpp"
 
 GEN_NS_BEGIN
+#include "helpers/push_container_defines.inline.hpp"
 #include "dependencies/parsing.cpp"
+#include "helpers/pop_container_defines.inline.hpp"
 GEN_NS_END
 
 #include "auxillary/builder.hpp"
@@ -118,22 +120,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" );
-
+		Code string_ops   = scan_file( project_dir "dependencies/string_ops.hpp" );
-		header.print_fmt( roll_own_dependencies_guard_start );
+		Code hashing      = scan_file( project_dir "dependencies/hashing.hpp" );
-		header.print( platform );
+		Code filesystem   = scan_file( project_dir "dependencies/filesystem.hpp" );
-		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+		Code timing       = scan_file( project_dir "dependencies/timing.hpp" );
-
-		header.print( macros );
-		header.print( basic_types );
-		header.print( debug );
 
 		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 +265,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 +295,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,9 +373,8 @@ 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;
 					}
 					strings.append(td);
@@ -400,30 +386,49 @@ int gen_main()
 				break;
 			}
 		}
-		header.print(dump_to_scratch_and_retireve(strings));
 
-		Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" );
+		CodeBody containers = def_body(CT_Global_Body);
-		Code timing = scan_file( project_dir "dependencies/timing.hpp" );
+		{
+			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" );
+#if 0
-		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+#region region Print Components
-		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
-		CodeBody ast_inlines = gen_ast_inlines();
-
-	#if 0
 		header.print_fmt("#pragma region Types\n");
 		header.print( types );
 		header.print( fmt_newline );
@@ -434,7 +439,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 );

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,70 +19,82 @@ CodeBody gen_array_base()
 		};
 	));
 
-	// Code grow_formula = untyped_str( txt( "#define gen_array_grow_formula( value ) ( 2 * value + 8 )\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( Type, self ) ( (ArrayHeader*)( self ) - 1)\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 );
+		void         <fn>_init           ( <array_type>*  self, AllocatorInfo allocator );
-		<array_type> <fn>_init_reserve   ( AllocatorInfo allocator, usize capacity );
+		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 );
+		<type>*      <fn>_back           ( <array_type>   self );
-		void         <fn>_clear          ( <array_type>  self );
+		void         <fn>_clear          ( <array_type>   self );
-		bool         <fn>_fill		     ( <array_type>  self, usize begin, usize end, <type> value );
+		bool         <fn>_fill		     ( <array_type>   self, usize begin, usize end, <type> value );
-		void         <fn>_free           ( <array_type>  self );
+		void         <fn>_free           ( <array_type>*  self );
-		bool         <fn>_grow           ( <array_type>* self, usize min_capacity );
+		bool         <fn>_grow           ( <array_type>*  self, usize min_capacity );
-		usize        <fn>_num            ( <array_type>  self );
+		usize        <fn>_num            ( <array_type>   self );
-		<type>       <fn>_pop 	         ( <array_type>  self );
+		<type>       <fn>_pop 	         ( <array_type>   self );
-		bool         <fn>_reserve        ( <array_type>* self, usize new_capacity );
+		void         <fn>_remove_at      ( <array_type>   self, usize idx );
-		bool         <fn>_resize         ( <array_type>* self, usize num );
+		bool         <fn>_reserve        ( <array_type>*  self, usize new_capacity );
-		bool         <fn>_set_capacity   ( <array_type>* self, usize new_capacity );
+		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 )
+			if (header == nullptr)
-				return NULL;
+				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 +105,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 +123,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 +133,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 +149,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 +176,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 +186,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;
@@ -188,32 +203,32 @@ CodeBody gen_array( StrC type, StrC array_name )
 			return true;
 		}
 
-		void <fn>_free( <array_type> self )
+		void <fn>_free( <array_type>* self )
 		{
-			ArrayHeader* header = get_header( self );
+			ArrayHeader* header = array_get_header( * self );
-			free( header->Allocator, header );
+			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 +238,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 +247,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 +273,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 +281,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 +296,38 @@ 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_free            <type_delimiter>,  <type_delimiter>_free
+#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_remove_at       <type_delimiter>,  <type_delimiter>_remove_at
+#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 +335,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"), array_by_ref) );
+	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("array_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")) );
+	return interface_defines;
+}

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 HashTable_<type> <tbl_type>;
 		typedef struct HTE_<tbl_name> HTE_<tbl_name>;
 		struct HTE_<tbl_name>
 		{
@@ -71,8 +72,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		"array_entry",    (StrC) entry_array_name,
 		"fn_array",       (StrC) entry_array_fn_ns,
 	stringize(
-		typedef struct <tbl_type> <tbl_type>;
+		struct HashTable_<type>
-		struct <tbl_type>
 		{
 			Array_ssize   Hashes;
 			<array_entry> Entries;
@@ -101,8 +101,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			<tbl_type>
 			result        = { NULL, NULL };
-			result.Hashes  = array_ssize_make( allocator );
+			array_init(result.Hashes, allocator );
-			result.Entries = <fn_array>_make( allocator );
+			array_init(result.Entries, allocator );
 
 			return result;
 		}
@@ -111,27 +111,27 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			<tbl_type>
 			result         = { NULL, NULL };
-			result.Hashes  = array_ssize_make_reserve( allocator, num );
+			array_init_reserve(result.Hashes, allocator, num );
-			result.Entries = <fn_array>_make_reserve( allocator, num );
+			array_init_reserve(result.Entries, allocator, num );
 
 			return result;
 		}
 
 		void <fn>_clear( <tbl_type> self )
 		{
-			for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
+			for ( ssize idx = 0; idx < array_get_header( self.Hashes )->Num; idx++ )
 				self.Hashes[idx] = -1;
 
-			array_ssize_clear( self.Hashes );
+			array_clear( self.Hashes );
-			<fn_array>_clear( self.Entries );
+			array_clear( self.Entries );
 		}
 
 		void <fn>_destroy( <tbl_type> self )
 		{
 			if ( self.Hashes && self.Entries )
 			{
-				array_ssize_free( self.Hashes );
+				array_free( self.Hashes );
-				<fn_array>_free( self.Entries );
+				array_free( self.Entries );
 			}
 		}
 
@@ -148,7 +148,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			GEN_ASSERT_NOT_NULL( map_proc );
 
-			for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
 			{
 				map_proc( self, self.Entries[idx].Key, self.Entries[idx].Value );
 			}
@@ -158,7 +158,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			GEN_ASSERT_NOT_NULL( map_proc );
 
-			for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
 			{
 				map_proc( self, self.Entries[idx].Key, & self.Entries[idx].Value );
 			}
@@ -166,7 +166,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 
 		void <fn>_grow( <tbl_type>* self )
 		{
-			ssize new_num = array_grow_formula( array_header( self->Entries )->Num );
+			ssize new_num = array_grow_formula( array_get_header( self->Entries )->Num );
 			<fn>_rehash( self, new_num );
 		}
 
@@ -175,12 +175,12 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 			ssize idx;
 			ssize last_added_index;
 
-			ArrayHeader* old_hash_header    = array_header( self->Hashes );
+			ArrayHeader* old_hash_header    = array_get_header( self->Hashes );
-			ArrayHeader* old_entries_header = array_header( self->Entries );
+			ArrayHeader* old_entries_header = array_get_header( self->Entries );
 
 			<tbl_type> new_tbl = <fn>_make_reserve( old_hash_header->Allocator, old_hash_header->Num );
 
-			ArrayHeader* new_hash_header = array_header( new_tbl.Hashes );
+			ArrayHeader* new_hash_header = array_get_header( new_tbl.Hashes );
 
 			for ( idx = 0; idx < new_hash_header->Num; idx++ )
 				new_tbl.Hashes[idx] = -1;
@@ -214,13 +214,13 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			ssize idx;
 
-			for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
 				self.Entries[ idx ].Next = -1;
 
-			for ( idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
+			for ( idx = 0; idx < array_get_header( self.Hashes )->Num; idx++ )
 				self.Hashes[ idx ] = -1;
 
-			for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
 			{
 				<entry_type>*     entry;
 				HT_FindResult find_result;
@@ -241,22 +241,22 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 
 			if ( find_result.EntryIndex >= 0 )
 			{
-				<fn_array>_remove_at( self.Entries, find_result.EntryIndex );
+				array_remove_at( self.Entries, find_result.EntryIndex );
 				<fn>_rehash_fast( self );
 			}
 		}
 
 		void <fn>_remove_entry( <tbl_type> self, ssize idx )
 		{
-			<fn_array>_remove_at( self.Entries, idx );
+			array_remove_at( self.Entries, idx );
 		}
 
 		void <fn>_set( <tbl_type>* self, u64 key, <type> value )
 		{
-			ssize            idx;
+			ssize         idx;
 			HT_FindResult find_result;
 
-			if ( array_header( self->Hashes )->Num == 0 )
+			if ( array_get_header( self->Hashes )->Num == 0 )
 				<fn>_grow( self );
 
 			find_result = <fn>__find( * self, key );
@@ -287,7 +287,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 
 		ssize <fn>_slot( <tbl_type> self, u64 key )
 		{
-			for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; ++idx )
+			for ( ssize idx = 0; idx < array_get_header( self.Hashes )->Num; ++idx )
 				if ( self.Hashes[ idx ] == key )
 					return idx;
 
@@ -299,8 +299,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 			ssize idx;
 			<entry_type> entry = { key, -1 };
 
-			idx = array_header( self.Entries )->Num;
+			idx = array_get_header( self.Entries )->Num;
-			<fn_array>_append( & self.Entries, entry );
+			array_append( self.Entries, entry );
 			return idx;
 		}
 
@@ -308,7 +308,7 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 		{
 			HT_FindResult result = { -1, -1, -1 };
 
-			ArrayHeader* hash_header = array_header( self.Hashes );
+			ArrayHeader* hash_header = array_get_header( self.Hashes );
 
 			if ( hash_header->Num > 0 )
 			{
@@ -330,8 +330,8 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 
 		b32 <fn>__full( <tbl_type> self )
 		{
-			ArrayHeader* hash_header    = array_header( self.Hashes );
+			ArrayHeader* hash_header    = array_get_header( self.Hashes );
-			ArrayHeader* entries_header = array_header( self.Entries );
+			ArrayHeader* entries_header = array_get_header( self.Entries );
 
 			return 0.75f * hash_header->Num < entries_header->Num;
 		}

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

project/bootstrap.cpp

@@ -9,7 +9,9 @@
 #include "helpers/helper.hpp"
 
 GEN_NS_BEGIN
+#include "helpers/push_container_defines.inline.hpp"
 #include "dependencies/parsing.cpp"
+#include "helpers/pop_container_defines.inline.hpp"
 GEN_NS_END
 
 #include "auxillary/builder.hpp"

project/components/interface.cpp

@@ -24,7 +24,7 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
 				if ( bucket.PhysicalStart == nullptr )
 					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
-				if ( ! array_append( & Global_AllocatorBuckets, bucket ) )
+				if ( ! array_append( Global_AllocatorBuckets, bucket ) )
 					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
 				last = array_back(Global_AllocatorBuckets);
@@ -51,7 +51,7 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
 				if ( bucket.PhysicalStart == nullptr )
 					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
-				if ( ! array_append( & Global_AllocatorBuckets, bucket ) )
+				if ( ! array_append( Global_AllocatorBuckets, bucket ) )
 					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
 				last = array_back(Global_AllocatorBuckets);
@@ -249,7 +249,7 @@ void init()
 		if ( bucket.PhysicalStart == nullptr )
 			GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
 
-		array_append( & Global_AllocatorBuckets, bucket );
+		array_append( Global_AllocatorBuckets, bucket );
 	}
 
 	// Setup the arrays
@@ -272,7 +272,7 @@ void init()
 		if ( code_pool.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the code pool" );
 
-		array_append( & CodePools, code_pool );
+		array_append( CodePools, code_pool );
 
 		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
 
@@ -281,7 +281,7 @@ void init()
 		if ( string_arena.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
 
-		array_append( & StringArenas, string_arena );
+		array_append( StringArenas, string_arena );
 	}
 
 	// Setup the hash tables
@@ -381,7 +381,7 @@ AllocatorInfo get_string_allocator( s32 str_length )
 	{
 		Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
-		if ( ! array_append( & StringArenas, new_arena ) )
+		if ( ! array_append( StringArenas, new_arena ) )
 			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
 
 		last = array_back(StringArenas);
@@ -419,7 +419,7 @@ Code make_code()
 		if ( code_pool.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
 
-		if ( ! array_append( & CodePools, code_pool ) )
+		if ( ! array_append( CodePools, code_pool ) )
 			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
 
 		allocator = array_back( CodePools);

project/components/lexer.cpp

@@ -236,7 +236,8 @@ forceinline
 s32 lex_preprocessor_directive( LexContext* ctx )
 {
 	char const* hash = ctx->scanner;
-	array_append( & Tokens, { hash, 1, Tok_Preprocess_Hash, ctx->line, ctx->column, TF_Preprocess } );
+	Token hash_tok = { hash, 1, Tok_Preprocess_Hash, ctx->line, ctx->column, TF_Preprocess };
+	array_append( Tokens, hash_tok  );
 
 	move_forward();
 	SkipWhitespace();
@@ -312,14 +313,14 @@ s32 lex_preprocessor_directive( LexContext* ctx )
 
 		ctx->token.Length = ctx->token.Length + ctx->token.Text - hash;
 		ctx->token.Text   = hash;
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		return Lex_Continue; // Skip found token, its all handled here.
 	}
 
 	if ( ctx->token.Type == Tok_Preprocess_Else || ctx->token.Type == Tok_Preprocess_EndIf )
 	{
 		ctx->token.Flags |= TF_Preprocess_Cond;
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		end_line();
 		return Lex_Continue;
 	}
@@ -328,7 +329,7 @@ s32 lex_preprocessor_directive( LexContext* ctx )
 		ctx->token.Flags |= TF_Preprocess_Cond;
 	}
 
-	array_append( & Tokens, ctx->token );
+	array_append( Tokens, ctx->token );
 
 	SkipWhitespace();
 
@@ -352,7 +353,7 @@ s32 lex_preprocessor_directive( LexContext* ctx )
 			name.Length++;
 		}
 
-		array_append( & Tokens, name );
+		array_append( Tokens, name );
 
 		u64 key = crc32( name.Text, name.Length );
 		hashtable_set(ctx->defines, key, to_str(name) );
@@ -398,7 +399,7 @@ s32 lex_preprocessor_directive( LexContext* ctx )
 			move_forward();
 		}
 
-		array_append( & Tokens, preprocess_content );
+		array_append( Tokens, preprocess_content );
 		return Lex_Continue; // Skip found token, its all handled here.
 	}
 
@@ -461,7 +462,7 @@ s32 lex_preprocessor_directive( LexContext* ctx )
 		preprocess_content.Length++;
 	}
 
-	array_append( & Tokens, preprocess_content );
+	array_append( Tokens, preprocess_content );
 	return Lex_Continue; // Skip found token, its all handled here.
 }
 
@@ -470,7 +471,7 @@ void lex_found_token( LexContext* ctx )
 {
 	if ( ctx->token.Type != Tok_Invalid )
 	{
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		return;
 	}
 
@@ -497,7 +498,7 @@ void lex_found_token( LexContext* ctx )
 		}
 
 		ctx->token.Type = type;
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		return;
 	}
 
@@ -507,7 +508,7 @@ void lex_found_token( LexContext* ctx )
 	{
 		ctx->token.Type   = type;
 		ctx->token.Flags |= TF_Specifier;
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		return;
 	}
 
@@ -515,7 +516,7 @@ void lex_found_token( LexContext* ctx )
 	if ( type != Tok_Invalid )
 	{
 		ctx->token.Type = type;
-		array_append( & Tokens, ctx->token );
+		array_append( Tokens, ctx->token );
 		return;
 	}
 
@@ -569,7 +570,7 @@ void lex_found_token( LexContext* ctx )
 		ctx->token.Type = Tok_Identifier;
 	}
 
-	array_append( & Tokens, ctx->token );
+	array_append( Tokens, ctx->token );
 }
 
 neverinline
@@ -643,7 +644,7 @@ TokArray lex( StrC content )
 				c.token.Type = Tok_NewLine;
 				c.token.Length++;
 
-				array_append( & Tokens, c.token );
+				array_append( Tokens, c.token );
 				continue;
 			}
 		}
@@ -679,7 +680,7 @@ TokArray lex( StrC content )
 								c.token.Length++;
 								move_forward();
 
-								array_append( & Tokens, c.token );
+								array_append( Tokens, c.token );
 							}
 						}
 
@@ -1134,7 +1135,7 @@ TokArray lex( StrC content )
 							move_forward();
 							c.token.Length++;
 						}
-						array_append( & Tokens, c.token );
+						array_append( Tokens, c.token );
 						continue;
 					}
 					else if ( current == '*' )
@@ -1170,7 +1171,7 @@ TokArray lex( StrC content )
 							move_forward();
 							c.token.Length++;
 						}
-						array_append( & Tokens, c.token );
+						array_append( Tokens, c.token );
 						// end_line();
 						continue;
 					}
@@ -1303,7 +1304,7 @@ TokArray lex( StrC content )
 					c.token.Length++;
 					move_forward();
 
-					array_append( & Tokens, c.token );
+					array_append( Tokens, c.token );
 					continue;
 				}
 			}

project/components/parser.cpp

@@ -755,7 +755,7 @@ Code parse_class_struct( TokType which, bool inplace_def = false )
 			}
 			Token interface_tok = parse_identifier();
 
-			array_append( & interfaces, def_type( to_str(interface_tok) ) );
+			array_append( interfaces, def_type( to_str(interface_tok) ) );
 			// <ModuleFlags> <class/struct> <Attributes> <Name> : <Access Specifier> <Name>, ...
 		}
 	}

project/dependencies/containers.hpp

@@ -39,10 +39,10 @@ usize array_grow_formula(ssize value);
 template<class Type> Array<Type>  array_init           (AllocatorInfo allocator);
 template<class Type> Array<Type>  array_init_reserve   (AllocatorInfo allocator, ssize capacity);
 template<class Type> bool         array_append_array   (Array<Type>* array, Array<Type> other);
-template<class Type> bool         array_append_value   (Array<Type>* array, Type value);
+template<class Type> bool         array_append         (Array<Type>* array, Type value);
 template<class Type> bool         array_append_items   (Array<Type>* array, Type* items, usize item_num);
 template<class Type> bool         array_append_at      (Array<Type>* array, Type item, usize idx);
-template<class Type> bool         array_append_at_items(Array<Type>* array, Type* items, usize item_num, usize idx);
+template<class Type> bool         array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx);
 template<class Type> Type*        array_back           (Array<Type>  array);
 template<class Type> void         array_clear          (Array<Type>  array);
 template<class Type> bool         array_fill           (Array<Type>  array, usize begin, usize end, Type value);
@@ -73,11 +73,11 @@ struct Array
 	forceinline static Array  init_reserve(AllocatorInfo allocator, ssize capacity) { return GEN_NS array_init_reserve<Type>(allocator, capacity); }
 	forceinline static usize  grow_formula(ssize value)                             { return GEN_NS array_grow_formula<Type>(value); }
 
-	forceinline bool         append(Array other)                               { return GEN_NS array_append<Type>(this, other); }
+	forceinline bool         append(Array other)                               { return GEN_NS array_append_array<Type>(this, other); }
 	forceinline bool         append(Type value)                                { return GEN_NS array_append<Type>(this, value); }
-	forceinline bool         append(Type* items, usize item_num)               { return GEN_NS array_append<Type>(this, items, item_num); }
+	forceinline bool         append(Type* items, usize item_num)               { return GEN_NS array_append_items<Type>(this, items, item_num); }
 	forceinline bool         append_at(Type item, usize idx)                   { return GEN_NS array_append_at<Type>(this, item, idx); }
-	forceinline bool         append_at(Type* items, usize item_num, usize idx) { return GEN_NS array_append_at<Type>(this, items, item_num, idx); }
+	forceinline bool         append_at(Type* items, usize item_num, usize idx) { return GEN_NS array_append_items_at<Type>(this, items, item_num, idx); }
 	forceinline Type*        back()                                            { return GEN_NS array_back<Type>(* this); }
 	forceinline void         clear()                                           {        GEN_NS array_clear<Type>(* this); }
 	forceinline bool         fill(usize begin, usize end, Type value)          { return GEN_NS array_fill<Type>(* this, begin, end, value); }
@@ -150,8 +150,8 @@ usize array_grow_formula(ssize value) {
 }
 
 template<class Type> inline
-bool array_append(Array<Type>* array, Array<Type> other) {
+bool array_append_array(Array<Type>* array, Array<Type> other) {
-	return append(array, other, num(other));
+	return array_append_items(array, (Type*)other, num(other));
 }
 
 template<class Type> inline
@@ -173,7 +173,7 @@ bool array_append(Array<Type>* array, Type value)
 }
 
 template<class Type> inline
-bool array_append(Array<Type>* array, Type* items, usize item_num)
+bool array_append_items(Array<Type>* array, Type* items, usize item_num)
 {
 	ArrayHeader* header = array_get_header(array);
 
@@ -221,7 +221,7 @@ bool array_append_at(Array<Type>* array, Type item, usize idx)
 }
 
 template<class Type> inline
-bool array_append_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)
 {
 	ArrayHeader* header = get_header(array);
 
@@ -396,9 +396,9 @@ bool array_set_capacity(Array<Type>* array, usize new_capacity)
 
 #define array_init(type, allocator)                        array_init           <type>                               (allocator )
 #define array_init_reserve(type, allocator, cap)           array_init_reserve   <type>                               (allocator, cap)
-#define array_append_array(array, other)                   array_append         < get_array_underlying_type(array) > (& array, other )
+#define array_append_array(array, other)                   array_append_array   < get_array_underlying_type(array) > (& array, other )
-#define array_append_value(array, value)                   array_append         < get_array_underlying_type(array) > (& array, value )
+#define array_append(array, value)                         array_append         < get_array_underlying_type(array) > (& array, value )
-#define array_append_items(array, items, item_num)         array_append         < get_array_underlying_type(array) > (& array, items, item_num )
+#define array_append_items(array, items, item_num)         array_append_items   < get_array_underlying_type(array) > (& array, items, item_num )
 #define array_append_at(array, item, idx )                 array_append_at      < get_array_underlying_type(array) > (& array, item, idx )
 #define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
 #define array_back(array)                                  array_back           < get_array_underlying_type(array) > (array )
@@ -680,7 +680,7 @@ ssize hashtable_add_entry(HashTable<Type>* table, u64 key) {
 	HashTableEntry<Type> entry = { key, -1 };
 
 	idx = array_num(table->Entries);
-	array_append( & table->Entries, entry);
+	array_append( table->Entries, entry);
 	return idx;
 }
 

project/dependencies/macros.hpp

@@ -89,6 +89,10 @@
 #endif
 
 #ifndef num_args_impl
+
+// This is essentially an arg couneter version of GEN_SELECT_ARG macros
+// See section : _Generic function overloading for that usage (explains this heavier case)
+
 #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,  \
@@ -265,4 +269,98 @@
     #define struct_init(type, value) {value}
 #endif
 
+// ------------------------ _Generic function overloading -----------------------------------------
+#if GEN_COMPILER_C
+// 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 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.
+
+#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.
+#define GEN_SELECT_ARG_3( _1, _2, _3, ... ) _3 // etc.. (by induction until _8, which we don't support any more beyond)
+// #define GEN_SELECT_ARG_4( _1, _2, _3, _4, ... ) _4
+// #define GEN_SELECT_ARG_5( _1, _2, _3, _4, _5, ... ) _5
+// #define GEN_SELECT_ARG_6( _1, _2, _3, _4, _5, _6, ... ) _6
+// #define GEN_SELECT_ARG_7( _1, _2, _3, _4, _5, _6, _7, ... ) _7
+// #define GEN_SELECT_ARG_8( _1, _2, _3, _4, _5, _6, _7, _8, ... ) _8
+
+#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> ,
+#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, , )
+//       ^Selects the comma                               ^ is the type                             ^ is the function                                    ^ comma delimiter to select                ^ Insert a comma
+// 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.
+#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.
+// ----------------------------------------------------------------------------------------------------------------------------------
+
+// Below are generated on demand for a generated function
+// ----------------------------------------------------------------------------------------------------------------------------------
+#define GEN_FUNCTION_GENERIC_EXAMPLE( function_arguments ) _Generic(   \
+(function_arguments), /* 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 )     \
+  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_RESOLVED_FUNCTION_CALL( function_arguments )
+// ----------------------------------------------------------------------------------------------------------------------------------
+
+// Then each definiton of a function has an associated define:
+// #define <function_id_macro> GEN_GENERIC_FUNCTION_ARG_SIGNATURE( <function_id>, <arguments> )
+#define GEN_GENERIC_FUNCTION_ARG_SIGNATURE( name_of_function, type_delimiter ) type_delimiter name_of_function
+
+// Then somehwere later on
+// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
+
+// Concrete example:
+#define ENABLE_GENERIC_EXAMPLE 0
+#if ENABLE_GENERIC_EXAMPLE
+
+// To add support for long:
+#define HASH__ARGS_SIG_1 GEN_GENERIC_FUNCTION_ARG_SIGNATURE( hash__P_long, long long )
+size_t hash__P_long    ( long val ) { return val * 2654435761ull; }
+
+// To add support for long long:
+#define 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; }
+
+// 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.
+#define hash( function_arguments ) _Generic(                      \
+(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_LAST( HASH__ARGS_SIG_8 ) \
+) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
+
+#endif // ENABLE_GENERIC_EXAMPLE
+
+// END OF ------------------------ _Generic function overloading ----------------------------------------- END OF
+#endif
+
 #pragma endregion Macros

project/dependencies/parsing.cpp

@@ -1,5 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
+#	include "parsing.hpp"
 #endif
 
 #pragma region ADT
@@ -42,7 +43,7 @@ u8 adt_destroy_branch( ADT_Node* node )
 			adt_destroy_branch( node->nodes + i );
 		}
 
-		array_free(& node->nodes);
+		array_free(node->nodes);
 	}
 	return 0;
 }
@@ -288,7 +289,7 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index )
 
 	ADT_Node o = { 0 };
 	o.parent   = parent;
-	if ( ! array_append_at( & parent->nodes, o, index ) )
+	if ( ! array_append_at( parent->nodes, o, index ) )
 		return NULL;
 
 	ADT_Node* node = & parent->nodes[index];
@@ -955,7 +956,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			adt_append_arr( root, NULL );
 		}
 
-		array_append( & root->nodes[ columnIndex ].nodes, rowItem );
+		array_append( root->nodes[ columnIndex ].nodes, rowItem );
 
 		if ( delimiter == delim )
 		{

project/gen.cpp

@@ -13,43 +13,7 @@
 // They are undefined in gen.hpp and gen.cpp at the end of the files.
 // We cpp library expects the user to use the regular calls as they can resolve the type fine.
 
-#define array_init(type, allocator)                        array_init           <type>                               (allocator )
+#include "helpers/push_container_defines.inline.hpp"
-#define array_init_reserve(type, allocator, cap)           array_init_reserve   <type>                               (allocator, cap)
-#define array_append_array(array, other)                   array_append         < get_array_underlying_type(array) > (& array, other )
-#define array_append_value(array, value)                   array_append         < get_array_underlying_type(array) > (& array, value )
-#define array_append_items(array, items, item_num)         array_append         < get_array_underlying_type(array) > (& array, items, item_num )
-#define array_append_at(array, item, idx )                 array_append_at      < get_array_underlying_type(array) > (& array, item, idx )
-#define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
-#define array_back(array)                                  array_back           < get_array_underlying_type(array) > (array )
-#define array_clear(array)                                 array_clear          < get_array_underlying_type(array) > (array )
-#define array_fill(array, begin, end, value)               array_fill           < get_array_underlying_type(array) > (array, begin, end, value )
-#define array_free(array)                                  array_free           < get_array_underlying_type(array) > (& array )
-#define arary_grow(array, min_capacity)                    arary_grow           < get_array_underlying_type(array) > (& array, min_capacity)
-#define array_num(array)                                   array_num            < get_array_underlying_type(array) > (array )
-#define arary_pop(array)                                   arary_pop            < get_array_underlying_type(array) > (array )
-#define arary_remove_at(array, idx)                        arary_remove_at      < get_array_underlying_type(array) > (idx)
-#define arary_reserve(array, new_capacity)                 arary_reserve        < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_resize(array, num)                           arary_resize         < get_array_underlying_type(array) > (& array, num)
-#define arary_set_capacity(new_capacity)                   arary_set_capacity   < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_get_header(array)                            arary_get_header     < get_array_underlying_type(array) > (array )
-
-#define hashtable_init(type, allocator)              hashtable_init        <type              >(allocator)
-#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type              >(allocator, num)
-#define hashtable_clear(table)                       hashtable_clear       < get_hashtable_underlying_type(table) >(table)
-#define hashtable_destroy(table)                     hashtable_destroy     < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_get(table, key)                    hashtable_get         < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_grow(table)                        hashtable_grow        < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_rehash(table, new_num)             hashtable_rehash      < get_hashtable_underlying_type(table) >(& table, new_num)
-#define hashtable_rehash_fast(table)                 hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
-#define hashtable_remove(table, key)                 hashtable_remove      < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_remove_entry(table, idx)           hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
-#define hashtable_set(table, key, value)             hashtable_set         < get_hashtable_underlying_type(table) >(& table, key, value)
-#define hashtable_slot(table, key)                   hashtable_slot        < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_add_entry(table, key)              hashtable_add_entry   < get_hashtable_underlying_type(table) >(& table, key)
-#define hashtable_find(table, key)                   hashtable_find        < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_full(table)                        hashtable_full        < get_hashtable_underlying_type(table) >(table)
-#define hashtable_map(table, map_proc)               hashtable_map         < get_hashtable_underlying_type(table) >(table, map_proc)
-#define hashtable_map_mut(table, map_proc)           hashtable_map_mut     < get_hashtable_underlying_type(table) >(table, map_proc)
 
 //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
 //! Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
@@ -75,42 +39,5 @@ GEN_NS_BEGIN
 
 GEN_NS_END
 
+#include "helpers/pop_container_defines.inline.hpp"
 #include "helpers/pop_ignores.inline.hpp"
-
-#undef array_init
-#undef array_init_reserve
-#undef array_append_array
-#undef array_append_value
-#undef array_append_items
-#undef array_append_at
-#undef array_append_at
-#undef array_back
-#undef array_clear
-#undef array_fill
-#undef array_free
-#undef arary_grow
-#undef array_num
-#undef arary_pop
-#undef arary_remove_at
-#undef arary_reserve
-#undef arary_resize
-#undef arary_set_capacity
-#undef arary_get_header
-
-#undef hashtable_init
-#undef hashtable_init_reserve
-#undef hashtable_clear
-#undef hashtable_destroy
-#undef hashtable_get
-#undef hashtable_grow
-#undef hashtable_rehash
-#undef hashtable_rehash_fast
-#undef hashtable_remove
-#undef hashtable_remove_entry
-#undef hashtable_set
-#undef hashtable_slot
-#undef hashtable_add_entry
-#undef hashtable_find
-#undef hashtable_full
-#undef hashtable_map
-#undef hashtable_map_mut

project/gen.hpp

@@ -11,6 +11,9 @@
 #include "helpers/push_ignores.inline.hpp"
 #include "components/header_start.hpp"
 
+// Has container defines pushed
+#include "gen.dep.hpp"
+
 GEN_NS_BEGIN
 
 #include "components/types.hpp"
@@ -30,42 +33,5 @@ GEN_NS_BEGIN
 
 GEN_NS_END
 
+#include "helpers/pop_container_defines.inline.hpp"
 #include "helpers/pop_ignores.inline.hpp"
-
-#undef array_init
-#undef array_init_reserve
-#undef array_append_array
-#undef array_append_value
-#undef array_append_items
-#undef array_append_at
-#undef array_append_at
-#undef array_back
-#undef array_clear
-#undef array_fill
-#undef array_free
-#undef arary_grow
-#undef array_num
-#undef arary_pop
-#undef arary_remove_at
-#undef arary_reserve
-#undef arary_resize
-#undef arary_set_capacity
-#undef arary_get_header
-
-#undef hashtable_init
-#undef hashtable_init_reserve
-#undef hashtable_clear
-#undef hashtable_destroy
-#undef hashtable_get
-#undef hashtable_grow
-#undef hashtable_rehash
-#undef hashtable_rehash_fast
-#undef hashtable_remove
-#undef hashtable_remove_entry
-#undef hashtable_set
-#undef hashtable_slot
-#undef hashtable_add_entry
-#undef hashtable_find
-#undef hashtable_full
-#undef hashtable_map
-#undef hashtable_map_mut

project/helpers/pop_container_defines.inline.hpp

@@ -0,0 +1,38 @@
+
+#undef array_init
+#undef array_init_reserve
+#undef array_append_array
+#undef array_append
+#undef array_append_items
+#undef array_append_at
+#undef array_append_items_at
+#undef array_back
+#undef array_clear
+#undef array_fill
+#undef array_free
+#undef arary_grow
+#undef array_num
+#undef arary_pop
+#undef arary_remove_at
+#undef arary_reserve
+#undef arary_resize
+#undef arary_set_capacity
+#undef arary_get_header
+
+#undef hashtable_init
+#undef hashtable_init_reserve
+#undef hashtable_clear
+#undef hashtable_destroy
+#undef hashtable_get
+#undef hashtable_grow
+#undef hashtable_rehash
+#undef hashtable_rehash_fast
+#undef hashtable_remove
+#undef hashtable_remove_entry
+#undef hashtable_set
+#undef hashtable_slot
+#undef hashtable_add_entry
+#undef hashtable_find
+#undef hashtable_full
+#undef hashtable_map
+#undef hashtable_map_mut

project/helpers/push_container_defines.inline.hpp

@@ -1,8 +1,9 @@
+
 #define array_init(type, allocator)                        array_init           <type>                               (allocator )
 #define array_init_reserve(type, allocator, cap)           array_init_reserve   <type>                               (allocator, cap)
-#define array_append_array(array, other)                   array_append         < get_array_underlying_type(array) > (& array, other )
+#define array_append_array(array, other)                   array_append_array   < get_array_underlying_type(array) > (& array, other )
-#define array_append_value(array, value)                   array_append         < get_array_underlying_type(array) > (& array, value )
+#define array_append(array, value)                         array_append         < get_array_underlying_type(array) > (& array, value )
-#define array_append_items(array, items, item_num)         array_append         < get_array_underlying_type(array) > (& array, items, item_num )
+#define array_append_items(array, items, item_num)         array_append_items   < get_array_underlying_type(array) > (& array, items, item_num )
 #define array_append_at(array, item, idx )                 array_append_at      < get_array_underlying_type(array) > (& array, item, idx )
 #define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
 #define array_back(array)                                  array_back           < get_array_underlying_type(array) > (array )
@@ -17,3 +18,21 @@
 #define arary_resize(array, num)                           arary_resize         < get_array_underlying_type(array) > (& array, num)
 #define arary_set_capacity(new_capacity)                   arary_set_capacity   < get_array_underlying_type(array) > (& array, new_capacity )
 #define arary_get_header(array)                            arary_get_header     < get_array_underlying_type(array) > (array )
+
+#define hashtable_init(type, allocator)              hashtable_init        <type              >(allocator)
+#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type              >(allocator, num)
+#define hashtable_clear(table)                       hashtable_clear       < get_hashtable_underlying_type(table) >(table)
+#define hashtable_destroy(table)                     hashtable_destroy     < get_hashtable_underlying_type(table) >(& table)
+#define hashtable_get(table, key)                    hashtable_get         < get_hashtable_underlying_type(table) >(table, key)
+#define hashtable_grow(table)                        hashtable_grow        < get_hashtable_underlying_type(table) >(& table)
+#define hashtable_rehash(table, new_num)             hashtable_rehash      < get_hashtable_underlying_type(table) >(& table, new_num)
+#define hashtable_rehash_fast(table)                 hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
+#define hashtable_remove(table, key)                 hashtable_remove      < get_hashtable_underlying_type(table) >(table, key)
+#define hashtable_remove_entry(table, idx)           hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
+#define hashtable_set(table, key, value)             hashtable_set         < get_hashtable_underlying_type(table) >(& table, key, value)
+#define hashtable_slot(table, key)                   hashtable_slot        < get_hashtable_underlying_type(table) >(table, key)
+#define hashtable_add_entry(table, key)              hashtable_add_entry   < get_hashtable_underlying_type(table) >(& table, key)
+#define hashtable_find(table, key)                   hashtable_find        < get_hashtable_underlying_type(table) >(table, key)
+#define hashtable_full(table)                        hashtable_full        < get_hashtable_underlying_type(table) >(table)
+#define hashtable_map(table, map_proc)               hashtable_map         < get_hashtable_underlying_type(table) >(table, map_proc)
+#define hashtable_map_mut(table, map_proc)           hashtable_map_mut     < get_hashtable_underlying_type(table) >(table, map_proc)

scripts/build.ci.ps1

@@ -237,6 +237,7 @@ if ( $c_library )
 	} elseif ($vendor -eq "msvc") {
 		$compiler_args += "/TC"       # Compile as C
 		$compiler_args += "/Zc:__cplusplus" # Fix __cplusplus macro
+		$compiler_args += "/std:c11"
 	}
 
 	build-simple $path_build $includes $compiler_args $linker_args $unit $executable