Updated c_library generation to support latest changes with context struct (also prepped for static/dynamic linkage)

Resolved https://github.com/Ed94/gencpp/issues/56

base/Readme.md

@@ -148,9 +148,9 @@ The convention you'll see used throughout the upfront interface of the library i
 1. Check name or parameters to make sure they are valid for the construction requested
 2. Create a code object using `make_code`.
 3. Populate immediate fields (Name, Type, ModuleFlags, etc)
-4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected).
+4. Populate sub-entires using `add_entry`. If using the default serialization function `to_strbuilder`, follow the order at which entires are expected to appear (there is a strong ordering expected).
 
-Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.
+Names or Content fields are interned strings and thus showed be cached using `cache_str` if its desired to preserve that behavior.
 
 `def_operator` is the most sophisticated upfront constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
 

base/auxillary/builder.cpp

@@ -15,7 +15,7 @@ Builder builder_open( char const* path )
 		return result;
 	}
 
-	result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+	result.Buffer = strbuilder_make_reserve( _ctx->Allocator_Temp, _ctx->InitSize_BuilderBuffer );
 
 	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
 	return result;
@@ -23,15 +23,15 @@ Builder builder_open( char const* path )
 
 void builder_pad_lines( Builder* builder, s32 num )
 {
-	string_append_strc( & builder->Buffer, txt("\n") );
+	strbuilder_append_str( & builder->Buffer, txt("\n") );
 }
 
 void builder_print( Builder* builder, Code code )
 {
-	String   str = code_to_string(code);
+	StrBuilder   str = code_to_strbuilder(code);
 	// const ssize len = str.length();
 	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
-	string_append_string( & builder->Buffer, str );
+	strbuilder_append_string( & builder->Buffer, str );
 }
 
 void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
@@ -39,21 +39,21 @@ void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
 	ssize   res;
 	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
 
-	res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+	res = c_str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
 
-	string_append_c_str_len( (String*) & (builder->Buffer), (char const*)buf, res);
+	strbuilder_append_c_str_len( (StrBuilder*) & (builder->Buffer), (char const*)buf, res);
 }
 
 void builder_write(Builder* builder)
 {
-	b32 result = file_write( & builder->File, builder->Buffer, string_length(builder->Buffer) );
+	b32 result = file_write( & builder->File, builder->Buffer, strbuilder_length(builder->Buffer) );
 
 	if ( result == false )
 		log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) );
 
 	log_fmt( "Generated: %s\n", builder->File.filename );
 	file_close( & builder->File );
-	string_free(& builder->Buffer);
+	strbuilder_free(& builder->Buffer);
 }
 
 #pragma endregion Builder

base/auxillary/builder.hpp

@@ -36,7 +36,7 @@ void builder_write( Builder* builder );
 struct Builder
 {
 	FileInfo File;
-	String   Buffer;
+	StrBuilder   Buffer;
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
 	forceinline static Builder open( char const* path ) { return builder_open(path); }

base/auxillary/gen_template.hpp

@@ -32,4 +32,4 @@ CodeFn       gen_func_template( CodeTemplate template, ...  );
 Code         gen_class_struct_template( CodeTemplate template, ... );
 
 Code gen_template( CodeTemplate template, ... );
-Code gen_template( StrC template, StrC instantiation );
+Code gen_template( Str template, Str instantiation );

base/auxillary/scanner.cpp

@@ -20,9 +20,9 @@ Code scan_file( char const* path )
 		GEN_FATAL("scan_file: %s is empty", path );
 	}
 
-	String str = string_make_reserve( GlobalAllocator, fsize );
+	StrBuilder str = strbuilder_make_reserve( _ctx->Allocator_Temp, fsize );
 		file_read( & file, str, fsize );
-		string_get_header(str)->Length = fsize;
+		strbuilder_get_header(str)->Length = fsize;
 
 	// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
 	// Its designed so that the directive should be the first thing in the file.
@@ -31,9 +31,9 @@ Code scan_file( char const* path )
 	#define current (*scanner)
 	#define matched    0
 	#define move_fwd() do { ++ scanner; -- left; } while (0)
-		const StrC directive_start = txt( "ifdef" );
+		const Str directive_start = txt( "ifdef" );
-		const StrC directive_end   = txt( "endif" );
+		const Str directive_end   = txt( "endif" );
-		const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
+		const Str def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
 
 		bool        found_directive = false;
 		char const* scanner         = (char const*)str;
@@ -49,7 +49,7 @@ Code scan_file( char const* path )
 
 				if ( ! found_directive )
 				{
-					if ( left && str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched )
+					if ( left && c_str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched )
 					{
 						scanner += directive_start.Len;
 						left    -= directive_start.Len;
@@ -57,7 +57,7 @@ Code scan_file( char const* path )
 						while ( left && char_is_space( current ) )
 							move_fwd();
 
-						if ( left && str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
+						if ( left && c_str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
 						{
 							scanner += def_intellisense.Len;
 							left    -= def_intellisense.Len;
@@ -77,7 +77,7 @@ Code scan_file( char const* path )
 					continue;
 				}
 
-				if ( left && str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched )
+				if ( left && c_str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched )
 				{
 					scanner += directive_end.Len;
 					left    -= directive_end.Len;
@@ -94,12 +94,12 @@ Code scan_file( char const* path )
 					if ( (scanner + 2) >= ( (char const*) str + fsize ) )
 					{
 						mem_move( str, scanner, left );
-						string_get_header(str)->Length = left;
+						strbuilder_get_header(str)->Length = left;
 						break;
 					}
 
 					mem_move( str, scanner, left );
-					string_get_header(str)->Length = left;
+					strbuilder_get_header(str)->Length = left;
 
 					break;
 				}
@@ -113,12 +113,12 @@ Code scan_file( char const* path )
 	}
 
 	file_close( & file );
-	return untyped_str( string_to_strc(str) );
+	return untyped_str( strbuilder_to_str(str) );
 }
 
 CodeBody parse_file( const char* path ) {
-	FileContents file    = file_read_contents( GlobalAllocator, true, path );
+	FileContents file    = file_read_contents( _ctx->Allocator_Temp, true, path );
-	StrC         content = { file.size, (char const*)file.data };
+	Str          content = { (char const*)file.data, file.size };
 	CodeBody     code    = parse_global_body( content );
 	log_fmt("\nParsed: %s\n", path);
 	return code;

base/base.cpp

@@ -27,7 +27,8 @@ constexpr char const* generation_notice =
 
 int gen_main()
 {
-	gen::init();
+	gen::Context ctx {};
+	gen::init( & ctx);
 
 	CodeBody gen_component_header = def_global_body( args(
 		def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
@@ -35,12 +36,13 @@ int gen_main()
 		def_include(txt("components/types.hpp")),
 		preprocess_endif,
 		fmt_newline,
-		untyped_str( to_strc_from_c_str(generation_notice) )
+		untyped_str( to_str_from_c_str(generation_notice) )
 	));
 
 	CodeBody ecode       = gen_ecode     ( "enums/ECodeTypes.csv" );
 	CodeBody eoperator   = gen_eoperator ( "enums/EOperator.csv" );
 	CodeBody especifier  = gen_especifier( "enums/ESpecifier.csv" );
+	CodeBody etoktype    = gen_etoktype  ( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
 	CodeBody ast_inlines = gen_ast_inlines();
 
 	Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" );
@@ -57,12 +59,17 @@ int gen_main()
 	builder_print( & header_especifier, gen_component_header );
 	builder_print( & header_especifier, format(especifier) );
 	builder_write( & header_especifier);
+	
+	Builder header_etoktype = builder_open( "components/gen/etoktype.hpp" );
+	builder_print( & header_etoktype, gen_component_header );
+	builder_print( & header_etoktype, format(etoktype) );
+	builder_write( & header_etoktype);
 
 	Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
 	builder_print( & header_ast_inlines, gen_component_header );
 	builder_print( & header_ast_inlines, format(ast_inlines) );
 	builder_write( & header_ast_inlines);
 
-	gen::deinit();
+	gen::deinit(& ctx);
 	return 0;
 }

base/components/ast.hpp

@@ -230,40 +230,25 @@ struct CodeUsing;
 struct CodeVar;
 #endif
 
-GEN_NS_PARSER_BEGIN
-
-struct Token;
-
-GEN_NS_PARSER_END
-
-#if GEN_COMPILER_CPP
-// Note(Ed): This is to alleviate an edge case with parsing usings or typedefs where I don't really have it setup
-// to parse a 'namespace' macro or a type with a macro.
-// I have ideas for ways to pack that into the typedef/using ast, but for now just keeping it like this
-#define ParserTokenType GEN_NS_PARSER Token
-typedef ParserTokenType Token;
-#undef ParserTokenType
-#endif
-
 #if GEN_COMPILER_CPP
 template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
 #endif
 
 #pragma region Code C-Interface
 
-void   code_append       (Code code, Code other );
+GEN_API void       code_append           (Code code, Code other );
-StrC   code_debug_str    (Code code);
+GEN_API Str        code_debug_str        (Code code);
-Code   code_duplicate    (Code code);
+GEN_API Code       code_duplicate        (Code code);
-Code*  code_entry        (Code code, u32 idx );
+GEN_API Code*      code_entry            (Code code, u32 idx );
-bool   code_has_entries  (Code code);
+GEN_API bool       code_has_entries      (Code code);
-bool   code_is_body      (Code code);
+GEN_API bool       code_is_body          (Code code);
-bool   code_is_equal     (Code code, Code other);
+GEN_API bool       code_is_equal         (Code code, Code other);
-bool   code_is_valid     (Code code);
+GEN_API bool       code_is_valid         (Code code);
-void   code_set_global   (Code code);
+GEN_API void       code_set_global       (Code code);
-String code_to_string    (Code self );
+GEN_API StrBuilder code_to_strbuilder    (Code self );
-void   code_to_string_ptr(Code self, String* result );
+GEN_API void       code_to_strbuilder_ptr(Code self, StrBuilder* result );
-StrC   code_type_str     (Code self );
+GEN_API Str        code_type_str         (Code self );
-bool   code_validate_body(Code self );
+GEN_API bool       code_validate_body    (Code self );
 
 #pragma endregion Code C-Interface
 
@@ -278,7 +263,7 @@ struct Code
 	AST* ast;
 
 #	define Using_Code( Typename )                                                        \
-	forceinline StrC debug_str()                { return code_debug_str(* this); }       \
+	forceinline Str  debug_str()                { return code_debug_str(* this); }       \
 	forceinline Code duplicate()                { return code_duplicate(* this); }	     \
 	forceinline bool is_equal( Code other )     { return code_is_equal(* this, other); } \
 	forceinline bool is_body()                  { return code_is_body(* this); }         \
@@ -295,16 +280,17 @@ struct Code
 
 #if ! GEN_C_LIKE_CPP
 	Using_Code( Code );
-	forceinline void   append(Code other)        { return code_append(* this, other); }
+	forceinline void       append(Code other)                { return code_append(* this, other); }
-	forceinline Code*  entry(u32 idx)            { return code_entry(* this, idx); }
+	forceinline Code*      entry(u32 idx)                    { return code_entry(* this, idx); }
-	forceinline bool   has_entries()             { return code_has_entries(* this); }
+	forceinline bool       has_entries()                     { return code_has_entries(* this); }
-	forceinline String to_string()               { return code_to_string(* this); }
+	forceinline StrBuilder to_strbuilder()                   { return code_to_strbuilder(* this); }
-	forceinline void   to_string(String& result) { return code_to_string_ptr(* this, & result); }
+	forceinline void       to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
-	forceinline StrC   type_str()                { return code_type_str(* this); }
+	forceinline Str        type_str()                        { return code_type_str(* this); }
-	forceinline bool   validate_body()           { return code_validate_body(*this); }
+	forceinline bool       validate_body()                   { return code_validate_body(*this); }
 #endif
 
 	Using_CodeOps( Code );
+	forceinline Code operator *() { return * this; } // Required to support for-range iteration.
 	forceinline AST* operator ->() { return ast; }
 
 	Code& operator ++();
@@ -367,7 +353,7 @@ int AST_ArrSpecs_Cap =
 (
 	AST_POD_Size
 	- sizeof(Code)
-	- sizeof(StringCached)
+	- sizeof(StrCached)
 	- sizeof(Code) * 2
 	- sizeof(Token*)
 	- sizeof(Code)
@@ -413,13 +399,13 @@ struct AST
 				Code  PostNameMacro;    // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
 			};
 		};
-		StringCached  Content;          // Attributes, Comment, Execution, Include
+		StrCached  Content;          // Attributes, Comment, Execution, Include
 		struct {
 			Specifier  ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
 			Code       NextSpecs;              // Specifiers; If ArrSpecs is full, then NextSpecs is used.
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	union {
 		Code Prev;
 		Code Front;

base/components/ast_types.hpp

@@ -31,7 +31,7 @@ struct AST_Body
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Front;
 	Code              Back;
 	Token*            Tok;
@@ -46,9 +46,9 @@ struct AST_Attributes
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -64,7 +64,7 @@ struct AST_BaseClass
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -79,9 +79,9 @@ struct AST_Comment
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -106,7 +106,7 @@ struct AST_Class
 			char 	        _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached            Name;
+	StrCached            Name;
 	CodeTypename            Prev;
 	CodeTypename            Next;
 	Token*                  Tok;
@@ -132,7 +132,7 @@ struct AST_Constructor
 			char 		   _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -146,9 +146,9 @@ struct AST_Define
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -172,7 +172,7 @@ struct AST_Destructor
 			char 		   _PAD_PROPERTIES_3_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -197,7 +197,7 @@ struct AST_Enum
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -212,9 +212,9 @@ struct AST_Exec
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -230,7 +230,7 @@ struct AST_Expr
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -245,7 +245,7 @@ struct AST_Expr_Assign
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -260,7 +260,7 @@ struct AST_Expr_Alignof
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -275,7 +275,7 @@ struct AST_Expr_Binary
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -290,7 +290,7 @@ struct AST_Expr_CStyleCast
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -305,7 +305,7 @@ struct AST_Expr_FunctionalCast
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -320,7 +320,7 @@ struct AST_Expr_CppCast
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -335,7 +335,7 @@ struct AST_Expr_ProcCall
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -350,7 +350,7 @@ struct AST_Expr_Decltype
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -365,7 +365,7 @@ struct AST_Expr_Comma
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -380,7 +380,7 @@ struct AST_Expr_AMS
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -395,7 +395,7 @@ struct AST_Expr_Sizeof
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -410,7 +410,7 @@ struct AST_Expr_Subscript
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -425,7 +425,7 @@ struct AST_Expr_Ternary
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -440,7 +440,7 @@ struct AST_Expr_UnaryPrefix
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -455,7 +455,7 @@ struct AST_Expr_UnaryPostfix
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -470,7 +470,7 @@ struct AST_Expr_Element
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -492,7 +492,7 @@ struct AST_Extern
 			char      _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -506,9 +506,9 @@ struct AST_Include
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -530,7 +530,7 @@ struct AST_Friend
 			char 	    _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -555,7 +555,7 @@ struct AST_Fn
 			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached            Name;
+	StrCached            Name;
 	Code                    Prev;
 	Code                    Next;
 	Token*                  Tok;
@@ -571,7 +571,7 @@ struct AST_Module
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -592,7 +592,7 @@ struct AST_NS
 			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -618,7 +618,7 @@ struct AST_Operator
 			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached   Name;
+	StrCached   Name;
 	Code           Prev;
 	Code           Next;
 	Token*         Tok;
@@ -644,7 +644,7 @@ struct AST_OpCast
 			char 	        _PAD_PROPERTIES_3_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -668,7 +668,7 @@ struct AST_Params
 			// char     _PAD_PROPERTIES_3_[sizeof( AST* )];
 		};
 	};
-	StringCached      Name;
+	StrCached      Name;
 	CodeParams        Last;
 	CodeParams        Next;
 	Token*            Tok;
@@ -683,9 +683,9 @@ struct AST_Pragma
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -699,9 +699,9 @@ struct AST_PreprocessCond
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
+	StrCached      Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -714,7 +714,7 @@ static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_Preprocess
 struct AST_Specifiers
 {
 	Specifier         ArrSpecs[ AST_ArrSpecs_Cap ];
-	StringCached      Name;
+	StrCached      Name;
 	CodeSpecifiers    NextSpecs;
 	Code              Prev;
 	Code              Next;
@@ -732,7 +732,7 @@ struct AST_Stmt
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -747,7 +747,7 @@ struct AST_Stmt_Break
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -762,7 +762,7 @@ struct AST_Stmt_Case
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -777,7 +777,7 @@ struct AST_Stmt_Continue
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -792,7 +792,7 @@ struct AST_Stmt_Decl
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -807,7 +807,7 @@ struct AST_Stmt_Do
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -822,7 +822,7 @@ struct AST_Stmt_Expr
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -837,7 +837,7 @@ struct AST_Stmt_Else
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -852,7 +852,7 @@ struct AST_Stmt_If
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -867,7 +867,7 @@ struct AST_Stmt_For
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -882,7 +882,7 @@ struct AST_Stmt_Goto
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -897,7 +897,7 @@ struct AST_Stmt_Label
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -912,7 +912,7 @@ struct AST_Stmt_Switch
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -927,7 +927,7 @@ struct AST_Stmt_While
 	union {
 		char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached   Name;
+	StrCached   Name;
 	CodeExpr       Prev;
 	CodeExpr       Next;
 	Token*         Tok;
@@ -953,7 +953,7 @@ struct AST_Struct
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	CodeTypename           Prev;
 	CodeTypename           Next;
 	Token*                 Tok;
@@ -976,7 +976,7 @@ struct AST_Template
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -1005,7 +1005,7 @@ struct AST_Type
 			// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                  Tok;
@@ -1032,7 +1032,7 @@ struct AST_Typename
 			CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -1058,7 +1058,7 @@ struct AST_Typedef
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -1082,7 +1082,7 @@ struct AST_Union
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -1106,7 +1106,7 @@ struct AST_Using
 			char 	        _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
 		};
 	};
-	StringCached            Name;
+	StrCached            Name;
 	Code                    Prev;
 	Code                    Next;
 	Token*                  Tok;
@@ -1132,7 +1132,7 @@ struct AST_Var
 			CodeVar		   NextVar;
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;

base/components/gen/ast_inlines.hpp

@@ -64,7 +64,7 @@ inline AST_Attributes* CodeAttributes::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -95,7 +95,7 @@ inline AST_Comment* CodeComment::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -126,7 +126,7 @@ inline AST_Constructor* CodeConstructor::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -173,7 +173,7 @@ inline AST_Define* CodeDefine::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -204,7 +204,7 @@ inline AST_Destructor* CodeDestructor::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -235,7 +235,7 @@ inline AST_Enum* CodeEnum::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -266,7 +266,7 @@ inline AST_Exec* CodeExec::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -297,7 +297,7 @@ inline AST_Extern* CodeExtern::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -328,7 +328,7 @@ inline AST_Friend* CodeFriend::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -359,7 +359,7 @@ inline AST_Fn* CodeFn::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -390,7 +390,7 @@ inline AST_Include* CodeInclude::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -421,7 +421,7 @@ inline AST_Module* CodeModule::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -452,7 +452,7 @@ inline AST_NS* CodeNS::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -483,7 +483,7 @@ inline AST_Operator* CodeOperator::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -514,7 +514,7 @@ inline AST_OpCast* CodeOpCast::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -561,7 +561,7 @@ inline AST_Pragma* CodePragma::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -592,7 +592,7 @@ inline AST_PreprocessCond* CodePreprocessCond::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -655,7 +655,7 @@ inline AST_Template* CodeTemplate::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -686,7 +686,7 @@ inline AST_Typename* CodeTypename::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -717,7 +717,7 @@ inline AST_Typedef* CodeTypedef::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -748,7 +748,7 @@ inline AST_Union* CodeUnion::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -779,7 +779,7 @@ inline AST_Using* CodeUsing::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -810,7 +810,7 @@ inline AST_Var* CodeVar::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;

base/components/gen/ecodetypes.hpp

@@ -72,148 +72,148 @@ enum CodeType : u32
 	CT_UnderlyingType = GEN_U32_MAX
 };
 
-inline StrC codetype_to_str( CodeType type )
+inline Str codetype_to_str( CodeType type )
 {
-	local_persist StrC lookup[61] = {
+	local_persist Str lookup[61] = {
-		{ sizeof( "Invalid" ),             "Invalid"             },
+		{ "Invalid",             sizeof( "Invalid" ) - 1             },
-		{ sizeof( "Untyped" ),             "Untyped"             },
+		{ "Untyped",             sizeof( "Untyped" ) - 1             },
-		{ sizeof( "NewLine" ),             "NewLine"             },
+		{ "NewLine",             sizeof( "NewLine" ) - 1             },
-		{ sizeof( "Comment" ),             "Comment"             },
+		{ "Comment",             sizeof( "Comment" ) - 1             },
-		{ sizeof( "Access_Private" ),      "Access_Private"      },
+		{ "Access_Private",      sizeof( "Access_Private" ) - 1      },
-		{ sizeof( "Access_Protected" ),    "Access_Protected"    },
+		{ "Access_Protected",    sizeof( "Access_Protected" ) - 1    },
-		{ sizeof( "Access_Public" ),       "Access_Public"       },
+		{ "Access_Public",       sizeof( "Access_Public" ) - 1       },
-		{ sizeof( "PlatformAttributes" ),  "PlatformAttributes"  },
+		{ "PlatformAttributes",  sizeof( "PlatformAttributes" ) - 1  },
-		{ sizeof( "Class" ),               "Class"               },
+		{ "Class",               sizeof( "Class" ) - 1               },
-		{ sizeof( "Class_Fwd" ),           "Class_Fwd"           },
+		{ "Class_Fwd",           sizeof( "Class_Fwd" ) - 1           },
-		{ sizeof( "Class_Body" ),          "Class_Body"          },
+		{ "Class_Body",          sizeof( "Class_Body" ) - 1          },
-		{ sizeof( "Constructor" ),         "Constructor"         },
+		{ "Constructor",         sizeof( "Constructor" ) - 1         },
-		{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"     },
+		{ "Constructor_Fwd",     sizeof( "Constructor_Fwd" ) - 1     },
-		{ sizeof( "Destructor" ),          "Destructor"          },
+		{ "Destructor",          sizeof( "Destructor" ) - 1          },
-		{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"      },
+		{ "Destructor_Fwd",      sizeof( "Destructor_Fwd" ) - 1      },
-		{ sizeof( "Enum" ),                "Enum"                },
+		{ "Enum",                sizeof( "Enum" ) - 1                },
-		{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"            },
+		{ "Enum_Fwd",            sizeof( "Enum_Fwd" ) - 1            },
-		{ sizeof( "Enum_Body" ),           "Enum_Body"           },
+		{ "Enum_Body",           sizeof( "Enum_Body" ) - 1           },
-		{ sizeof( "Enum_Class" ),          "Enum_Class"          },
+		{ "Enum_Class",          sizeof( "Enum_Class" ) - 1          },
-		{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"      },
+		{ "Enum_Class_Fwd",      sizeof( "Enum_Class_Fwd" ) - 1      },
-		{ sizeof( "Execution" ),           "Execution"           },
+		{ "Execution",           sizeof( "Execution" ) - 1           },
-		{ sizeof( "Export_Body" ),         "Export_Body"         },
+		{ "Export_Body",         sizeof( "Export_Body" ) - 1         },
-		{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"      },
+		{ "Extern_Linkage",      sizeof( "Extern_Linkage" ) - 1      },
-		{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
+		{ "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
-		{ sizeof( "Friend" ),              "Friend"              },
+		{ "Friend",              sizeof( "Friend" ) - 1              },
-		{ sizeof( "Function" ),            "Function"            },
+		{ "Function",            sizeof( "Function" ) - 1            },
-		{ sizeof( "Function_Fwd" ),        "Function_Fwd"        },
+		{ "Function_Fwd",        sizeof( "Function_Fwd" ) - 1        },
-		{ sizeof( "Function_Body" ),       "Function_Body"       },
+		{ "Function_Body",       sizeof( "Function_Body" ) - 1       },
-		{ sizeof( "Global_Body" ),         "Global_Body"         },
+		{ "Global_Body",         sizeof( "Global_Body" ) - 1         },
-		{ sizeof( "Module" ),              "Module"              },
+		{ "Module",              sizeof( "Module" ) - 1              },
-		{ sizeof( "Namespace" ),           "Namespace"           },
+		{ "Namespace",           sizeof( "Namespace" ) - 1           },
-		{ sizeof( "Namespace_Body" ),      "Namespace_Body"      },
+		{ "Namespace_Body",      sizeof( "Namespace_Body" ) - 1      },
-		{ sizeof( "Operator" ),            "Operator"            },
+		{ "Operator",            sizeof( "Operator" ) - 1            },
-		{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"        },
+		{ "Operator_Fwd",        sizeof( "Operator_Fwd" ) - 1        },
-		{ sizeof( "Operator_Member" ),     "Operator_Member"     },
+		{ "Operator_Member",     sizeof( "Operator_Member" ) - 1     },
-		{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
+		{ "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
-		{ sizeof( "Operator_Cast" ),       "Operator_Cast"       },
+		{ "Operator_Cast",       sizeof( "Operator_Cast" ) - 1       },
-		{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"   },
+		{ "Operator_Cast_Fwd",   sizeof( "Operator_Cast_Fwd" ) - 1   },
-		{ sizeof( "Parameters" ),          "Parameters"          },
+		{ "Parameters",          sizeof( "Parameters" ) - 1          },
-		{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"   },
+		{ "Preprocess_Define",   sizeof( "Preprocess_Define" ) - 1   },
-		{ sizeof( "Preprocess_Include" ),  "Preprocess_Include"  },
+		{ "Preprocess_Include",  sizeof( "Preprocess_Include" ) - 1  },
-		{ sizeof( "Preprocess_If" ),       "Preprocess_If"       },
+		{ "Preprocess_If",       sizeof( "Preprocess_If" ) - 1       },
-		{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"    },
+		{ "Preprocess_IfDef",    sizeof( "Preprocess_IfDef" ) - 1    },
-		{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
+		{ "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
-		{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"     },
+		{ "Preprocess_ElIf",     sizeof( "Preprocess_ElIf" ) - 1     },
-		{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"     },
+		{ "Preprocess_Else",     sizeof( "Preprocess_Else" ) - 1     },
-		{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"    },
+		{ "Preprocess_EndIf",    sizeof( "Preprocess_EndIf" ) - 1    },
-		{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"   },
+		{ "Preprocess_Pragma",   sizeof( "Preprocess_Pragma" ) - 1   },
-		{ sizeof( "Specifiers" ),          "Specifiers"          },
+		{ "Specifiers",          sizeof( "Specifiers" ) - 1          },
-		{ sizeof( "Struct" ),              "Struct"              },
+		{ "Struct",              sizeof( "Struct" ) - 1              },
-		{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"          },
+		{ "Struct_Fwd",          sizeof( "Struct_Fwd" ) - 1          },
-		{ sizeof( "Struct_Body" ),         "Struct_Body"         },
+		{ "Struct_Body",         sizeof( "Struct_Body" ) - 1         },
-		{ sizeof( "Template" ),            "Template"            },
+		{ "Template",            sizeof( "Template" ) - 1            },
-		{ sizeof( "Typedef" ),             "Typedef"             },
+		{ "Typedef",             sizeof( "Typedef" ) - 1             },
-		{ sizeof( "Typename" ),            "Typename"            },
+		{ "Typename",            sizeof( "Typename" ) - 1            },
-		{ sizeof( "Union" ),               "Union"               },
+		{ "Union",               sizeof( "Union" ) - 1               },
-		{ sizeof( "Union_Fwd" ),           "Union_Fwd"           },
+		{ "Union_Fwd",           sizeof( "Union_Fwd" ) - 1           },
-		{ sizeof( "Union_Body" ),          "Union_Body"          },
+		{ "Union_Body",          sizeof( "Union_Body" ) - 1          },
-		{ sizeof( "Using" ),               "Using"               },
+		{ "Using",               sizeof( "Using" ) - 1               },
-		{ sizeof( "Using_Namespace" ),     "Using_Namespace"     },
+		{ "Using_Namespace",     sizeof( "Using_Namespace" ) - 1     },
-		{ sizeof( "Variable" ),            "Variable"            },
+		{ "Variable",            sizeof( "Variable" ) - 1            },
 	};
 	return lookup[type];
 }
 
-inline StrC codetype_to_keyword_str( CodeType type )
+inline Str codetype_to_keyword_str( CodeType type )
 {
-	local_persist StrC lookup[61] = {
+	local_persist Str lookup[61] = {
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "//" ) - 1,              "//"              },
+		{ "//",              sizeof( "//" ) - 1              },
-		{ sizeof( "private" ) - 1,         "private"         },
+		{ "private",         sizeof( "private" ) - 1         },
-		{ sizeof( "protected" ) - 1,       "protected"       },
+		{ "protected",       sizeof( "protected" ) - 1       },
-		{ sizeof( "public" ) - 1,          "public"          },
+		{ "public",          sizeof( "public" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "class" ) - 1,           "class"           },
+		{ "class",           sizeof( "class" ) - 1           },
-		{ sizeof( "clsss" ) - 1,           "clsss"           },
+		{ "clsss",           sizeof( "clsss" ) - 1           },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "enum" ) - 1,            "enum"            },
+		{ "enum",            sizeof( "enum" ) - 1            },
-		{ sizeof( "enum" ) - 1,            "enum"            },
+		{ "enum",            sizeof( "enum" ) - 1            },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "enum class" ) - 1,      "enum class"      },
+		{ "enum class",      sizeof( "enum class" ) - 1      },
-		{ sizeof( "enum class" ) - 1,      "enum class"      },
+		{ "enum class",      sizeof( "enum class" ) - 1      },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "extern" ) - 1,          "extern"          },
+		{ "extern",          sizeof( "extern" ) - 1          },
-		{ sizeof( "extern" ) - 1,          "extern"          },
+		{ "extern",          sizeof( "extern" ) - 1          },
-		{ sizeof( "friend" ) - 1,          "friend"          },
+		{ "friend",          sizeof( "friend" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "module" ) - 1,          "module"          },
+		{ "module",          sizeof( "module" ) - 1          },
-		{ sizeof( "namespace" ) - 1,       "namespace"       },
+		{ "namespace",       sizeof( "namespace" ) - 1       },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
+		{ "operator",        sizeof( "operator" ) - 1        },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "define" ) - 1,          "define"          },
+		{ "define",          sizeof( "define" ) - 1          },
-		{ sizeof( "include" ) - 1,         "include"         },
+		{ "include",         sizeof( "include" ) - 1         },
-		{ sizeof( "if" ) - 1,              "if"              },
+		{ "if",              sizeof( "if" ) - 1              },
-		{ sizeof( "ifdef" ) - 1,           "ifdef"           },
+		{ "ifdef",           sizeof( "ifdef" ) - 1           },
-		{ sizeof( "ifndef" ) - 1,          "ifndef"          },
+		{ "ifndef",          sizeof( "ifndef" ) - 1          },
-		{ sizeof( "elif" ) - 1,            "elif"            },
+		{ "elif",            sizeof( "elif" ) - 1            },
-		{ sizeof( "else" ) - 1,            "else"            },
+		{ "else",            sizeof( "else" ) - 1            },
-		{ sizeof( "endif" ) - 1,           "endif"           },
+		{ "endif",           sizeof( "endif" ) - 1           },
-		{ sizeof( "pragma" ) - 1,          "pragma"          },
+		{ "pragma",          sizeof( "pragma" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "struct" ) - 1,          "struct"          },
+		{ "struct",          sizeof( "struct" ) - 1          },
-		{ sizeof( "struct" ) - 1,          "struct"          },
+		{ "struct",          sizeof( "struct" ) - 1          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "template" ) - 1,        "template"        },
+		{ "template",        sizeof( "template" ) - 1        },
-		{ sizeof( "typedef" ) - 1,         "typedef"         },
+		{ "typedef",         sizeof( "typedef" ) - 1         },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "union" ) - 1,           "union"           },
+		{ "union",           sizeof( "union" ) - 1           },
-		{ sizeof( "union" ) - 1,           "union"           },
+		{ "union",           sizeof( "union" ) - 1           },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
-		{ sizeof( "using" ) - 1,           "using"           },
+		{ "using",           sizeof( "using" ) - 1           },
-		{ sizeof( "using namespace" ) - 1, "using namespace" },
+		{ "using namespace", sizeof( "using namespace" ) - 1 },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
 	};
 	return lookup[type];
 }
 
-forceinline StrC to_str( CodeType type )
+forceinline Str to_str( CodeType type )
 {
 	return codetype_to_str( type );
 }
 
-forceinline StrC to_keyword_str( CodeType type )
+forceinline Str to_keyword_str( CodeType type )
 {
 	return codetype_to_keyword_str( type );
 }

base/components/gen/eoperator.hpp

@@ -58,61 +58,61 @@ enum Operator : u32
 	Op_UnderlyingType = 0xffffffffu
 };
 
-inline StrC operator_to_str( Operator op )
+inline Str operator_to_str( Operator op )
 {
-	local_persist StrC lookup[47] = {
+	local_persist Str lookup[47] = {
-		{ sizeof( "INVALID" ),  "INVALID"  },
+		{ "INVALID",  sizeof( "INVALID" ) - 1  },
-		{ sizeof( "=" ),        "="        },
+		{ "=",        sizeof( "=" ) - 1        },
-		{ sizeof( "+=" ),       "+="       },
+		{ "+=",       sizeof( "+=" ) - 1       },
-		{ sizeof( "-=" ),       "-="       },
+		{ "-=",       sizeof( "-=" ) - 1       },
-		{ sizeof( "*=" ),       "*="       },
+		{ "*=",       sizeof( "*=" ) - 1       },
-		{ sizeof( "/=" ),       "/="       },
+		{ "/=",       sizeof( "/=" ) - 1       },
-		{ sizeof( "%=" ),       "%="       },
+		{ "%=",       sizeof( "%=" ) - 1       },
-		{ sizeof( "&=" ),       "&="       },
+		{ "&=",       sizeof( "&=" ) - 1       },
-		{ sizeof( "|=" ),       "|="       },
+		{ "|=",       sizeof( "|=" ) - 1       },
-		{ sizeof( "^=" ),       "^="       },
+		{ "^=",       sizeof( "^=" ) - 1       },
-		{ sizeof( "<<=" ),      "<<="      },
+		{ "<<=",      sizeof( "<<=" ) - 1      },
-		{ sizeof( ">>=" ),      ">>="      },
+		{ ">>=",      sizeof( ">>=" ) - 1      },
-		{ sizeof( "++" ),       "++"       },
+		{ "++",       sizeof( "++" ) - 1       },
-		{ sizeof( "--" ),       "--"       },
+		{ "--",       sizeof( "--" ) - 1       },
-		{ sizeof( "+" ),        "+"        },
+		{ "+",        sizeof( "+" ) - 1        },
-		{ sizeof( "-" ),        "-"        },
+		{ "-",        sizeof( "-" ) - 1        },
-		{ sizeof( "!" ),        "!"        },
+		{ "!",        sizeof( "!" ) - 1        },
-		{ sizeof( "+" ),        "+"        },
+		{ "+",        sizeof( "+" ) - 1        },
-		{ sizeof( "-" ),        "-"        },
+		{ "-",        sizeof( "-" ) - 1        },
-		{ sizeof( "*" ),        "*"        },
+		{ "*",        sizeof( "*" ) - 1        },
-		{ sizeof( "/" ),        "/"        },
+		{ "/",        sizeof( "/" ) - 1        },
-		{ sizeof( "%" ),        "%"        },
+		{ "%",        sizeof( "%" ) - 1        },
-		{ sizeof( "~" ),        "~"        },
+		{ "~",        sizeof( "~" ) - 1        },
-		{ sizeof( "&" ),        "&"        },
+		{ "&",        sizeof( "&" ) - 1        },
-		{ sizeof( "|" ),        "|"        },
+		{ "|",        sizeof( "|" ) - 1        },
-		{ sizeof( "^" ),        "^"        },
+		{ "^",        sizeof( "^" ) - 1        },
-		{ sizeof( "<<" ),       "<<"       },
+		{ "<<",       sizeof( "<<" ) - 1       },
-		{ sizeof( ">>" ),       ">>"       },
+		{ ">>",       sizeof( ">>" ) - 1       },
-		{ sizeof( "&&" ),       "&&"       },
+		{ "&&",       sizeof( "&&" ) - 1       },
-		{ sizeof( "||" ),       "||"       },
+		{ "||",       sizeof( "||" ) - 1       },
-		{ sizeof( "==" ),       "=="       },
+		{ "==",       sizeof( "==" ) - 1       },
-		{ sizeof( "!=" ),       "!="       },
+		{ "!=",       sizeof( "!=" ) - 1       },
-		{ sizeof( "<" ),        "<"        },
+		{ "<",        sizeof( "<" ) - 1        },
-		{ sizeof( ">" ),        ">"        },
+		{ ">",        sizeof( ">" ) - 1        },
-		{ sizeof( "<=" ),       "<="       },
+		{ "<=",       sizeof( "<=" ) - 1       },
-		{ sizeof( ">=" ),       ">="       },
+		{ ">=",       sizeof( ">=" ) - 1       },
-		{ sizeof( "[]" ),       "[]"       },
+		{ "[]",       sizeof( "[]" ) - 1       },
-		{ sizeof( "*" ),        "*"        },
+		{ "*",        sizeof( "*" ) - 1        },
-		{ sizeof( "&" ),        "&"        },
+		{ "&",        sizeof( "&" ) - 1        },
-		{ sizeof( "->" ),       "->"       },
+		{ "->",       sizeof( "->" ) - 1       },
-		{ sizeof( "->*" ),      "->*"      },
+		{ "->*",      sizeof( "->*" ) - 1      },
-		{ sizeof( "()" ),       "()"       },
+		{ "()",       sizeof( "()" ) - 1       },
-		{ sizeof( "," ),        ","        },
+		{ ",",        sizeof( "," ) - 1        },
-		{ sizeof( "new" ),      "new"      },
+		{ "new",      sizeof( "new" ) - 1      },
-		{ sizeof( "new[]" ),    "new[]"    },
+		{ "new[]",    sizeof( "new[]" ) - 1    },
-		{ sizeof( "delete" ),   "delete"   },
+		{ "delete",   sizeof( "delete" ) - 1   },
-		{ sizeof( "delete[]" ), "delete[]" },
+		{ "delete[]", sizeof( "delete[]" ) - 1 },
 	};
 	return lookup[op];
 }
 
-forceinline StrC to_str( Operator op )
+forceinline Str to_str( Operator op )
 {
 	return operator_to_str( op );
 }

base/components/gen/especifier.hpp

@@ -37,35 +37,35 @@ enum Specifier : u32
 	Spec_UnderlyingType = 0xffffffffu
 };
 
-inline StrC spec_to_str( Specifier type )
+inline Str spec_to_str( Specifier type )
 {
-	local_persist StrC lookup[26] = {
+	local_persist Str lookup[26] = {
-		{ sizeof( "INVALID" ),       "INVALID"       },
+		{ "INVALID",       sizeof( "INVALID" ) - 1       },
-		{ sizeof( "consteval" ),     "consteval"     },
+		{ "consteval",     sizeof( "consteval" ) - 1     },
-		{ sizeof( "constexpr" ),     "constexpr"     },
+		{ "constexpr",     sizeof( "constexpr" ) - 1     },
-		{ sizeof( "constinit" ),     "constinit"     },
+		{ "constinit",     sizeof( "constinit" ) - 1     },
-		{ sizeof( "explicit" ),      "explicit"      },
+		{ "explicit",      sizeof( "explicit" ) - 1      },
-		{ sizeof( "extern" ),        "extern"        },
+		{ "extern",        sizeof( "extern" ) - 1        },
-		{ sizeof( "forceinline" ),   "forceinline"   },
+		{ "forceinline",   sizeof( "forceinline" ) - 1   },
-		{ sizeof( "global" ),        "global"        },
+		{ "global",        sizeof( "global" ) - 1        },
-		{ sizeof( "inline" ),        "inline"        },
+		{ "inline",        sizeof( "inline" ) - 1        },
-		{ sizeof( "internal" ),      "internal"      },
+		{ "internal",      sizeof( "internal" ) - 1      },
-		{ sizeof( "local_persist" ), "local_persist" },
+		{ "local_persist", sizeof( "local_persist" ) - 1 },
-		{ sizeof( "mutable" ),       "mutable"       },
+		{ "mutable",       sizeof( "mutable" ) - 1       },
-		{ sizeof( "neverinline" ),   "neverinline"   },
+		{ "neverinline",   sizeof( "neverinline" ) - 1   },
-		{ sizeof( "*" ),             "*"             },
+		{ "*",             sizeof( "*" ) - 1             },
-		{ sizeof( "&" ),             "&"             },
+		{ "&",             sizeof( "&" ) - 1             },
-		{ sizeof( "register" ),      "register"      },
+		{ "register",      sizeof( "register" ) - 1      },
-		{ sizeof( "&&" ),            "&&"            },
+		{ "&&",            sizeof( "&&" ) - 1            },
-		{ sizeof( "static" ),        "static"        },
+		{ "static",        sizeof( "static" ) - 1        },
-		{ sizeof( "thread_local" ),  "thread_local"  },
+		{ "thread_local",  sizeof( "thread_local" ) - 1  },
-		{ sizeof( "virtual" ),       "virtual"       },
+		{ "virtual",       sizeof( "virtual" ) - 1       },
-		{ sizeof( "const" ),         "const"         },
+		{ "const",         sizeof( "const" ) - 1         },
-		{ sizeof( "final" ),         "final"         },
+		{ "final",         sizeof( "final" ) - 1         },
-		{ sizeof( "noexcept" ),      "noexcept"      },
+		{ "noexcept",      sizeof( "noexcept" ) - 1      },
-		{ sizeof( "override" ),      "override"      },
+		{ "override",      sizeof( "override" ) - 1      },
-		{ sizeof( "= 0" ),           "= 0"           },
+		{ "= 0",           sizeof( "= 0" ) - 1           },
-		{ sizeof( "volatile" ),      "volatile"      },
+		{ "volatile",      sizeof( "volatile" ) - 1      },
 	};
 	return lookup[type];
 }
@@ -75,13 +75,13 @@ inline bool spec_is_trailing( Specifier specifier )
 	return specifier > Spec_Virtual;
 }
 
-inline Specifier strc_to_specifier( StrC str )
+inline Specifier str_to_specifier( Str str )
 {
 	local_persist u32 keymap[Spec_NumSpecifiers];
 	do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 	{
-		StrC enum_str = spec_to_str( (Specifier)index );
+		Str enum_str  = spec_to_str( (Specifier)index );
-		keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+		keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
 	}
 	do_once_end u32 hash = crc32( str.Ptr, str.Len );
 	for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
@@ -92,14 +92,14 @@ inline Specifier strc_to_specifier( StrC str )
 	return Spec_Invalid;
 }
 
-forceinline StrC to_str( Specifier spec )
+forceinline Str to_str( Specifier spec )
 {
 	return spec_to_str( spec );
 }
 
-forceinline Specifier to_type( StrC str )
+forceinline Specifier to_type( Str str )
 {
-	return strc_to_specifier( str );
+	return str_to_specifier( str );
 }
 
 forceinline bool is_trailing( Specifier specifier )

base/components/gen/etoktype.cpp

@@ -1,235 +0,0 @@
-#ifdef GEN_INTELLISENSE_DIRECTIVES
-#pragma once
-#include "components/types.hpp"
-#endif
-
-// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
-
-GEN_NS_PARSER_BEGIN
-
-#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
-
-enum TokType : u32
-{
-	Tok_Invalid,
-	Tok_Access_Private,
-	Tok_Access_Protected,
-	Tok_Access_Public,
-	Tok_Access_MemberSymbol,
-	Tok_Access_StaticSymbol,
-	Tok_Ampersand,
-	Tok_Ampersand_DBL,
-	Tok_Assign_Classifer,
-	Tok_Attribute_Open,
-	Tok_Attribute_Close,
-	Tok_BraceCurly_Open,
-	Tok_BraceCurly_Close,
-	Tok_BraceSquare_Open,
-	Tok_BraceSquare_Close,
-	Tok_Capture_Start,
-	Tok_Capture_End,
-	Tok_Comment,
-	Tok_Comment_End,
-	Tok_Comment_Start,
-	Tok_Char,
-	Tok_Comma,
-	Tok_Decl_Class,
-	Tok_Decl_GNU_Attribute,
-	Tok_Decl_MSVC_Attribute,
-	Tok_Decl_Enum,
-	Tok_Decl_Extern_Linkage,
-	Tok_Decl_Friend,
-	Tok_Decl_Module,
-	Tok_Decl_Namespace,
-	Tok_Decl_Operator,
-	Tok_Decl_Struct,
-	Tok_Decl_Template,
-	Tok_Decl_Typedef,
-	Tok_Decl_Using,
-	Tok_Decl_Union,
-	Tok_Identifier,
-	Tok_Module_Import,
-	Tok_Module_Export,
-	Tok_NewLine,
-	Tok_Number,
-	Tok_Operator,
-	Tok_Preprocess_Hash,
-	Tok_Preprocess_Define,
-	Tok_Preprocess_If,
-	Tok_Preprocess_IfDef,
-	Tok_Preprocess_IfNotDef,
-	Tok_Preprocess_ElIf,
-	Tok_Preprocess_Else,
-	Tok_Preprocess_EndIf,
-	Tok_Preprocess_Include,
-	Tok_Preprocess_Pragma,
-	Tok_Preprocess_Content,
-	Tok_Preprocess_Macro,
-	Tok_Preprocess_Unsupported,
-	Tok_Spec_Alignas,
-	Tok_Spec_Const,
-	Tok_Spec_Consteval,
-	Tok_Spec_Constexpr,
-	Tok_Spec_Constinit,
-	Tok_Spec_Explicit,
-	Tok_Spec_Extern,
-	Tok_Spec_Final,
-	Tok_Spec_ForceInline,
-	Tok_Spec_Global,
-	Tok_Spec_Inline,
-	Tok_Spec_Internal_Linkage,
-	Tok_Spec_LocalPersist,
-	Tok_Spec_Mutable,
-	Tok_Spec_NeverInline,
-	Tok_Spec_Override,
-	Tok_Spec_Static,
-	Tok_Spec_ThreadLocal,
-	Tok_Spec_Volatile,
-	Tok_Spec_Virtual,
-	Tok_Star,
-	Tok_Statement_End,
-	Tok_StaticAssert,
-	Tok_String,
-	Tok_Type_Typename,
-	Tok_Type_Unsigned,
-	Tok_Type_Signed,
-	Tok_Type_Short,
-	Tok_Type_Long,
-	Tok_Type_bool,
-	Tok_Type_char,
-	Tok_Type_int,
-	Tok_Type_double,
-	Tok_Type_MS_int8,
-	Tok_Type_MS_int16,
-	Tok_Type_MS_int32,
-	Tok_Type_MS_int64,
-	Tok_Type_MS_W64,
-	Tok_Varadic_Argument,
-	Tok___Attributes_Start,
-	Tok_Attribute_API_Export,
-	Tok_Attribute_API_Import,
-	Tok_NumTokens
-};
-
-inline StrC toktype_to_str( TokType type )
-{
-	local_persist StrC lookup[] = {
-		{ sizeof( "__invalid__" ),         "__invalid__"         },
-		{ sizeof( "private" ),             "private"             },
-		{ sizeof( "protected" ),           "protected"           },
-		{ sizeof( "public" ),              "public"              },
-		{ sizeof( "." ),                   "."                   },
-		{ sizeof( "::" ),                  "::"                  },
-		{ sizeof( "&" ),                   "&"                   },
-		{ sizeof( "&&" ),                  "&&"                  },
-		{ sizeof( ":" ),                   ":"                   },
-		{ sizeof( "[[" ),                  "[["                  },
-		{ sizeof( "]]" ),                  "]]"                  },
-		{ sizeof( "{" ),                   "{"                   },
-		{ sizeof( "}" ),                   "}"                   },
-		{ sizeof( "[" ),                   "["                   },
-		{ sizeof( "]" ),                   "]"                   },
-		{ sizeof( "(" ),                   "("                   },
-		{ sizeof( ")" ),                   ")"                   },
-		{ sizeof( "__comment__" ),         "__comment__"         },
-		{ sizeof( "__comment_end__" ),     "__comment_end__"     },
-		{ sizeof( "__comment_start__" ),   "__comment_start__"   },
-		{ sizeof( "__character__" ),       "__character__"       },
-		{ sizeof( "," ),                   ","                   },
-		{ sizeof( "class" ),               "class"               },
-		{ sizeof( "__attribute__" ),       "__attribute__"       },
-		{ sizeof( "__declspec" ),          "__declspec"          },
-		{ sizeof( "enum" ),                "enum"                },
-		{ sizeof( "extern" ),              "extern"              },
-		{ sizeof( "friend" ),              "friend"              },
-		{ sizeof( "module" ),              "module"              },
-		{ sizeof( "namespace" ),           "namespace"           },
-		{ sizeof( "operator" ),            "operator"            },
-		{ sizeof( "struct" ),              "struct"              },
-		{ sizeof( "template" ),            "template"            },
-		{ sizeof( "typedef" ),             "typedef"             },
-		{ sizeof( "using" ),               "using"               },
-		{ sizeof( "union" ),               "union"               },
-		{ sizeof( "__identifier__" ),      "__identifier__"      },
-		{ sizeof( "import" ),              "import"              },
-		{ sizeof( "export" ),              "export"              },
-		{ sizeof( "__new_line__" ),        "__new_line__"        },
-		{ sizeof( "__number__" ),          "__number__"          },
-		{ sizeof( "__operator__" ),        "__operator__"        },
-		{ sizeof( "#" ),                   "#"                   },
-		{ sizeof( "define" ),              "define"              },
-		{ sizeof( "if" ),                  "if"                  },
-		{ sizeof( "ifdef" ),               "ifdef"               },
-		{ sizeof( "ifndef" ),              "ifndef"              },
-		{ sizeof( "elif" ),                "elif"                },
-		{ sizeof( "else" ),                "else"                },
-		{ sizeof( "endif" ),               "endif"               },
-		{ sizeof( "include" ),             "include"             },
-		{ sizeof( "pragma" ),              "pragma"              },
-		{ sizeof( "__macro_content__" ),   "__macro_content__"   },
-		{ sizeof( "__macro__" ),           "__macro__"           },
-		{ sizeof( "__unsupported__" ),     "__unsupported__"     },
-		{ sizeof( "alignas" ),             "alignas"             },
-		{ sizeof( "const" ),               "const"               },
-		{ sizeof( "consteval" ),           "consteval"           },
-		{ sizeof( "constexpr" ),           "constexpr"           },
-		{ sizeof( "constinit" ),           "constinit"           },
-		{ sizeof( "explicit" ),            "explicit"            },
-		{ sizeof( "extern" ),              "extern"              },
-		{ sizeof( "final" ),               "final"               },
-		{ sizeof( "forceinline" ),         "forceinline"         },
-		{ sizeof( "global" ),              "global"              },
-		{ sizeof( "inline" ),              "inline"              },
-		{ sizeof( "internal" ),            "internal"            },
-		{ sizeof( "local_persist" ),       "local_persist"       },
-		{ sizeof( "mutable" ),             "mutable"             },
-		{ sizeof( "neverinline" ),         "neverinline"         },
-		{ sizeof( "override" ),            "override"            },
-		{ sizeof( "static" ),              "static"              },
-		{ sizeof( "thread_local" ),        "thread_local"        },
-		{ sizeof( "volatile" ),            "volatile"            },
-		{ sizeof( "virtual" ),             "virtual"             },
-		{ sizeof( "*" ),                   "*"                   },
-		{ sizeof( ";" ),                   ";"                   },
-		{ sizeof( "static_assert" ),       "static_assert"       },
-		{ sizeof( "__string__" ),          "__string__"          },
-		{ sizeof( "typename" ),            "typename"            },
-		{ sizeof( "unsigned" ),            "unsigned"            },
-		{ sizeof( "signed" ),              "signed"              },
-		{ sizeof( "short" ),               "short"               },
-		{ sizeof( "long" ),                "long"                },
-		{ sizeof( "bool" ),                "bool"                },
-		{ sizeof( "char" ),                "char"                },
-		{ sizeof( "int" ),                 "int"                 },
-		{ sizeof( "double" ),              "double"              },
-		{ sizeof( "__int8" ),              "__int8"              },
-		{ sizeof( "__int16" ),             "__int16"             },
-		{ sizeof( "__int32" ),             "__int32"             },
-		{ sizeof( "__int64" ),             "__int64"             },
-		{ sizeof( "_W64" ),                "_W64"                },
-		{ sizeof( "..." ),                 "..."                 },
-		{ sizeof( "__attrib_start__" ),    "__attrib_start__"    },
-		{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
-		{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
-	};
-	return lookup[type];
-}
-
-inline TokType strc_to_toktype( StrC str )
-{
-	local_persist u32 keymap[Tok_NumTokens];
-	do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
-	{
-		StrC enum_str = toktype_to_str( (TokType)index );
-		keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
-	}
-	do_once_end u32 hash = crc32( str.Ptr, str.Len );
-	for ( u32 index = 0; index < Tok_NumTokens; index++ )
-	{
-		if ( keymap[index] == hash )
-			return (TokType)index;
-	}
-	return Tok_Invalid;
-}
-
-GEN_NS_PARSER_END

base/components/gen/etoktype.hpp

@@ -0,0 +1,229 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "components/types.hpp"
+#endif
+
+// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
+
+#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_GEN_API, "GEN_API" )
+
+enum TokType : u32
+{
+	Tok_Invalid,
+	Tok_Access_Private,
+	Tok_Access_Protected,
+	Tok_Access_Public,
+	Tok_Access_MemberSymbol,
+	Tok_Access_StaticSymbol,
+	Tok_Ampersand,
+	Tok_Ampersand_DBL,
+	Tok_Assign_Classifer,
+	Tok_Attribute_Open,
+	Tok_Attribute_Close,
+	Tok_BraceCurly_Open,
+	Tok_BraceCurly_Close,
+	Tok_BraceSquare_Open,
+	Tok_BraceSquare_Close,
+	Tok_Capture_Start,
+	Tok_Capture_End,
+	Tok_Comment,
+	Tok_Comment_End,
+	Tok_Comment_Start,
+	Tok_Char,
+	Tok_Comma,
+	Tok_Decl_Class,
+	Tok_Decl_GNU_Attribute,
+	Tok_Decl_MSVC_Attribute,
+	Tok_Decl_Enum,
+	Tok_Decl_Extern_Linkage,
+	Tok_Decl_Friend,
+	Tok_Decl_Module,
+	Tok_Decl_Namespace,
+	Tok_Decl_Operator,
+	Tok_Decl_Struct,
+	Tok_Decl_Template,
+	Tok_Decl_Typedef,
+	Tok_Decl_Using,
+	Tok_Decl_Union,
+	Tok_Identifier,
+	Tok_Module_Import,
+	Tok_Module_Export,
+	Tok_NewLine,
+	Tok_Number,
+	Tok_Operator,
+	Tok_Preprocess_Hash,
+	Tok_Preprocess_Define,
+	Tok_Preprocess_If,
+	Tok_Preprocess_IfDef,
+	Tok_Preprocess_IfNotDef,
+	Tok_Preprocess_ElIf,
+	Tok_Preprocess_Else,
+	Tok_Preprocess_EndIf,
+	Tok_Preprocess_Include,
+	Tok_Preprocess_Pragma,
+	Tok_Preprocess_Content,
+	Tok_Preprocess_Macro,
+	Tok_Preprocess_Unsupported,
+	Tok_Spec_Alignas,
+	Tok_Spec_Const,
+	Tok_Spec_Consteval,
+	Tok_Spec_Constexpr,
+	Tok_Spec_Constinit,
+	Tok_Spec_Explicit,
+	Tok_Spec_Extern,
+	Tok_Spec_Final,
+	Tok_Spec_ForceInline,
+	Tok_Spec_Global,
+	Tok_Spec_Inline,
+	Tok_Spec_Internal_Linkage,
+	Tok_Spec_LocalPersist,
+	Tok_Spec_Mutable,
+	Tok_Spec_NeverInline,
+	Tok_Spec_Override,
+	Tok_Spec_Static,
+	Tok_Spec_ThreadLocal,
+	Tok_Spec_Volatile,
+	Tok_Spec_Virtual,
+	Tok_Star,
+	Tok_Statement_End,
+	Tok_StaticAssert,
+	Tok_String,
+	Tok_Type_Typename,
+	Tok_Type_Unsigned,
+	Tok_Type_Signed,
+	Tok_Type_Short,
+	Tok_Type_Long,
+	Tok_Type_bool,
+	Tok_Type_char,
+	Tok_Type_int,
+	Tok_Type_double,
+	Tok_Type_MS_int8,
+	Tok_Type_MS_int16,
+	Tok_Type_MS_int32,
+	Tok_Type_MS_int64,
+	Tok_Type_MS_W64,
+	Tok_Varadic_Argument,
+	Tok___Attributes_Start,
+	Tok_Attribute_GEN_API,
+	Tok_NumTokens
+};
+
+inline Str toktype_to_str( TokType type )
+{
+	local_persist Str lookup[] = {
+		{ "__invalid__",       sizeof( "__invalid__" ) - 1       },
+		{ "private",           sizeof( "private" ) - 1           },
+		{ "protected",         sizeof( "protected" ) - 1         },
+		{ "public",            sizeof( "public" ) - 1            },
+		{ ".",		         sizeof( "." ) - 1                 },
+		{ "::",		        sizeof( "::" ) - 1                },
+		{ "&",		         sizeof( "&" ) - 1                 },
+		{ "&&",		        sizeof( "&&" ) - 1                },
+		{ ":",		         sizeof( ":" ) - 1                 },
+		{ "[[",		        sizeof( "[[" ) - 1                },
+		{ "]]",		        sizeof( "]]" ) - 1                },
+		{ "{",		         sizeof( "{" ) - 1                 },
+		{ "}",		         sizeof( "}" ) - 1                 },
+		{ "[",		         sizeof( "[" ) - 1                 },
+		{ "]",		         sizeof( "]" ) - 1                 },
+		{ "(",		         sizeof( "(" ) - 1                 },
+		{ ")",		         sizeof( ")" ) - 1                 },
+		{ "__comment__",       sizeof( "__comment__" ) - 1       },
+		{ "__comment_end__",   sizeof( "__comment_end__" ) - 1   },
+		{ "__comment_start__", sizeof( "__comment_start__" ) - 1 },
+		{ "__character__",     sizeof( "__character__" ) - 1     },
+		{ ",",		         sizeof( "," ) - 1                 },
+		{ "class",             sizeof( "class" ) - 1             },
+		{ "__attribute__",     sizeof( "__attribute__" ) - 1     },
+		{ "__declspec",        sizeof( "__declspec" ) - 1        },
+		{ "enum",              sizeof( "enum" ) - 1              },
+		{ "extern",            sizeof( "extern" ) - 1            },
+		{ "friend",            sizeof( "friend" ) - 1            },
+		{ "module",            sizeof( "module" ) - 1            },
+		{ "namespace",         sizeof( "namespace" ) - 1         },
+		{ "operator",          sizeof( "operator" ) - 1          },
+		{ "struct",            sizeof( "struct" ) - 1            },
+		{ "template",          sizeof( "template" ) - 1          },
+		{ "typedef",           sizeof( "typedef" ) - 1           },
+		{ "using",             sizeof( "using" ) - 1             },
+		{ "union",             sizeof( "union" ) - 1             },
+		{ "__identifier__",    sizeof( "__identifier__" ) - 1    },
+		{ "import",            sizeof( "import" ) - 1            },
+		{ "export",            sizeof( "export" ) - 1            },
+		{ "__new_line__",      sizeof( "__new_line__" ) - 1      },
+		{ "__number__",        sizeof( "__number__" ) - 1        },
+		{ "__operator__",      sizeof( "__operator__" ) - 1      },
+		{ "#",		         sizeof( "#" ) - 1                 },
+		{ "define",            sizeof( "define" ) - 1            },
+		{ "if",		        sizeof( "if" ) - 1                },
+		{ "ifdef",             sizeof( "ifdef" ) - 1             },
+		{ "ifndef",            sizeof( "ifndef" ) - 1            },
+		{ "elif",              sizeof( "elif" ) - 1              },
+		{ "else",              sizeof( "else" ) - 1              },
+		{ "endif",             sizeof( "endif" ) - 1             },
+		{ "include",           sizeof( "include" ) - 1           },
+		{ "pragma",            sizeof( "pragma" ) - 1            },
+		{ "__macro_content__", sizeof( "__macro_content__" ) - 1 },
+		{ "__macro__",         sizeof( "__macro__" ) - 1         },
+		{ "__unsupported__",   sizeof( "__unsupported__" ) - 1   },
+		{ "alignas",           sizeof( "alignas" ) - 1           },
+		{ "const",             sizeof( "const" ) - 1             },
+		{ "consteval",         sizeof( "consteval" ) - 1         },
+		{ "constexpr",         sizeof( "constexpr" ) - 1         },
+		{ "constinit",         sizeof( "constinit" ) - 1         },
+		{ "explicit",          sizeof( "explicit" ) - 1          },
+		{ "extern",            sizeof( "extern" ) - 1            },
+		{ "final",             sizeof( "final" ) - 1             },
+		{ "forceinline",       sizeof( "forceinline" ) - 1       },
+		{ "global",            sizeof( "global" ) - 1            },
+		{ "inline",            sizeof( "inline" ) - 1            },
+		{ "internal",          sizeof( "internal" ) - 1          },
+		{ "local_persist",     sizeof( "local_persist" ) - 1     },
+		{ "mutable",           sizeof( "mutable" ) - 1           },
+		{ "neverinline",       sizeof( "neverinline" ) - 1       },
+		{ "override",          sizeof( "override" ) - 1          },
+		{ "static",            sizeof( "static" ) - 1            },
+		{ "thread_local",      sizeof( "thread_local" ) - 1      },
+		{ "volatile",          sizeof( "volatile" ) - 1          },
+		{ "virtual",           sizeof( "virtual" ) - 1           },
+		{ "*",		         sizeof( "*" ) - 1                 },
+		{ ";",		         sizeof( ";" ) - 1                 },
+		{ "static_assert",     sizeof( "static_assert" ) - 1     },
+		{ "__string__",        sizeof( "__string__" ) - 1        },
+		{ "typename",          sizeof( "typename" ) - 1          },
+		{ "unsigned",          sizeof( "unsigned" ) - 1          },
+		{ "signed",            sizeof( "signed" ) - 1            },
+		{ "short",             sizeof( "short" ) - 1             },
+		{ "long",              sizeof( "long" ) - 1              },
+		{ "bool",              sizeof( "bool" ) - 1              },
+		{ "char",              sizeof( "char" ) - 1              },
+		{ "int",               sizeof( "int" ) - 1               },
+		{ "double",            sizeof( "double" ) - 1            },
+		{ "__int8",            sizeof( "__int8" ) - 1            },
+		{ "__int16",           sizeof( "__int16" ) - 1           },
+		{ "__int32",           sizeof( "__int32" ) - 1           },
+		{ "__int64",           sizeof( "__int64" ) - 1           },
+		{ "_W64",              sizeof( "_W64" ) - 1              },
+		{ "...",               sizeof( "..." ) - 1               },
+		{ "__attrib_start__",  sizeof( "__attrib_start__" ) - 1  },
+		{ "GEN_API",           sizeof( "GEN_API" ) - 1           },
+	};
+	return lookup[type];
+}
+
+inline TokType str_to_toktype( Str str )
+{
+	local_persist u32 keymap[Tok_NumTokens];
+	do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
+	{
+		Str enum_str  = toktype_to_str( (TokType)index );
+		keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
+	}
+	do_once_end u32 hash = crc32( str.Ptr, str.Len );
+	for ( u32 index = 0; index < Tok_NumTokens; index++ )
+	{
+		if ( keymap[index] == hash )
+			return (TokType)index;
+	}
+	return Tok_Invalid;
+}

base/components/header_end.hpp

@@ -6,54 +6,7 @@
 
 #pragma region Constants
 
-#ifndef GEN_GLOBAL_BUCKET_SIZE
+extern Str enum_underlying_sig;
-#	define GEN_GLOBAL_BUCKET_SIZE megabytes(8)
-#endif
-#ifndef GEN_CODEPOOL_NUM_BLOCKS
-#	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(16)
-#endif
-#ifndef GEN_SIZE_PER_STRING_ARENA
-#	define GEN_SIZE_PER_STRING_ARENA megabytes(1)
-#endif
-#ifndef GEN_MAX_COMMENT_LINE_LENGTH
-#	define GEN_MAX_COMMENT_LINE_LENGTH 1024
-#endif
-#ifndef GEN_MAX_NAME_LENGTH
-#	define GEN_MAX_NAME_LENGTH 128
-#endif
-#ifndef GEN_MAX_UNTYPED_STR_LENGTH
-#	define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
-#endif
-#ifndef TokenMap_FixedArena
-#	define TokenMap_FixedArena FixedArena_8KB
-#endif
-#ifndef GEN_LEX_ALLOCATOR_SIZE
-#	define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
-#endif
-#ifndef GEN_BUILDER_STR_BUFFER_RESERVE
-#	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(2)
-#endif
-
-// These constexprs are used for allocation behavior of data structures
-// or string handling while constructing or serializing.
-// Change them to suit your needs.
-
-constexpr s32 InitSize_DataArrays = 16;
-
-// NOTE: This limits the maximum size of an allocation
-// If you are generating a string larger than this, increase the size of the bucket here.
-constexpr usize  Global_BucketSize      = GEN_GLOBAL_BUCKET_SIZE;
-constexpr s32 CodePool_NumBlocks        = GEN_CODEPOOL_NUM_BLOCKS;
-constexpr s32 SizePer_StringArena       = GEN_SIZE_PER_STRING_ARENA;
-
-constexpr s32 MaxCommentLineLength      = GEN_MAX_COMMENT_LINE_LENGTH;
-constexpr s32 MaxNameLength             = GEN_MAX_NAME_LENGTH;
-constexpr s32 MaxUntypedStrLength       = GEN_MAX_UNTYPED_STR_LENGTH;
-// constexpr s32 TokenFmt_TokenMap_MemSize	= GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
-constexpr s32 LexAllocator_Size         = GEN_LEX_ALLOCATOR_SIZE;
-constexpr s32 Builder_StrBufferReserve  = GEN_BUILDER_STR_BUFFER_RESERVE;
-
-extern StrC enum_underlying_sig;
 
 extern Code access_public;
 extern Code access_protected;
@@ -111,6 +64,7 @@ extern CodeTypename t_typename;
 
 #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 	// Predefined typename codes. Are set to readonly and are setup during gen::init()
+	extern Context* _ctx;
 
 	extern CodeTypename t_b32;
 
@@ -132,28 +86,3 @@ extern CodeTypename t_typename;
 #endif
 
 #pragma endregion Constants
-
-// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
-// Populate with strings via gen::get_cached_string.
-// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
-extern Array(StringCached) PreprocessorDefines;
-
-#ifdef GEN_EXPOSE_BACKEND
-	// Global allocator used for data with process lifetime.
-	extern AllocatorInfo  GlobalAllocator;
-	extern Array(Arena) Global_AllocatorBuckets;
-
-	extern Array(Pool)  CodePools;
-	extern Array(Arena) StringArenas;
-
-	extern StringTable StringCache;
-
-	extern Arena LexArena;
-
-	extern AllocatorInfo Allocator_DataArrays;
-	extern AllocatorInfo Allocator_CodePool;
-	extern AllocatorInfo Allocator_Lexer;
-	extern AllocatorInfo Allocator_StringArena;
-	extern AllocatorInfo Allocator_StringTable;
-	extern AllocatorInfo Allocator_TypeTable;
-#endif

base/components/inlines.hpp

@@ -101,7 +101,7 @@ Code& Code::operator ++()
 }
 #endif
 forceinline
-StrC code_type_str(Code self)
+Str code_type_str(Code self)
 {
 	GEN_ASSERT(self != nullptr);
 	return codetype_to_str( self->Type );
@@ -397,7 +397,7 @@ CodeBody def_body( CodeType type )
 }
 
 inline
-StrC token_fmt_impl( ssize num, ... )
+Str token_fmt_impl( ssize num, ... )
 {
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
@@ -408,7 +408,7 @@ StrC token_fmt_impl( ssize num, ... )
 	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
 	va_end(va);
 
-	StrC str = { result, buf };
+	Str str = { buf, result };
 	return str;
 }
 #pragma endregion Interface

base/components/interface.cpp

@@ -3,15 +3,15 @@
 #include "code_serialization.cpp"
 #endif
 
-GEN_NS_PARSER_BEGIN
 internal void parser_init();
 internal void parser_deinit();
-GEN_NS_PARSER_END
 
 internal
-void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
+void* fallback_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
 {
-	Arena* last = array_back(Global_AllocatorBuckets);
+	GEN_ASSERT(_ctx);
+	GEN_ASSERT(_ctx->Fallback_AllocatorBuckets);
+	Arena* last = array_back(_ctx->Fallback_AllocatorBuckets);
 
 	switch ( type )
 	{
@@ -19,15 +19,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
 		{
 			if ( ( last->TotalUsed + size ) > last->TotalSize )
 			{
-				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
+				Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
 
 				if ( bucket.PhysicalStart == nullptr )
-					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
 
-				if ( ! array_append( Global_AllocatorBuckets, bucket ) )
+				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
-					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
 
-				last = array_back(Global_AllocatorBuckets);
+				last = array_back(_ctx->Fallback_AllocatorBuckets);
 			}
 
 			return alloc_align( arena_allocator_info(last), size, alignment );
@@ -46,15 +46,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
 		{
 			if ( last->TotalUsed + size > last->TotalSize )
 			{
-				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
+				Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
 
 				if ( bucket.PhysicalStart == nullptr )
-					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
 
-				if ( ! array_append( Global_AllocatorBuckets, bucket ) )
+				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
-					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
 
-				last = array_back(Global_AllocatorBuckets);
+				last = array_back( _ctx->Fallback_AllocatorBuckets);
 			}
 
 			void* result = alloc_align( last->Backing, size, alignment );
@@ -74,8 +74,12 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
 internal
 void define_constants()
 {
+	// We only initalize these if there is no base context.
+	if ( context_counter > 0 )
+		return;
+
 	Code_Global          = make_code();
-	Code_Global->Name    = get_cached_string( txt("Global Code") );
+	Code_Global->Name    = cache_str( txt("Global Code") );
 	Code_Global->Content = Code_Global->Name;
 
 	Code_Invalid = make_code();
@@ -83,41 +87,41 @@ void define_constants()
 
 	t_empty       = (CodeTypename) make_code();
 	t_empty->Type = CT_Typename;
-	t_empty->Name = get_cached_string( txt("") );
+	t_empty->Name = cache_str( txt("") );
 	code_set_global(cast(Code, t_empty));
 
 	access_private       = make_code();
 	access_private->Type = CT_Access_Private;
-	access_private->Name = get_cached_string( txt("private:\n") );
+	access_private->Name = cache_str( txt("private:\n") );
 	code_set_global(cast(Code, access_private));
 
 	access_protected       = make_code();
 	access_protected->Type = CT_Access_Protected;
-	access_protected->Name = get_cached_string( txt("protected:\n") );
+	access_protected->Name = cache_str( txt("protected:\n") );
 	code_set_global(access_protected);
 
 	access_public       = make_code();
 	access_public->Type = CT_Access_Public;
-	access_public->Name = get_cached_string( txt("public:\n") );
+	access_public->Name = cache_str( txt("public:\n") );
 	code_set_global(access_public);
 
-	StrC api_export_str = code(GEN_API_Export_Code);
+	Str api_export_str = code(GEN_API_Export_Code);
 	attrib_api_export = def_attributes( api_export_str );
 	code_set_global(cast(Code, attrib_api_export));
 
-	StrC api_import_str = code(GEN_API_Import_Code);
+	Str api_import_str = code(GEN_API_Import_Code);
 	attrib_api_import = def_attributes( api_import_str );
 	code_set_global(cast(Code, attrib_api_import));
 
 	module_global_fragment          = make_code();
 	module_global_fragment->Type    = CT_Untyped;
-	module_global_fragment->Name    = get_cached_string( txt("module;") );
+	module_global_fragment->Name    = cache_str( txt("module;") );
 	module_global_fragment->Content = module_global_fragment->Name;
 	code_set_global(cast(Code, module_global_fragment));
 
 	module_private_fragment          = make_code();
 	module_private_fragment->Type    = CT_Untyped;
-	module_private_fragment->Name    = get_cached_string( txt("module : private;") );
+	module_private_fragment->Name    = cache_str( txt("module : private;") );
 	module_private_fragment->Content = module_private_fragment->Name;
 	code_set_global(cast(Code, module_private_fragment));
 
@@ -127,13 +131,13 @@ void define_constants()
 
 	pragma_once          = (CodePragma) make_code();
 	pragma_once->Type    = CT_Preprocess_Pragma;
-	pragma_once->Name    = get_cached_string( txt("once") );
+	pragma_once->Name    = cache_str( txt("once") );
 	pragma_once->Content = pragma_once->Name;
 	code_set_global((Code)pragma_once);
 
 	param_varadic            = (CodeParams) make_code();
 	param_varadic->Type      = CT_Parameters;
-	param_varadic->Name      = get_cached_string( txt("...") );
+	param_varadic->Name      = cache_str( txt("...") );
 	param_varadic->ValueType = t_empty;
 	code_set_global((Code)param_varadic);
 
@@ -145,33 +149,33 @@ void define_constants()
 	preprocess_endif->Type = CT_Preprocess_EndIf;
 	code_set_global((Code)preprocess_endif);
 
-	StrC auto_str     = txt("auto");     t_auto     = def_type( auto_str );     code_set_global( t_auto );
+	Str auto_str     = txt("auto");     t_auto     = def_type( auto_str );     code_set_global( t_auto );
-	StrC void_str     = txt("void");     t_void     = def_type( void_str );     code_set_global( t_void );
+	Str void_str     = txt("void");     t_void     = def_type( void_str );     code_set_global( t_void );
-	StrC int_str      = txt("int");      t_int      = def_type( int_str );      code_set_global( t_int  );
+	Str int_str      = txt("int");      t_int      = def_type( int_str );      code_set_global( t_int  );
-	StrC bool_str     = txt("bool");     t_bool     = def_type( bool_str );     code_set_global( t_bool );
+	Str bool_str     = txt("bool");     t_bool     = def_type( bool_str );     code_set_global( t_bool );
-	StrC char_str     = txt("char");     t_char     = def_type( char_str );     code_set_global( t_char );
+	Str char_str     = txt("char");     t_char     = def_type( char_str );     code_set_global( t_char );
-	StrC wchar_str    = txt("wchar_t");  t_wchar_t  = def_type( wchar_str );    code_set_global( t_wchar_t );
+	Str wchar_str    = txt("wchar_t");  t_wchar_t  = def_type( wchar_str );    code_set_global( t_wchar_t );
-	StrC class_str    = txt("class");    t_class    = def_type( class_str );    code_set_global( t_class );
+	Str class_str    = txt("class");    t_class    = def_type( class_str );    code_set_global( t_class );
-	StrC typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename );
+	Str typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename );
 
 #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 	t_b32 = def_type( name(b32) ); code_set_global( t_b32 );
 
-	StrC s8_str  = txt("s8");  t_s8  = def_type( s8_str ); code_set_global( t_s8 );
+	Str s8_str  = txt("s8");  t_s8  = def_type( s8_str ); code_set_global( t_s8 );
-	StrC s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
+	Str s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
-	StrC s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
+	Str s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
-	StrC s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
+	Str s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
 
-	StrC u8_str  = txt("u8");  t_u8  = def_type( u8_str );  code_set_global( t_u8 );
+	Str u8_str  = txt("u8");  t_u8  = def_type( u8_str );  code_set_global( t_u8 );
-	StrC u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
+	Str u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
-	StrC u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
+	Str u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
-	StrC u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
+	Str u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
 
-	StrC ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
+	Str ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
-	StrC usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
+	Str usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
 
-	StrC f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
+	Str f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
-	StrC f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
+	Str f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
 #endif
 
 	spec_const            = def_specifier( Spec_Const);            code_set_global( cast(Code, spec_const ));
@@ -205,249 +209,264 @@ void define_constants()
 	if (enum_underlying_sig.Len == 0) {
 		enum_underlying_sig = txt("enum_underlying(");
 	}
-	array_append(PreprocessorDefines, enum_underlying_sig);
+	array_append( _ctx->PreprocessorDefines, enum_underlying_sig);
-
-#	undef def_constant_spec
 }
 
-void init()
+void init(Context* ctx)
 {
-	// Setup global allocator
+	do_once() {
+		context_counter = 0;
+	}
+	AllocatorInfo fallback_allocator = { & fallback_allocator_proc, nullptr };
+	
+	b32 using_fallback_allocator = false;
+	if (ctx->Allocator_DyanmicContainers.Proc == nullptr) {
+		ctx->Allocator_DyanmicContainers = fallback_allocator;
+		using_fallback_allocator = true;
+	}
+	if (ctx->Allocator_Pool.Proc == nullptr ) {
+		ctx->Allocator_Pool = fallback_allocator;
+		using_fallback_allocator = true;
+	}
+	if (ctx->Allocator_StrCache.Proc == nullptr) {
+		ctx->Allocator_StrCache = fallback_allocator;
+		using_fallback_allocator = true;
+	}
+	if (ctx->Allocator_Temp.Proc == nullptr) {
+		ctx->Allocator_Temp = fallback_allocator;
+		using_fallback_allocator = true;
+	}
+	// Setup fallback allocator
+	if (using_fallback_allocator)
 	{
-		AllocatorInfo becasue_C = { & Global_Allocator_Proc, nullptr };
+		ctx->Fallback_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
-		GlobalAllocator = becasue_C;
+		if ( ctx->Fallback_AllocatorBuckets == nullptr )
-
+			GEN_FATAL( "Failed to reserve memory for Fallback_AllocatorBuckets");
-		Global_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
-
-		if ( Global_AllocatorBuckets == nullptr )
-			GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
-
-		Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
 
+		Arena bucket = arena_init_from_allocator( heap(), ctx->InitSize_Fallback_Allocator_Bucket_Size );
 		if ( bucket.PhysicalStart == nullptr )
-			GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
+			GEN_FATAL( "Failed to create first bucket for Fallback_AllocatorBuckets");
 
-		array_append( Global_AllocatorBuckets, bucket );
+		array_append( ctx->Fallback_AllocatorBuckets, bucket );
 	}
 
-	if (Allocator_DataArrays.Proc == nullptr) {
+	if (ctx->Max_CommentLineLength == 0) {
-		Allocator_DataArrays = GlobalAllocator;
+		ctx->Max_CommentLineLength = 1024;
 	}
-	if (Allocator_CodePool.Proc == nullptr ) {
+	if (ctx->Max_StrCacheLength == 0) {
-		Allocator_CodePool = GlobalAllocator;
+		ctx->Max_StrCacheLength = kilobytes(512);
 	}
-	if (Allocator_Lexer.Proc == nullptr) {
+
-		Allocator_Lexer = GlobalAllocator;
+	if (ctx->InitSize_BuilderBuffer == 0) {
+		ctx->InitSize_BuilderBuffer = megabytes(2);
 	}
-	if (Allocator_StringArena.Proc == nullptr) {
+	if (ctx->InitSize_CodePoolsArray == 0) { 
-		Allocator_StringArena = GlobalAllocator;
+		ctx->InitSize_CodePoolsArray = 16; 
 	}
-	if (Allocator_StringTable.Proc == nullptr) {
+	if (ctx->InitSize_StringArenasArray == 0) {
-		Allocator_StringTable = GlobalAllocator;
+		ctx->InitSize_StringArenasArray = 16; 
 	}
-	if (Allocator_TypeTable.Proc == nullptr) {
+	if (ctx->CodePool_NumBlocks == 0) {
-		Allocator_TypeTable = GlobalAllocator;
+		ctx->CodePool_NumBlocks = kilobytes(16);
 	}
 
+	if (ctx->InitSize_LexArena == 0 ) {
+		ctx->InitSize_LexArena = megabytes(4);
+	}
+	if (ctx->SizePer_StringArena == 0) {
+		ctx->SizePer_StringArena = megabytes(1);
+	}
+
+	if (ctx->InitSize_Fallback_Allocator_Bucket_Size == 0) { 
+		ctx->InitSize_Fallback_Allocator_Bucket_Size = megabytes(8);
+	}
+
+	// Override the current context (user has to put it back if unwanted).
+	_ctx = ctx;
+
 	// Setup the arrays
 	{
-		CodePools = array_init_reserve(Pool, Allocator_DataArrays, InitSize_DataArrays );
+		ctx->CodePools = array_init_reserve(Pool, ctx->Allocator_DyanmicContainers, ctx->InitSize_CodePoolsArray );
-
+		if ( ctx->CodePools == nullptr )
-		if ( CodePools == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
 
-		StringArenas = array_init_reserve(Arena, Allocator_DataArrays, InitSize_DataArrays );
+		ctx->StringArenas = array_init_reserve(Arena, ctx->Allocator_DyanmicContainers, ctx->InitSize_StringArenasArray );
-
+		if ( ctx->StringArenas == nullptr )
-		if ( StringArenas == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
 	}
-
 	// Setup the code pool and code entries arena.
 	{
-		Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+		Pool code_pool = pool_init( ctx->Allocator_Pool, ctx->CodePool_NumBlocks, sizeof(AST) );
-
 		if ( code_pool.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the code pool" );
+		array_append( ctx->CodePools, code_pool );
 
-		array_append( CodePools, code_pool );
+		// TODO(Ed): This is going to be phased out most likely.
+		ctx->LexArena = arena_init_from_allocator( ctx->Allocator_DyanmicContainers, ctx->InitSize_LexArena );
 
-		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
+		// TODO(Ed): Eventually the string arenas needs to be phased out for a dedicated string slab allocator
-
+		Arena strbuilder_arena = arena_init_from_allocator( ctx->Allocator_StrCache, ctx->SizePer_StringArena );
-		Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+		if ( strbuilder_arena.PhysicalStart == nullptr )
-
-		if ( string_arena.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
-
+		array_append( ctx->StringArenas, strbuilder_arena );
-		array_append( StringArenas, string_arena );
 	}
-
 	// Setup the hash tables
 	{
-		StringCache = hashtable_init(StringCached, Allocator_StringTable);
+		ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
-
+		if ( ctx->StrCache.Entries == nullptr )
-		if ( StringCache.Entries == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
 	}
-
 	// Preprocessor Defines
-	PreprocessorDefines = array_init_reserve(StringCached, GlobalAllocator, kilobytes(1) );
+	ctx->PreprocessorDefines = array_init_reserve(StrCached, ctx->Allocator_DyanmicContainers, kilobytes(1) );
 
 	define_constants();
-	GEN_NS_PARSER parser_init();
+	parser_init();
+
+	++ context_counter;
 }
 
-void deinit()
+void deinit(Context* ctx)
 {
+	GEN_ASSERT(context_counter);
+	GEN_ASSERT_MSG(context_counter > 0, "Attempted to deinit a context that for some reason wan't accounted for!");
 	usize index = 0;
-	usize left  = array_num(CodePools);
+	usize left  = array_num(ctx->CodePools);
 	do
 	{
-		Pool* code_pool = & CodePools[index];
+		Pool* code_pool = & ctx->CodePools[index];
 		pool_free(code_pool);
 		index++;
 	}
 	while ( left--, left );
 
 	index = 0;
-	left  = array_num(StringArenas);
+	left  = array_num(ctx->StringArenas);
 	do
 	{
-		Arena* string_arena = & StringArenas[index];
+		Arena* strbuilder_arena = & ctx->StringArenas[index];
-		arena_free(string_arena);
+		arena_free(strbuilder_arena);
 		index++;
 	}
 	while ( left--, left );
 
-	hashtable_destroy(StringCache);
+	hashtable_destroy(ctx->StrCache);
 
-	array_free( CodePools);
+	array_free( ctx->CodePools);
-	array_free( StringArenas);
+	array_free( ctx->StringArenas);
 
-	arena_free(& LexArena);
+	arena_free(& ctx->LexArena);
 
-	array_free(PreprocessorDefines);
+	array_free(ctx->PreprocessorDefines);
 
-	index = 0;
+	left  = array_num( ctx->Fallback_AllocatorBuckets);
-	left  = array_num(Global_AllocatorBuckets);
+	if (left)
-	do
 	{
-		Arena* bucket = & Global_AllocatorBuckets[ index ];
+		index = 0;
-		arena_free(bucket);
+		do
-		index++;
+		{
+			Arena* bucket = & ctx->Fallback_AllocatorBuckets[ index ];
+			arena_free(bucket);
+			index++;
+		}
+		while ( left--, left );
+		array_free( ctx->Fallback_AllocatorBuckets);
 	}
-	while ( left--, left );
+	parser_deinit();
 
-	array_free(Global_AllocatorBuckets);
+	if (_ctx == ctx) 
-	GEN_NS_PARSER parser_deinit();
+		_ctx = nullptr;
+	-- context_counter;
 }
 
-void reset()
+void reset(Context* ctx)
 {
 	s32 index = 0;
-	s32 left  = array_num(CodePools);
+	s32 left  = array_num(ctx->CodePools);
 	do
 	{
-		Pool* code_pool = & CodePools[index];
+		Pool* code_pool = & ctx->CodePools[index];
 		pool_clear(code_pool);
 		index++;
 	}
 	while ( left--, left );
 
 	index = 0;
-	left  = array_num(StringArenas);
+	left  = array_num(ctx->StringArenas);
 	do
 	{
-		Arena* string_arena = & StringArenas[index];
+		Arena* strbuilder_arena = & ctx->StringArenas[index];
-		string_arena->TotalUsed = 0;;
+		strbuilder_arena->TotalUsed = 0;;
 		index++;
 	}
 	while ( left--, left );
 
-	hashtable_clear(StringCache);
+	hashtable_clear(ctx->StrCache);
-
 	define_constants();
 }
 
-AllocatorInfo get_string_allocator( s32 str_length )
+void set_context(Context* new_ctx) {
+	GEN_ASSERT(new_ctx);
+	_ctx = new_ctx;
+}
+
+AllocatorInfo get_cached_str_allocator( s32 str_length )
 {
-	Arena* last = array_back(StringArenas);
+	Arena* last     = array_back(_ctx->StringArenas);
-
+	usize  size_req = str_length + sizeof(StrBuilderHeader) + sizeof(char*);
-	usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
-
 	if ( last->TotalUsed + scast(ssize, size_req) > last->TotalSize )
 	{
-		Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+		Arena new_arena = arena_init_from_allocator( _ctx->Allocator_StrCache, _ctx->SizePer_StringArena );
+		if ( ! array_append( _ctx->StringArenas, new_arena ) )
+			GEN_FATAL( "gen::get_cached_str_allocator: Failed to allocate a new string arena" );
 
-		if ( ! array_append( StringArenas, new_arena ) )
+		last = array_back( _ctx->StringArenas);
-			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
-
-		last = array_back(StringArenas);
 	}
-
 	return arena_allocator_info(last);
 }
 
 // Will either make or retrive a code string.
-StringCached get_cached_string( StrC str )
+StrCached cache_str( Str str )
 {
-	s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len;
+	if (str.Len > _ctx->Max_StrCacheLength) {
-	u64 key         = crc32( str.Ptr, hash_length );
+		// Do not cache the string, just shove into the arena and and return it.
-	{
+		Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
-		StringCached* result = hashtable_get(StringCache, key );
+		return result;
-
+	}
+	u64 key = crc32( str.Ptr, str.Len ); {
+		StrCached* result = hashtable_get( _ctx->StrCache, key );
 		if ( result )
 			return * result;
 	}
-
+	Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
-	StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str ));
+	hashtable_set( _ctx->StrCache, key, result );
-	hashtable_set(StringCache, key, result );
-
 	return result;
 }
 
 // Used internally to retireve a Code object form the CodePool.
 Code make_code()
 {
-	Pool* allocator = array_back( CodePools);
+	Pool* allocator = array_back( _ctx->CodePools);
 	if ( allocator->FreeList == nullptr )
 	{
-		Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+		Pool code_pool = pool_init( _ctx->Allocator_Pool, _ctx->CodePool_NumBlocks, sizeof(AST) );
 
 		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( _ctx->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);
+		allocator = array_back( _ctx->CodePools);
 	}
-
 	Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) };
 	mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) );
 	return result;
 }
 
-void set_allocator_data_arrays( AllocatorInfo allocator )
+void set_preprocess_define( Str id, b32 is_functional ) {
-{
+	StrBuilder builder = strbuilder_make_str( _ctx->Allocator_Temp, id );
-	Allocator_DataArrays = allocator;
+	if (is_functional) {
-}
+		strbuilder_append_char( & builder, '(' );
-
+	}
-void set_allocator_code_pool( AllocatorInfo allocator )
+	array_append( _ctx->PreprocessorDefines, cache_str( strbuilder_to_str(builder)) ); 
-{
-	Allocator_CodePool = allocator;
-}
-
-void set_allocator_lexer( AllocatorInfo allocator )
-{
-	Allocator_Lexer = allocator;
-}
-
-void set_allocator_string_arena( AllocatorInfo allocator )
-{
-	Allocator_StringArena = allocator;
-}
-
-void set_allocator_string_table( AllocatorInfo allocator )
-{
-	Allocator_StringArena = allocator;
 }

base/components/interface.hpp

@@ -15,41 +15,121 @@
   \▓▓▓▓▓▓  \▓▓▓▓▓▓▓\▓▓   \▓▓     \▓▓▓▓▓▓\▓▓   \▓▓   \▓▓▓▓  \▓▓▓▓▓▓▓\▓▓      \▓▓       \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
 */
 
-// Initialize the library.
+#if 0
-void init();
+enum LogLevel : u32
+{
+	Info,
+	Warning,
+	Panic,
+};
+
+struct LogEntry
+{
+	Str   msg;
+	u32   line_num;
+	void* data;
+};
+
+typedef void LoggerCallback(LogEntry entry);
+#endif
+
+// Note(Ed): This is subject to heavily change 
+// with upcoming changes to the library's fallback (default) allocations strategy;
+// and major changes to lexer/parser context usage.
+struct Context
+{
+// User Configuration
+
+// Persistent Data Allocation
+	AllocatorInfo Allocator_DyanmicContainers; // By default will use a genral slab allocator (TODO(Ed): Currently does not)
+	AllocatorInfo Allocator_Pool;              // By default will use the growing vmem reserve (TODO(Ed): Currently does not)
+	AllocatorInfo Allocator_StrCache;          // By default will use a dedicated slab allocator (TODO(Ed): Currently does not)
+
+// Temporary Allocation
+	AllocatorInfo Allocator_Temp;
+
+	// LoggerCallaback* log_callback; // TODO(Ed): Impl user logger callback as an option.
+
+	u32 Max_CommentLineLength; // Used by def_comment
+	u32 Max_StrCacheLength;    // Any cached string longer than this is always allocated again.
+
+	u32 InitSize_BuilderBuffer;
+	u32 InitSize_CodePoolsArray;
+	u32 InitSize_StringArenasArray;
+
+	u32 CodePool_NumBlocks;
+
+	// TODO(Ed): Review these... (No longer needed if using the proper allocation strategy)
+	u32 InitSize_LexArena;
+	u32 SizePer_StringArena;
+
+// TODO(Ed): Symbol Table
+	// Keep track of all resolved symbols (naemspaced identifiers)
+
+// Parser
+
+	// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
+	// Populate with strings via gen::cache_str.
+	// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
+	Array(StrCached) PreprocessorDefines;
+
+// Backend
+
+	// The fallback allocator is utilized if any fo the three above allocators is not specified by the user.
+	u32 InitSize_Fallback_Allocator_Bucket_Size;
+	Array(Arena) Fallback_AllocatorBuckets;
+
+	// Array(Token) LexerTokens;
+
+	Array(Pool)  CodePools;
+	Array(Arena) StringArenas;
+
+	StringTable StrCache;
+
+	// TODO(Ed): This needs to be just handled by a parser context
+
+	Arena LexArena;
+	StringTable  Lexer_defines;
+	Array(Token) Lexer_Tokens;
+
+	// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
+	ParseContext parser;
+};
+
+// Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that
+GEN_API void init(Context* ctx);
 
 // Currently manually free's the arenas, code for checking for leaks.
 // However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
-void deinit();
+GEN_API void deinit(Context* ctx);
 
-// Clears the allocations, but doesn't return to the heap, the calls init() again.
+// Clears the allocations, but doesn't free the memoery, then calls init() again.
 // Ease of use.
-void reset();
+GEN_API void reset(Context* ctx);
+
+GEN_API void set_context(Context* ctx);
+
+// Alternative way to add a preprocess define entry for the lexer & parser to utilize 
+// if the user doesn't want to use def_define
+GEN_API void set_preprocess_define( Str id, b32 is_functional );
 
 // Used internally to retrive or make string allocations.
 // Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
-StringCached get_cached_string( StrC str );
+GEN_API StrCached cache_str( Str str );
 
 /*
 	This provides a fresh Code AST.
 	The gen interface use this as their method from getting a new AST object from the CodePool.
 	Use this if you want to make your own API for formatting the supported Code Types.
 */
-Code make_code();
+GEN_API Code make_code();
 
 // Set these before calling gen's init() procedure.
 
-void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
-void set_allocator_code_pool   ( AllocatorInfo pool_allocator );
-void set_allocator_lexer       ( AllocatorInfo lex_allocator );
-void set_allocator_string_arena( AllocatorInfo string_allocator );
-void set_allocator_string_table( AllocatorInfo string_allocator );
-void set_allocator_type_table  ( AllocatorInfo type_reg_allocator );
-
 #pragma region Upfront
 
-CodeAttributes def_attributes( StrC content );
+GEN_API CodeAttributes def_attributes( Str content );
-CodeComment    def_comment   ( StrC content );
+GEN_API CodeComment    def_comment   ( Str content );
 
 struct Opts_def_struct {
 	CodeBody       body;
@@ -60,25 +140,25 @@ struct Opts_def_struct {
 	s32            num_interfaces;
 	ModuleFlag     mflags;
 };
-CodeClass def_class( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
+GEN_API CodeClass def_class( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_constructor {
 	CodeParams params;
 	Code      initializer_list;
 	Code      body;
 };
-CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
+GEN_API CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_define {
 	b32 dont_append_preprocess_defines;
 };
-CodeDefine def_define( StrC name, StrC content, Opts_def_define opts GEN_PARAM_DEFAULT );
+GEN_API CodeDefine def_define( Str name, Str content, Opts_def_define opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_destructor {
 	Code           body;
 	CodeSpecifiers specifiers;
 };
-CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
+GEN_API CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_enum {
 	CodeBody       body;
@@ -88,11 +168,11 @@ struct Opts_def_enum {
 	ModuleFlag     mflags;
 	Code           type_macro;
 };
-CodeEnum def_enum( StrC name, Opts_def_enum opts GEN_PARAM_DEFAULT );
+GEN_API CodeEnum def_enum( Str name, Opts_def_enum opts GEN_PARAM_DEFAULT );
 
-CodeExec   def_execution  ( StrC content );
+GEN_API CodeExec   def_execution  ( Str content );
-CodeExtern def_extern_link( StrC name, CodeBody body );
+GEN_API CodeExtern def_extern_link( Str name, CodeBody body );
-CodeFriend def_friend     ( Code symbol );
+GEN_API CodeFriend def_friend     ( Code symbol );
 
 struct Opts_def_function {
 	CodeParams      params;
@@ -102,14 +182,14 @@ struct Opts_def_function {
 	CodeAttributes  attrs;
 	ModuleFlag      mflags;
 };
-CodeFn def_function( StrC name, Opts_def_function opts GEN_PARAM_DEFAULT );
+GEN_API CodeFn def_function( Str name, Opts_def_function opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_include   { b32        foreign; };
 struct Opts_def_module    { ModuleFlag mflags;  };
 struct Opts_def_namespace { ModuleFlag mflags;  };
-CodeInclude def_include  ( StrC content,             Opts_def_include   opts GEN_PARAM_DEFAULT );
+GEN_API CodeInclude def_include  ( Str content,             Opts_def_include   opts GEN_PARAM_DEFAULT );
-CodeModule  def_module   ( StrC name,                Opts_def_module    opts GEN_PARAM_DEFAULT );
+GEN_API CodeModule  def_module   ( Str name,                Opts_def_module    opts GEN_PARAM_DEFAULT );
-CodeNS      def_namespace( StrC name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
+GEN_API CodeNS      def_namespace( Str name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_operator {
 	CodeParams      params;
@@ -119,26 +199,26 @@ struct Opts_def_operator {
 	CodeAttributes  attributes;
 	ModuleFlag      mflags;
 };
-CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
+GEN_API CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_operator_cast {
 	CodeBody       body;
 	CodeSpecifiers specs;
 };
-CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
+GEN_API CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_param { Code value; };
-CodeParams  def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT );
+GEN_API CodeParams  def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
-CodePragma def_pragma( StrC directive );
+GEN_API CodePragma def_pragma( Str directive );
 
-CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
+GEN_API CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str content );
 
-CodeSpecifiers def_specifier( Specifier specifier );
+GEN_API CodeSpecifiers def_specifier( Specifier specifier );
 
-CodeStruct def_struct( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
+GEN_API CodeStruct def_struct( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_template { ModuleFlag mflags; };
-CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
+GEN_API CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_type {
 	ETypenameTag   type_tag;
@@ -146,27 +226,27 @@ struct Opts_def_type {
 	CodeSpecifiers specifiers;
 	CodeAttributes attributes;
 };
-CodeTypename def_type( StrC name, Opts_def_type opts GEN_PARAM_DEFAULT );
+GEN_API CodeTypename def_type( Str name, Opts_def_type opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_typedef {
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
 };
-CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
+GEN_API CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_union {
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
 };
-CodeUnion def_union( StrC name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT );
+GEN_API CodeUnion def_union( Str name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_using {
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
 };
-CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
+GEN_API CodeUsing def_using( Str name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
 
-CodeUsing def_using_namespace( StrC name );
+GEN_API CodeUsing def_using_namespace( Str name );
 
 struct Opts_def_variable
 {
@@ -175,36 +255,36 @@ struct Opts_def_variable
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
 };
-CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable opts GEN_PARAM_DEFAULT );
+GEN_API CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable opts GEN_PARAM_DEFAULT );
 
 // Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
-CodeBody def_body( CodeType type );
+GEN_API CodeBody def_body( CodeType type );
 
 // There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
 /// or provide as an array of Code objects.
 
-CodeBody       def_class_body      ( s32 num, ... );
+GEN_API CodeBody       def_class_body      ( s32 num, ... );
-CodeBody       def_class_body      ( s32 num, Code* codes );
+GEN_API CodeBody       def_class_body      ( s32 num, Code* codes );
-CodeBody       def_enum_body       ( s32 num, ... );
+GEN_API CodeBody       def_enum_body       ( s32 num, ... );
-CodeBody       def_enum_body       ( s32 num, Code* codes );
+GEN_API CodeBody       def_enum_body       ( s32 num, Code* codes );
-CodeBody       def_export_body     ( s32 num, ... );
+GEN_API CodeBody       def_export_body     ( s32 num, ... );
-CodeBody       def_export_body     ( s32 num, Code* codes);
+GEN_API CodeBody       def_export_body     ( s32 num, Code* codes);
-CodeBody       def_extern_link_body( s32 num, ... );
+GEN_API CodeBody       def_extern_link_body( s32 num, ... );
-CodeBody       def_extern_link_body( s32 num, Code* codes );
+GEN_API CodeBody       def_extern_link_body( s32 num, Code* codes );
-CodeBody       def_function_body   ( s32 num, ... );
+GEN_API CodeBody       def_function_body   ( s32 num, ... );
-CodeBody       def_function_body   ( s32 num, Code* codes );
+GEN_API CodeBody       def_function_body   ( s32 num, Code* codes );
-CodeBody       def_global_body     ( s32 num, ... );
+GEN_API CodeBody       def_global_body     ( s32 num, ... );
-CodeBody       def_global_body     ( s32 num, Code* codes );
+GEN_API CodeBody       def_global_body     ( s32 num, Code* codes );
-CodeBody       def_namespace_body  ( s32 num, ... );
+GEN_API CodeBody       def_namespace_body  ( s32 num, ... );
-CodeBody       def_namespace_body  ( s32 num, Code* codes );
+GEN_API CodeBody       def_namespace_body  ( s32 num, Code* codes );
-CodeParams     def_params          ( s32 num, ... );
+GEN_API CodeParams     def_params          ( s32 num, ... );
-CodeParams     def_params          ( s32 num, CodeParams* params );
+GEN_API CodeParams     def_params          ( s32 num, CodeParams* params );
-CodeSpecifiers def_specifiers      ( s32 num, ... );
+GEN_API CodeSpecifiers def_specifiers      ( s32 num, ... );
-CodeSpecifiers def_specifiers      ( s32 num, Specifier* specs );
+GEN_API CodeSpecifiers def_specifiers      ( s32 num, Specifier* specs );
-CodeBody       def_struct_body     ( s32 num, ... );
+GEN_API CodeBody       def_struct_body     ( s32 num, ... );
-CodeBody       def_struct_body     ( s32 num, Code* codes );
+GEN_API CodeBody       def_struct_body     ( s32 num, Code* codes );
-CodeBody       def_union_body      ( s32 num, ... );
+GEN_API CodeBody       def_union_body      ( s32 num, ... );
-CodeBody       def_union_body      ( s32 num, Code* codes );
+GEN_API CodeBody       def_union_body      ( s32 num, Code* codes );
 
 #pragma endregion Upfront
 
@@ -213,23 +293,21 @@ CodeBody       def_union_body      ( s32 num, Code* codes );
 // TODO(Ed) : Implmeent the new parser API design.
 
 #if 0
-GEN_NS_PARSER_BEGIN
 struct StackNode
 {
 	StackNode* Prev;
 
 	Token Start;
 	Token Name;       // The name of the AST node (if parsed)
-	StrC  FailedProc; // The name of the procedure that failed
+	Str  FailedProc; // The name of the procedure that failed
 };
 // Stack nodes are allocated the error's allocator
 
 struct Error
 {
-	String     message;
+	StrBuilder     message;
 	StackNode* context_stack;
 };
-GEN_NS_PARSER_END
 
 struct ParseInfo
 {
@@ -243,40 +321,40 @@ struct ParseInfo
 	// Errors are allocated to a dedicated general arena.
 };
 
-CodeBody parse_file( StrC path );
+CodeBody parse_file( Str path );
 #endif
 
-CodeClass       parse_class        ( StrC class_def       );
+GEN_API CodeClass       parse_class        ( Str class_def       );
-CodeConstructor parse_constructor  ( StrC constructor_def );
+GEN_API CodeConstructor parse_constructor  ( Str constructor_def );
-CodeDestructor  parse_destructor   ( StrC destructor_def  );
+GEN_API CodeDestructor  parse_destructor   ( Str destructor_def  );
-CodeEnum        parse_enum         ( StrC enum_def        );
+GEN_API CodeEnum        parse_enum         ( Str enum_def        );
-CodeBody        parse_export_body  ( StrC export_def      );
+GEN_API CodeBody        parse_export_body  ( Str export_def      );
-CodeExtern      parse_extern_link  ( StrC exten_link_def  );
+GEN_API CodeExtern      parse_extern_link  ( Str exten_link_def  );
-CodeFriend      parse_friend       ( StrC friend_def      );
+GEN_API CodeFriend      parse_friend       ( Str friend_def      );
-CodeFn          parse_function     ( StrC fn_def          );
+GEN_API CodeFn          parse_function     ( Str fn_def          );
-CodeBody        parse_global_body  ( StrC body_def        );
+GEN_API CodeBody        parse_global_body  ( Str body_def        );
-CodeNS          parse_namespace    ( StrC namespace_def   );
+GEN_API CodeNS          parse_namespace    ( Str namespace_def   );
-CodeOperator    parse_operator     ( StrC operator_def    );
+GEN_API CodeOperator    parse_operator     ( Str operator_def    );
-CodeOpCast      parse_operator_cast( StrC operator_def    );
+GEN_API CodeOpCast      parse_operator_cast( Str operator_def    );
-CodeStruct      parse_struct       ( StrC struct_def      );
+GEN_API CodeStruct      parse_struct       ( Str struct_def      );
-CodeTemplate    parse_template     ( StrC template_def    );
+GEN_API CodeTemplate    parse_template     ( Str template_def    );
-CodeTypename    parse_type         ( StrC type_def        );
+GEN_API CodeTypename    parse_type         ( Str type_def        );
-CodeTypedef     parse_typedef      ( StrC typedef_def     );
+GEN_API CodeTypedef     parse_typedef      ( Str typedef_def     );
-CodeUnion       parse_union        ( StrC union_def       );
+GEN_API CodeUnion       parse_union        ( Str union_def       );
-CodeUsing       parse_using        ( StrC using_def       );
+GEN_API CodeUsing       parse_using        ( Str using_def       );
-CodeVar         parse_variable     ( StrC var_def         );
+GEN_API CodeVar         parse_variable     ( Str var_def         );
 
 #pragma endregion Parsing
 
 #pragma region Untyped text
 
-ssize   token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
+GEN_API ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
 //! Do not use directly. Use the token_fmt macro instead.
-StrC token_fmt_impl( ssize, ... );
+GEN_API Str token_fmt_impl( ssize, ... );
 
-Code untyped_str      ( StrC content);
+GEN_API Code untyped_str( Str content);
-Code untyped_fmt      ( char const* fmt, ... );
+GEN_API Code untyped_fmt      ( char const* fmt, ... );
-Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
+GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
 
 #pragma endregion Untyped text
 
@@ -289,12 +367,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
 #ifndef name
 //	Convienence for defining any name used with the gen api.
 //  Lets you provide the length and string literal to the functions without the need for the DSL.
-#define name( Id_ )   { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
+#define name( Id_ )   { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
 #endif
 
 #ifndef code
 //  Same as name just used to indicate intention of literal for code instead of names.
-#define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
+#define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
 #endif
 
 #ifndef args
@@ -317,21 +395,21 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
 
 #ifndef token_fmt
 /*
-Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
+Takes a format string (char const*) and a list of tokens (Str) and returns a Str of the formatted string.
 Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
 ---------------------------------------------------------
 	Example - A string with:
 		typedef <type> <name> <name>;
 	Will have a token_fmt arguments populated with:
-		"type", strc_for_type,
+		"type", str_for_type,
-		"name", strc_for_name,
+		"name", str_for_name,
 	and:
 		stringize( typedef <type> <name> <name>; )
 -----------------------------------------------------------
 So the full call for this example would be:
 	token_fmt(
-		"type", strc_for_type
+		"type", str_for_type
-	,	"name", strc_for_name
+	,	"name", str_for_name
 	,	stringize(
 		typedef <type> <name> <name>
 	));

base/components/interface.parsing.cpp

@@ -8,25 +8,23 @@
 
 // Publically Exposed Interface
 
-CodeClass parse_class( StrC def )
+CodeClass parse_class( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	push_scope();
 	CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
-	parser_pop(& Context);
+	parser_pop(& _ctx->parser);
 	return result;
 }
 
-CodeConstructor parse_constructor( StrC def )
+CodeConstructor parse_constructor( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
@@ -41,7 +39,7 @@ CodeConstructor parse_constructor( StrC def )
 
 	while ( left && tok_is_specifier(currtok) )
 	{
-		Specifier spec = strc_to_specifier( tok_to_str(currtok) );
+		Specifier spec = str_to_specifier( tok_to_str(currtok) );
 
 		b32 ignore_spec = false;
 
@@ -59,8 +57,8 @@ CodeConstructor parse_constructor( StrC def )
 				break;
 
 			default :
-				log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) );
+				log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
-				parser_pop(& Context);
+				parser_pop(& _ctx->parser);
 				return InvalidCode;
 		}
 
@@ -79,14 +77,13 @@ CodeConstructor parse_constructor( StrC def )
 		// <specifiers> ...
 	}
 
-	Context.Tokens         = toks;
+	_ctx->parser.Tokens         = toks;
 	CodeConstructor result = parser_parse_constructor( specifiers );
 	return result;
 }
 
-CodeDestructor parse_destructor( StrC def )
+CodeDestructor parse_destructor( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
@@ -96,225 +93,209 @@ CodeDestructor parse_destructor( StrC def )
 	// TODO(Ed): Destructors can have prefix attributes
 	// TODO(Ed): Destructors can have virtual
 
-	Context.Tokens        = toks;
+	_ctx->parser.Tokens        = toks;
 	CodeDestructor result = parser_parse_destructor(NullCode);
 	return result;
 }
 
-CodeEnum parse_enum( StrC def )
+CodeEnum parse_enum( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 	{
-		parser_pop(& Context);
+		parser_pop(& _ctx->parser);
 		return InvalidCode;
 	}
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_enum( parser_not_inplace_def);
 }
 
-CodeBody parse_export_body( StrC def )
+CodeBody parse_export_body( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_export_body();
 }
 
-CodeExtern parse_extern_link( StrC def )
+CodeExtern parse_extern_link( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_extern_link();
 }
 
-CodeFriend parse_friend( StrC def )
+CodeFriend parse_friend( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_friend();
 }
 
-CodeFn parse_function( StrC def )
+CodeFn parse_function( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return (CodeFn) parser_parse_function();
 }
 
-CodeBody parse_global_body( StrC def )
+CodeBody parse_global_body( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	push_scope();
 	CodeBody result = parse_global_nspace( CT_Global_Body );
-	parser_pop(& Context);
+	parser_pop(& _ctx->parser);
 	return result;
 }
 
-CodeNS parse_namespace( StrC def )
+CodeNS parse_namespace( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_namespace();
 }
 
-CodeOperator parse_operator( StrC def )
+CodeOperator parse_operator( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return (CodeOperator) parser_parse_operator();
 }
 
-CodeOpCast parse_operator_cast( StrC def )
+CodeOpCast parse_operator_cast( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_operator_cast(NullCode);
 }
 
-CodeStruct parse_struct( StrC def )
+CodeStruct parse_struct( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	push_scope();
 	CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
-	parser_pop(& Context);
+	parser_pop(& _ctx->parser);
 	return result;
 }
 
-CodeTemplate parse_template( StrC def )
+CodeTemplate parse_template( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_template();
 }
 
-CodeTypename parse_type( StrC def )
+CodeTypename parse_type( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_type( parser_not_from_template, nullptr);
 }
 
-CodeTypedef parse_typedef( StrC def )
+CodeTypedef parse_typedef( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_typedef();
 }
 
-CodeUnion parse_union( StrC def )
+CodeUnion parse_union( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_union( parser_not_inplace_def);
 }
 
-CodeUsing parse_using( StrC def )
+CodeUsing parse_using( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_using();
 }
 
-CodeVar parse_variable( StrC def )
+CodeVar parse_variable( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
 	if ( toks.Arr == nullptr )
 		return InvalidCode;
 
-	Context.Tokens = toks;
+	_ctx->parser.Tokens = toks;
 	return parser_parse_variable();
 }
 

base/components/interface.untyped.cpp

@@ -8,23 +8,20 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 	char const* buf_begin = buf;
 	ssize       remaining = buf_size;
 
-	local_persist
+	local_persist StringTable tok_map;
-	TokenMap_FixedArena tok_map_arena;
+	do_once() {
-	fixed_arena_init( & tok_map_arena);
+		tok_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers );
-
+	}
-	local_persist
+	// Populate token pairs
-	StringTable tok_map;
 	{
-		tok_map = hashtable_init(StrC, fixed_arena_allocator_info(& tok_map_arena) );
-
 		s32 left = num_tokens - 1;
 
 		while ( left-- )
 		{
 			char const* token = va_arg( va, char const* );
-			StrC        value = va_arg( va, StrC );
+			Str         value = va_arg( va, Str );
 
-			u32 key = crc32( token, str_len(token) );
+			u32 key = crc32( token, c_str_len(token) );
 			hashtable_set( tok_map, key, value );
 		}
 	}
@@ -61,7 +58,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 			char const* token = fmt + 1;
 
 			u32       key   = crc32( token, tok_len );
-			StrC*     value = hashtable_get(tok_map, key );
+			Str*     value = hashtable_get(tok_map, key );
 
 			if ( value )
 			{
@@ -90,16 +87,12 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 			current = * fmt;
 		}
 	}
-
 	hashtable_clear(tok_map);
-	fixed_arena_free(& tok_map_arena);
-
 	ssize result = buf_size - remaining;
-
 	return result;
 }
 
-Code untyped_str( StrC content )
+Code untyped_str( Str content )
 {
 	if ( content.Len == 0 )
 	{
@@ -109,7 +102,7 @@ Code untyped_str( StrC content )
 
 	Code
 	result          = make_code();
-	result->Name    = get_cached_string( content );
+	result->Name    = cache_str( content );
 	result->Type    = CT_Untyped;
 	result->Content = result->Name;
 
@@ -135,17 +128,14 @@ Code untyped_fmt( char const* fmt, ...)
 
 	va_list va;
 	va_start(va, fmt);
-	ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	ssize length = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
 	va_end(va);
-
+    Str content = { buf, length };
-	StrC buf_str      = { str_len_capped(fmt, MaxNameLength), fmt };
-    StrC uncapped_str = { length, buf };
 
 	Code
 	result          = make_code();
-	result->Name    = get_cached_string( buf_str );
 	result->Type    = CT_Untyped;
-	result->Content = get_cached_string( uncapped_str );
+	result->Content = cache_str( content );
 
 	if ( result->Name.Len == 0 )
 	{
@@ -172,13 +162,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
 	ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
 	va_end(va);
 
-	StrC buf_str = { length, buf };
+	Str buf_str = { buf, length };
 
 	Code
 	result          = make_code();
-	result->Name    = get_cached_string( buf_str );
 	result->Type    = CT_Untyped;
-	result->Content = result->Name;
+	result->Content = cache_str( buf_str );
 
 	if ( result->Name.Len == 0 )
 	{

base/components/interface.upfront.cpp

@@ -373,7 +373,7 @@ OpValidateResult operator__validate( Operator op, CodeParams params_code, CodeTy
 }
 
 forceinline
-bool name__check( char const* context, StrC name )
+bool name__check( char const* context, Str name )
 {
 	if ( name.Len <= 0 ) {
 		log_failure( "gen::%s: Invalid name length provided - %d",  name.Len );
@@ -409,7 +409,7 @@ identify the issue without having to debug too much (at least they can debug tho
 The largest of the functions is related to operator overload definitions.
 The library validates a good protion of their form and thus the argument processing for is quite a bit.
 */
-CodeAttributes def_attributes( StrC content )
+CodeAttributes def_attributes( Str content )
 {
 	if ( content.Len <= 0 || content.Ptr == nullptr ) {
 		log_failure( "gen::def_attributes: Invalid attributes provided" );
@@ -419,12 +419,12 @@ CodeAttributes def_attributes( StrC content )
 	Code
 	result          = make_code();
 	result->Type    = CT_PlatformAttributes;
-	result->Name    = get_cached_string( content );
+	result->Name    = cache_str( content );
 	result->Content = result->Name;
 	return (CodeAttributes) result;
 }
 
-CodeComment def_comment( StrC content )
+CodeComment def_comment( Str content )
 {
 	if ( content.Len <= 0 || content.Ptr == nullptr )
 	{
@@ -433,9 +433,7 @@ CodeComment def_comment( StrC content )
 		return InvalidCode;
 	}
 
-	static char line[ MaxCommentLineLength ];
+	StrBuilder  cmt_formatted = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-
-	String      cmt_formatted = string_make_reserve( GlobalAllocator, kilobytes(1) );
 	char const* end           = content.Ptr + content.Len;
 	char const* scanner       = content.Ptr;
 	s32         curr          = 0;
@@ -450,26 +448,23 @@ CodeComment def_comment( StrC content )
 		}
 		length++;
 
-		str_copy( line, scanner, length );
+		strbuilder_append_fmt(& cmt_formatted, "//%.*s", length, scanner );
-		string_append_fmt(& cmt_formatted, "//%.*s", length, line );
-		mem_set( line, 0, MaxCommentLineLength );
-
 		scanner += length;
 	}
 	while ( scanner <= end );
 
-	if ( * string_back(cmt_formatted) != '\n' )
+	if ( * strbuilder_back(cmt_formatted) != '\n' )
-		string_append_strc( & cmt_formatted, txt("\n") );
+		strbuilder_append_str( & cmt_formatted, txt("\n") );
 
-	StrC name = { string_length(cmt_formatted), cmt_formatted };
+	Str name = strbuilder_to_str(cmt_formatted);
 
 	Code
 	result          = make_code();
 	result->Type    = CT_Comment;
-	result->Name    = get_cached_string( name );
+	result->Name    = cache_str( name );
 	result->Content = result->Name;
 
-	string_free(& cmt_formatted);
+	strbuilder_free(& cmt_formatted);
 
 	return (CodeComment) result;
 }
@@ -511,7 +506,7 @@ CodeConstructor def_constructor( Opts_def_constructor p )
 	return result;
 }
 
-CodeClass def_class( StrC name, Opts_def_struct p )
+CodeClass def_class( Str name, Opts_def_struct p )
 {
 	if ( ! name_check( def_class, name ) ) {
 		GEN_DEBUG_TRAP();
@@ -531,7 +526,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
 
 	CodeClass
 	result              = (CodeClass) make_code();
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->ModuleFlags = p.mflags;
 	if ( p.body )
 	{
@@ -564,7 +559,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
 	return result;
 }
 
-CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
+CodeDefine def_define( Str name, Str content, Opts_def_define p )
 {
 	if ( ! name_check( def_define, name ) ) {
 		GEN_DEBUG_TRAP();
@@ -574,12 +569,12 @@ CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
 	CodeDefine
 	result          = (CodeDefine) make_code();
 	result->Type    = CT_Preprocess_Define;
-	result->Name    = get_cached_string( name );
+	result->Name    = cache_str( name );
 
 	if ( content.Len <= 0 || content.Ptr == nullptr )
-		result->Content = get_cached_string( txt("") );
+		result->Content = cache_str( txt("") );
 	else
-		result->Content = get_cached_string( string_to_strc(string_fmt_buf(GlobalAllocator, "%SC\n", content)) );
+		result->Content = cache_str( strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S\n", content)) );
 
 	b32  append_preprocess_defines = ! p.dont_append_preprocess_defines;
 	if ( append_preprocess_defines ) {
@@ -589,8 +584,8 @@ CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
 			if ( result->Name.Ptr[lex_id_len] == '(' )
 				break;
 		}
-		StrC lex_id = { lex_id_len, result->Name.Ptr };
+		Str lex_id = { result->Name.Ptr,  lex_id_len };
-		array_append(PreprocessorDefines, lex_id );
+		array_append(_ctx->PreprocessorDefines, cache_str(lex_id) );
 	}
 	return result;
 }
@@ -629,7 +624,7 @@ CodeDestructor def_destructor( Opts_def_destructor p )
 	return result;
 }
 
-CodeEnum def_enum( StrC name, Opts_def_enum p )
+CodeEnum def_enum( Str name, Opts_def_enum p )
 {
 	if ( ! name_check( def_enum, name ) ) {
 		GEN_DEBUG_TRAP();
@@ -648,7 +643,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
 
 	CodeEnum
 	result              = (CodeEnum) make_code();
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->ModuleFlags = p.mflags;
 	if ( p.body )
 	{
@@ -690,7 +685,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
 	return result;
 }
 
-CodeExec def_execution( StrC content )
+CodeExec def_execution( Str content )
 {
 	if ( content.Len <= 0 || content.Ptr == nullptr ) {
 		log_failure( "gen::def_execution: Invalid execution provided" );
@@ -700,11 +695,11 @@ CodeExec def_execution( StrC content )
 	CodeExec
 	result          = (CodeExec) make_code();
 	result->Type    = CT_Execution;
-	result->Content = get_cached_string( content );
+	result->Content = cache_str( content );
 	return result;
 }
 
-CodeExtern def_extern_link( StrC name, CodeBody body )
+CodeExtern def_extern_link( Str name, CodeBody body )
 {
 	if ( ! name_check(def_extern_link, name) || ! null_check(def_extern_link, body) ) {
 		GEN_DEBUG_TRAP();
@@ -718,7 +713,7 @@ CodeExtern def_extern_link( StrC name, CodeBody body )
 	CodeExtern
 	result        = (CodeExtern)make_code();
 	result->Type  = CT_Extern_Linkage;
-	result->Name  = get_cached_string( name );
+	result->Name  = cache_str( name );
 	result->Body  = body;
 	return result;
 }
@@ -752,7 +747,7 @@ CodeFriend def_friend( Code declaration )
 	return result;
 }
 
-CodeFn def_function( StrC name, Opts_def_function p )
+CodeFn def_function( Str name, Opts_def_function p )
 {
 	if ( ! name_check( def_function, name )) {
 		GEN_DEBUG_TRAP();
@@ -781,7 +776,7 @@ CodeFn def_function( StrC name, Opts_def_function p )
 
 	CodeFn
 	result              = (CodeFn) make_code();
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->ModuleFlags = p.mflags;
 	if ( p.body )
 	{
@@ -812,26 +807,26 @@ CodeFn def_function( StrC name, Opts_def_function p )
 	return result;
 }
 
-CodeInclude def_include( StrC path, Opts_def_include p )
+CodeInclude def_include( Str path, Opts_def_include p )
 {
 	if ( path.Len <= 0 || path.Ptr == nullptr ) {
 		log_failure( "gen::def_include: Invalid path provided - %d" );
 		GEN_DEBUG_TRAP();
 		return InvalidCode;
 	}
-	String content = p.foreign ?
+	StrBuilder content = p.foreign ?
-			string_fmt_buf( GlobalAllocator, "<%.*s>",   path.Len, path.Ptr )
+			strbuilder_fmt_buf( _ctx->Allocator_Temp, "<%.*s>",   path.Len, path.Ptr )
-		:	string_fmt_buf( GlobalAllocator, "\"%.*s\"", path.Len, path.Ptr );
+		:	strbuilder_fmt_buf( _ctx->Allocator_Temp, "\"%.*s\"", path.Len, path.Ptr );
 
 	CodeInclude
 	result          = (CodeInclude) make_code();
 	result->Type    = CT_Preprocess_Include;
-	result->Name    = get_cached_string( string_to_strc(content) );
+	result->Name    = cache_str( strbuilder_to_str(content) );
 	result->Content = result->Name;
 	return result;
 }
 
-CodeModule def_module( StrC name, Opts_def_module p )
+CodeModule def_module( Str name, Opts_def_module p )
 {
 	if ( ! name_check( def_module, name )) {
 		GEN_DEBUG_TRAP();
@@ -840,12 +835,12 @@ CodeModule def_module( StrC name, Opts_def_module p )
 	CodeModule
 	result              = (CodeModule) make_code();
 	result->Type        = CT_Module;
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->ModuleFlags = p.mflags;
 	return result;
 }
 
-CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace p )
+CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace p )
 {
 	if ( ! name_check( def_namespace, name )) {
 		GEN_DEBUG_TRAP();
@@ -863,13 +858,13 @@ CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace p )
 	CodeNS
 	result              = (CodeNS) make_code();
 	result->Type        = CT_Namespace;
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->ModuleFlags = p.mflags;
 	result->Body        = body;
 	return result;
 }
 
-CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator p )
+CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator p )
 {
 	if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
 		log_failure( "gen::def_operator: PlatformAttributes was provided but its not of attributes type: %s", code_debug_str(p.attributes) );
@@ -889,17 +884,17 @@ CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator p )
 
 	char const* name = nullptr;
 
-	StrC op_str = operator_to_str( op );
+	Str op_str = operator_to_str( op );
 	if ( nspace.Len > 0 )
-		name = str_fmt_buf( "%.*soperator %.*s", nspace.Len, nspace.Ptr, op_str.Len, op_str.Ptr );
+		name = c_str_fmt_buf( "%.*soperator %.*s", nspace.Len, nspace.Ptr, op_str.Len, op_str.Ptr );
 	else
-		name = str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr );
+		name = c_str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr );
 
-	StrC name_resolved = { str_len(name), name };
+	Str name_resolved = { name, c_str_len(name) };
 
 	CodeOperator
 	result              = (CodeOperator) make_code();
-	result->Name        = get_cached_string( name_resolved );
+	result->Name        = cache_str( name_resolved );
 	result->ModuleFlags = p.mflags;
 	result->Op          = op;
 	if ( p.body )
@@ -969,7 +964,7 @@ CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast p )
 	return result;
 }
 
-CodeParams def_param( CodeTypename type, StrC name, Opts_def_param p )
+CodeParams def_param( CodeTypename type, Str name, Opts_def_param p )
 {
 	if ( ! name_check( def_param, name ) || ! null_check( def_param, type ) ) {
 		GEN_DEBUG_TRAP();
@@ -986,14 +981,14 @@ CodeParams def_param( CodeTypename type, StrC name, Opts_def_param p )
 	CodeParams
 	result            = (CodeParams) make_code();
 	result->Type      = CT_Parameters;
-	result->Name      = get_cached_string( name );
+	result->Name      = cache_str( name );
 	result->ValueType = type;
 	result->Value     = p.value;
 	result->NumEntries++;
 	return result;
 }
 
-CodePragma def_pragma( StrC directive )
+CodePragma def_pragma( Str directive )
 {
 	if ( directive.Len <= 0 || directive.Ptr == nullptr ) {
 		log_failure( "gen::def_comment: Invalid comment provided:" );
@@ -1003,11 +998,11 @@ CodePragma def_pragma( StrC directive )
 	CodePragma
 	result          = (CodePragma) make_code();
 	result->Type    = CT_Preprocess_Pragma;
-	result->Content = get_cached_string( directive );
+	result->Content = cache_str( directive );
 	return result;
 }
 
-CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str expr )
 {
 	if ( expr.Len <= 0 || expr.Ptr == nullptr ) {
 		log_failure( "gen::def_comment: Invalid comment provided:" );
@@ -1016,7 +1011,7 @@ CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
 	}
 	CodePreprocessCond
 	result          = (CodePreprocessCond) make_code();
-	result->Content = get_cached_string( expr );
+	result->Content = cache_str( expr );
 	switch (type)
 	{
 		case PreprocessCond_If:
@@ -1044,7 +1039,7 @@ CodeSpecifiers def_specifier( Specifier spec )
 	return result;
 }
 
-CodeStruct def_struct( StrC name, Opts_def_struct p )
+CodeStruct def_struct( Str name, Opts_def_struct p )
 {
 	if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
 		log_failure( "gen::def_struct: attributes was not a `PlatformAttributes` type - %s", code_debug_str(cast(Code, p.attributes)) );
@@ -1066,7 +1061,7 @@ CodeStruct def_struct( StrC name, Opts_def_struct p )
 	result              = (CodeStruct) make_code();
 	result->ModuleFlags = p.mflags;
 	if ( name.Len )
-		result->Name = get_cached_string( name );
+		result->Name = cache_str( name );
 
 	if ( p.body ) {
 		result->Type = CT_Struct;
@@ -1117,7 +1112,7 @@ CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_templat
 	return result;
 }
 
-CodeTypename def_type( StrC name, Opts_def_type p )
+CodeTypename def_type( Str name, Opts_def_type p )
 {
 	if ( ! name_check( def_type, name )) {
 		GEN_DEBUG_TRAP();
@@ -1143,7 +1138,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
 	}
 	CodeTypename
 	result             = (CodeTypename) make_code();
-	result->Name       = get_cached_string( name );
+	result->Name       = cache_str( name );
 	result->Type       = CT_Typename;
 	result->Attributes = p.attributes;
 	result->Specs      = p.specifiers;
@@ -1152,7 +1147,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
 	return result;
 }
 
-CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef p )
+CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef p )
 {
 	if ( ! null_check( def_typedef, type ) ) {
 		GEN_DEBUG_TRAP();
@@ -1204,18 +1199,18 @@ CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef p )
 			GEN_DEBUG_TRAP();
 			return InvalidCode;
 		}
-		result->Name       = get_cached_string( type->Name );
+		result->Name       = cache_str( type->Name );
 		result->IsFunction = true;
 	}
 	else
 	{
-		result->Name       = get_cached_string( name );
+		result->Name       = cache_str( name );
 		result->IsFunction = false;
 	}
 	return result;
 }
 
-CodeUnion def_union( StrC name, CodeBody body, Opts_def_union p )
+CodeUnion def_union( Str name, CodeBody body, Opts_def_union p )
 {
 	if ( ! null_check( def_union, body ) ) {
 		GEN_DEBUG_TRAP();
@@ -1238,11 +1233,11 @@ CodeUnion def_union( StrC name, CodeBody body, Opts_def_union p )
 	result->Body        = body;
 	result->Attributes  = p.attributes;
 	if ( name.Ptr )
-		result->Name = get_cached_string( name );
+		result->Name = cache_str( name );
 	return result;
 }
 
-CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
+CodeUsing def_using( Str name, CodeTypename type, Opts_def_using p )
 {
 	if ( ! name_check( def_using, name ) || null_check( def_using, type ) ) {
 		GEN_DEBUG_TRAP();
@@ -1262,7 +1257,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
 	}
 	CodeUsing
 	result                 = (CodeUsing) make_code();
-	result->Name           = get_cached_string( name );
+	result->Name           = cache_str( name );
 	result->ModuleFlags    = p.mflags;
 	result->Type           = CT_Using;
 	result->UnderlyingType = type;
@@ -1270,7 +1265,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
 	return result;
 }
 
-CodeUsing def_using_namespace( StrC name )
+CodeUsing def_using_namespace( Str name )
 {
 	if ( ! name_check( def_using_namespace, name ) ) {
 		GEN_DEBUG_TRAP();
@@ -1278,12 +1273,12 @@ CodeUsing def_using_namespace( StrC name )
 	}
 	CodeUsing
 	result          = (CodeUsing) make_code();
-	result->Name    = get_cached_string( name );
+	result->Name    = cache_str( name );
 	result->Type    = CT_Using_Namespace;
 	return result;
 }
 
-CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable p )
+CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable p )
 {
 	if ( ! name_check( def_variable, name ) || null_check( def_variable, type ) ) {
 		GEN_DEBUG_TRAP();
@@ -1311,7 +1306,7 @@ CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable p )
 	}
 	CodeVar
 	result              = (CodeVar) make_code();
-	result->Name        = get_cached_string( name );
+	result->Name        = cache_str( name );
 	result->Type        = CT_Variable;
 	result->ModuleFlags = p.mflags;
 	result->ValueType   = type;
@@ -1357,15 +1352,12 @@ CodeBody def_class_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::"
 						"def_class_body"
 						": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@@ -1375,7 +1367,6 @@ CodeBody def_class_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1391,18 +1382,14 @@ CodeBody def_class_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Function_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_class_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@@ -1412,7 +1399,6 @@ CodeBody def_class_body( s32 num, Code* codes )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1434,19 +1420,14 @@ CodeBody def_enum_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry ) {
-		if ( ! entry )
-		{
 			log_failure("gen::def_enum_body: Provided a null entry");
 			return InvalidCode;
 		}
-
+		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
-		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
-		{
 			log_failure("gen::def_enum_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) );
 			return InvalidCode;
 		}
-
 		body_append(result, entry );
 	}
 	while ( num--, num > 0 );
@@ -1462,23 +1443,17 @@ CodeBody def_enum_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Enum_Body;
-
 	do
 	{
 		Code entry = *codes;
-
+		if ( ! entry ) {
-		if ( ! entry )
-		{
 			log_failure("gen::def_enum_body: Provided a null entry");
 			return InvalidCode;
 		}
-
+		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
-		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
-		{
 			log_failure("gen::def_enum_body: Entry type is not allowed: %s", code_debug_str(entry) );
 			return InvalidCode;
 		}
-
 		body_append(result, entry );
 	}
 	while ( codes++, num--, num > 0 );
@@ -1500,13 +1475,11 @@ CodeBody def_export_body( s32 num, ... )
 	{
 		Code_POD pod = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry)
-		if (!entry)
 		{
 			log_failure("gen::" "def_export_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@@ -1516,7 +1489,6 @@ CodeBody def_export_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1532,18 +1504,14 @@ CodeBody def_export_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Export_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_export_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@@ -1553,7 +1521,6 @@ CodeBody def_export_body( s32 num, Code* codes )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1575,13 +1542,10 @@ CodeBody def_extern_link_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@@ -1591,7 +1555,6 @@ CodeBody def_extern_link_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1607,18 +1570,15 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Extern_Linkage_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
 		if (!entry)
 		{
 			log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@@ -1628,7 +1588,6 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1650,16 +1609,12 @@ CodeBody def_function_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" stringize(def_function_body) ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
-
 			GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES:
 				log_failure("gen::" stringize(def_function_body) ": Entry type is not allowed: %s", code_debug_str(entry));
 				return InvalidCode;
@@ -1667,7 +1622,6 @@ CodeBody def_function_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1683,18 +1637,14 @@ CodeBody def_function_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Function_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if (!entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_function_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES:
@@ -1725,13 +1675,10 @@ CodeBody def_global_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_global_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			case CT_Global_Body:
@@ -1746,7 +1693,6 @@ CodeBody def_global_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1762,18 +1708,14 @@ CodeBody def_global_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Global_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_global_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			case CT_Global_Body:
@@ -1809,13 +1751,10 @@ CodeBody def_namespace_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_namespace_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@@ -1825,7 +1764,6 @@ CodeBody def_namespace_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1841,18 +1779,14 @@ CodeBody def_namespace_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Global_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_namespace_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@@ -1861,7 +1795,6 @@ CodeBody def_namespace_body( s32 num, Code* codes )
 
 			default: break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -1880,26 +1813,20 @@ CodeParams def_params( s32 num, ... )
 	CodeParams param = pcast( CodeParams, pod );
 
 	null_check( def_params, param );
-
+	if ( param->Type != CT_Parameters ) {
-	if ( param->Type != CT_Parameters )
-	{
 		log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 );
 		return InvalidCode;
 	}
 
 	CodeParams result = (CodeParams) code_duplicate(param);
-
 	while ( -- num )
 	{
 		pod   = va_arg(va, Code_POD);
 		param = pcast( CodeParams, pod );
-
+		if ( param->Type != CT_Parameters ) {
-		if ( param->Type != CT_Parameters )
-		{
 			log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 );
 			return InvalidCode;
 		}
-
 		params_append(result, param );
 	}
 	va_end(va);
@@ -1912,18 +1839,14 @@ CodeParams def_params( s32 num, CodeParams* codes )
 	def_body_code_array_start( def_params );
 
 #	define check_current(current)                                                                                      \
-	if ( current == nullptr )                                                                                          \
+	if ( current == nullptr ) {                                                                                        \
-	{                                                                                                                  \
 		log_failure("gen::def_params: Provide a null code in codes array");                                            \
 		return InvalidCode;                                                                                            \
 	}                                                                                                                  \
-																												       \
+	if (current->Type != CT_Parameters ) {                                                                             \
-	if (current->Type != CT_Parameters )                                                                               \
-	{                                                                                                                  \
 		log_failure("gen::def_params: Code in coes array is not of paramter type - %s", code_debug_str(current) );     \
 		return InvalidCode;                                                                                            \
 	}
-
 	CodeParams current = (CodeParams)code_duplicate(* codes);
 	check_current(current);
 
@@ -1932,9 +1855,7 @@ CodeParams def_params( s32 num, CodeParams* codes )
 	result->Name      = current->Name;
 	result->Type      = current->Type;
 	result->ValueType = current->ValueType;
-
+	while( codes++, current = * codes, num--, num > 0 ) {
-	while( codes++, current = * codes, num--, num > 0 )
-	{
 		check_current(current);
 		params_append(result, current );
 	}
@@ -1945,28 +1866,22 @@ CodeParams def_params( s32 num, CodeParams* codes )
 
 CodeSpecifiers def_specifiers( s32 num, ... )
 {
-	if ( num <= 0 )
+	if ( num <= 0 ) {
-	{
 		log_failure("gen::def_specifiers: num cannot be zero or less");
 		return InvalidCode;
 	}
-
+	if ( num > AST_ArrSpecs_Cap ) {
-	if ( num > AST_ArrSpecs_Cap )
-	{
 		log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num);
 		return InvalidCode;
 	}
-
 	CodeSpecifiers
 	result       = (CodeSpecifiers) make_code();
 	result->Type = CT_Specifiers;
 
 	va_list va;
 	va_start(va, num);
-	do
+	do {
-	{
 		Specifier type = (Specifier)va_arg(va, int);
-
 		specifiers_append(result, type );
 	}
 	while ( --num, num );
@@ -1977,25 +1892,20 @@ CodeSpecifiers def_specifiers( s32 num, ... )
 
 CodeSpecifiers def_specifiers( s32 num, Specifier* specs )
 {
-	if ( num <= 0 )
+	if ( num <= 0 ) {
-	{
 		log_failure("gen::def_specifiers: num cannot be zero or less");
 		return InvalidCode;
 	}
-
+	if ( num > AST_ArrSpecs_Cap ) {
-	if ( num > AST_ArrSpecs_Cap )
-	{
 		log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num);
 		return InvalidCode;
 	}
-
 	CodeSpecifiers
 	result       = (CodeSpecifiers) make_code();
 	result->Type = CT_Specifiers;
 
 	s32 idx = 0;
-	do
+	do {
-	{
 		specifiers_append(result, specs[idx] );
 		idx++;
 	}
@@ -2018,13 +1928,10 @@ CodeBody def_struct_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast(Code, pod);
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_struct_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@@ -2034,7 +1941,6 @@ CodeBody def_struct_body( s32 num, ... )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -2050,18 +1956,14 @@ CodeBody def_struct_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Struct_Body;
-
 	do
 	{
 		Code entry = *codes;
 		codes++;
-
+		if ( ! entry) {
-		if (!entry)
-		{
 			log_failure("gen::" "def_struct_body" ": Provided an null entry");
 			return InvalidCode;
 		}
-
 		switch (entry->Type)
 		{
 			GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@@ -2071,7 +1973,6 @@ CodeBody def_struct_body( s32 num, Code* codes )
 			default:
 			break;
 		}
-
 		body_append(result, entry);
 	}
 	while (num--, num > 0);
@@ -2093,19 +1994,14 @@ CodeBody def_union_body( s32 num, ... )
 	{
 		Code_POD pod   = va_arg(va, Code_POD);
 		Code     entry = pcast( Code, pod );
-
+		if ( ! entry ) {
-		if ( ! entry )
-		{
 			log_failure("gen::def_union_body: Provided a null entry");
 			return InvalidCode;
 		}
-
+		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
-		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
-		{
 			log_failure("gen::def_union_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) );
 			return InvalidCode;
 		}
-
 		body_append(result, entry );
 	}
 	while ( num--, num > 0 );
@@ -2121,23 +2017,17 @@ CodeBody def_union_body( s32 num, Code* codes )
 	CodeBody
 	result       = (CodeBody) make_code();
 	result->Type = CT_Union_Body;
-
 	do
 	{
 		Code entry = *codes;
-
+		if ( ! entry ) {
-		if ( ! entry )
-		{
 			log_failure("gen::def_union_body: Provided a null entry");
 			return InvalidCode;
 		}
-
+		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
-		if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
-		{
 			log_failure("gen::def_union_body: Entry type is not allowed: %s", code_debug_str(entry) );
 			return InvalidCode;
 		}
-
 		body_append(result, entry );
 	}
 	while ( codes++, num--, num > 0 );

base/components/parser_types.hpp

@@ -0,0 +1,125 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "types.hpp"
+#include "gen/ecode.hpp"
+#include "gen/eoperator.hpp"
+#include "gen/especifier.hpp"
+#endif
+
+enum TokFlags : u32
+{
+	TF_Operator		   = bit(0),
+	TF_Assign          = bit(1),
+	TF_Preprocess      = bit(2),
+	TF_Preprocess_Cond = bit(3),
+	TF_Attribute       = bit(6),
+	TF_AccessOperator  = bit( 7 ),
+	TF_AccessSpecifier = bit( 8 ),
+	TF_Specifier       = bit( 9 ),
+	TF_EndDefinition   = bit( 10 ),    // Either ; or }
+	TF_Formatting      = bit( 11 ),
+	TF_Literal         = bit( 12 ),
+
+	TF_Null = 0,
+	TF_UnderlyingType = GEN_U32_MAX,
+};
+
+struct Token
+{
+	Str     Text;
+	TokType Type;
+	s32     Line;
+	s32     Column;
+	u32     Flags;
+};
+
+constexpr Token NullToken { {}, Tok_Invalid, 0, 0, TF_Null };
+
+forceinline
+AccessSpec tok_to_access_specifier(Token tok) {
+	return scast(AccessSpec, tok.Type);
+}
+
+forceinline
+Str tok_to_str(Token tok) {
+	return tok.Text;
+}
+
+forceinline
+bool tok_is_valid( Token tok ) {
+	return tok.Text.Ptr && tok.Text.Len && tok.Type != Tok_Invalid;
+}
+
+forceinline
+bool tok_is_access_operator(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_AccessOperator );
+}
+
+forceinline
+bool tok_is_access_specifier(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_AccessSpecifier );
+}
+
+forceinline
+bool tok_is_attribute(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_Attribute );
+}
+
+forceinline
+bool tok_is_operator(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_Operator );
+}
+
+forceinline
+bool tok_is_preprocessor(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_Preprocess );
+}
+
+forceinline
+bool tok_is_preprocess_cond(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_Preprocess_Cond );
+}
+
+forceinline
+bool tok_is_specifier(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_Specifier );
+}
+
+forceinline
+bool tok_is_end_definition(Token tok) {
+	return bitfield_is_equal( u32, tok.Flags, TF_EndDefinition );
+}
+
+StrBuilder tok_to_strbuilder(Token tok);
+
+struct TokArray 
+{
+	Array(Token) Arr;
+	s32          Idx;
+};
+
+struct LexContext
+{
+	Str             content;
+	s32             left;
+	char const*     scanner;
+	s32             line;
+	s32             column;
+	StringTable     defines;
+	Token           token;
+};
+
+struct StackNode
+{
+	StackNode* Prev;
+
+	Token* Start;
+	Str    Name;          // The name of the AST node (if parsed)
+	Str    ProcName;    // The name of the procedure
+};
+
+struct ParseContext
+{
+	TokArray   Tokens;
+	StackNode* Scope;
+};

base/components/static_data.cpp

@@ -4,31 +4,15 @@
 #endif
 
 #pragma region StaticData
-
+global Context* _ctx;
-// TODO : Convert global allocation strategy to use a slab allocation strategy.
-global AllocatorInfo  GlobalAllocator;
-global Array( Arena )   Global_AllocatorBuckets;
-
-// TODO(Ed) : Make the code pool a dynamic arena
-global Array( Pool )  CodePools         = { nullptr };
-global Array( Arena ) StringArenas      = { nullptr };
-
-global StringTable StringCache;
-
-global Arena LexArena;
-
-global AllocatorInfo Allocator_DataArrays  = {0};
-global AllocatorInfo Allocator_CodePool    = {0};
-global AllocatorInfo Allocator_Lexer       = {0};
-global AllocatorInfo Allocator_StringArena = {0};
-global AllocatorInfo Allocator_StringTable = {0};
-global AllocatorInfo Allocator_TypeTable   = {0};
-
-#pragma endregion StaticData
 
 #pragma region Constants
+global u32 context_counter;
 
-global StrC enum_underlying_sig;
+global Str enum_underlying_sig;
+
+global Code Code_Global;
+global Code Code_Invalid;
 
 global Code access_public;
 global Code access_protected;
@@ -84,8 +68,6 @@ global CodeTypename t_wchar_t;
 global CodeTypename t_class;
 global CodeTypename t_typename;
 
-global Array(StringCached) PreprocessorDefines;
-
 #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 global CodeTypename t_b32;
 
@@ -107,3 +89,5 @@ global CodeTypename t_f64;
 #endif
 
 #pragma endregion Constants
+
+#pragma endregion StaticData

base/components/types.hpp

@@ -44,17 +44,17 @@ enum AccessSpec : u32
 static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
 
 inline
-StrC access_spec_to_str( AccessSpec type )
+Str access_spec_to_str( AccessSpec type )
 {
 	local_persist
-	StrC lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
+	Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
-		{ sizeof("") - 1,          "" },
+		{ "",        sizeof( "" )        - 1 },
-		{ sizeof("prviate") - 1,   "private" },
+		{ "private", sizeof("prviate")   - 1 },
-		{ sizeof("protected") - 1, "private" },
+		{ "private", sizeof("protected") - 1 },
-		{ sizeof("public") - 1,    "public" },
+		{ "public",  sizeof("public")    - 1 },
 	};
 
-	StrC invalid = { sizeof("Invalid") - 1, "Invalid" };
+	Str invalid = { "Invalid", sizeof("Invalid") - 1 };
 	if ( type > AccessSpec_Public )
 		return invalid;
 
@@ -97,17 +97,17 @@ enum ModuleFlag : u32
 static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
 
 inline
-StrC module_flag_to_str( ModuleFlag flag )
+Str module_flag_to_str( ModuleFlag flag )
 {
 	local_persist
-	StrC lookup[ (u32)Num_ModuleFlags ] = {
+	Str lookup[ (u32)Num_ModuleFlags ] = {
-		{ sizeof("__none__"), "__none__" },
+		{ "__none__", sizeof("__none__") - 1 },
-		{ sizeof("export"), "export" },
+		{ "export",   sizeof("export")   - 1 },
-		{ sizeof("import"), "import" },
+		{ "import",   sizeof("import")   - 1 },
 	};
 
 	local_persist
-	StrC invalid_flag = { sizeof("invalid"), "invalid" };
+	Str invalid_flag = { "invalid", sizeof("invalid") };
 	if ( flag > ModuleFlag_Import )
 		return invalid_flag;
 

base/dependencies/containers.hpp

@@ -102,16 +102,16 @@ struct Array
 #endif
 
 #if GEN_COMPILER_CPP && 0
-template<class Type> bool         append(Array<Type>& array, Array<Type> other)                         { return append( & array, other ); }
+template<class Type> bool append(Array<Type>& array, Array<Type> other)                         { return append( & array, other ); }
-template<class Type> bool         append(Array<Type>& array, Type value)                                { return append( & array, value ); }
+template<class Type> bool append(Array<Type>& array, Type value)                                { return append( & array, value ); }
-template<class Type> bool         append(Array<Type>& array, Type* items, usize item_num)               { return append( & array, items, item_num ); }
+template<class Type> bool append(Array<Type>& array, Type* items, usize item_num)               { return append( & array, items, item_num ); }
-template<class Type> bool         append_at(Array<Type>& array, Type item, usize idx)                   { return append_at( & array, item, idx ); }
+template<class Type> bool append_at(Array<Type>& array, Type item, usize idx)                   { return append_at( & array, item, idx ); }
-template<class Type> bool         append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
+template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
-template<class Type> void         free(Array<Type>& array)                                              { return free( & array ); }
+template<class Type> void free(Array<Type>& array)                                              { return free( & array ); }
-template<class Type> bool         grow(Array<Type>& array, usize min_capacity)                          { return grow( & array, min_capacity); }
+template<class Type> bool grow(Array<Type>& array, usize min_capacity)                          { return grow( & array, min_capacity); }
-template<class Type> bool         reserve(Array<Type>& array, usize new_capacity)                       { return reserve( & array, new_capacity); }
+template<class Type> bool reserve(Array<Type>& array, usize new_capacity)                       { return reserve( & array, new_capacity); }
-template<class Type> bool         resize(Array<Type>& array, usize num)                                 { return resize( & array, num); }
+template<class Type> bool resize(Array<Type>& array, usize num)                                 { return resize( & array, num); }
-template<class Type> bool         set_capacity(Array<Type>& array, usize new_capacity)                  { return set_capacity( & array, new_capacity); }
+template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity)                  { return set_capacity( & array, new_capacity); }
 
 template<class Type> forceinline Type* begin(Array<Type>& array)             { return array;      }
 template<class Type> forceinline Type* end(Array<Type>& array)               { return array + array_get_header(array)->Num; }

base/dependencies/debug.hpp

@@ -11,8 +11,10 @@
 #if GEN_BUILD_DEBUG
 #	if defined( GEN_COMPILER_MSVC )
 #		if _MSC_VER < 1300
+#pragma message("GEN_BUILD_DEBUG: __asm int 3")
 #			define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
 #		else
+#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
 #			define GEN_DEBUG_TRAP() __debugbreak()
 #		endif
 #	elif defined( GEN_COMPILER_TINYC )
@@ -21,6 +23,7 @@
 #		define GEN_DEBUG_TRAP() __builtin_trap()
 #	endif
 #else
+#pragma message("GEN_BUILD_DEBUG: omitted")
 #	define GEN_DEBUG_TRAP()
 #endif
 
@@ -48,7 +51,7 @@
 		local_persist thread_local                         \
 		char buf[GEN_PRINTF_MAXLEN] = { 0 };               \
 		                                                   \
-		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__);      \
+		c_str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__);    \
 		GEN_PANIC(buf);                                    \
 	}                                                      \
 	while (0)
@@ -57,7 +60,8 @@
 #	define GEN_FATAL( ... )                  \
 	do                                       \
 	{                                        \
-		str_fmt_out_err( __VA_ARGS__ );      \
+		c_str_fmt_out_err( __VA_ARGS__ );    \
+		GEN_DEBUG_TRAP();                    \
 		process_exit(1);                     \
 	}                                        \
 	while (0)

base/dependencies/filesystem.cpp

@@ -18,7 +18,7 @@ wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
 			*w_len_ = w_len;
 		return NULL;
 	}
-	len = str_len( text );
+	len = c_str_len( text );
 	if ( len == 0 )
 	{
 		if ( w_len_ )
@@ -284,7 +284,7 @@ GEN_FILE_OPEN_PROC( _posix_file_open )
 
 internal void _dirinfo_free_entry( DirEntry* entry );
 
-// TODO : Is this a bad idea?
+// TODO(zpl) : Is this a bad idea?
 global b32      _std_file_set                     = false;
 global FileInfo _std_files[ EFileStandard_COUNT ] = {
 {
@@ -375,7 +375,7 @@ FileError file_close( FileInfo* f )
 FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename )
 {
 	FileError err = EFileError_NONE;
-	ssize        len = str_len( filename );
+	ssize        len = c_str_len( filename );
 
 	f->ops             = ops;
 	f->fd              = fd;

base/dependencies/filesystem.hpp

@@ -93,7 +93,7 @@ struct DirInfo
 
 	// Internals
 	char** filenames;    // zpl_array
-	String buf;
+	StrBuilder buf;
 };
 
 struct FileInfo

base/dependencies/macros.hpp

@@ -5,6 +5,24 @@
 
 #pragma region Macros
 
+#if GEN_COMPILER_MSVC
+    #ifdef GEN_DYN_LINK
+        #ifdef GEN_EXPORTS
+            #define GEN_API __declspec(dllexport)
+        #else
+            #define GEN_API __declspec(dllimport)
+        #endif
+    #else
+        #define GEN_API  // Empty for static builds
+    #endif
+#else
+    #ifdef GEN_DYN_LINK
+        #define GEN_API __attribute__((visibility("default")))
+    #else
+        #define GEN_API  // Empty for static builds
+    #endif
+#endif
+
 #ifndef global
 #define global        static    // Global variables
 #endif
@@ -69,7 +87,13 @@
 #endif
 
 #ifndef do_once
-#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
+#define do_once()                                                               \
+    static int __do_once_counter_##__LINE__ = 0;                                \
+    for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1 ) \
+
+#define do_once_defer( expression )                                                          \
+    static int __do_once_counter_##__LINE__ = 0;                                             \
+    for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1, (expression)) \
 
 #define do_once_start      \
 	do                     \

base/dependencies/parsing.cpp

@@ -8,7 +8,7 @@
 #define _adt_fprintf( s_, fmt_, ... )                      \
 	do                                                     \
 	{                                                      \
-		if ( str_fmt_file( s_, fmt_, ##__VA_ARGS__ ) < 0 ) \
+		if ( c_str_fmt_file( s_, fmt_, ##__VA_ARGS__ ) < 0 ) \
 			return EADT_ERROR_OUT_OF_MEMORY;               \
 	} while ( 0 )
 
@@ -69,7 +69,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
 
 	for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
 	{
-		if ( ! str_compare( node->nodes[ i ].name, name ) )
+		if ( ! c_str_compare( node->nodes[ i ].name, name ) )
 		{
 			return ( node->nodes + i );
 		}
@@ -96,7 +96,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 		case EADT_TYPE_MULTISTRING :
 		case EADT_TYPE_STRING :
 			{
-				if ( node->string && ! str_compare( node->string, value ) )
+				if ( node->string && ! c_str_compare( node->string, value ) )
 				{
 					return node;
 				}
@@ -115,7 +115,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 				ssize  fsize = 0;
 				u8* buf   = file_stream_buf( &tmp, &fsize );
 
-				if ( ! str_compare( ( char const* )buf, value ) )
+				if ( ! c_str_compare( ( char const* )buf, value ) )
 				{
 					file_close( &tmp );
 					return node;
@@ -135,7 +135,7 @@ internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
 {
 	for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
 	{
-		if ( ! str_compare( node->nodes[ i ].name, name ) )
+		if ( ! c_str_compare( node->nodes[ i ].name, name ) )
 		{
 			ADT_Node* child = &node->nodes[ i ];
 			if ( _adt_get_value( child, value ) )
@@ -168,22 +168,22 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	}
 
 #if defined EADT_URI_DEBUG || 0
-	str_fmt_out( "uri: %s\n", uri );
+	c_str_fmt_out( "uri: %s\n", uri );
 #endif
 
 	char *    p = ( char* )uri, *b = p, *e = p;
 	ADT_Node* found_node = NULL;
 
 	b = p;
-	p = e     = ( char* )str_skip( p, '/' );
+	p = e     = ( char* )c_str_skip( p, '/' );
-	char* buf = str_fmt_buf( "%.*s", ( int )( e - b ), b );
+	char* buf = c_str_fmt_buf( "%.*s", ( int )( e - b ), b );
 
 	/* handle field value lookup */
 	if ( *b == '[' )
 	{
 		char *l_p = buf + 1, *l_b = l_p, *l_e = l_p, *l_b2 = l_p, *l_e2 = l_p;
-		l_e  = ( char* )str_skip( l_p, '=' );
+		l_e  = ( char* )c_str_skip( l_p, '=' );
-		l_e2 = ( char* )str_skip( l_p, ']' );
+		l_e2 = ( char* )c_str_skip( l_p, ']' );
 
 		if ( ( ! *l_e && node->type != EADT_TYPE_ARRAY ) || ! *l_e2 )
 		{
@@ -257,7 +257,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	/* handle array index lookup */
 	else
 	{
-		ssize idx = ( ssize )str_to_i64( buf, NULL, 10 );
+		ssize idx = ( ssize )c_str_to_i64( buf, NULL, 10 );
 		if ( idx >= 0 && idx < scast(ssize, array_num(node->nodes)) )
 		{
 			found_node = &node->nodes[ idx ];
@@ -511,7 +511,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 	}
 	else
 	{
-		if ( ! str_compare_len( e, "0x", 2 ) || ! str_compare_len( e, "0X", 2 ) )
+		if ( ! c_str_compare_len( e, "0x", 2 ) || ! c_str_compare_len( e, "0X", 2 ) )
 		{
 			node_props = EADT_PROPS_IS_HEX;
 		}
@@ -575,12 +575,12 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 			}
 		}
 
-		orig_exp = exp = ( u8 )str_to_i64( expbuf, NULL, 10 );
+		orig_exp = exp = ( u8 )c_str_to_i64( expbuf, NULL, 10 );
 	}
 
 	if ( node_type == EADT_TYPE_INTEGER )
 	{
-		node->integer = str_to_i64( buf, 0, 0 );
+		node->integer = c_str_to_i64( buf, 0, 0 );
 #ifndef GEN_PARSER_DISABLE_ANALYSIS
 		/* special case: negative zero */
 		if ( node->integer == 0 && buf[ 0 ] == '-' )
@@ -595,19 +595,19 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 	}
 	else
 	{
-		node->real = str_to_f64( buf, 0 );
+		node->real = c_str_to_f64( buf, 0 );
 
 #ifndef GEN_PARSER_DISABLE_ANALYSIS
 		char *q = buf, *base_string = q, *base_string2 = q;
-		base_string           = ccast( char*, str_skip( base_string, '.' ));
+		base_string           = ccast( char*, c_str_skip( base_string, '.' ));
 		*base_string          = '\0';
 		base_string2          = base_string + 1;
-		char* base_string_off = base_string2;
+		char* base_strbuilder_off = base_string2;
-		while ( *base_string_off++ == '0' )
+		while ( *base_strbuilder_off++ == '0' )
 			base2_offset++;
 
-		base  = ( s32 )str_to_i64( q, 0, 0 );
+		base  = ( s32 )c_str_to_i64( q, 0, 0 );
-		base2 = ( s32 )str_to_i64( base_string2, 0, 0 );
+		base2 = ( s32 )c_str_to_i64( base_string2, 0, 0 );
 		if ( exp )
 		{
 			exp        = exp * ( ! ( eb == 10.0f ) ? -1 : 1 );
@@ -750,7 +750,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
 
 	do
 	{
-		p = str_skip_any( p, escaped_chars );
+		p = c_str_skip_any( p, escaped_chars );
 		_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
 		if ( *p && ! ! char_first_occurence( escaped_chars, *p ) )
 		{
@@ -763,7 +763,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
 	return EADT_ERROR_NONE;
 }
 
-ADT_Error adt_str_to_number( ADT_Node* node )
+ADT_Error adt_c_str_to_number( ADT_Node* node )
 {
 	GEN_ASSERT( node );
 
@@ -779,7 +779,7 @@ ADT_Error adt_str_to_number( ADT_Node* node )
 	return EADT_ERROR_NONE;
 }
 
-ADT_Error adt_str_to_number_strict( ADT_Node* node )
+ADT_Error adt_c_str_to_number_strict( ADT_Node* node )
 {
 	GEN_ASSERT( node );
 
@@ -826,7 +826,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	do
 	{
 		char delimiter = 0;
-		currentChar = ccast( char*, str_trim( currentChar, false ));
+		currentChar = ccast( char*, c_str_trim( currentChar, false ));
 
 		if ( *currentChar == 0 )
 			break;
@@ -850,7 +850,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 		#endif
 			do
 			{
-				endChar = ccast( char*, str_skip( endChar, '"' ));
+				endChar = ccast( char*, c_str_skip( endChar, '"' ));
 
 				if ( *endChar && *( endChar + 1 ) == '"' )
 				{
@@ -869,7 +869,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			}
 
 			*endChar    = 0;
-			currentChar = ccast( char*, str_trim( endChar + 1, true ));
+			currentChar = ccast( char*, c_str_trim( endChar + 1, true ));
 			delimiter   = * currentChar;
 
 			/* unescape escaped quotes (so that unescaped text escapes :) */
@@ -879,7 +879,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 				{
 					if ( *escapedChar == '"' && *( escapedChar + 1 ) == '"' )
 					{
-						mem_move( escapedChar, escapedChar + 1, str_len( escapedChar ) );
+						mem_move( escapedChar, escapedChar + 1, c_str_len( escapedChar ) );
 					}
 					escapedChar++;
 				}
@@ -906,7 +906,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 
 			if ( * endChar )
 			{
-				currentChar = ccast( char*, str_trim( endChar, true ));
+				currentChar = ccast( char*, c_str_trim( endChar, true ));
 
 				while ( char_is_space( *( endChar - 1 ) ) )
 				{
@@ -927,7 +927,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			char* num_p       = beginChar;
 
 			// We only consider hexadecimal values if they start with 0x
-			if ( str_len(num_p) > 2 && num_p[0] == '0' && (num_p[1] == 'x' || num_p[1] == 'X') )
+			if ( c_str_len(num_p) > 2 && num_p[0] == '0' && (num_p[1] == 'x' || num_p[1] == 'X') )
 			{
 				num_p += 2; // skip '0x' prefix
 				do
@@ -946,7 +946,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 
 			if (!skip_number)
 			{
-				adt_str_to_number(&rowItem);
+				adt_c_str_to_number(&rowItem);
 			}
 		}
 
@@ -1021,16 +1021,16 @@ void _csv_write_record( FileInfo* file, CSV_Object* node )
 				{
 					case EADT_NAME_STYLE_DOUBLE_QUOTE :
 						{
-							str_fmt_file( file, "\"" );
+							c_str_fmt_file( file, "\"" );
 							adt_print_string( file, node, "\"", "\"" );
-							str_fmt_file( file, "\"" );
+							c_str_fmt_file( file, "\"" );
 						}
 						break;
 
 					case EADT_NAME_STYLE_NO_QUOTES :
 						{
 #endif
-							str_fmt_file( file, "%s", node->string );
+							c_str_fmt_file( file, "%s", node->string );
 #ifndef GEN_PARSER_DISABLE_ANALYSIS
 						}
 						break;
@@ -1078,10 +1078,10 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 			_csv_write_header( file, &obj->nodes[ i ] );
 			if ( i + 1 != cols )
 			{
-				str_fmt_file( file, "%c", delimiter );
+				c_str_fmt_file( file, "%c", delimiter );
 			}
 		}
-		str_fmt_file( file, "\n" );
+		c_str_fmt_file( file, "\n" );
 	}
 
 	for ( ssize r = 0; r < rows; r++ )
@@ -1091,14 +1091,14 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 			_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
 			if ( i + 1 != cols )
 			{
-				str_fmt_file( file, "%c", delimiter );
+				c_str_fmt_file( file, "%c", delimiter );
 			}
 		}
-		str_fmt_file( file, "\n" );
+		c_str_fmt_file( file, "\n" );
 	}
 }
 
-String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimiter )
+StrBuilder csv_write_strbuilder_delimiter( AllocatorInfo a, CSV_Object* obj, char delimiter )
 {
 	FileInfo tmp;
 	file_stream_new( &tmp, a );
@@ -1106,7 +1106,7 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
 
 	ssize  fsize;
 	u8*    buf    = file_stream_buf( &tmp, &fsize );
-	String output = string_make_length( a, ( char* )buf, fsize );
+	StrBuilder output = strbuilder_make_length( a, ( char* )buf, fsize );
 	file_close( &tmp );
 	return output;
 }

base/dependencies/parsing.hpp

@@ -350,7 +350,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str );
 	* @param node
 	* @return
 	*/
-ADT_Error adt_str_to_number( ADT_Node* node );
+ADT_Error adt_c_str_to_number( ADT_Node* node );
 
 /**
 	* @brief Parses and converts an existing string node into a number.
@@ -359,7 +359,7 @@ ADT_Error adt_str_to_number( ADT_Node* node );
 	* @param node
 	* @return
 	*/
-ADT_Error adt_str_to_number_strict( ADT_Node* node );
+ADT_Error adt_c_str_to_number_strict( ADT_Node* node );
 
 /**
 	* @brief Prints a number into a file stream.
@@ -406,9 +406,9 @@ u8   csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator,
 void csv_free( CSV_Object* obj );
 
 void   csv_write( FileInfo* file, CSV_Object* obj );
-String csv_write_string( AllocatorInfo a, CSV_Object* obj );
+StrBuilder csv_write_string( AllocatorInfo a, CSV_Object* obj );
 void   csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
-String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
+StrBuilder csv_write_strbuilder_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
 
 /* inline */
 
@@ -425,9 +425,9 @@ void csv_write( FileInfo* file, CSV_Object* obj )
 }
 
 inline
-String csv_write_string( AllocatorInfo a, CSV_Object* obj )
+StrBuilder csv_write_string( AllocatorInfo a, CSV_Object* obj )
 {
-	return csv_write_string_delimiter( a, obj, ',' );
+	return csv_write_strbuilder_delimiter( a, obj, ',' );
 }
 
 #pragma endregion CSV

base/dependencies/platform.hpp

@@ -143,27 +143,15 @@
 
 #if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
 #	if GEN_COMPILER_C
-#		define GEN_NS_PARSER_BEGIN
-#		define GEN_NS_PARSER_END
-#		define GEN_USING_NS_PARSER
-#		define GEN_NS_PARSER
 #		define GEN_NS
 #		define GEN_NS_BEGIN
 #		define GEN_NS_END
 #	else
-#		define GEN_NS_PARSER_BEGIN namespace parser {
-#		define GEN_NS_PARSER_END   }
-#		define GEN_USING_NS_PARSER using namespace parser
-#		define GEN_NS_PARSER       parser::
 #		define GEN_NS              ::
 #		define GEN_NS_BEGIN
 #		define GEN_NS_END
 #	endif
 #else
-#	define GEN_NS_PARSER_BEGIN namespace parser {
-#	define GEN_NS_PARSER_END   }
-#	define GEN_NS_PARSER       parser::
-#	define GEN_USING_NS_PARSER using namespace parser
 #	define GEN_NS              gen::
 #	define GEN_NS_BEGIN        namespace gen {
 #	define GEN_NS_END          }

base/dependencies/printing.cpp

@@ -1,6 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "string_ops.cpp"
+#	include "strbuilder_ops.cpp"
 #endif
 
 #pragma region Printing
@@ -48,7 +48,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
 
 	if ( str == NULL && max_len >= 6 )
 	{
-		res += str_copy_nulpad( text, "(null)", 6 );
+		res += c_str_copy_nulpad( text, "(null)", 6 );
 		return res;
 	}
 
@@ -56,7 +56,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
 		// Made the design decision for this library that precision is the length of the string.
 		len = info->precision;
 	else
-		len = str_len( str );
+		len = c_str_len( str );
 
 	if ( info && ( info->width == 0 && info->flags & GEN_FMT_WIDTH ) )
 	{
@@ -69,7 +69,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
 			len = info->precision < len ? info->precision : len;
 		if ( res + len > max_len )
 			return res;
-		res  += str_copy_nulpad( text, str, len );
+		res  += c_str_copy_nulpad( text, str, len );
 		text += res;
 
 		if ( info->width > res )
@@ -93,15 +93,15 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
 
 		if ( res + len > max_len )
 			return res;
-		res += str_copy_nulpad( text, str, len );
+		res += c_str_copy_nulpad( text, str, len );
 	}
 
 	if ( info )
 	{
 		if ( info->flags & GEN_FMT_UPPER )
-			str_to_upper( begin );
+			c_str_to_upper( begin );
 		else if ( info->flags & GEN_FMT_LOWER )
-			str_to_lower( begin );
+			c_str_to_lower( begin );
 	}
 
 	return res;
@@ -238,7 +238,7 @@ internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is
 	return ( text - text_begin );
 }
 
-neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
+neverinline ssize c_str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
 {
 	char const* text_begin = text;
 	ssize          remaining  = max_len, res;
@@ -310,7 +310,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
 		}
 		else
 		{
-			info.width = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
+			info.width = scast( s32, c_str_to_i64( fmt, ccast( char**, & fmt), 10 ));
 			if ( info.width != 0 )
 			{
 				info.flags |= GEN_FMT_WIDTH;
@@ -328,7 +328,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
 			}
 			else
 			{
-				info.precision = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
+				info.precision = scast( s32, c_str_to_i64( fmt, ccast( char**, & fmt), 10 ));
 			}
 			info.flags &= ~GEN_FMT_ZERO;
 		}
@@ -419,19 +419,20 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
 
 			case 'S':
 			{
-				if ( *(fmt + 1) == 'C' )
+				if ( *(fmt + 1) == 'B' )
 				{
+
 					++ fmt;
-					StrC gen_str   = va_arg( va, StrC);
+					StrBuilder gen_str = { va_arg( va, char*) };
-					info.precision = gen_str.Len;
+
-					len            = _print_string( text, remaining, &info, gen_str.Ptr );
+					info.precision = strbuilder_length(gen_str);
+					len            = _print_string( text, remaining, &info, gen_str );
 					break;
 				}
 
-				String gen_str = { va_arg( va, char*) };
+				Str gen_str    = va_arg( va, Str);
-
+				info.precision = gen_str.Len;
-				info.precision = string_length(gen_str);
+				len            = _print_string( text, remaining, &info, gen_str.Ptr );
-				len            = _print_string( text, remaining, &info, gen_str );
 			}
 			break;
 
@@ -531,67 +532,67 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
 	return ( res >= max_len || res < 0 ) ? -1 : res;
 }
 
-char* str_fmt_buf_va( char const* fmt, va_list va )
+char* c_str_fmt_buf_va( char const* fmt, va_list va )
 {
 	local_persist thread_local char buffer[ GEN_PRINTF_MAXLEN ];
-	str_fmt_va( buffer, size_of( buffer ), fmt, va );
+	c_str_fmt_va( buffer, size_of( buffer ), fmt, va );
 	return buffer;
 }
 
-char* str_fmt_buf( char const* fmt, ... )
+char* c_str_fmt_buf( char const* fmt, ... )
 {
 	va_list va;
 	char*   str;
 	va_start( va, fmt );
-	str = str_fmt_buf_va( fmt, va );
+	str = c_str_fmt_buf_va( fmt, va );
 	va_end( va );
 	return str;
 }
 
-ssize str_fmt_file_va( FileInfo* f, char const* fmt, va_list va )
+ssize c_str_fmt_file_va( FileInfo* f, char const* fmt, va_list va )
 {
 	local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ];
-	ssize                              len = str_fmt_va( buf, size_of( buf ), fmt, va );
+	ssize                              len = c_str_fmt_va( buf, size_of( buf ), fmt, va );
 	b32                             res = file_write( f, buf, len - 1 );    // NOTE: prevent extra whitespace
 	return res ? len : -1;
 }
 
-ssize str_fmt_file( FileInfo* f, char const* fmt, ... )
+ssize c_str_fmt_file( FileInfo* f, char const* fmt, ... )
 {
 	ssize      res;
 	va_list va;
 	va_start( va, fmt );
-	res = str_fmt_file_va( f, fmt, va );
+	res = c_str_fmt_file_va( f, fmt, va );
 	va_end( va );
 	return res;
 }
 
-ssize str_fmt( char* str, ssize n, char const* fmt, ... )
+ssize c_str_fmt( char* str, ssize n, char const* fmt, ... )
 {
 	ssize      res;
 	va_list va;
 	va_start( va, fmt );
-	res = str_fmt_va( str, n, fmt, va );
+	res = c_str_fmt_va( str, n, fmt, va );
 	va_end( va );
 	return res;
 }
 
-ssize str_fmt_out_va( char const* fmt, va_list va )
+ssize c_str_fmt_out_va( char const* fmt, va_list va )
 {
-	return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
+	return c_str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
 }
 
-ssize str_fmt_out_err_va( char const* fmt, va_list va )
+ssize c_str_fmt_out_err_va( char const* fmt, va_list va )
 {
-	return str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va );
+	return c_str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va );
 }
 
-ssize str_fmt_out_err( char const* fmt, ... )
+ssize c_str_fmt_out_err( char const* fmt, ... )
 {
 	ssize      res;
 	va_list va;
 	va_start( va, fmt );
-	res = str_fmt_out_err_va( fmt, va );
+	res = c_str_fmt_out_err_va( fmt, va );
 	va_end( va );
 	return res;
 }

base/dependencies/printing.hpp

@@ -1,6 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "string_ops.hpp"
+#	include "strbuilder_ops.hpp"
 #endif
 
 #pragma region Printing
@@ -13,15 +13,15 @@ typedef struct FileInfo FileInfo;
 typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN];
 
 // NOTE: A locally persisting buffer is used internally
-char*  str_fmt_buf       ( char const* fmt, ... );
+char*  c_str_fmt_buf       ( char const* fmt, ... );
-char*  str_fmt_buf_va    ( char const* fmt, va_list va );
+char*  c_str_fmt_buf_va    ( char const* fmt, va_list va );
-ssize  str_fmt           ( char* str, ssize n, char const* fmt, ... );
+ssize  c_str_fmt           ( char* str, ssize n, char const* fmt, ... );
-ssize  str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
+ssize  c_str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
-ssize  str_fmt_out_va    ( char const* fmt, va_list va );
+ssize  c_str_fmt_out_va    ( char const* fmt, va_list va );
-ssize  str_fmt_out_err   ( char const* fmt, ... );
+ssize  c_str_fmt_out_err   ( char const* fmt, ... );
-ssize  str_fmt_out_err_va( char const* fmt, va_list va );
+ssize  c_str_fmt_out_err_va( char const* fmt, va_list va );
-ssize  str_fmt_file      ( FileInfo* f, char const* fmt, ... );
+ssize  c_str_fmt_file      ( FileInfo* f, char const* fmt, ... );
-ssize  str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+ssize  c_str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
 
 constexpr
 char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
@@ -33,7 +33,7 @@ ssize log_fmt(char const* fmt, ...)
 	va_list va;
 
 	va_start(va, fmt);
-	res = str_fmt_out_va(fmt, va);
+	res = c_str_fmt_out_va(fmt, va);
 	va_end(va);
 
 	return res;

base/dependencies/src_start.cpp

@@ -13,9 +13,9 @@
 #			define _printf_err( fmt, ... )   fprintf( stderr, fmt, __VA_ARGS__ )
 #			define _printf_err_va( fmt, va ) vfprintf( stderr, fmt, va )
 #		else
-#			define _strlen                   str_len
+#			define _strlen                   c_str_len
-#			define _printf_err( fmt, ... )   str_fmt_out_err( fmt, __VA_ARGS__ )
+#			define _printf_err( fmt, ... )   c_str_fmt_out_err( fmt, __VA_ARGS__ )
-#			define _printf_err_va( fmt, va ) str_fmt_out_err_va( fmt, va )
+#			define _printf_err_va( fmt, va ) c_str_fmt_out_err_va( fmt, va )
 #		endif
 #	endif
 #

base/dependencies/string_ops.cpp

@@ -18,7 +18,7 @@ ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
 		text++;
 	}
 
-	if ( base == 16 && str_compare_len( text, "0x", 2 ) == 0 )
+	if ( base == 16 && c_str_compare_len( text, "0x", 2 ) == 0 )
 		text += 2;
 
 	for ( ;; )
@@ -53,14 +53,14 @@ global const char _num_to_char_table[] =
 	"abcdefghijklmnopqrstuvwxyz"
 	"@$";
 
-s64 str_to_i64( const char* str, char** end_ptr, s32 base )
+s64 c_str_to_i64( const char* str, char** end_ptr, s32 base )
 {
 	ssize  len;
 	s64 value;
 
 	if ( ! base )
 	{
-		if ( ( str_len( str ) > 2 ) && ( str_compare_len( str, "0x", 2 ) == 0 ) )
+		if ( ( c_str_len( str ) > 2 ) && ( c_str_compare_len( str, "0x", 2 ) == 0 ) )
 			base = 16;
 		else
 			base = 10;
@@ -100,7 +100,7 @@ void i64_to_str( s64 value, char* string, s32 base )
 	if ( negative )
 		*buf++ = '-';
 	*buf = '\0';
-	str_reverse( string );
+	c_str_reverse( string );
 }
 
 void u64_to_str( u64 value, char* string, s32 base )
@@ -121,10 +121,10 @@ void u64_to_str( u64 value, char* string, s32 base )
 	}
 	*buf = '\0';
 
-	str_reverse( string );
+	c_str_reverse( string );
 }
 
-f64 str_to_f64( const char* str, char** end_ptr )
+f64 c_str_to_f64( const char* str, char** end_ptr )
 {
 	f64 result, value, sign, scale;
 	s32 frac;

base/dependencies/string_ops.hpp

@@ -18,25 +18,25 @@ char  char_to_upper( char c );
 s32  digit_to_int( char c );
 s32  hex_digit_to_int( char c );
 
-s32         str_compare( const char* s1, const char* s2 );
+s32         c_str_compare( const char* s1, const char* s2 );
-s32         str_compare_len( const char* s1, const char* s2, ssize len );
+s32         c_str_compare_len( const char* s1, const char* s2, ssize len );
-char*       str_copy( char* dest, const char* source, ssize len );
+char*       c_str_copy( char* dest, const char* source, ssize len );
-ssize       str_copy_nulpad( char* dest, const char* source, ssize len );
+ssize       c_str_copy_nulpad( char* dest, const char* source, ssize len );
-ssize       str_len( const char* str );
+ssize       c_str_len( const char* str );
-ssize       str_len_capped( const char* str, ssize max_len );
+ssize       c_str_len_capped( const char* str, ssize max_len );
-char*       str_reverse( char* str );    // NOTE: ASCII only
+char*       c_str_reverse( char* str );    // NOTE: ASCII only
-char const* str_skip( char const* str, char c );
+char const* c_str_skip( char const* str, char c );
-char const* str_skip_any( char const* str, char const* char_list );
+char const* c_str_skip_any( char const* str, char const* char_list );
-char const* str_trim( char const* str, b32 catch_newline );
+char const* c_str_trim( char const* str, b32 catch_newline );
 
 // NOTE: ASCII only
-void str_to_lower( char* str );
+void c_str_to_lower( char* str );
-void str_to_upper( char* str );
+void c_str_to_upper( char* str );
 
-s64  str_to_i64( const char* str, char** end_ptr, s32 base );
+s64  c_str_to_i64( const char* str, char** end_ptr, s32 base );
 void i64_to_str( s64 value, char* string, s32 base );
 void u64_to_str( u64 value, char* string, s32 base );
-f64  str_to_f64( const char* str, char** end_ptr );
+f64  c_str_to_f64( const char* str, char** end_ptr );
 
 inline
 const char* char_first_occurence( const char* s, char c )
@@ -122,7 +122,7 @@ s32 hex_digit_to_int( char c )
 }
 
 inline
-s32 str_compare( const char* s1, const char* s2 )
+s32 c_str_compare( const char* s1, const char* s2 )
 {
 	while ( *s1 && ( *s1 == *s2 ) )
 	{
@@ -132,7 +132,7 @@ s32 str_compare( const char* s1, const char* s2 )
 }
 
 inline
-s32 str_compare_len( const char* s1, const char* s2, ssize len )
+s32 c_str_compare_len( const char* s1, const char* s2, ssize len )
 {
 	for ( ; len > 0; s1++, s2++, len-- )
 	{
@@ -145,7 +145,7 @@ s32 str_compare_len( const char* s1, const char* s2, ssize len )
 }
 
 inline
-char* str_copy( char* dest, const char* source, ssize len )
+char* c_str_copy( char* dest, const char* source, ssize len )
 {
 	GEN_ASSERT_NOT_NULL( dest );
 	if ( source )
@@ -166,7 +166,7 @@ char* str_copy( char* dest, const char* source, ssize len )
 }
 
 inline
-ssize str_copy_nulpad( char* dest, const char* source, ssize len )
+ssize c_str_copy_nulpad( char* dest, const char* source, ssize len )
 {
 	ssize result = 0;
 	GEN_ASSERT_NOT_NULL( dest );
@@ -191,7 +191,7 @@ ssize str_copy_nulpad( char* dest, const char* source, ssize len )
 }
 
 inline
-ssize str_len( const char* str )
+ssize c_str_len( const char* str )
 {
 	if ( str == NULL )
 	{
@@ -204,7 +204,7 @@ ssize str_len( const char* str )
 }
 
 inline
-ssize str_len_capped( const char* str, ssize max_len )
+ssize c_str_len_capped( const char* str, ssize max_len )
 {
 	const char* end = rcast(const char*, mem_find( str, 0, max_len ));
 	if ( end )
@@ -213,9 +213,9 @@ ssize str_len_capped( const char* str, ssize max_len )
 }
 
 inline
-char* str_reverse( char* str )
+char* c_str_reverse( char* str )
 {
-	ssize    len  = str_len( str );
+	ssize    len  = c_str_len( str );
 	char* a    = str + 0;
 	char* b    = str + len - 1;
 	len       /= 2;
@@ -228,7 +228,7 @@ char* str_reverse( char* str )
 }
 
 inline
-char const* str_skip( char const* str, char c )
+char const* c_str_skip( char const* str, char c )
 {
 	while ( *str && *str != c )
 	{
@@ -238,20 +238,20 @@ char const* str_skip( char const* str, char c )
 }
 
 inline
-char const* str_skip_any( char const* str, char const* char_list )
+char const* c_str_skip_any( char const* str, char const* char_list )
 {
-	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), str_len( str ) ));
+	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), c_str_len( str ) ));
-	ssize       char_list_count = str_len( char_list );
+	ssize       char_list_count = c_str_len( char_list );
 	for ( ssize i = 0; i < char_list_count; i++ )
 	{
-		char const* p = str_skip( str, char_list[ i ] );
+		char const* p = c_str_skip( str, char_list[ i ] );
 		closest_ptr   = min( closest_ptr, p );
 	}
 	return closest_ptr;
 }
 
 inline
-char const* str_trim( char const* str, b32 catch_newline )
+char const* c_str_trim( char const* str, b32 catch_newline )
 {
 	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
 	{
@@ -261,7 +261,7 @@ char const* str_trim( char const* str, b32 catch_newline )
 }
 
 inline
-void str_to_lower( char* str )
+void c_str_to_lower( char* str )
 {
 	if ( ! str )
 		return;
@@ -273,7 +273,7 @@ void str_to_lower( char* str )
 }
 
 inline
-void str_to_upper( char* str )
+void c_str_to_upper( char* str )
 {
 	if ( ! str )
 		return;

base/dependencies/strings.cpp

@@ -3,27 +3,27 @@
 #	include "hashing.cpp"
 #endif
 
-#pragma region String
+#pragma region StrBuilder
 
-String string_make_length( AllocatorInfo allocator, char const* str, ssize length )
+StrBuilder strbuilder_make_length( AllocatorInfo allocator, char const* str, ssize length )
 {
-	ssize const header_size = sizeof( StringHeader );
+	ssize const header_size = sizeof( StrBuilderHeader );
 
 	s32   alloc_size = header_size + length + 1;
 	void* allocation = alloc( allocator, alloc_size );
 
 	if ( allocation == nullptr ) {
-		String null_string = {nullptr};
+		StrBuilder null_string = {nullptr};
 		return null_string;
 	}
 
-	StringHeader*
+	StrBuilderHeader*
-	header = rcast(StringHeader*, allocation);
+	header = rcast(StrBuilderHeader*, allocation);
 	header->Allocator = allocator;
 	header->Capacity  = length;
 	header->Length    = length;
 
-	String  result = { rcast( char*, allocation) + header_size };
+	StrBuilder  result = { rcast( char*, allocation) + header_size };
 
 	if ( length && str )
 		mem_copy( result, str, length );
@@ -35,27 +35,27 @@ String string_make_length( AllocatorInfo allocator, char const* str, ssize lengt
 	return result;
 }
 
-String string_make_reserve( AllocatorInfo allocator, ssize capacity )
+StrBuilder strbuilder_make_reserve( AllocatorInfo allocator, ssize capacity )
 {
-	ssize const header_size = sizeof( StringHeader );
+	ssize const header_size = sizeof( StrBuilderHeader );
 
 	s32   alloc_size = header_size + capacity + 1;
 	void* allocation = alloc( allocator, alloc_size );
 
 	if ( allocation == nullptr ) {
-		String null_string = {nullptr};
+		StrBuilder null_string = {nullptr};
 		return null_string;
 	}
 	mem_set( allocation, 0, alloc_size );
 
-	StringHeader*
+	StrBuilderHeader*
-	header            = rcast(StringHeader*, allocation);
+	header            = rcast(StrBuilderHeader*, allocation);
 	header->Allocator = allocator;
 	header->Capacity  = capacity;
 	header->Length    = 0;
 
-	String result = { rcast(char*, allocation) + header_size };
+	StrBuilder result = { rcast(char*, allocation) + header_size };
 	return result;
 }
 
-#pragma endregion String
+#pragma endregion StrBuilder

base/dependencies/strings.hpp

@@ -5,61 +5,61 @@
 
 #pragma region Strings
 
-struct StrC;
+struct Str;
 
-StrC        to_strc_from_c_str       (char const* bad_string);
+Str         to_str_from_c_str       (char const* bad_string);
-bool        strc_are_equal           (StrC lhs, StrC rhs);
+bool        str_are_equal           (Str lhs, Str rhs);
-char const* strc_back                (StrC str);
+char const* str_back                (Str str);
-bool        strc_contains            (StrC str, StrC substring);
+bool        str_contains            (Str str, Str substring);
-StrC        strc_duplicate           (StrC str, AllocatorInfo allocator);
+Str         str_duplicate           (Str str, AllocatorInfo allocator);
-b32         strc_starts_with         (StrC str, StrC substring);
+b32         str_starts_with         (Str str, Str substring);
-StrC        strc_visualize_whitespace(StrC str, AllocatorInfo allocator);
+Str         str_visualize_whitespace(Str str, AllocatorInfo allocator);
 
 // Constant string with length.
-struct StrC
+struct Str
 {
-	ssize       Len;
 	char const* Ptr;
+	ssize       Len;
 
 #if GEN_COMPILER_CPP
 	forceinline operator char const* ()               const { return Ptr; }
 	forceinline char const& operator[]( ssize index ) const { return Ptr[index]; }
 
 #if ! GEN_C_LIKE_CPP
-	forceinline bool        is_equal            (StrC rhs)                const { return strc_are_equal(* this, rhs); }
+	forceinline bool        is_equal            (Str rhs)                 const { return str_are_equal(* this, rhs); }
-	forceinline char const* back                ()                        const { return strc_back(* this); }
+	forceinline char const* back                ()                        const { return str_back(* this); }
-	forceinline bool        contains            (StrC substring)          const { return strc_contains(* this, substring); }
+	forceinline bool        contains            (Str substring)           const { return str_contains(* this, substring); }
-	forceinline StrC        duplicate           (AllocatorInfo allocator) const { return strc_duplicate(* this, allocator); }
+	forceinline Str         duplicate           (AllocatorInfo allocator) const { return str_duplicate(* this, allocator); }
-	forceinline b32         starts_with         (StrC substring)          const { return strc_starts_with(* this, substring); }
+	forceinline b32         starts_with         (Str substring)           const { return str_starts_with(* this, substring); }
-	forceinline StrC        visualize_whitespace(AllocatorInfo allocator) const { return strc_visualize_whitespace(* this, allocator); }
+	forceinline Str         visualize_whitespace(AllocatorInfo allocator) const { return str_visualize_whitespace(* this, allocator); }
 #endif
 #endif
 };
 
-#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
+#define cast_to_str( str ) * rcast( Str*, (str) - sizeof(ssize) )
 
 #ifndef txt
 #	if GEN_COMPILER_CPP
-#		define txt( text )          StrC { sizeof( text ) - 1, ( text ) }
+#		define txt( text )          Str { ( text ), sizeof( text ) - 1 }
 #	else
-#		define txt( text )         (StrC){ sizeof( text ) - 1, ( text ) }
+#		define txt( text )         (Str){ ( text ), sizeof( text ) - 1 }
 #	endif
 #endif
 
 GEN_API_C_BEGIN
-forceinline char const* strc_begin(StrC str)                   { return str.Ptr; }
+forceinline char const* str_begin(Str str)                   { return str.Ptr; }
-forceinline char const* strc_end  (StrC str)                   { return str.Ptr + str.Len; }
+forceinline char const* str_end  (Str str)                   { return str.Ptr + str.Len; }
-forceinline char const* strc_next (StrC str, char const* iter) { return iter + 1; }
+forceinline char const* str_next (Str str, char const* iter) { return iter + 1; }
 GEN_API_C_END
 
 #if GEN_COMPILER_CPP
-forceinline char const* begin(StrC str)                   { return str.Ptr; }
+forceinline char const* begin(Str str)                   { return str.Ptr; }
-forceinline char const* end  (StrC str)                   { return str.Ptr + str.Len; }
+forceinline char const* end  (Str str)                   { return str.Ptr + str.Len; }
-forceinline char const* next (StrC str, char const* iter) { return iter + 1; }
+forceinline char const* next (Str str, char const* iter) { return iter + 1; }
 #endif
 
 inline
-bool strc_are_equal(StrC lhs, StrC rhs)
+bool str_are_equal(Str lhs, Str rhs)
 {
 	if (lhs.Len != rhs.Len)
 		return false;
@@ -72,12 +72,12 @@ bool strc_are_equal(StrC lhs, StrC rhs)
 }
 
 inline
-char const* strc_back(StrC str) {
+char const* str_back(Str str) {
 	return & str.Ptr[str.Len - 1];
 }
 
 inline
-bool strc_contains(StrC str, StrC substring)
+bool str_contains(Str str, Str substring)
 {
 	if (substring.Len > str.Len)
 		return false;
@@ -86,97 +86,97 @@ bool strc_contains(StrC str, StrC substring)
 	ssize sub_len  = substring.Len;
 	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
 	{
-		if (str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
+		if (c_str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
 			return true;
 	}
 	return false;
 }
 
 inline
-b32 strc_starts_with(StrC str, StrC substring) {
+b32 str_starts_with(Str str, Str substring) {
 	if (substring.Len > str.Len)
 		return false;
 
-	b32 result = str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
+	b32 result = c_str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
 		return result;
 }
 
 inline
-StrC to_strc_from_c_str( char const* bad_str ) {
+Str to_str_from_c_str( char const* bad_str ) {
-	StrC result = { str_len( bad_str ), bad_str };
+	Str result = { bad_str, c_str_len( bad_str ) };
 	return result;
 }
 
-// Dynamic String
+// Dynamic StrBuilder
 // This is directly based off the ZPL string api.
 // They used a header pattern
 // I kept it for simplicty of porting but its not necessary to keep it that way.
-#pragma region String
+#pragma region StrBuilder
-struct StringHeader;
+struct StrBuilderHeader;
 
 #if GEN_COMPILER_C
-typedef char* String;
+typedef char* StrBuilder;
 #else
-struct String;
+struct StrBuilder;
 #endif
 
-forceinline usize string_grow_formula(usize value);
+forceinline usize strbuilder_grow_formula(usize value);
 
-String        string_make_c_str          (AllocatorInfo allocator, char const*  str);
+StrBuilder        strbuilder_make_c_str          (AllocatorInfo allocator, char const*  str);
-String        string_make_strc           (AllocatorInfo allocator, StrC         str);
+StrBuilder        strbuilder_make_str            (AllocatorInfo allocator, Str         str);
-String        string_make_reserve        (AllocatorInfo allocator, ssize        capacity);
+StrBuilder        strbuilder_make_reserve        (AllocatorInfo allocator, ssize        capacity);
-String        string_make_length         (AllocatorInfo allocator, char const*  str,   ssize length);
+StrBuilder        strbuilder_make_length         (AllocatorInfo allocator, char const*  str,   ssize length);
-String        string_fmt                 (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
+StrBuilder        strbuilder_fmt                 (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
-String        string_fmt_buf             (AllocatorInfo allocator, char const*  fmt, ...);
+StrBuilder        strbuilder_fmt_buf             (AllocatorInfo allocator, char const*  fmt, ...);
-String        string_join                (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
+StrBuilder        strbuilder_join                (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
-bool          string_are_equal           (String const lhs, String const rhs);
+bool              strbuilder_are_equal           (StrBuilder const lhs, StrBuilder const rhs);
-bool          string_are_equal_strc      (String const lhs, StrC rhs);
+bool              strbuilder_are_equal_str       (StrBuilder const lhs, Str rhs);
-bool          string_make_space_for      (String*      str, char const*  to_append, ssize add_len);
+bool              strbuilder_make_space_for      (StrBuilder*      str, char const*  to_append, ssize add_len);
-bool          string_append_char         (String*      str, char         c);
+bool              strbuilder_append_char         (StrBuilder*      str, char         c);
-bool          string_append_c_str        (String*      str, char const*  str_to_append);
+bool              strbuilder_append_c_str        (StrBuilder*      str, char const*  c_str_to_append);
-bool          string_append_c_str_len    (String*      str, char const*  str_to_append, ssize length);
+bool              strbuilder_append_c_str_len    (StrBuilder*      str, char const*  c_str_to_append, ssize length);
-bool          string_append_strc         (String*      str, StrC         str_to_append);
+bool              strbuilder_append_str          (StrBuilder*      str, Str         c_str_to_append);
-bool          string_append_string       (String*      str, String const other);
+bool              strbuilder_append_string       (StrBuilder*      str, StrBuilder const other);
-bool          string_append_fmt          (String*      str, char const*  fmt, ...);
+bool              strbuilder_append_fmt          (StrBuilder*      str, char const*  fmt, ...);
-ssize         string_avail_space         (String const str);
+ssize             strbuilder_avail_space         (StrBuilder const str);
-char*         string_back                (String       str);
+char*             strbuilder_back                (StrBuilder       str);
-bool          string_contains_strc       (String const str, StrC         substring);
+bool              strbuilder_contains_str        (StrBuilder const str, Str         substring);
-bool          string_contains_string     (String const str, String const substring);
+bool              strbuilder_contains_string     (StrBuilder const str, StrBuilder const substring);
-ssize         string_capacity            (String const str);
+ssize             strbuilder_capacity            (StrBuilder const str);
-void          string_clear               (String       str);
+void              strbuilder_clear               (StrBuilder       str);
-String        string_duplicate           (String const str, AllocatorInfo allocator);
+StrBuilder        strbuilder_duplicate           (StrBuilder const str, AllocatorInfo allocator);
-void          string_free                (String*      str);
+void              strbuilder_free                (StrBuilder*      str);
-StringHeader* string_get_header          (String       str);
+StrBuilderHeader* strbuilder_get_header          (StrBuilder       str);
-ssize         string_length              (String const str);
+ssize             strbuilder_length              (StrBuilder const str);
-b32           string_starts_with_strc    (String const str, StrC   substring);
+b32               strbuilder_starts_with_str     (StrBuilder const str, Str   substring);
-b32           string_starts_with_string  (String const str, String substring);
+b32               strbuilder_starts_with_string  (StrBuilder const str, StrBuilder substring);
-void          string_skip_line           (String       str);
+void              strbuilder_skip_line           (StrBuilder       str);
-void          string_strip_space         (String       str);
+void              strbuilder_strip_space         (StrBuilder       str);
-StrC          string_to_strc             (String       str);
+Str               strbuilder_to_str              (StrBuilder       str);
-void          string_trim                (String       str, char const* cut_set);
+void              strbuilder_trim                (StrBuilder       str, char const* cut_set);
-void          string_trim_space          (String       str);
+void              strbuilder_trim_space          (StrBuilder       str);
-String        string_visualize_whitespace(String const str);
+StrBuilder        strbuilder_visualize_whitespace(StrBuilder const str);
 
-struct StringHeader {
+struct StrBuilderHeader {
 	AllocatorInfo Allocator;
 	ssize         Capacity;
 	ssize         Length;
 };
 
 #if GEN_COMPILER_CPP
-struct String
+struct StrBuilder
 {
 	char* Data;
 
 	forceinline operator char*()             { return Data; }
 	forceinline operator char const*() const { return Data; }
-	forceinline operator StrC()        const { return { string_length(* this), Data }; }
+	forceinline operator Str()         const { return { Data, strbuilder_length(* this) }; }
 
-	String const& operator=(String const& other) const {
+	StrBuilder const& operator=(StrBuilder const& other) const {
 		if (this == &other)
 			return *this;
 
-		String* this_ = ccast(String*, this);
+		StrBuilder* this_ = ccast(StrBuilder*, this);
 		this_->Data = other.Data;
 
 		return *this;
@@ -185,69 +185,69 @@ struct String
 	forceinline char&       operator[](ssize index)       { return Data[index]; }
 	forceinline char const& operator[](ssize index) const { return Data[index]; }
 
-	       forceinline bool operator==(std::nullptr_t) const             { return     Data == nullptr; }
+	       forceinline bool operator==(std::nullptr_t) const                 { return     Data == nullptr; }
-	       forceinline bool operator!=(std::nullptr_t) const             { return     Data != nullptr; }
+	       forceinline bool operator!=(std::nullptr_t) const                 { return     Data != nullptr; }
-	friend forceinline bool operator==(std::nullptr_t, const String str) { return str.Data == nullptr; }
+	friend forceinline bool operator==(std::nullptr_t, const StrBuilder str) { return str.Data == nullptr; }
-	friend forceinline bool operator!=(std::nullptr_t, const String str) { return str.Data != nullptr; }
+	friend forceinline bool operator!=(std::nullptr_t, const StrBuilder str) { return str.Data != nullptr; }
 
 #if ! GEN_C_LIKE_CPP
 	forceinline char* begin() const { return Data; }
-	forceinline char* end()   const { return Data + string_length(* this); }
+	forceinline char* end()   const { return Data + strbuilder_length(* this); }
 
 #pragma region Member Mapping
-	forceinline static String make(AllocatorInfo allocator, char const* str)                { return string_make_c_str(allocator, str); }
+	forceinline static StrBuilder make(AllocatorInfo allocator, char const* str)                { return strbuilder_make_c_str(allocator, str); }
-	forceinline static String make(AllocatorInfo allocator, StrC str)                       { return string_make_strc(allocator, str); }
+	forceinline static StrBuilder make(AllocatorInfo allocator, Str str)                        { return strbuilder_make_str(allocator, str); }
-	forceinline static String make_reserve(AllocatorInfo allocator, ssize cap)              { return string_make_reserve(allocator, cap); }
+	forceinline static StrBuilder make_reserve(AllocatorInfo allocator, ssize cap)              { return strbuilder_make_reserve(allocator, cap); }
-	forceinline static String make_length(AllocatorInfo a, char const* s, ssize l)          { return string_make_length(a, s, l); }
+	forceinline static StrBuilder make_length(AllocatorInfo a, char const* s, ssize l)          { return strbuilder_make_length(a, s, l); }
-	forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return string_join(a, p, n, g); }
+	forceinline static StrBuilder join(AllocatorInfo a, char const** p, ssize n, char const* g) { return strbuilder_join(a, p, n, g); }
-	forceinline static usize  grow_formula(usize value)                                     { return string_grow_formula(value); }
+	forceinline static usize      grow_formula(usize value)                                     { return strbuilder_grow_formula(value); }
 
 	static
-	String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+	StrBuilder fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
 		va_list va;
 		va_start(va, fmt);
-		ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1;
+		ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
 		va_end(va);
-		return string_make_length(allocator, buf, res);
+		return strbuilder_make_length(allocator, buf, res);
 	}
 
 	static
-	String fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
+	StrBuilder fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
 		local_persist thread_local
 		char buf[GEN_PRINTF_MAXLEN] = { 0 };
 		va_list va;
 		va_start(va, fmt);
-		ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
+		ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
 		va_end(va);
-		return string_make_length(allocator, buf, res);
+		return strbuilder_make_length(allocator, buf, res);
 	}
 
-	forceinline bool          make_space_for(char const* str, ssize add_len) { return string_make_space_for(this, str, add_len); }
+	forceinline bool              make_space_for(char const* str, ssize add_len) { return strbuilder_make_space_for(this, str, add_len); }
-	forceinline bool          append(char c)                                 { return string_append_char(this, c); }
+	forceinline bool              append(char c)                                 { return strbuilder_append_char(this, c); }
-	forceinline bool          append(char const* str)                        { return string_append_c_str(this, str); }
+	forceinline bool              append(char const* str)                        { return strbuilder_append_c_str(this, str); }
-	forceinline bool          append(char const* str, ssize length)          { return string_append_c_str_len(this, str, length); }
+	forceinline bool              append(char const* str, ssize length)          { return strbuilder_append_c_str_len(this, str, length); }
-	forceinline bool          append(StrC str)                               { return string_append_strc(this, str); }
+	forceinline bool              append(Str str)                                { return strbuilder_append_str(this, str); }
-	forceinline bool          append(const String other)                     { return string_append_string(this, other); }
+	forceinline bool              append(const StrBuilder other)                 { return strbuilder_append_string(this, other); }
-	forceinline ssize         avail_space() const                            { return string_avail_space(* this); }
+	forceinline ssize             avail_space() const                            { return strbuilder_avail_space(* this); }
-	forceinline char*         back()                                         { return string_back(* this); }
+	forceinline char*             back()                                         { return strbuilder_back(* this); }
-	forceinline bool          contains(StrC substring) const                 { return string_contains_strc(* this, substring); }
+	forceinline bool              contains(Str substring) const                  { return strbuilder_contains_str(* this, substring); }
-	forceinline bool          contains(String const& substring) const        { return string_contains_string(* this, substring); }
+	forceinline bool              contains(StrBuilder const& substring) const    { return strbuilder_contains_string(* this, substring); }
-	forceinline ssize         capacity() const                               { return string_capacity(* this); }
+	forceinline ssize             capacity() const                               { return strbuilder_capacity(* this); }
-	forceinline void          clear()                                        {        string_clear(* this); }
+	forceinline void              clear()                                        {        strbuilder_clear(* this); }
-	forceinline String        duplicate(AllocatorInfo allocator) const       { return string_duplicate(* this, allocator); }
+	forceinline StrBuilder        duplicate(AllocatorInfo allocator) const       { return strbuilder_duplicate(* this, allocator); }
-	forceinline void          free()                                         {        string_free(this); }
+	forceinline void              free()                                         {        strbuilder_free(this); }
-	forceinline bool          is_equal(String const& other) const            { return string_are_equal(* this, other); }
+	forceinline bool              is_equal(StrBuilder const& other) const        { return strbuilder_are_equal(* this, other); }
-	forceinline bool          is_equal(StrC other) const                     { return string_are_equal_strc(* this, other); }
+	forceinline bool              is_equal(Str other) const                      { return strbuilder_are_equal_str(* this, other); }
-	forceinline ssize         length() const                                 { return string_length(* this); }
+	forceinline ssize             length() const                                 { return strbuilder_length(* this); }
-	forceinline b32           starts_with(StrC substring) const              { return string_starts_with_strc(* this, substring); }
+	forceinline b32               starts_with(Str substring) const               { return strbuilder_starts_with_str(* this, substring); }
-	forceinline b32           starts_with(String substring) const            { return string_starts_with_string(* this, substring); }
+	forceinline b32               starts_with(StrBuilder substring) const        { return strbuilder_starts_with_string(* this, substring); }
-	forceinline void          skip_line()                                    {        string_skip_line(* this); }
+	forceinline void              skip_line()                                    {        strbuilder_skip_line(* this); }
-	forceinline void          strip_space()                                  {        string_strip_space(* this); }
+	forceinline void              strip_space()                                  {        strbuilder_strip_space(* this); }
-	forceinline StrC          to_strc()                                      { return { string_length(*this), Data}; }
+	forceinline Str               to_str()                                       { return { Data, strbuilder_length(*this) }; }
-	forceinline void          trim(char const* cut_set)                      {        string_trim(* this, cut_set); }
+	forceinline void              trim(char const* cut_set)                      {        strbuilder_trim(* this, cut_set); }
-	forceinline void          trim_space()                                   {        string_trim_space(* this); }
+	forceinline void              trim_space()                                   {        strbuilder_trim_space(* this); }
-	forceinline String        visualize_whitespace() const                   { return string_visualize_whitespace(* this); }
+	forceinline StrBuilder        visualize_whitespace() const                   { return strbuilder_visualize_whitespace(* this); }
-	forceinline StringHeader& get_header()                                   { return * string_get_header(* this); }
+	forceinline StrBuilderHeader& get_header()                                   { return * strbuilder_get_header(* this); }
 
 	bool append_fmt(char const* fmt, ...) {
 		ssize res;
@@ -255,163 +255,163 @@ struct String
 
 		va_list va;
 		va_start(va, fmt);
-		res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+		res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
 		va_end(va);
 
-		return string_append_c_str_len(this, buf, res);
+		return strbuilder_append_c_str_len(this, buf, res);
 	}
 #pragma endregion Member Mapping
 #endif
 };
 #endif
 
-forceinline char* string_begin(String str)                   { return ((char*) str); }
+forceinline char* strbuilder_begin(StrBuilder str)                   { return ((char*) str); }
-forceinline char* string_end  (String str)                   { return ((char*) str + string_length(str)); }
+forceinline char* strbuilder_end  (StrBuilder str)                   { return ((char*) str + strbuilder_length(str)); }
-forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); }
+forceinline char* strbuilder_next (StrBuilder str, char const* iter) { return ((char*) iter + 1); }
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-forceinline char* begin(String str)             { return ((char*) str); }
+forceinline char* begin(StrBuilder str)             { return ((char*) str); }
-forceinline char* end  (String str)             { return ((char*) str + string_length(str)); }
+forceinline char* end  (StrBuilder str)             { return ((char*) str + strbuilder_length(str)); }
-forceinline char* next (String str, char* iter) { return ((char*) iter + 1); }
+forceinline char* next (StrBuilder str, char* iter) { return ((char*) iter + 1); }
 #endif
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-forceinline bool  make_space_for(String& str, char const* to_append, ssize add_len);
+forceinline bool  make_space_for(StrBuilder& str, char const* to_append, ssize add_len);
-forceinline bool  append(String& str, char c);
+forceinline bool  append(StrBuilder& str, char c);
-forceinline bool  append(String& str, char const* str_to_append);
+forceinline bool  append(StrBuilder& str, char const* c_str_to_append);
-forceinline bool  append(String& str, char const* str_to_append, ssize length);
+forceinline bool  append(StrBuilder& str, char const* c_str_to_append, ssize length);
-forceinline bool  append(String& str, StrC str_to_append);
+forceinline bool  append(StrBuilder& str, Str c_str_to_append);
-forceinline bool  append(String& str, const String other);
+forceinline bool  append(StrBuilder& str, const StrBuilder other);
-forceinline bool  append_fmt(String& str, char const* fmt, ...);
+forceinline bool  append_fmt(StrBuilder& str, char const* fmt, ...);
-forceinline char& back(String& str);
+forceinline char& back(StrBuilder& str);
-forceinline void  clear(String& str);
+forceinline void  clear(StrBuilder& str);
-forceinline void  free(String& str);
+forceinline void  free(StrBuilder& str);
 #endif
 
 forceinline
-usize string_grow_formula(usize value) {
+usize strbuilder_grow_formula(usize value) {
 	// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
 	return 4 * value + 8;
 }
 
 forceinline
-String string_make_c_str(AllocatorInfo allocator, char const* str) {
+StrBuilder strbuilder_make_c_str(AllocatorInfo allocator, char const* str) {
-	ssize length = str ? str_len(str) : 0;
+	ssize length = str ? c_str_len(str) : 0;
-	return string_make_length(allocator, str, length);
+	return strbuilder_make_length(allocator, str, length);
 }
 
 forceinline
-String string_make_strc(AllocatorInfo allocator, StrC str) {
+StrBuilder strbuilder_make_str(AllocatorInfo allocator, Str str) {
-	return string_make_length(allocator, str.Ptr, str.Len);
+	return strbuilder_make_length(allocator, str.Ptr, str.Len);
 }
 
 inline
-String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+StrBuilder strbuilder_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
 	va_list va;
 	va_start(va, fmt);
-	ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1;
+	ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
 	va_end(va);
 
-	return string_make_length(allocator, buf, res);
+	return strbuilder_make_length(allocator, buf, res);
 }
 
 inline
-String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
+StrBuilder strbuilder_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
 {
 	local_persist thread_local
 	PrintF_Buffer buf = struct_init(PrintF_Buffer, {0});
 
 	va_list va;
 	va_start(va, fmt);
-	ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
+	ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
 	va_end(va);
 
-	return string_make_length(allocator, buf, res);
+	return strbuilder_make_length(allocator, buf, res);
 }
 
 inline
-String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
+StrBuilder strbuilder_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
 {
-	String result = string_make_c_str(allocator, "");
+	StrBuilder result = strbuilder_make_c_str(allocator, "");
 
 	for (ssize idx = 0; idx < num_parts; ++idx)
 	{
-		string_append_c_str(& result, parts[idx]);
+		strbuilder_append_c_str(& result, parts[idx]);
 
 		if (idx < num_parts - 1)
-			string_append_c_str(& result, glue);
+			strbuilder_append_c_str(& result, glue);
 	}
 
 	return result;
 }
 
 forceinline
-bool string_append_char(String* str, char c) {
+bool strbuilder_append_char(StrBuilder* str, char c) {
 	GEN_ASSERT(str != nullptr);
-	return string_append_c_str_len( str, (char const*)& c, (ssize)1);
+	return strbuilder_append_c_str_len( str, (char const*)& c, (ssize)1);
 }
 
 forceinline
-bool string_append_c_str(String* str, char const* str_to_append) {
+bool strbuilder_append_c_str(StrBuilder* str, char const* c_str_to_append) {
 	GEN_ASSERT(str != nullptr);
-	return string_append_c_str_len(str, str_to_append, str_len(str_to_append));
+	return strbuilder_append_c_str_len(str, c_str_to_append, c_str_len(c_str_to_append));
 }
 
 inline
-bool string_append_c_str_len(String* str, char const* str_to_append, ssize append_length)
+bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length)
 {
 	GEN_ASSERT(str != nullptr);
-	if ( rcast(sptr, str_to_append) > 0)
+	if ( rcast(sptr, c_str_to_append) > 0)
 	{
-		ssize curr_len = string_length(* str);
+		ssize curr_len = strbuilder_length(* str);
 
-		if ( ! string_make_space_for(str, str_to_append, append_length))
+		if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length))
 			return false;
 
-		StringHeader* header = string_get_header(* str);
+		StrBuilderHeader* header = strbuilder_get_header(* str);
 
 		char* Data = * str;
-		mem_copy( Data + curr_len, str_to_append, append_length);
+		mem_copy( Data + curr_len, c_str_to_append, append_length);
 
 		Data[curr_len + append_length] = '\0';
 
 		header->Length = curr_len + append_length;
 	}
-	return str_to_append != nullptr;
+	return c_str_to_append != nullptr;
 }
 
 forceinline
-bool string_append_strc(String* str, StrC str_to_append) {
+bool strbuilder_append_str(StrBuilder* str, Str c_str_to_append) {
 	GEN_ASSERT(str != nullptr);
-	return string_append_c_str_len(str, str_to_append.Ptr, str_to_append.Len);
+	return strbuilder_append_c_str_len(str, c_str_to_append.Ptr, c_str_to_append.Len);
 }
 
 forceinline
-bool string_append_string(String* str, String const other) {
+bool strbuilder_append_string(StrBuilder* str, StrBuilder const other) {
 	GEN_ASSERT(str != nullptr);
-	return string_append_c_str_len(str, (char const*)other, string_length(other));
+	return strbuilder_append_c_str_len(str, (char const*)other, strbuilder_length(other));
 }
 
-bool string_append_fmt(String* str, char const* fmt, ...) {
+bool strbuilder_append_fmt(StrBuilder* str, char const* fmt, ...) {
 	GEN_ASSERT(str != nullptr);
 	ssize res;
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
 
 	va_list va;
 	va_start(va, fmt);
-	res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+	res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
 	va_end(va);
 
-	return string_append_c_str_len(str, (char const*)buf, res);
+	return strbuilder_append_c_str_len(str, (char const*)buf, res);
 }
 
 inline
-bool string_are_equal_string(String const lhs, String const rhs)
+bool strbuilder_are_equal_string(StrBuilder const lhs, StrBuilder const rhs)
 {
-	if (string_length(lhs) != string_length(rhs))
+	if (strbuilder_length(lhs) != strbuilder_length(rhs))
 		return false;
 
-	for (ssize idx = 0; idx < string_length(lhs); ++idx)
+	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
 		if (lhs[idx] != rhs[idx])
 			return false;
 
@@ -419,12 +419,12 @@ bool string_are_equal_string(String const lhs, String const rhs)
 }
 
 inline
-bool string_are_equal_strc(String const lhs, StrC rhs)
+bool strbuilder_are_equal_str(StrBuilder const lhs, Str rhs)
 {
-	if (string_length(lhs) != (rhs.Len))
+	if (strbuilder_length(lhs) != (rhs.Len))
 		return false;
 
-	for (ssize idx = 0; idx < string_length(lhs); ++idx)
+	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
 		if (lhs[idx] != rhs.Ptr[idx])
 			return false;
 
@@ -432,20 +432,20 @@ bool string_are_equal_strc(String const lhs, StrC rhs)
 }
 
 forceinline
-ssize string_avail_space(String const str) {
+ssize strbuilder_avail_space(StrBuilder const str) {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 	return header->Capacity - header->Length;
 }
 
 forceinline
-char* string_back(String str) {
+char* strbuilder_back(StrBuilder str) {
-	return & (str)[string_length(str) - 1];
+	return & (str)[strbuilder_length(str) - 1];
 }
 
 inline
-bool string_contains_StrC(String const str, StrC substring)
+bool strbuilder_contains_StrC(StrBuilder const str, Str substring)
 {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 
 	if (substring.Len > header->Length)
 		return false;
@@ -455,7 +455,7 @@ bool string_contains_StrC(String const str, StrC substring)
 
 	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
 	{
-		if (str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
+		if (c_str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
 			return true;
 	}
 
@@ -463,19 +463,19 @@ bool string_contains_StrC(String const str, StrC substring)
 }
 
 inline
-bool string_contains_string(String const str, String const substring)
+bool strbuilder_contains_string(StrBuilder const str, StrBuilder const substring)
 {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 
-	if (string_length(substring) > header->Length)
+	if (strbuilder_length(substring) > header->Length)
 		return false;
 
 	ssize main_len = header->Length;
-	ssize sub_len  = string_length(substring);
+	ssize sub_len  = strbuilder_length(substring);
 
 	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
 	{
-		if (str_compare_len(str + idx, substring, sub_len) == 0)
+		if (c_str_compare_len(str + idx, substring, sub_len) == 0)
 			return true;
 	}
 
@@ -483,47 +483,47 @@ bool string_contains_string(String const str, String const substring)
 }
 
 forceinline
-ssize string_capacity(String const str) {
+ssize strbuilder_capacity(StrBuilder const str) {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 	return header->Capacity;
 }
 
 forceinline
-void string_clear(String str) {
+void strbuilder_clear(StrBuilder str) {
-	string_get_header(str)->Length = 0;
+	strbuilder_get_header(str)->Length = 0;
 }
 
 forceinline
-String string_duplicate(String const str, AllocatorInfo allocator) {
+StrBuilder strbuilder_duplicate(StrBuilder const str, AllocatorInfo allocator) {
-	return string_make_length(allocator, str, string_length(str));
+	return strbuilder_make_length(allocator, str, strbuilder_length(str));
 }
 
 forceinline
-void string_free(String* str) {
+void strbuilder_free(StrBuilder* str) {
 	GEN_ASSERT(str != nullptr);
 	if (! (* str))
 		return;
 
-	StringHeader* header = string_get_header(* str);
+	StrBuilderHeader* header = strbuilder_get_header(* str);
 	allocator_free(header->Allocator, header);
 }
 
 forceinline
-StringHeader* string_get_header(String str) {
+StrBuilderHeader* strbuilder_get_header(StrBuilder str) {
-	return (StringHeader*)(scast(char*, str) - sizeof(StringHeader));
+	return (StrBuilderHeader*)(scast(char*, str) - sizeof(StrBuilderHeader));
 }
 
 forceinline
-ssize string_length(String const str)
+ssize strbuilder_length(StrBuilder const str)
 {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 	return header->Length;
 }
 
 inline
-bool string_make_space_for(String* str, char const* to_append, ssize add_len)
+bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len)
 {
-	ssize available = string_avail_space(* str);
+	ssize available = strbuilder_avail_space(* str);
 
 	if (available >= add_len) {
 		return true;
@@ -534,20 +534,20 @@ bool string_make_space_for(String* str, char const* to_append, ssize add_len)
 		void* ptr;
 		void* new_ptr;
 
-		AllocatorInfo allocator = string_get_header(* str)->Allocator;
+		AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator;
-		StringHeader* header    = nullptr;
+		StrBuilderHeader* header    = nullptr;
 
-		new_len  = string_grow_formula(string_length(* str) + add_len);
+		new_len  = strbuilder_grow_formula(strbuilder_length(* str) + add_len);
-		ptr      = string_get_header(* str);
+		ptr      = strbuilder_get_header(* str);
-		old_size = size_of(StringHeader) + string_length(* str) + 1;
+		old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 1;
-		new_size = size_of(StringHeader) + new_len + 1;
+		new_size = size_of(StrBuilderHeader) + new_len + 1;
 
 		new_ptr = resize(allocator, ptr, old_size, new_size);
 
 		if (new_ptr == nullptr)
 			return false;
 
-		header = rcast(StringHeader*, new_ptr);
+		header = rcast(StrBuilderHeader*, new_ptr);
 		header->Allocator = allocator;
 		header->Capacity  = new_len;
 
@@ -559,25 +559,25 @@ bool string_make_space_for(String* str, char const* to_append, ssize add_len)
 }
 
 forceinline
-b32 string_starts_with_strc(String const str, StrC substring) {
+b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) {
-	if (substring.Len > string_length(str))
+	if (substring.Len > strbuilder_length(str))
 	return false;
 
-	b32 result = str_compare_len(str, substring.Ptr, substring.Len) == 0;
+	b32 result = c_str_compare_len(str, substring.Ptr, substring.Len) == 0;
 	return result;
 }
 
 forceinline
-b32 string_starts_with_string(String const str, String substring) {
+b32 strbuilder_starts_with_string(StrBuilder const str, StrBuilder substring) {
-	if (string_length(substring) > string_length(str))
+	if (strbuilder_length(substring) > strbuilder_length(str))
 		return false;
 
-	b32 result = str_compare_len(str, substring, string_length(substring) - 1) == 0;
+	b32 result = c_str_compare_len(str, substring, strbuilder_length(substring) - 1) == 0;
 	return result;
 }
 
 inline
-void string_skip_line(String str)
+void strbuilder_skip_line(StrBuilder str)
 {
 #define current (*scanner)
 	char* scanner = str;
@@ -593,13 +593,13 @@ void string_skip_line(String str)
 
 	mem_move((char*)str, scanner, new_length);
 
-	StringHeader* header = string_get_header(str);
+	StrBuilderHeader* header = strbuilder_get_header(str);
 	header->Length = new_length;
 #undef current
 }
 
 inline
-void strip_space(String str)
+void strip_space(StrBuilder str)
 {
 	char* write_pos = str;
 	char* read_pos  = str;
@@ -616,22 +616,22 @@ void strip_space(String str)
    write_pos[0] = '\0';  // Null-terminate the modified string
 
 	// Update the length if needed
-	string_get_header(str)->Length = write_pos - str;
+	strbuilder_get_header(str)->Length = write_pos - str;
 }
 
 forceinline
-StrC string_to_strc(String str) {
+Str strbuilder_to_str(StrBuilder str) {
-	StrC result = { string_length(str), (char const*)str };
+	Str result = { (char const*)str, strbuilder_length(str) };
 	return result;
 }
 
 inline
-void string_trim(String str, char const* cut_set)
+void strbuilder_trim(StrBuilder str, char const* cut_set)
 {
 	ssize len = 0;
 
 	char* start_pos = str;
-	char* end_pos   = scast(char*, str) + string_length(str) - 1;
+	char* end_pos   = scast(char*, str) + strbuilder_length(str) - 1;
 
 	while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos))
 	start_pos++;
@@ -646,99 +646,99 @@ void string_trim(String str, char const* cut_set)
 
 	str[len] = '\0';
 
-	string_get_header(str)->Length = len;
+	strbuilder_get_header(str)->Length = len;
 }
 
 forceinline
-void string_trim_space(String str) {
+void strbuilder_trim_space(StrBuilder str) {
-	string_trim(str, " \t\r\n\v\f");
+	strbuilder_trim(str, " \t\r\n\v\f");
 }
 
 inline
-String string_visualize_whitespace(String const str)
+StrBuilder strbuilder_visualize_whitespace(StrBuilder const str)
 {
-	StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader));
+	StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader));
-	String        result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements.
+	StrBuilder        result = strbuilder_make_reserve(header->Allocator, strbuilder_length(str) * 2); // Assume worst case for space requirements.
 
-	for (char const* c = string_begin(str); c != string_end(str); c = string_next(str, c))
+	for (char const* c = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c))
 	switch ( * c )
 	{
 		case ' ':
-			string_append_strc(& result, txt("·"));
+			strbuilder_append_str(& result, txt("·"));
 		break;
 		case '\t':
-			string_append_strc(& result, txt("→"));
+			strbuilder_append_str(& result, txt("→"));
 		break;
 		case '\n':
-			string_append_strc(& result, txt("↵"));
+			strbuilder_append_str(& result, txt("↵"));
 		break;
 		case '\r':
-			string_append_strc(& result, txt("⏎"));
+			strbuilder_append_str(& result, txt("⏎"));
 		break;
 		case '\v':
-			string_append_strc(& result, txt("⇕"));
+			strbuilder_append_str(& result, txt("⇕"));
 		break;
 		case '\f':
-			string_append_strc(& result, txt("⌂"));
+			strbuilder_append_str(& result, txt("⌂"));
 		break;
 		default:
-			string_append_char(& result, * c);
+			strbuilder_append_char(& result, * c);
 		break;
 	}
 
 	return result;
 }
-#pragma endregion String
+#pragma endregion StrBuilder
 
 #if GEN_COMPILER_CPP
-struct String_POD {
+struct StrBuilder_POD {
 	char* Data;
 };
-static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
+static_assert( sizeof( StrBuilder_POD ) == sizeof( StrBuilder ), "StrBuilder is not a POD" );
 #endif
 
 forceinline
-StrC strc_duplicate(StrC str, AllocatorInfo allocator) {
+Str str_duplicate(Str str, AllocatorInfo allocator) {
-	StrC result = string_to_strc( string_make_length(allocator, str.Ptr, str.Len));
+	Str result = strbuilder_to_str( strbuilder_make_length(allocator, str.Ptr, str.Len));
 	return result;
 }
 
 inline
-StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator)
+Str str_visualize_whitespace(Str str, AllocatorInfo allocator)
 {
-	String result = string_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
+	StrBuilder result = strbuilder_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
-	for (char const* c = strc_begin(str); c != strc_end(str); c = strc_next(str, c))
+	for (char const* c = str_begin(str); c != str_end(str); c = str_next(str, c))
 	switch ( * c )
 	{
 		case ' ':
-			string_append_strc(& result, txt("·"));
+			strbuilder_append_str(& result, txt("·"));
 		break;
 		case '\t':
-			string_append_strc(& result, txt("→"));
+			strbuilder_append_str(& result, txt("→"));
 		break;
 		case '\n':
-			string_append_strc(& result, txt("↵"));
+			strbuilder_append_str(& result, txt("↵"));
 		break;
 		case '\r':
-			string_append_strc(& result, txt("⏎"));
+			strbuilder_append_str(& result, txt("⏎"));
 		break;
 		case '\v':
-			string_append_strc(& result, txt("⇕"));
+			strbuilder_append_str(& result, txt("⇕"));
 		break;
 		case '\f':
-			string_append_strc(& result, txt("⌂"));
+			strbuilder_append_str(& result, txt("⌂"));
 		break;
 		default:
-			string_append_char(& result, * c);
+			strbuilder_append_char(& result, * c);
 		break;
 }
-	return string_to_strc(result);
+	return strbuilder_to_str(result);
 }
 
 // Represents strings cached with the string table.
 // Should never be modified, if changed string is desired, cache_string( str ) another.
-typedef StrC StringCached;
+typedef Str StrCached;
 
 // Implements basic string interning. Data structure is based off the ZPL Hashtable.
-typedef HashTable(StringCached) StringTable;
+typedef HashTable(StrCached) StringTable;
 #pragma endregion Strings

base/enums/AttributeTokens.csv

@@ -1,2 +1 @@
-API_Export, GEN_API_Export_Code
+GEN_API,    GEN_API
-API_Import, GEN_API_Import_Code

base/gen.cpp

@@ -31,7 +31,6 @@ GEN_NS_BEGIN
 
 #include "components/interface.cpp"
 #include "components/interface.upfront.cpp"
-#include "components/gen/etoktype.cpp"
 #include "components/lexer.cpp"
 #include "components/parser.cpp"
 #include "components/interface.parsing.cpp"

base/gen.hpp

@@ -20,6 +20,8 @@ GEN_NS_BEGIN
 #include "components/gen/ecodetypes.hpp"
 #include "components/gen/eoperator.hpp"
 #include "components/gen/especifier.hpp"
+#include "components/gen/etoktype.hpp"
+#include "components/parser_types.hpp"
 
 #include "components/ast.hpp"
 #include "components/code_types.hpp"

base/gencpp.refactor

@@ -1,423 +0,0 @@
- __VERSION 1
-
-// This is a example template to be used with the refactor program
-// Use it to refactor the naming convention of this library to your own.
-// Can be used as an aid to help use use your project's implementation if it fullfills the dependencies of this project.
-// Example: Most likely have a memory and string library already, just rename the functions and make sure the args are the same.
-// Program: https://github.com/Ed94/refactor
-
-// NOTE: Due to the current limitations of the program, not every symbol in the library can be renamed.
-// This is due to the program not actually parsing C/C++.
-
-// not       : Ignore
-// include   : #includes
-// word      : Alphanumeric or underscore
-// namespace : Prefix search and replace (c-namspaces).
-// regex     : Unavailable in __VERSION 1.
-
-// Precedence (highest to lowest):
-// word, namespace, regex
-
-// TODO(ED): THIS IS VERY OUTDATED
-
-// Gen Macro namespace
-// namespace GEN_, new_namespace_
-
-// ---------- Dependency Macros
-    // Platform
-// word GEN_ARCH_64_BIT, new_name
-// word GEN_ARCH_32_BIT, new_name
-
-// word GEN_SYSTEM_ANDROID,    new_name
-// word GEN_SYSTEM_CYGWIN,     new_name
-// word GEN_SYSTEM_EMSCRIPTEN, new_name
-// word GEN_SYSTEM_FREEBSD,    new_name
-// word GEN_SYSTEM_IOS,	       new_name
-// word GEN_SYSTEM_LINUX,      new_name
-// word GEN_SYSTEM_MACOS,      new_name
-// word GEN_SYSTEM_OPENBSD,    new_name
-// word GEN_SYSTEM_OSX,        new_name
-// word GEN_SYSTEM_UNIX,       new_name
-// word GEN_SYSTEM_WINDOWS,    new_name
-
-// word GEN_COMPILER_CLANG, new_name
-// word GEN_COMPILER_GCC,   new_name
-// word GEN_COMPILER_MINGW, new_name
-// word GEN_COMPILER_MSVC,  new_name
-
-// word global,        new_name
-// word internal,      new_name
-// word local_persist, new_name
-// word forceinline,   new_name
-// word neverinline,   new_name
-
-// word bit,               new_name
-// word bitfield_is_equal, new_name
-
-// word ccast, new_name
-// word pcast, new_name
-// word rcast, new_name
-// word scast, new_name
-
-// word num_args,      new_name
-// word num_args_impl, new_name
-
-// word stringize,    new_name
-// word stringize_va, new_name
-
-// word do_once,           new_name
-// word do_once_start,     new_name
-// word do_once_end,       new_name
-// word label_scope_start, new_name
-// word label_scope_end,   new_name
-
-// word count_of,   new_name
-// word is_between, new_name
-// word min,        new_name
-// word size_of,    new_name
-// word offset_of,  new_name
-// word swap,       new_name
-
-    // Basic Types
-// word GEN_U8_MIN, new_name
-// word GEN_U8_MAX, new_name
-// word GEN_I8_MIN, new_name
-// word GEN_I8_MAX, new_name
-
-// word GEN_U16_MIN, new_name
-// word GEN_U16_MAX, new_name
-// word GEN_I16_MIN, new_name
-// word GEN_I16_MAX, new_name
-
-// word GEN_U32_MIN, new_name
-// word GEN_U32_MAX, new_name
-// word GEN_I32_MIN, new_name
-// word GEN_I32_MAX, new_name
-
-// word GEN_U64_MIN, new_name
-// word GEN_U64_MAX, new_name
-// word GEN_I64_MIN, new_name
-// word GEN_I64_MAX, new_name
-
-// word GEN_USIZE_MIN, new_name
-// word GEN_USIZE_MAX, new_name
-// word GEN_ISIZE_MIN, new_name
-// word GEN_ISIZE_MAX, new_name
-
-// word GEN_F32_MIN, new_name
-// word GEN_F32_MAX, new_name
-// word GEN_F64_MIN, new_name
-// word GEN_F64_MAX, new_name
-
-    // Debug
-// word GEN_DEBUG_TRAP,      new_name
-// word GEN_ASSERT,          new_name
-// word GEN_ASSERT_MSG,      new_name
-// word GEN_ASSERT_NOT_NULL, new_name
-// word GEN_PANIC,           new_name
-// word GEN_FATAL,           new_name
-
-    // Memory
-// word kilobytes, new_name
-// word megabytes, new_name
-// word gigabytes, new_name
-// word terabytes, new_name
-
-// word zero_item,  new_name
-// word zero_array, new_name
-
-// word alloc_item,  new_name
-// word alloc_array, new_name
-
-// word malloc, new_name
-// word mfree,  new_name
-
-    // Strings
-// word txt, new_name
-// word cast_to_strc, new_name
-
-// ---------- Dependency Types
-
-// word b8,   new_name
-// word b16,  new_name
-// word b32,  new_name
-// word s8,   new_name
-// word s16,  new_name
-// word s32,  new_name
-// word s64,  new_name
-// word u8,   new_name
-// word u16,  new_name
-// word u32,  new_name
-// word u64,  new_name
-// word usize,   new_name
-// word ssize,   new_name
-// word sptr, new_name
-// word uptr, new_name
-// word f32,  new_name
-// word f64,  new_name
-
-// namespace EAllocator_, new_namespace_
-// namespace EFileMode_,  new_namespace_
-// namespace EFileError_, new_namespace_
-
-// word AllocatorInfo,    new_name
-// word AllocatorProc,    new_name
-// word AllocFlag,        new_name
-// word AllocType,        new_name
-// word ArrayHeader,      new_name
-// word DirEntry,         new_name
-// word DirInfo,          new_name
-// word DirType,          new_name
-// word FileDescriptor,   new_name
-// word FileError,        new_name
-// word FileInfo,         new_name
-// word FileTime,         new_name
-// word FileModeFlag,     new_name
-// word FileOperations,   new_name
-// word FileStandardType, new_name
-// word SeekWhenceType,   new_name
-
-// ---------- Dependency Data
-
-// word default_file_operations, new_name
-
-// ---------- Dependency Procedures
-
-// word align_forward,          new_name
-// word align_fordward_i64,     new_name
-// word alloc,                  new_name
-// word alloc_align,            new_name
-// word assert_handler,         new_name
-// word assert_crash,           new_name
-// word char_first_occurence,   new_name
-// word char_is_alpha,          new_name
-// word char_is_alphanumeric,   new_name
-// word char_is_digit,          new_name
-// word char_is_hex_digit,      new_name
-// word char_is_space,          new_name
-// word char_to_lower,		    new_name
-// word char_to_upper,		    new_name
-// word crc32,                  new_name
-// word default_resize_align,   new_name
-// word digit_to_int,		    new_name
-// word file_close,  		    new_name
-// word file_get_standard,      new_name
-// word file_name,              new_name
-// word file_open,              new_name
-// word file_open_mode,         new_name
-// word file_seek, 			    new_name
-// word file_tell, 			    new_name
-// word file_write, 		    new_name
-// word file_write_at, 		    new_name
-// word file_write_at_check,    new_name
-// word free,                   new_name
-// word free_all,               new_name
-// word heap,                   new_name
-// word heap_allocator_proc,    new_name
-// word heap_stats_check,       new_name
-// word heap_stats_alloc_count, new_name
-// word heap_stats_init,        new_name
-// word heap_stats_used_memory, new_name
-// word hex_digit_to_int,	    new_name
-// word i64_to_str,			    new_name
-// word is_power_of_two,        new_name
-// word log_fmt,                new_name
-// word mem_copy,               new_name
-// word mem_move,               new_name
-// word mem_set,                new_name
-// word pointer_add,            new_name
-// word mem_copy,               new_name
-// word mem_find,               new_name
-// word mem_move,               new_name
-// word mem_set,                new_name
-// word resize,                 new_name
-// word resize_align,           new_name
-// word process_exit,           new_name
-// word str_compare,            new_name
-// word str_copy,               new_name
-// word str_copy_nulpad, 	    new_name
-// word str_fmt_buf,            new_name
-// word str_fmt_buf_va,	        new_name
-// word str_fmt_file_va,        new_name
-// word str_fmt_out_va,         new_name
-// word str_fmt_out_err,        new_name
-// word str_fmt_out_err_va,	    new_name
-// word str_fmt_va,             new_name
-// word str_len,                new_name
-// word str_reverse, 		    new_name
-// word str_to_i64, 		    new_name
-// word str_to_lower, 		    new_name
-// word str_to_upper,  	        new_name
-// word u64_to_str, 		    new_name
-// word zero_size,              new_name
-
-// ---------- gencpp Macros
-
-// word log_failure, new_name
-
-// word NullCode,      new_name
-// word CodeInvalid, new_name
-
-// ------------ gencpp common
-
-// word Arena,     new_name
-// word Array,     new_name
-// word HashTable, new_name
-// word Pool,      new_name
-// word StrC,      new_name
-// word String,    new_name
-
-// word to_str,  new_name
-// word to_str,  new_name
-// word to_type, new_name
-
-// ------------ gencpp Types & Constants
-
-// word LogFailType, new_name
-
-// word AccessSpec,     new_name
-// word ECode,          new_name
-// word EnumClass,      new_name
-// word EnumRegular,    new_name
-// word EnumT,          new_name
-// word EOperator,      new_name
-// word ESpecifier,     new_name
-// word OperatorT,      new_name
-// word ModuleFlag,     new_name
-// word SpecifierT,     new_name
-// word StringCached,   new_name
-// word StringTable,    new_name
-// word UsingRegular,   new_name
-// word UsingNamespace, new_name
-
-// ------------ gencpp Data
-
-// word API_Export,   new_name
-// word API_Import,   new_name
-// word AST_POD_Size, new_name
-// word AST,          new_name
-// word AST_POD,      new_name
-// word Code,         new_name
-// word Code_POD,     new_name
-// word Keyword,      new_name
-
-// ------------ gencpp API
-
-// word init,                             new_name
-// word deinit,                           new_name
-
-// word get_cached_string,                new_name
-// word make_code,                        new_name
-// word make_code_entries,                new_name
-
-// word set_allocator_data_arrays,        new_name
-// word set_allocator_code_pool,          new_name
-// word set_allocator_code_entries_arena, new_name
-// word set_allocator_string_arena,       new_name
-// word set_allocator_string_table,       new_name
-// word set_allocator_type_table,         new_name
-
-// ------------ upfront constructor namespace
-// namespace def_ new_namespace_
-
-// ------------ upfront constructor individual
-
-// word def_attributes,      new_name
-// word def_comment,         new_name
-// word def_class,           new_name
-// word def_constructor,     new_name
-// word def_destructor,      new_name
-// word def_define,          new_name
-// word def_enum,            new_name
-// word def_execution,       new_name
-// word def_extern_link,     new_name
-// word def_friend,          new_name
-// word def_function,        new_name
-// word def_include,         new_name
-// word def_module,          new_name
-// word def_namespace,       new_name
-// word def_operator,        new_name
-// word def_operator_cast,   new_name
-// word def_param,           new_name
-// word def_pargma,          new_name
-// word def_preprocess_cond, new_name
-// word def_specifier,       new_name
-// word def_struct,          new_name
-// word def_template,        new_name
-// word def_type,            new_name
-// word def_typedef,         new_name
-// word def_union,           new_name
-// word def_using,           new_name
-// word def_using_namespace, new_name
-// word def_variable,        new_name
-
-// word def_body,             new_name
-// word def_class_body,       new_name
-// word def_enum_body,        new_name
-// word def_export_body,      new_name
-// word def_extern_link_body, new_name
-// word def_function_body,    new_name
-// word def_global_body,      new_name
-// word def_namespace_body,   new_name
-// word def_params,           new_name
-// word def_specifiers,       new_name
-// word def_struct_body,      new_name
-// word def_union_body,       new_name
-
-// ------------ parse constructor namespace
-// namespace parse_, new_namespace_
-
-// ------------ parse constructor individual
-
-// word parse_class,       new_name
-// word parse_enum,        new_name
-// word parse_export_body, new_name
-// word parse_extern_link, new_name
-// word parse_friend,      new_name
-// word parse_function,    new_name
-// word parse_global_body, new_name
-// word parse_namespace,   new_name
-// word parse_operator,    new_name
-// word parse_struct,      new_name
-// word parse_template,    new_name
-// word parse_type,        new_name
-// word parse_typedef,     new_name
-// word parse_union,       new_name
-// word parse_using,       new_name
-// word parse_variable,    new_name
-
-// ------------ untyped constructor namespace
-// namespace untyped_, new_namespace_
-
-// ------------ untyped constructor individual
-
-// word token_fmt_impl,    new_name
-// word token_fmt_va,      new_name
-// word untyped_str,       new_name
-// word untyped_fmt,       new_name
-// word untyped_token_fmt, new_name
-
-// ------------ File Ops
-
-// word Builder, new_name
-// word Editor,  new_name
-// word Scanner, new_name
-
-// ------------ gencpp user macros
-
-// word gen_main,     new_name
-// word GEN_TIME,     new_name
-
-// word __,        new_name
-// word name,      new_name
-// word code,      new_name
-// word args,      new_name
-// word code_str,  new_name
-// word code_fmt,  new_name
-// word token_fmt, new_name
-
-// ------------ Type AST namespace
-// namespace t_, new_namespace_
-
-// ------------ Specifier AST namespace
-// namespace spec_, new_namespace_

base/helpers/base_codegen.hpp

@@ -9,58 +9,58 @@ using namespace gen;
 
 CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 {
-	FixedArena_32KB scratch; fixed_arena_init(& scratch);
+	FixedArena_32KB scratch;       fixed_arena_init(& scratch);
 	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	CSV_Columns2 csv_enum         = parse_csv_two_columns( scratch_info, path );
+	CSV_Columns2 csv_enum                 = parse_csv_two_columns( scratch_info, path );
-	String enum_entries           = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	StrBuilder   enum_entries             = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-	String to_str_entries         = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	StrBuilder   to_c_str_entries         = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-	String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	StrBuilder   to_keyword_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
 
 	for ( ssize idx = 0; idx < array_num(csv_enum.Col_1); ++ idx ) 	{
 		char const* code    = csv_enum.Col_1[idx].string;
 		char const* keyword = csv_enum.Col_2[idx].string;
-		// TODO(Ed): to_str_entries and the others in here didn't have proper sizing of the StrC slice.
+		// TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
-		string_append_fmt( & enum_entries,           "CT_%s,\n", code );
+		strbuilder_append_fmt( & enum_entries,             "CT_%s,\n", code );
-		string_append_fmt( & to_str_entries,         "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
+		strbuilder_append_fmt( & to_c_str_entries,         "{ \"%s\",  sizeof(\"%s\") - 1 },\n", code,    code );
-		string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword );
+		strbuilder_append_fmt( & to_keyword_c_str_entries, "{  \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
 	}
 
 	CodeEnum enum_code;
 	if (use_c_definition) {
-		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries),
+		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
 			"enum CodeType enum_underlying(u32) { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
 		));
 	}
 	else {
-		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries),
+		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
 			"enum CodeType : u32 { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
 		));
 	}
 
 #pragma push_macro("local_persist")
 #undef local_persist
-	StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
+	Str      lookup_size  = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
-	CodeBody to_str_fns = parse_global_body( token_fmt(
+	CodeBody to_c_str_fns = parse_global_body( token_fmt(
-		"entries",  string_to_strc(to_str_entries)
+		"entries",  strbuilder_to_str(to_c_str_entries)
-	,	"keywords", string_to_strc(to_keyword_str_entries)
+	,	"keywords", strbuilder_to_str(to_keyword_c_str_entries)
 	,	"num",      lookup_size
 	, stringize(
 		inline
-		StrC codetype_to_str( CodeType type )
+		Str codetype_to_str( CodeType type )
 		{
 			local_persist
-			StrC lookup[<num>] = {
+			Str lookup[<num>] = {
 				<entries>
 			};
 			return lookup[ type ];
 		}
 
 		inline
-		StrC codetype_to_keyword_str( CodeType type )
+		Str codetype_to_keyword_str( CodeType type )
 		{
 			local_persist
-			StrC lookup[ <num> ] = {
+			Str lookup[ <num> ] = {
 				<keywords>
 			};
 			return lookup[ type ];
@@ -76,14 +76,14 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 		body_append(result, code_t);
 	}
 
-	body_append(result, to_str_fns);
+	body_append(result, to_c_str_fns);
 
 	if (! use_c_definition) {
 		#pragma push_macro("forceinline")
 		#undef forceinline
 		CodeBody alias_mappings = parse_global_body(code(
-			forceinline StrC to_str        (CodeType type) { return codetype_to_str(type);         }
+			forceinline Str to_str        (CodeType type) { return codetype_to_str(type);         }
-			forceinline StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
+			forceinline Str to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
 		));
 		#pragma pop_macro("forceinline")
 		body_append(result, alias_mappings);
@@ -93,19 +93,18 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 
 CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 {
-	FixedArena_16KB scratch; fixed_arena_init(& scratch);
+	FixedArena_16KB scratch;       fixed_arena_init(& scratch);
 	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns( scratch_info, path );
-	String enum_entries   = string_make_reserve( GlobalAllocator, 32 );
+	StrBuilder enum_entries     = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
-	String to_str_entries = string_make_reserve( GlobalAllocator, 32 );
+	StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
 
 	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) {
 		char const* enum_str     = csv_enum.Col_1[idx].string;
 		char const* entry_to_str = csv_enum.Col_2[idx].string;
-
+		strbuilder_append_fmt( & enum_entries,     "Op_%s,\n", enum_str );
-		string_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
+		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
 	}
 
 	CodeEnum  enum_code;
@@ -113,7 +112,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	{
 	#pragma push_macro("enum_underlying")
 	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Operator enum_underlying(u32)
 			{
 				<entries>
@@ -125,7 +124,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Operator : u32
 			{
 				<entries>
@@ -137,16 +136,16 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 
 #pragma push_macro("local_persist")
 #undef local_persist
-	StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
+	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
 	CodeFn to_str   = parse_function(token_fmt(
-		"entries", string_to_strc(to_str_entries)
+		"entries", strbuilder_to_str(to_c_str_entries)
 	,	"num",     lookup_size
 	, stringize(
 		inline
-		StrC operator_to_str( Operator op )
+		Str operator_to_str( Operator op )
 		{
 			local_persist
-			StrC lookup[<num>] = {
+			Str lookup[<num>] = {
 				<entries>
 			};
 
@@ -169,7 +168,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	#pragma push_macro("forceinline")
 	#undef forceinline
 		CodeBody alias_mappings = parse_global_body(code(
-			forceinline StrC to_str(Operator op) { return operator_to_str(op); }
+			forceinline Str to_str(Operator op) { return operator_to_str(op); }
 		));
 	#pragma pop_macro("forceinline")
 		body_append(result, alias_mappings);
@@ -179,20 +178,19 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 
 CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 {
-	FixedArena_16KB scratch; fixed_arena_init(& scratch);
+	FixedArena_16KB scratch;       fixed_arena_init(& scratch);
 	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns(   scratch_info, path );
-	String enum_entries   = string_make_reserve( scratch_info, kilobytes(1) );
+	StrBuilder enum_entries     = strbuilder_make_reserve( scratch_info, kilobytes(1) );
-	String to_str_entries = string_make_reserve( scratch_info, kilobytes(1) );
+	StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
 
 	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++)
 	{
 		char const* enum_str     = csv_enum.Col_1[idx].string;
 		char const* entry_to_str = csv_enum.Col_2[idx].string;
-
+		strbuilder_append_fmt( & enum_entries,     "Spec_%s,\n", enum_str );
-		string_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
+		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
 	}
 
 	CodeEnum enum_code;
@@ -200,7 +198,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	{
 	#pragma push_macro("enum_underlying")
 	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Specifier enum_underlying(u32)
 			{
 				<entries>
@@ -212,7 +210,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Specifier : u32
 			{
 				<entries>
@@ -221,8 +219,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 			};
 		)));
 	}
-
+	CodeFn is_trailing = parse_function(token_fmt("specifier", strbuilder_to_str(to_c_str_entries), stringize(
-	CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize(
 		inline
 		bool spec_is_trailing( Specifier specifier )
 		{
@@ -240,16 +237,16 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 #undef do_once_end
 #undef forceinline
 #undef neverinline
-	StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
+	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
 	CodeFn to_str   = parse_function(token_fmt(
-		"entries", string_to_strc(to_str_entries)
+		"entries", strbuilder_to_str(to_c_str_entries)
 	,	"num",     lookup_size
 	, stringize(
 		inline
-		StrC spec_to_str( Specifier type )
+		Str spec_to_str( Specifier type )
 		{
 			local_persist
-			StrC lookup[<num>] = {
+			Str lookup[<num>] = {
 				<entries>
 			};
 
@@ -257,20 +254,20 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
+	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
 		inline
-		Specifier strc_to_specifier( StrC str )
+		Specifier str_to_specifier( Str str )
 		{
 			local_persist
 			u32 keymap[ Spec_NumSpecifiers ];
 			do_once_start
 				for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 				{
-					StrC enum_str = spec_to_str( (Specifier)index );
+					Str enum_str = spec_to_str( (Specifier)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
-					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len  );
 				}
 			do_once_end
 
@@ -308,8 +305,8 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	#pragma push_macro("forceinline")
 	#undef forceinline
 		CodeBody alias_mappings = parse_global_body(code(
-			forceinline StrC      to_str (Specifier spec)            { return spec_to_str(spec); }
+			forceinline Str      to_str (Specifier spec)            { return spec_to_str(spec); }
-			forceinline Specifier to_type( StrC str )                { return strc_to_specifier(str); }
+			forceinline Specifier to_type( Str str )                { return str_to_specifier(str); }
 			forceinline bool      is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
 		));
 	#pragma pop_macro("forceinline")
@@ -320,7 +317,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 
 CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false )
 {
-	FixedArena_64KB scratch; fixed_arena_init(& scratch);
+	FixedArena_64KB scratch;       fixed_arena_init(& scratch);
 	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
 	FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
@@ -333,51 +330,51 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 	CSV_Object csv_attr_nodes;
 	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
 
-	Array<ADT_Node> enum_strs          = csv_enum_nodes.nodes[0].nodes;
+	Array<ADT_Node> enum_strs            = csv_enum_nodes.nodes[0].nodes;
-	Array<ADT_Node> enum_str_strs      = csv_enum_nodes.nodes[1].nodes;
+	Array<ADT_Node> enum_c_str_strs      = csv_enum_nodes.nodes[1].nodes;
-	Array<ADT_Node> attribute_strs     = csv_attr_nodes.nodes[0].nodes;
+	Array<ADT_Node> attribute_strs       = csv_attr_nodes.nodes[0].nodes;
-	Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes;
+	Array<ADT_Node> attribute_c_str_strs = csv_attr_nodes.nodes[1].nodes;
 
-	String enum_entries             = string_make_reserve( scratch_info, kilobytes(2) );
+	StrBuilder enum_entries             = strbuilder_make_reserve( scratch_info, kilobytes(2) );
-	String to_str_entries           = string_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder to_c_str_entries         = strbuilder_make_reserve( scratch_info, kilobytes(4) );
-	String attribute_entries        = string_make_reserve( scratch_info, kilobytes(2) );
+	StrBuilder attribute_entries        = strbuilder_make_reserve( scratch_info, kilobytes(2) );
-	String to_str_attributes        = string_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder to_c_str_attributes      = strbuilder_make_reserve( scratch_info, kilobytes(4) );
-	String attribute_define_entries = string_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder attribute_define_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
 
 	for (usize idx = 0; idx < array_num(enum_strs); idx++)
 	{
 		char const* enum_str     = enum_strs[idx].string;
-		char const* entry_to_str = enum_str_strs [idx].string;
+		char const* entry_to_str = enum_c_str_strs [idx].string;
 
-		string_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
+		strbuilder_append_fmt( & enum_entries,     "Tok_%s,\n",                         enum_str );
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
 	}
 
 	for ( usize idx = 0; idx < array_num(attribute_strs); idx++ )
 	{
 		char const* attribute_str = attribute_strs[idx].string;
-		char const* entry_to_str  = attribute_str_strs [idx].string;
+		char const* entry_to_str  = attribute_c_str_strs [idx].string;
 
-		string_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str );
+		strbuilder_append_fmt( & attribute_entries,        "Tok_Attribute_%s,\n",               attribute_str );
-		string_append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		strbuilder_append_fmt( & to_c_str_attributes,      "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-		string_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
+		strbuilder_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
 
 		if ( idx < array_num(attribute_strs) - 1 )
-			string_append_strc( & attribute_define_entries, txt(" \\\n"));
+			strbuilder_append_str( & attribute_define_entries, txt(" \\\n"));
 		else
-			string_append_strc( & attribute_define_entries, txt("\n"));
+			strbuilder_append_str( & attribute_define_entries, txt("\n"));
 	}
 
 #pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
 #undef GEN_DEFINE_ATTRIBUTE_TOKENS
-	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), string_to_strc(attribute_define_entries)  );
+	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), strbuilder_to_str(attribute_define_entries)  );
 #pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
 
 	// We cannot parse this enum, it has Attribute names as enums
 	CodeEnum enum_code;
 	if (use_c_definition)
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
 			enum TokType
 			{
 				<entries>
@@ -389,7 +386,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
 			enum TokType : u32
 			{
 				<entries>
@@ -405,12 +402,12 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 #undef local_persist
 #undef do_once_start
 #undef do_once_end
-	CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), "attribute_toks", string_to_strc(to_str_attributes), stringize(
+	CodeFn to_str = parse_function(token_fmt("entries", strbuilder_to_str(to_c_str_entries), "attribute_toks", strbuilder_to_str(to_c_str_attributes), stringize(
 		inline
-		StrC toktype_to_str( TokType type )
+		Str toktype_to_str( TokType type )
 		{
 			local_persist
-			StrC lookup[] = {
+			Str lookup[] = {
 				<entries>
 				<attribute_toks>
 			};
@@ -419,20 +416,20 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
+	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
 		inline
-		TokType strc_to_toktype( StrC str )
+		TokType str_to_toktype( Str str )
 		{
 			local_persist
 			u32 keymap[ Tok_NumTokens ];
 			do_once_start
 				for ( u32 index = 0; index < Tok_NumTokens; index++ )
 				{
-					StrC enum_str = toktype_to_str( (TokType)index );
+					Str enum_str = toktype_to_str( (TokType)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
-					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len);
 				}
 			do_once_end
 
@@ -452,7 +449,6 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 #pragma pop_macro("do_once_end")
 
 	CodeBody result = def_body(CT_Global_Body);
-	body_append(result, untyped_str(txt("GEN_NS_PARSER_BEGIN\n\n")));
 	body_append(result, attribute_entires_def);
 	body_append(result, enum_code);
 	if (use_c_definition)
@@ -462,7 +458,6 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 	}
 	body_append(result, to_str);
 	body_append(result, to_type);
-	body_append(result, untyped_str(txt("\nGEN_NS_PARSER_END\n\n")));
 	return result;
 }
 
@@ -508,7 +503,7 @@ CodeBody gen_ast_inlines()
 		{
 			if ( ast == nullptr )
 			{
-				log_failure( "Attempt to dereference a nullptr!" );
+				log_failure( "Attempt to dereference a nullptr!\n" );
 				return nullptr;
 			}
 			return ast;
@@ -518,59 +513,59 @@ CodeBody gen_ast_inlines()
 #pragma pop_macro("GEN_NS")
 #pragma pop_macro("CodeInvalid")
 
-	CodeBody impl_code          = parse_global_body( token_fmt( "typename", StrC name(Code),               code_impl_tmpl ));
+	CodeBody impl_code          = parse_global_body( token_fmt( "typename", Str name(Code),               code_impl_tmpl ));
-	CodeBody impl_code_body     = parse_global_body( token_fmt( "typename", StrC name(CodeBody),           code_impl_tmpl ));
+	CodeBody impl_code_body     = parse_global_body( token_fmt( "typename", Str name(CodeBody),           code_impl_tmpl ));
-	CodeBody impl_code_attr     = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes),     code_impl_tmpl ));
+	CodeBody impl_code_attr     = parse_global_body( token_fmt( "typename", Str name(CodeAttributes),     code_impl_tmpl ));
-	CodeBody impl_code_cmt      = parse_global_body( token_fmt( "typename", StrC name(CodeComment),        code_impl_tmpl ));
+	CodeBody impl_code_cmt      = parse_global_body( token_fmt( "typename", Str name(CodeComment),        code_impl_tmpl ));
-	CodeBody impl_code_constr   = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor),    code_impl_tmpl ));
+	CodeBody impl_code_constr   = parse_global_body( token_fmt( "typename", Str name(CodeConstructor),    code_impl_tmpl ));
-	CodeBody impl_code_class    = parse_global_body( token_fmt( "typename", StrC name(CodeClass),          code_impl_tmpl ));
+	CodeBody impl_code_class    = parse_global_body( token_fmt( "typename", Str name(CodeClass),          code_impl_tmpl ));
-	CodeBody impl_code_define   = parse_global_body( token_fmt( "typename", StrC name(CodeDefine),         code_impl_tmpl ));
+	CodeBody impl_code_define   = parse_global_body( token_fmt( "typename", Str name(CodeDefine),         code_impl_tmpl ));
-	CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor),     code_impl_tmpl ));
+	CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", Str name(CodeDestructor),     code_impl_tmpl ));
-	CodeBody impl_code_enum     = parse_global_body( token_fmt( "typename", StrC name(CodeEnum),           code_impl_tmpl ));
+	CodeBody impl_code_enum     = parse_global_body( token_fmt( "typename", Str name(CodeEnum),           code_impl_tmpl ));
-	CodeBody impl_code_exec     = parse_global_body( token_fmt( "typename", StrC name(CodeExec),           code_impl_tmpl ));
+	CodeBody impl_code_exec     = parse_global_body( token_fmt( "typename", Str name(CodeExec),           code_impl_tmpl ));
-	CodeBody impl_code_extern   = parse_global_body( token_fmt( "typename", StrC name(CodeExtern),         code_impl_tmpl ));
+	CodeBody impl_code_extern   = parse_global_body( token_fmt( "typename", Str name(CodeExtern),         code_impl_tmpl ));
-	CodeBody impl_code_include  = parse_global_body( token_fmt( "typename", StrC name(CodeInclude),        code_impl_tmpl ));
+	CodeBody impl_code_include  = parse_global_body( token_fmt( "typename", Str name(CodeInclude),        code_impl_tmpl ));
-	CodeBody impl_code_friend   = parse_global_body( token_fmt( "typename", StrC name(CodeFriend),         code_impl_tmpl ));
+	CodeBody impl_code_friend   = parse_global_body( token_fmt( "typename", Str name(CodeFriend),         code_impl_tmpl ));
-	CodeBody impl_code_fn	    = parse_global_body( token_fmt( "typename", StrC name(CodeFn),             code_impl_tmpl ));
+	CodeBody impl_code_fn	    = parse_global_body( token_fmt( "typename", Str name(CodeFn),             code_impl_tmpl ));
-	CodeBody impl_code_module   = parse_global_body( token_fmt( "typename", StrC name(CodeModule),         code_impl_tmpl ));
+	CodeBody impl_code_module   = parse_global_body( token_fmt( "typename", Str name(CodeModule),         code_impl_tmpl ));
-	CodeBody impl_code_ns       = parse_global_body( token_fmt( "typename", StrC name(CodeNS),             code_impl_tmpl ));
+	CodeBody impl_code_ns       = parse_global_body( token_fmt( "typename", Str name(CodeNS),             code_impl_tmpl ));
-	CodeBody impl_code_op       = parse_global_body( token_fmt( "typename", StrC name(CodeOperator),       code_impl_tmpl ));
+	CodeBody impl_code_op       = parse_global_body( token_fmt( "typename", Str name(CodeOperator),       code_impl_tmpl ));
-	CodeBody impl_code_opcast   = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast),         code_impl_tmpl ));
+	CodeBody impl_code_opcast   = parse_global_body( token_fmt( "typename", Str name(CodeOpCast),         code_impl_tmpl ));
-	CodeBody impl_code_params   = parse_global_body( token_fmt( "typename", StrC name(CodeParams),         code_impl_tmpl ));
+	CodeBody impl_code_params   = parse_global_body( token_fmt( "typename", Str name(CodeParams),         code_impl_tmpl ));
-	CodeBody impl_code_pragma   = parse_global_body( token_fmt( "typename", StrC name(CodePragma),         code_impl_tmpl ));
+	CodeBody impl_code_pragma   = parse_global_body( token_fmt( "typename", Str name(CodePragma),         code_impl_tmpl ));
-	CodeBody impl_code_precond  = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl ));
+	CodeBody impl_code_precond  = parse_global_body( token_fmt( "typename", Str name(CodePreprocessCond), code_impl_tmpl ));
-	CodeBody impl_code_specs    = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers),     code_impl_tmpl ));
+	CodeBody impl_code_specs    = parse_global_body( token_fmt( "typename", Str name(CodeSpecifiers),     code_impl_tmpl ));
-	CodeBody impl_code_struct   = parse_global_body( token_fmt( "typename", StrC name(CodeStruct),         code_impl_tmpl ));
+	CodeBody impl_code_struct   = parse_global_body( token_fmt( "typename", Str name(CodeStruct),         code_impl_tmpl ));
-	CodeBody impl_code_tmpl     = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate),       code_impl_tmpl ));
+	CodeBody impl_code_tmpl     = parse_global_body( token_fmt( "typename", Str name(CodeTemplate),       code_impl_tmpl ));
-	CodeBody impl_code_type     = parse_global_body( token_fmt( "typename", StrC name(CodeTypename),       code_impl_tmpl ));
+	CodeBody impl_code_type     = parse_global_body( token_fmt( "typename", Str name(CodeTypename),       code_impl_tmpl ));
-	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef),        code_impl_tmpl ));
+	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", Str name(CodeTypedef),        code_impl_tmpl ));
-	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", StrC name(CodeUnion),          code_impl_tmpl ));
+	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", Str name(CodeUnion),          code_impl_tmpl ));
-	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", StrC name(CodeUsing),          code_impl_tmpl ));
+	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", Str name(CodeUsing),          code_impl_tmpl ));
-	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", StrC name(CodeVar),            code_impl_tmpl ));
+	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", Str name(CodeVar),            code_impl_tmpl ));
 
-	body_append(impl_code_attr,     parse_global_body( token_fmt( "typename", StrC name(Attributes),     codetype_impl_tmpl )));
+	body_append(impl_code_attr,     parse_global_body( token_fmt( "typename", Str name(Attributes),     codetype_impl_tmpl )));
-	body_append(impl_code_cmt,      parse_global_body( token_fmt( "typename", StrC name(Comment),        codetype_impl_tmpl )));
+	body_append(impl_code_cmt,      parse_global_body( token_fmt( "typename", Str name(Comment),        codetype_impl_tmpl )));
-	body_append(impl_code_constr,   parse_global_body( token_fmt( "typename", StrC name(Constructor),    codetype_impl_tmpl )));
+	body_append(impl_code_constr,   parse_global_body( token_fmt( "typename", Str name(Constructor),    codetype_impl_tmpl )));
-	body_append(impl_code_define,   parse_global_body( token_fmt( "typename", StrC name(Define),         codetype_impl_tmpl )));
+	body_append(impl_code_define,   parse_global_body( token_fmt( "typename", Str name(Define),         codetype_impl_tmpl )));
-	body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", StrC name(Destructor),     codetype_impl_tmpl )));
+	body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", Str name(Destructor),     codetype_impl_tmpl )));
-	body_append(impl_code_enum,     parse_global_body( token_fmt( "typename", StrC name(Enum),           codetype_impl_tmpl )));
+	body_append(impl_code_enum,     parse_global_body( token_fmt( "typename", Str name(Enum),           codetype_impl_tmpl )));
-	body_append(impl_code_exec,     parse_global_body( token_fmt( "typename", StrC name(Exec),           codetype_impl_tmpl )));
+	body_append(impl_code_exec,     parse_global_body( token_fmt( "typename", Str name(Exec),           codetype_impl_tmpl )));
-	body_append(impl_code_extern,   parse_global_body( token_fmt( "typename", StrC name(Extern),         codetype_impl_tmpl )));
+	body_append(impl_code_extern,   parse_global_body( token_fmt( "typename", Str name(Extern),         codetype_impl_tmpl )));
-	body_append(impl_code_include,  parse_global_body( token_fmt( "typename", StrC name(Include),        codetype_impl_tmpl )));
+	body_append(impl_code_include,  parse_global_body( token_fmt( "typename", Str name(Include),        codetype_impl_tmpl )));
-	body_append(impl_code_friend,   parse_global_body( token_fmt( "typename", StrC name(Friend),         codetype_impl_tmpl )));
+	body_append(impl_code_friend,   parse_global_body( token_fmt( "typename", Str name(Friend),         codetype_impl_tmpl )));
-	body_append(impl_code_fn,       parse_global_body( token_fmt( "typename", StrC name(Fn),             codetype_impl_tmpl )));
+	body_append(impl_code_fn,       parse_global_body( token_fmt( "typename", Str name(Fn),             codetype_impl_tmpl )));
-	body_append(impl_code_module,   parse_global_body( token_fmt( "typename", StrC name(Module),         codetype_impl_tmpl )));
+	body_append(impl_code_module,   parse_global_body( token_fmt( "typename", Str name(Module),         codetype_impl_tmpl )));
-	body_append(impl_code_ns,       parse_global_body( token_fmt( "typename", StrC name(NS),             codetype_impl_tmpl )));
+	body_append(impl_code_ns,       parse_global_body( token_fmt( "typename", Str name(NS),             codetype_impl_tmpl )));
-	body_append(impl_code_op,       parse_global_body( token_fmt( "typename", StrC name(Operator),       codetype_impl_tmpl )));
+	body_append(impl_code_op,       parse_global_body( token_fmt( "typename", Str name(Operator),       codetype_impl_tmpl )));
-	body_append(impl_code_opcast,   parse_global_body( token_fmt( "typename", StrC name(OpCast),         codetype_impl_tmpl )));
+	body_append(impl_code_opcast,   parse_global_body( token_fmt( "typename", Str name(OpCast),         codetype_impl_tmpl )));
-	body_append(impl_code_pragma,   parse_global_body( token_fmt( "typename", StrC name(Pragma),         codetype_impl_tmpl )));
+	body_append(impl_code_pragma,   parse_global_body( token_fmt( "typename", Str name(Pragma),         codetype_impl_tmpl )));
-	body_append(impl_code_precond,  parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), codetype_impl_tmpl )));
+	body_append(impl_code_precond,  parse_global_body( token_fmt( "typename", Str name(PreprocessCond), codetype_impl_tmpl )));
-	body_append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", StrC name(Template),       codetype_impl_tmpl )));
+	body_append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", Str name(Template),       codetype_impl_tmpl )));
-	body_append(impl_code_type,     parse_global_body( token_fmt( "typename", StrC name(Typename),       codetype_impl_tmpl )));
+	body_append(impl_code_type,     parse_global_body( token_fmt( "typename", Str name(Typename),       codetype_impl_tmpl )));
-	body_append(impl_code_typedef,  parse_global_body( token_fmt( "typename", StrC name(Typedef),        codetype_impl_tmpl )));
+	body_append(impl_code_typedef,  parse_global_body( token_fmt( "typename", Str name(Typedef),        codetype_impl_tmpl )));
-	body_append(impl_code_union,    parse_global_body( token_fmt( "typename", StrC name(Union),          codetype_impl_tmpl )));
+	body_append(impl_code_union,    parse_global_body( token_fmt( "typename", Str name(Union),          codetype_impl_tmpl )));
-	body_append(impl_code_using,    parse_global_body( token_fmt( "typename", StrC name(Using),          codetype_impl_tmpl )));
+	body_append(impl_code_using,    parse_global_body( token_fmt( "typename", Str name(Using),          codetype_impl_tmpl )));
-	body_append(impl_code_var,      parse_global_body( token_fmt( "typename", StrC name(Var),            codetype_impl_tmpl )));
+	body_append(impl_code_var,      parse_global_body( token_fmt( "typename", Str name(Var),            codetype_impl_tmpl )));
 
 	#pragma push_macro("forceinline")
 	#undef forceinline
@@ -582,34 +577,34 @@ CodeBody gen_ast_inlines()
 	);
 	#pragma pop_macro("forceinline")
 
-	CodeBody impl_cast_body      = parse_global_body( token_fmt( "typename", StrC name(Body),           cast_tmpl ));
+	CodeBody impl_cast_body      = parse_global_body( token_fmt( "typename", Str name(Body),           cast_tmpl ));
-	CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes),     cast_tmpl ));
+	CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", Str name(Attributes),     cast_tmpl ));
-	CodeBody impl_cast_cmt       = parse_global_body( token_fmt( "typename", StrC name(Comment),        cast_tmpl ));
+	CodeBody impl_cast_cmt       = parse_global_body( token_fmt( "typename", Str name(Comment),        cast_tmpl ));
-	CodeBody impl_cast_constr    = parse_global_body( token_fmt( "typename", StrC name(Constructor),    cast_tmpl ));
+	CodeBody impl_cast_constr    = parse_global_body( token_fmt( "typename", Str name(Constructor),    cast_tmpl ));
-	CodeBody impl_cast_class     = parse_global_body( token_fmt( "typename", StrC name(Class),          cast_tmpl ));
+	CodeBody impl_cast_class     = parse_global_body( token_fmt( "typename", Str name(Class),          cast_tmpl ));
-	CodeBody impl_cast_define    = parse_global_body( token_fmt( "typename", StrC name(Define),         cast_tmpl ));
+	CodeBody impl_cast_define    = parse_global_body( token_fmt( "typename", Str name(Define),         cast_tmpl ));
-	CodeBody impl_cast_destruct  = parse_global_body( token_fmt( "typename", StrC name(Destructor),     cast_tmpl ));
+	CodeBody impl_cast_destruct  = parse_global_body( token_fmt( "typename", Str name(Destructor),     cast_tmpl ));
-	CodeBody impl_cast_enum      = parse_global_body( token_fmt( "typename", StrC name(Enum),           cast_tmpl ));
+	CodeBody impl_cast_enum      = parse_global_body( token_fmt( "typename", Str name(Enum),           cast_tmpl ));
-	CodeBody impl_cast_exec      = parse_global_body( token_fmt( "typename", StrC name(Exec),           cast_tmpl ));
+	CodeBody impl_cast_exec      = parse_global_body( token_fmt( "typename", Str name(Exec),           cast_tmpl ));
-	CodeBody impl_cast_extern    = parse_global_body( token_fmt( "typename", StrC name(Extern),         cast_tmpl ));
+	CodeBody impl_cast_extern    = parse_global_body( token_fmt( "typename", Str name(Extern),         cast_tmpl ));
-	CodeBody impl_cast_friend    = parse_global_body( token_fmt( "typename", StrC name(Friend),         cast_tmpl ));
+	CodeBody impl_cast_friend    = parse_global_body( token_fmt( "typename", Str name(Friend),         cast_tmpl ));
-	CodeBody impl_cast_fn        = parse_global_body( token_fmt( "typename", StrC name(Fn),             cast_tmpl ));
+	CodeBody impl_cast_fn        = parse_global_body( token_fmt( "typename", Str name(Fn),             cast_tmpl ));
-	CodeBody impl_cast_include   = parse_global_body( token_fmt( "typename", StrC name(Include),        cast_tmpl ));
+	CodeBody impl_cast_include   = parse_global_body( token_fmt( "typename", Str name(Include),        cast_tmpl ));
-	CodeBody impl_cast_module    = parse_global_body( token_fmt( "typename", StrC name(Module),         cast_tmpl ));
+	CodeBody impl_cast_module    = parse_global_body( token_fmt( "typename", Str name(Module),         cast_tmpl ));
-	CodeBody impl_cast_ns        = parse_global_body( token_fmt( "typename", StrC name(NS),             cast_tmpl ));
+	CodeBody impl_cast_ns        = parse_global_body( token_fmt( "typename", Str name(NS),             cast_tmpl ));
-	CodeBody impl_cast_op        = parse_global_body( token_fmt( "typename", StrC name(Operator),       cast_tmpl ));
+	CodeBody impl_cast_op        = parse_global_body( token_fmt( "typename", Str name(Operator),       cast_tmpl ));
-	CodeBody impl_cast_opcast    = parse_global_body( token_fmt( "typename", StrC name(OpCast),         cast_tmpl ));
+	CodeBody impl_cast_opcast    = parse_global_body( token_fmt( "typename", Str name(OpCast),         cast_tmpl ));
-	CodeBody impl_cast_params    = parse_global_body( token_fmt( "typename", StrC name(Params),         cast_tmpl ));
+	CodeBody impl_cast_params    = parse_global_body( token_fmt( "typename", Str name(Params),         cast_tmpl ));
-	CodeBody impl_cast_pragma    = parse_global_body( token_fmt( "typename", StrC name(Pragma),         cast_tmpl ));
+	CodeBody impl_cast_pragma    = parse_global_body( token_fmt( "typename", Str name(Pragma),         cast_tmpl ));
-	CodeBody impl_cast_precond   = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl ));
+	CodeBody impl_cast_precond   = parse_global_body( token_fmt( "typename", Str name(PreprocessCond), cast_tmpl ));
-	CodeBody impl_cast_specs     = parse_global_body( token_fmt( "typename", StrC name(Specifiers),     cast_tmpl ));
+	CodeBody impl_cast_specs     = parse_global_body( token_fmt( "typename", Str name(Specifiers),     cast_tmpl ));
-	CodeBody impl_cast_struct    = parse_global_body( token_fmt( "typename", StrC name(Struct),         cast_tmpl ));
+	CodeBody impl_cast_struct    = parse_global_body( token_fmt( "typename", Str name(Struct),         cast_tmpl ));
-	CodeBody impl_cast_tmpl      = parse_global_body( token_fmt( "typename", StrC name(Template),       cast_tmpl ));
+	CodeBody impl_cast_tmpl      = parse_global_body( token_fmt( "typename", Str name(Template),       cast_tmpl ));
-	CodeBody impl_cast_type      = parse_global_body( token_fmt( "typename", StrC name(Typename),       cast_tmpl ));
+	CodeBody impl_cast_type      = parse_global_body( token_fmt( "typename", Str name(Typename),       cast_tmpl ));
-	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", StrC name(Typedef),        cast_tmpl ));
+	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", Str name(Typedef),        cast_tmpl ));
-	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", StrC name(Union),          cast_tmpl ));
+	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", Str name(Union),          cast_tmpl ));
-	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", StrC name(Using),          cast_tmpl ));
+	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", Str name(Using),          cast_tmpl ));
-	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", StrC name(Var),            cast_tmpl ));
+	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", Str name(Var),            cast_tmpl ));
 
 	CodeBody result = def_global_body( args(
 		def_pragma( txt("region generated code inline implementation")),

base/helpers/misc.hpp

@@ -21,22 +21,22 @@ using namespace gen;
 void clang_format_file( char const* path, char const* style_path )
 {
 	GEN_ASSERT_NOT_NULL(path);
-	String resolved_path = string_make_strc(GlobalAllocator, to_strc_from_c_str(path));
+	StrBuilder resolved_path = strbuilder_make_str(_ctx->Allocator_Temp, to_str_from_c_str(path));
-	String style_arg;
+	StrBuilder style_arg;
 	if (style_path) {
-		style_arg = string_make_strc(GlobalAllocator, txt("-style=file:"));
+		style_arg = strbuilder_make_str(_ctx->Allocator_Temp, txt("-style=file:"));
-		string_append_fmt( & style_arg, "%s ", style_path );
+		strbuilder_append_fmt( & style_arg, "%s ", style_path );
 	}
 
-	StrC clang_format      = txt("clang-format ");
+	Str clang_format      = txt("clang-format ");
-	StrC cf_format_inplace = txt("-i ");
+	Str cf_format_inplace = txt("-i ");
-	StrC cf_verbose        = txt("-verbose ");
+	Str cf_verbose        = txt("-verbose ");
 
-	String command = string_make_strc( GlobalAllocator, clang_format );
+	StrBuilder command = strbuilder_make_str( _ctx->Allocator_Temp, clang_format );
-	string_append_strc( & command, cf_format_inplace );
+	strbuilder_append_str( & command, cf_format_inplace );
-	string_append_strc( & command, cf_verbose );
+	strbuilder_append_str( & command, cf_verbose );
-	string_append_string( & command, style_arg );
+	strbuilder_append_string( & command, style_arg );
-	string_append_string( & command, resolved_path );
+	strbuilder_append_string( & command, resolved_path );
 	system( command );
 }
 
@@ -48,11 +48,11 @@ void refactor_file( char const* path, char const* refactor_script )
 	GEN_ASSERT_NOT_NULL(path);
 	GEN_ASSERT_NOT_NULL(refactor_script);
 
-	String command = string_make_strc(GlobalAllocator, txt("refactor "));
+	StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, txt("refactor "));
-	// string_append_strc( & command, txt("-debug ") );
+	// strbuilder_append_str( & command, txt("-debug ") );
-	string_append_strc( & command, txt("-num=1 ") );
+	strbuilder_append_str( & command, txt("-num=1 ") );
-	string_append_fmt( & command, "-src=%s ", path );
+	strbuilder_append_fmt( & command, "-src=%s ", path );
-	string_append_fmt( & command,"-spec=%s ", refactor_script );
+	strbuilder_append_fmt( & command,"-spec=%s ", refactor_script );
 	system(command);
 	log_fmt("\n");
 }

docs/AST_Design.md

@@ -46,13 +46,13 @@ The C/C++ interface procedures are located with `ast.hpp` (for the Code type), a
 All code types can either serialize using a function of the pattern:
 
 ```c
-String <prefix>_to_string(Code code);
+StrBuilder <prefix>_to_strbuilder(Code code);
 // or
-<prefix>_to_string(Code code, String& result);
+<prefix>_to_strbuilder(Code code, StrBuilder& result);
 ```
 
 Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator.
 
-Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_string_ptr` & `code_to_string`.  
+Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`.  
 Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp).  
 Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

docs/AST_Types.md

@@ -25,7 +25,7 @@ These are containers representing a scope body of a definition that can be of th
 Fields:
 
 ```cpp
-StringCached   Name;
+StrCached   Name;
 Code           Front;
 Code           Back;
 Token*         Tok;
@@ -56,8 +56,8 @@ Represent standard or vendor specific C/C++ attributes.
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -80,8 +80,8 @@ Stores a comment.
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -109,7 +109,7 @@ CodeComment    InlineCmt;  // Only supported by forward declarations
 CodeAttributes Attributes;
 CodeType       ParentType;
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 CodeType       Prev;
 CodeType       Next;
 Token*         Tok;
@@ -143,7 +143,7 @@ CodeComment    InlineCmt;  // Only supported by forward declarations
 Code           InitializerList;
 CodeParams     Params;
 Code           Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -178,8 +178,8 @@ Represents a preprocessor define
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -201,7 +201,7 @@ Fields:
 CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 Code           Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -242,13 +242,13 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-StringCached   Name;
+StrCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
 UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment.  
-The `enum_underlying_sig` is a `StrC` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro.
+The `enum_underlying_sig` is a `Str` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro.
 
 Serialization:
 
@@ -271,8 +271,8 @@ Will be obsolute when function body parsing is implemented.
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -292,7 +292,7 @@ Fields:
 
 ```cpp
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -314,8 +314,8 @@ extern "<Name>"
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Code           Parent;
@@ -338,7 +338,7 @@ Fields:
 ```cpp
 CodeComment    InlineCmt;
 Code           Declaration;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -363,7 +363,7 @@ CodeSpecifiers Specs;
 CodeType       ReturnType;
 CodeParams     Params;
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -390,7 +390,7 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -411,7 +411,7 @@ Fields:
 
 ```cpp
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -440,7 +440,7 @@ CodeSpecifiers Specs;
 CodeType       ReturnType;
 CodeParams     Params;
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -472,7 +472,7 @@ CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 CodeType       ValueType;
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -502,7 +502,7 @@ CodeType       ValueType;
 Code           Macro;
 Code           Value;
 Code           PostNameMacro;
-StringCached   Name;
+StrCached   Name;
 CodeParams     Last;
 CodeParams     Next;
 Token*         Tok;
@@ -524,8 +524,8 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached   Content;
+StrCached   Content;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -544,8 +544,8 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached  Content;
+StrCached  Content;
-StringCached  Name;
+StrCached  Name;
 Code          Prev;
 Code          Next;
 Token*        Tok;
@@ -566,7 +566,7 @@ Fields:
 ```cpp
 SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
 CodeSpecifiers NextSpecs;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -588,7 +588,7 @@ Fields:
 ```cpp
 CodeParams     Params;
 Code           Declaration;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -621,7 +621,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-StringCached   Name;
+StrCached   Name;
 CodeT          Type;
 b32            IsParamPack;
 ETypenameTag   TypeTag;
@@ -637,7 +637,7 @@ Serialization:
 
 `<Name>` currently has the full serialization of anything with
 
-*Note: ArrExpr is not used in serialization by `typename_to_string_ref` its instead handled by a parent AST's serailization (variable, typedef, using).*
+*Note: ArrExpr is not used in serialization by `typename_to_strbuilder_ref` its instead handled by a parent AST's serailization (variable, typedef, using).*
 
 ## Typedef
 
@@ -649,7 +649,7 @@ Fields:
 ```cpp
 CodeComment   InlineCmt;
 Code          UnderlyingType;
-StringCached  Name;
+StrCached  Name;
 Code          Prev;
 Code          Next;
 Token*        Tok
@@ -682,7 +682,7 @@ Fields:
 ```cpp
 CodeAttributes Attributes;
 CodeBody       Body;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -708,7 +708,7 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
-StringCached   Name;
+StrCached   Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
@@ -740,7 +740,7 @@ CodeSpecifiers Specs;
 CodeType       ValueType;
 Code           BitfieldSize;
 Code           Value;
-StringCached   Name;
+StrCached   Name;
 CodeVar        NextVar;
 Code           Prev;
 Code           Next;

docs/Parser_Algo.md

@@ -12,7 +12,7 @@ gencpp uses a hand-written recursive descent parser. Both the lexer and parser c
 
 ### Lexer
 
-The lex procedure does the lexical pass of content provided as a `StrC` type.  
+The lex procedure does the lexical pass of content provided as a `Str` type.  
 The tokens are stored (for now) in `Lexer_Tokens`.
 
 Fields:
@@ -75,7 +75,7 @@ The parser has a limited user interface, only specific types of definitions or s
 Each public user interface procedure has the following format:
 
 ```cpp
-<code type> parse_<definition type>( StrC def )
+<code type> parse_<definition type>( Str def )
 {
     check_parse_args( def );
     using namespace Parser;
@@ -287,7 +287,7 @@ In the future statements and expressions will be parsed.
         1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes`
         2. Specifiers ( consteval, constexpr, constinit, extern, forceinline, global, inline, internal_linkage, neverinline, static )
         3. Is either ( identifier, const specifier, long, short, signed, unsigned, bool, char, double, int)
-            1. Attempt to parse as constrcutor or destructor : `parse_global_nspace_constructor_destructor`
+            1. Attempt to parse as construtor or destructor : `parse_global_nspace_constructor_destructor`
             2. If its an operator cast (definition outside class) : `parse_operator_cast`
             3. Its an operator, function, or varaible : `parse_operator_function_or_varaible`
 4. If its not a global body, consume the closing curly brace

docs/Parsing.md

@@ -15,25 +15,25 @@ You can think of this parser as *frontend parser* vs a *semantic parser*. Its in
 User exposed interface:
 
 ```cpp
-CodeClass       parse_class        ( StrC class_def       );
+CodeClass       parse_class        ( Str class_def       );
-CodeConstructor parse_constructor  ( StrC constructor_def );
+CodeConstructor parse_constructor  ( Str constructor_def );
-CodeDestructor  parse_destructor   ( StrC destructor_def  );
+CodeDestructor  parse_destructor   ( Str destructor_def  );
-CodeEnum        parse_enum         ( StrC enum_def        );
+CodeEnum        parse_enum         ( Str enum_def        );
-CodeBody        parse_export_body  ( StrC export_def      );
+CodeBody        parse_export_body  ( Str export_def      );
-CodeExtern      parse_extern_link  ( StrC exten_link_def  );
+CodeExtern      parse_extern_link  ( Str exten_link_def  );
-CodeFriend      parse_friend       ( StrC friend_def      );
+CodeFriend      parse_friend       ( Str friend_def      );
-CodeFn          parse_function     ( StrC fn_def          );
+CodeFn          parse_function     ( Str fn_def          );
-CodeBody        parse_global_body  ( StrC body_def        );
+CodeBody        parse_global_body  ( Str body_def        );
-CodeNS          parse_namespace    ( StrC namespace_def   );
+CodeNS          parse_namespace    ( Str namespace_def   );
-CodeOperator    parse_operator     ( StrC operator_def    );
+CodeOperator    parse_operator     ( Str operator_def    );
-CodeOpCast      parse_operator_cast( StrC operator_def    );
+CodeOpCast      parse_operator_cast( Str operator_def    );
-CodeStruct      parse_struct       ( StrC struct_def      );
+CodeStruct      parse_struct       ( Str struct_def      );
-CodeTemplate    parse_template     ( StrC template_def    );
+CodeTemplate    parse_template     ( Str template_def    );
-CodeType        parse_type         ( StrC type_def        );
+CodeType        parse_type         ( Str type_def        );
-CodeTypedef     parse_typedef      ( StrC typedef_def     );
+CodeTypedef     parse_typedef      ( Str typedef_def     );
-CodeUnion       parse_union        ( StrC union_def       );
+CodeUnion       parse_union        ( Str union_def       );
-CodeUsing       parse_using        ( StrC using_def       );
+CodeUsing       parse_using        ( Str using_def       );
-CodeVar         parse_variable     ( StrC var_def         );
+CodeVar         parse_variable     ( Str var_def         );
 ```
 
 To parse file buffers, use the `parse_global_body` function.

docs/Readme.md

@@ -49,10 +49,10 @@ However, the user may specifiy memory configuration.
 
 https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
 
-*`StringCahced` is a typedef for `StrC` (a string slice), to denote it is an interned string*  
+*`StringCahced` is a typedef for `Str` (a string slice), to denote it is an interned string*  
 *`CodeType` is enum taggin the type of code. Has an underlying type of `u32`*  
 *`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*  
-*`String` is the dynamically allocated string type for the library*  
+*`StrBuilder` is the dynamically allocated string type for the library*  
 
 AST widths are setup to be AST_POD_Size.  
 The width dictates how much the static array can hold before it must give way to using an allocated array:
@@ -63,7 +63,7 @@ int AST_ArrSpecs_Cap =
 (
     AST_POD_Size
     - sizeof(Code)
-    - sizeof(StringCached)
+    - sizeof(StrCached)
     - sizeof(Code) * 2
     - sizeof(Token*)
     - sizeof(Code)
@@ -79,7 +79,7 @@ int AST_ArrSpecs_Cap =
 Data Notes:
 
 * The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
+  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_strbuilder_allocator`, `cache_str`, `make_code`.
   * Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
   * Most of the work is just defining the allocation procedure:
 
@@ -93,7 +93,7 @@ Data Notes:
 * Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
   * `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
 * Strings used for serialization and file buffers are not contained by those used for cached strings.
-  * They are currently using `GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
+  * They are currently using `FallbackAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
   * Memory within the buckets is not reused, so its inherently wasteful.
   * I will be augmenting the default allocator with virtual memory & a slab allocator in the [future](https://github.com/Ed94/gencpp/issues/12)
 * Intrusive linked lists used children nodes on bodies, and parameters.
@@ -308,7 +308,7 @@ Code <name> = code_str( <some code without "" quotes > )
 Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
 
 ```cpp
-StrC value = txt("Something");
+Str value = txt("Something");
 
 char const* template_str = txt(
     Code with <key> to replace with token_values
@@ -403,7 +403,7 @@ There are two provided auxillary interfaces:
 * Builder
 * Scanner
 
-### Builder is a similar object to the jai language's string_builder
+### Builder is a similar object to the jai language's strbuilder_builder
 
 * The purpose of it is to generate a file.
 * A file is specified and opened for writing using the open( file_path) function.

gen_c_library/Readme.md

@@ -18,6 +18,6 @@ If using the library's provided build scripts:
 .\build.ps1 <compiler> <debug or omit> c_library
 ```
 
-All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying c_library.refactor.
+All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying [c_library.refactor](./c_library.refactor).
 
 **If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.**

gen_c_library/c_library.cpp

@@ -24,24 +24,24 @@ constexpr char const* generation_notice =
 "// This file was generated automatially by gencpp's c_library.cpp  "
 "(See: https://github.com/Ed94/gencpp)\n\n";
 
-constexpr StrC roll_own_dependencies_guard_start = txt(R"(
+constexpr Str roll_own_dependencies_guard_start = txt(R"(
 //! 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
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 )");
 
-constexpr StrC roll_own_dependencies_guard_end = txt(R"(
+constexpr Str roll_own_dependencies_guard_end = txt(R"(
 // GEN_ROLL_OWN_DEPENDENCIES
 #endif
 )");
 
-constexpr StrC implementation_guard_start = txt(R"(
+constexpr Str implementation_guard_start = txt(R"(
 #pragma region GENCPP IMPLEMENTATION GUARD
 #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
 #	define GEN_IMPLEMENTED
 )");
 
-constexpr StrC implementation_guard_end = txt(R"(
+constexpr Str implementation_guard_end = txt(R"(
 #endif
 #pragma endregion GENCPP IMPLEMENTATION GUARD
 )");
@@ -62,20 +62,21 @@ constexpr bool helper_use_c_definition = true;
 
 int gen_main()
 {
-	gen::init();
+	Context ctx {};
+	gen::init(& ctx);
 
-	PreprocessorDefines.append(txt("GEN_API_C_BEGIN"));
+	ctx.PreprocessorDefines.append(txt("GEN_API_C_BEGIN"));
-	PreprocessorDefines.append(txt("GEN_API_C_END"));
+	ctx.PreprocessorDefines.append(txt("GEN_API_C_END"));
-	PreprocessorDefines.append(txt("Array("));
+	ctx.PreprocessorDefines.append(txt("Array("));
-	PreprocessorDefines.append(txt("HashTable("));
+	ctx.PreprocessorDefines.append(txt("HashTable("));
-	PreprocessorDefines.append(txt("GEN_NS_PARSER"));
+	ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER"));
-	PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN"));
+	ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN"));
-	PreprocessorDefines.append(txt("GEN_NS_PARSER_END"));
+	ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_END"));
-	PreprocessorDefines.append(txt("Using_Code("));
+	ctx.PreprocessorDefines.append(txt("Using_Code("));
-	PreprocessorDefines.append(txt("Using_CodeOps("));
+	ctx.PreprocessorDefines.append(txt("Using_CodeOps("));
-	PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"));
+	ctx.PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"));
-	PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END"));
+	ctx.PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END"));
-	PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT"));
+	ctx.PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT"));
 	//PreprocessorDefines.append(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"));
 
 	Code push_ignores           = scan_file( path_base "helpers/push_ignores.inline.hpp" );
@@ -87,7 +88,7 @@ int gen_main()
 #pragma region Resolve Dependencies
 	Code header_platform       = scan_file( path_base "dependencies/platform.hpp" );
 	Code header_macros         = scan_file( path_base "dependencies/macros.hpp" );
-	Code header_generic_macros = scan_file(           "components/generic_macros.hpp" );
+	Code header_generic_macros = scan_file(           "components/generic_macros.h" );
 	Code header_basic_types    = scan_file( path_base "dependencies/basic_types.hpp" );
 	Code header_debug          = scan_file( path_base "dependencies/debug.hpp" );
 	Code header_string_ops     = scan_file( path_base "dependencies/string_ops.hpp" );
@@ -100,7 +101,7 @@ int gen_main()
 	{
 		case CT_Using:
 		{
-			log_fmt("REPLACE THIS MANUALLY: %SC\n", entry->Name);
+			log_fmt("REPLACE THIS MANUALLY: %S\n", entry->Name);
 			CodeUsing   using_ver   = cast(CodeUsing, entry);
 			CodeTypedef typedef_ver = def_typedef(using_ver->Name, using_ver->UnderlyingType);
 
@@ -126,7 +127,7 @@ int gen_main()
 			if (fn->Specs) {
 				s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
 				if (constexpr_found > -1) {
-					//log_fmt("Found constexpr: %S\n", entry.to_string());
+					//log_fmt("Found constexpr: %SB\n", entry.to_strbuilder());
 					fn->Specs.append(Spec_Inline);
 				}
 			}
@@ -238,7 +239,7 @@ do                          \
 		break;
 		case CT_Variable:
 		{
-			if ( strc_contains(entry->Name, txt("Msg_Invalid_Value")))
+			if ( str_contains(entry->Name, txt("Msg_Invalid_Value")))
 			{
 				CodeDefine define = def_define(entry->Name, entry->Value->Content);
 				header_printing.append(define);
@@ -253,7 +254,7 @@ do                          \
 	}
 
 	Code array_ssize         = gen_array(txt("gen_ssize"), txt("Array_gen_ssize"));
-	Code array_string_cached = gen_array(txt("gen_StringCached"), txt("Array_gen_StringCached"));
+	Code array_string_cached = gen_array(txt("gen_StrCached"), txt("Array_gen_StrCached"));
 
 	CodeBody parsed_header_strings = parse_file( path_base "dependencies/strings.hpp" );
 	CodeBody header_strings        = def_body(CT_Global_Body);
@@ -292,16 +293,16 @@ do                          \
 
 		case CT_Preprocess_IfNotDef:
 		{
-			//log_fmt("\nIFNDEF: %SC\n", entry->Content);
+			//log_fmt("\nIFNDEF: %S\n", entry->Content);
 			header_strings.append(entry);
 		}
 		break;
 
 		case CT_Struct_Fwd:
 		{
-			if ( entry->Name.is_equal(txt("String")) )
+			if ( entry->Name.is_equal(txt("StrBuilder")) )
 			{
-				CodeTypedef c_def = parse_typedef(code( typedef char* String; ));
+				CodeTypedef c_def = parse_typedef(code( typedef char* StrBuilder; ));
 				header_strings.append(c_def);
 				header_strings.append(fmt_newline);
 				++ entry;
@@ -341,12 +342,12 @@ do                          \
 
 		case CT_Typedef:
 		{
-			StrC name_string_table = txt("StringTable");
+			Str name_string_table = txt("StringTable");
 
 			CodeTypedef td = cast(CodeTypedef, entry);
 			if (td->Name.contains(name_string_table))
 			{
-				CodeBody ht = gen_hashtable(txt("gen_StrC"), name_string_table);
+				CodeBody ht = gen_hashtable(txt("gen_Str"), name_string_table);
 				header_strings.append(ht);
 				break;
 			}
@@ -388,8 +389,8 @@ do                          \
 		case CT_Union:
 		case CT_Union_Fwd:
 		{
-			StrC type_str      = codetype_to_keyword_str(entry->Type);
+			Str type_str      = codetype_to_keyword_str(entry->Type);
-			StrC formated_tmpl = token_fmt_impl( 3,
+			Str formated_tmpl = token_fmt_impl( 3,
 				"type", type_str
 			,	"name", entry->Name,
 			stringize(
@@ -490,8 +491,8 @@ do                          \
 				continue;
 			}
 
-			StrC type_str      = codetype_to_keyword_str(entry->Type);
+			Str type_str      = codetype_to_keyword_str(entry->Type);
-			StrC formated_tmpl = token_fmt_impl( 3,
+			Str formated_tmpl = token_fmt_impl( 3,
 				"type", type_str
 			,	"name", entry->Name,
 			stringize(
@@ -549,9 +550,9 @@ do                          \
 			{
 				CodeTypename type       = using_ver->UnderlyingType;
 				CodeTypedef typedef_ver = parse_typedef(token_fmt(
-					"ReturnType", to_string(type->ReturnType).to_strc()
+					"ReturnType", to_strbuilder(type->ReturnType).to_str()
 				,	"Name"      , using_ver->Name
-				,	"Parameters", to_string(type->Params).to_strc()
+				,	"Parameters", to_strbuilder(type->Params).to_str()
 				,	stringize(
 						typedef <ReturnType>( * <Name>)(<Parameters>);
 				)));
@@ -578,7 +579,7 @@ do                          \
 				types.append(entry_td);
 				continue;
 			}
-			//log_fmt("Detected ENUM: %S", entry->Name);
+			//log_fmt("Detected ENUM: %SB", entry->Name);
 			convert_cpp_enum_to_c(cast(CodeEnum, entry), types);
 		}
 		break;
@@ -588,8 +589,102 @@ do                          \
 		break;
 	}
 
+	CodeBody array_token = gen_array(txt("gen_Token"), txt("Array_gen_Token"));
+
+	CodeBody parsed_parser_types = parse_file( path_base "components/parser_types.hpp" );
+	CodeBody parser_types        = def_body(CT_Global_Body);
+	for ( Code entry = parsed_parser_types.begin(); entry != parsed_parser_types.end(); ++ entry ) switch(entry->Type)
+	{
+		case CT_Preprocess_IfDef:
+		{
+			b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_parser_types, parser_types );
+			if (found) break;
+
+			parser_types.append(entry);
+		}
+		break;
+
+		case CT_Enum:
+		{
+			if (entry->Name.Len)
+			{
+				convert_cpp_enum_to_c(cast(CodeEnum, entry), parser_types);
+				break;
+			}
+
+			parser_types.append(entry);
+		}
+		break;
+
+		case CT_Struct:
+		{
+			if ( entry->Name.is_equal(txt("Token")))
+			{
+				// Add struct Token forward and typedef early.
+				CodeStruct  token_fwd     = parse_struct(code( struct Token; ));
+				CodeTypedef token_typedef = parse_typedef(code( typedef struct Token Token; ));
+				parser_types.append(token_fwd);
+				parser_types.append(token_typedef);
+
+				// Skip typedef since we added it
+				b32 continue_for = true;
+				for (Code array_entry = array_token.begin(); continue_for && array_entry != array_token.end(); ++ array_entry) switch (array_entry->Type)
+				{
+					case CT_Typedef:
+					{
+						// pop the array entry
+						array_token->NumEntries -= 1;
+						Code next                   = array_entry->Next;
+						Code prev                   = array_entry->Prev;
+						next->Prev                  = array_entry->Prev;
+						prev->Next                  = next;
+						if ( array_token->Front == array_entry )
+							array_token->Front = next;
+
+							parser_types.append(array_entry);
+						continue_for = false;
+					}
+					break;
+				}
+
+				// Append the struct
+				parser_types.append(entry);
+
+				// Append the token array
+				parser_types.append(array_token);
+				continue;
+			}
+
+			CodeTypedef struct_tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
+			parser_types.append(struct_tdef);
+			parser_types.append(entry);
+		}
+		break;
+
+		case CT_Variable:
+		{
+			CodeVar var = cast(CodeVar, entry);
+			if (var->Specs && var->Specs.has(Spec_Constexpr) > -1) {
+				Code define_ver = untyped_str(token_fmt(
+						"name",  var->Name
+					,	"value", var->Value->Content
+					,	"type",  var->ValueType.to_strbuilder().to_str()
+					,	"#define <name> (<type>) <value>\n"
+				));
+				parser_types.append(define_ver);
+				continue;
+			}
+			parser_types.append(entry);
+		}
+		break;
+
+		default:
+			parser_types.append(entry);
+		break;
+	}
+
 	// Used to track which functions need generic selectors.
-	Array(CodeFn) code_c_interface = array_init_reserve<CodeFn>(GlobalAllocator, 16);
+	Array(CodeFn) code_c_interface = array_init_reserve<CodeFn>(_ctx->Allocator_Temp, 16);
 
 	CodeBody parsed_ast = parse_file( path_base "components/ast.hpp" );
 	CodeBody ast        = def_body(CT_Global_Body);
@@ -645,11 +740,11 @@ do                          \
 					CodeFn fn = cast(CodeFn, entry);
 					if (fn->Name.starts_with(txt("code_")))
 					{
-						StrC   old_prefix  = txt("code_");
+						Str   old_prefix  = txt("code_");
-						StrC   actual_name = { fn->Name.Len  - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
+						Str   actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len  - old_prefix.Len };
-						String new_name    = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
+						StrBuilder new_name    = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
 
-						fn->Name = get_cached_string(new_name);
+						fn->Name = cache_str(new_name);
 						code_c_interface.append(fn);
 					}
 					ast.append(entry);
@@ -694,21 +789,21 @@ do                          \
 
 			s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 1;
 			if (constexpr_found > -1) {
-				//log_fmt("Found constexpr: %S\n", entry.to_string());
+				//log_fmt("Found constexpr: %SB\n", entry.to_strbuilder());
 				if (var->Name.contains(txt("AST_ArrSpecs_Cap")))
 				{
 					Code def = untyped_str(txt(
 R"(#define AST_ArrSpecs_Cap \
 (                           \
-	AST_POD_Size            \
+	AST_POD_Size              \
-	- sizeof(Code)          \
+	- sizeof(Code)            \
-	- sizeof(StringCached)  \
+	- sizeof(StrCached)    \
-	- sizeof(Code) * 2      \
+	- sizeof(Code) * 2        \
-	- sizeof(Token*)        \
+	- sizeof(Token*)          \
-	- sizeof(Code)          \
+	- sizeof(Code)            \
-	- sizeof(CodeType)      \
+	- sizeof(CodeType)        \
-	- sizeof(ModuleFlag)    \
+	- sizeof(ModuleFlag)      \
-	- sizeof(u32)           \
+	- sizeof(u32)             \
 )                           \
 / sizeof(Specifier) - 1
 )"
@@ -716,7 +811,7 @@ R"(#define AST_ArrSpecs_Cap \
 					ast.append(def);
 					break;
 				}
-				CodeDefine def = def_define(var->Name, var->Value.to_string());
+				CodeDefine def = def_define(var->Name, var->Value.to_strbuilder());
 				ast.append(def);
 				break;
 			}
@@ -729,7 +824,7 @@ R"(#define AST_ArrSpecs_Cap \
 		break;
 	}
 
-	StrC code_typenames[] = {
+	Str code_typenames[] = {
 		txt("Code"),
 		txt("CodeBody"),
 		txt("CodeAttributes"),
@@ -791,24 +886,24 @@ R"(#define AST_ArrSpecs_Cap \
 				default: gen_generic_selection (Fail case)                                    \
 			) GEN_RESOLVED_FUNCTION_CALL( code, ... )                                       \
 			*/
-			String generic_selector = String::make_reserve(GlobalAllocator, kilobytes(2));
+			StrBuilder generic_selector = StrBuilder::make_reserve(_ctx->Allocator_Temp, kilobytes(2));
 			for ( CodeFn fn : code_c_interface )
 			{
 				generic_selector.clear();
-				StrC   private_prefix  = txt("code__");
+				Str   private_prefix  = txt("code__");
-				StrC   actual_name     = { fn->Name.Len - private_prefix.Len, fn->Name.Ptr + private_prefix.Len };
+				Str   actual_name     = { fn->Name.Ptr + private_prefix.Len, fn->Name.Len - private_prefix.Len };
-				String interface_name  = String::fmt_buf(GlobalAllocator, "code_%SC", actual_name );
+				StrBuilder interface_name  = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code_%S", actual_name );
 
 				// Resolve generic's arguments
 				b32    has_args   = fn->Params->NumEntries > 1;
-				String params_str = String::make_reserve(GlobalAllocator, 32);
+				StrBuilder params_str = StrBuilder::make_reserve(_ctx->Allocator_Temp, 32);
 				for (CodeParams param = fn->Params->Next; param != fn->Params.end(); ++ param) {
 					// We skip the first parameter as its always going to be the code for selection
 					if (param->Next == nullptr) {
-						params_str.append_fmt( "%SC", param->Name );
+						params_str.append_fmt( "%S", param->Name );
 						continue;
 					}
-					params_str.append_fmt( "%SC, ", param->Name );
+					params_str.append_fmt( "%S, ", param->Name );
 				}
 
 				char const* tmpl_def_start = nullptr;
@@ -824,14 +919,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				}
 				// Definition start
 				generic_selector.append( token_fmt(
-							"interface_name", interface_name.to_strc()
+							"interface_name", interface_name.to_str()
-					,		"params",         params_str.to_strc() // Only used if has_args
+					,		"params",         params_str.to_str() // Only used if has_args
 					, tmpl_def_start
 				));
 
 				// Append slots
-				for(StrC type : code_typenames ) {
+				for(Str type : code_typenames ) {
-					generic_selector.append_fmt("%SC : %SC,\\\n", type, fn->Name );
+					generic_selector.append_fmt("%S : %S,\\\n", type, fn->Name );
 				}
 				generic_selector.append(txt("default: gen_generic_selection_fail \\\n"));
 
@@ -844,7 +939,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				}
 				// Definition end
 				generic_selector.append( token_fmt(
-						"params", params_str.to_strc()
+						"params", params_str.to_str()
 				, 	"type",   fn->Params->ValueType->Name
 				,		tmpl_def_end ) );
 
@@ -890,8 +985,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 						char conversion_buf[32] = {};
 						u64_to_str(size_of(AST_Body::_PAD_), conversion_buf, 10);
 
-						StrC arr_exp  = union_entry->ValueType->ArrExpr->Content;
+						Str arr_exp  = union_entry->ValueType->ArrExpr->Content;
-						StrC cpp_size = to_strc_from_c_str(conversion_buf);
+						Str cpp_size = to_str_from_c_str(conversion_buf);
 						union_entry->ValueType->ArrExpr = untyped_str( cpp_size );
 						union_entry->InlineCmt          = untyped_str(token_fmt("arr_exp", arr_exp,
 							"// Had to hardcode _PAD_ because (<arr_exp>) was 67 bytes in C\n"
@@ -910,6 +1005,9 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		break;
 	}
 
+	CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena"));
+	CodeBody array_pool  = gen_array(txt("gen_Pool"),  txt("Array_gen_Pool"));
+
 	CodeBody parsed_interface = parse_file( path_base "components/interface.hpp" );
 	CodeBody interface        = def_body(CT_Global_Body);
 	for ( Code entry = parsed_interface.begin(); entry != parsed_interface.end(); ++ entry ) switch( entry->Type )
@@ -931,8 +1029,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 
 			if (prev && prev->Name.is_equal(entry->Name)) {
 				// rename second definition so there isn't a symbol conflict
-				String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", entry->Name);
+				StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", entry->Name);
-				entry->Name = get_cached_string(postfix_arr.to_strc());
+				entry->Name = cache_str(postfix_arr.to_str());
 				postfix_arr.free();
 			}
 
@@ -940,20 +1038,20 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 			for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
 			{
 				// Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295
-				StrC prefix      = txt("def_");
+				Str prefix      = txt("def_");
-				StrC actual_name = { fn->Name.Len  - prefix.Len, fn->Name.Ptr + prefix.Len };
+				Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len  - prefix.Len };
-				StrC new_name    = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc();
+				Str new_name    = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
 
 				// Resolve define's arguments
 				b32    has_args   = fn->Params->NumEntries > 1;
-				String params_str = String::make_reserve(GlobalAllocator, 32);
+				StrBuilder params_str = StrBuilder::make_reserve(_ctx->Allocator_Temp, 32);
 				for (CodeParams other_param = fn->Params; other_param != opt_param; ++ other_param) {
 					if ( other_param == opt_param ) {
-						params_str.append_fmt( "%SC", other_param->Name );
+						params_str.append_fmt( "%S", other_param->Name );
 						break;
 					}
 					// If there are arguments before the optional, prepare them here.
-					params_str.append_fmt( "%SC, ", other_param->Name );
+					params_str.append_fmt( "%S, ", other_param->Name );
 				}
 				char const* tmpl_fn_macro = nullptr;
 				if (params_str.length() > 0 ) {
@@ -965,12 +1063,12 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				Code fn_macro = untyped_str(token_fmt(
 						"def_name",  fn->Name
 				,		"def__name", new_name
-				,		"params",    params_str.to_strc()
+				,		"params",    params_str.to_str()
 				,		"opts_type", opt_param->ValueType->Name
 				,	tmpl_fn_macro
 				));
 
-				fn->Name = get_cached_string(new_name);
+				fn->Name = cache_str(new_name);
 				interface.append(fn);
 				interface.append(fn_macro);
 				if (entry->Next && entry->Next->Type != CT_NewLine) {
@@ -1019,11 +1117,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 			CodeFn fn = cast(CodeFn, entry);
 			if (fn->Name.starts_with(txt("code_")))
 			{
-				StrC   old_prefix  = txt("code_");
+				Str   old_prefix  = txt("code_");
-				StrC   actual_name = { fn->Name.Len  - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
+				Str   actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len  - old_prefix.Len };
-				String new_name    = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
+				StrBuilder new_name    = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
 
-				fn->Name = get_cached_string(new_name);
+				fn->Name = cache_str(new_name);
 			}
 			inlines.append(entry);
 		}
@@ -1142,10 +1240,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 #pragma endregion Resolve Dependencies
 
 #pragma region Resolve Components
-	CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena"));
-	CodeBody array_pool  = gen_array(txt("gen_Pool"),  txt("Array_gen_Pool"));
-	CodeBody array_token = gen_array(txt("gen_Token"), txt("Array_gen_Token"));
-
 	Code src_start              = scan_file(           "components/src_start.c" );
 	Code src_static_data 	      = scan_file( path_base "components/static_data.cpp" );
 	Code src_ast_case_macros    = scan_file( path_base "components/ast_case_macros.cpp" );
@@ -1174,11 +1268,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 			CodeFn fn = cast(CodeFn, entry);
 			if (fn->Name.starts_with(txt("code_")))
 			{
-				StrC   old_prefix  = txt("code_");
+				Str   old_prefix  = txt("code_");
-				StrC   actual_name = { fn->Name.Len  - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
+				Str   actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len  - old_prefix.Len };
-				String new_name    = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
+				StrBuilder new_name    = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
 
-				fn->Name = get_cached_string(new_name);
+				fn->Name = cache_str(new_name);
 			}
 			src_ast.append(entry);
 		}
@@ -1219,18 +1313,18 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				)
 				{
 					// rename second definition so there isn't a symbol conflict
-					String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", fn->Name);
+					StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", fn->Name);
-					fn->Name = get_cached_string(postfix_arr.to_strc());
+					fn->Name = cache_str(postfix_arr.to_str());
 					postfix_arr.free();
 				}
 
 			for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
 			{
-				StrC prefix      = txt("def_");
+				Str prefix      = txt("def_");
-				StrC actual_name = { fn->Name.Len  - prefix.Len, fn->Name.Ptr + prefix.Len };
+				Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len  - prefix.Len };
-				StrC new_name    = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc();
+				Str new_name    = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
 
-				fn->Name = get_cached_string(new_name);
+				fn->Name = cache_str(new_name);
 			}
 
 			src_upfront.append(fn);
@@ -1267,51 +1361,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		}
 		break;
 
-		case CT_Struct:
-		{
-			if ( entry->Name.is_equal(txt("Token")))
-			{
-				// Add struct Token forward and typedef early.
-				CodeStruct  token_fwd     = parse_struct(code( struct Token; ));
-				CodeTypedef token_typedef = parse_typedef(code( typedef struct Token Token; ));
-				src_lexer.append(token_fwd);
-				src_lexer.append(token_typedef);
-
-				// Skip typedef since we added it
-				b32 continue_for = true;
-				for (Code array_entry = array_token.begin(); continue_for && array_entry != array_token.end(); ++ array_entry) switch (array_entry->Type)
-				{
-					case CT_Typedef:
-					{
-						// pop the array entry
-						array_token->NumEntries -= 1;
-						Code next                   = array_entry->Next;
-						Code prev                   = array_entry->Prev;
-						next->Prev                  = array_entry->Prev;
-						prev->Next                  = next;
-						if ( array_token->Front == array_entry )
-							array_token->Front = next;
-
-						src_lexer.append(array_entry);
-						continue_for = false;
-					}
-					break;
-				}
-
-				// Append the struct
-				src_lexer.append(entry);
-
-				// Append the token array
-				src_lexer.append(array_token);
-				continue;
-			}
-
-			CodeTypedef struct_tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
-			src_lexer.append(entry);
-			src_lexer.append(struct_tdef);
-		}
-		break;
-
 		case CT_Variable:
 		{
 			CodeVar var = cast(CodeVar, entry);
@@ -1319,7 +1368,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				Code define_ver = untyped_str(token_fmt(
 						"name",  var->Name
 					,	"value", var->Value->Content
-					,	"type",  var->ValueType.to_string().to_strc()
+					,	"type",  var->ValueType.to_strbuilder().to_str()
 					,	"#define <name> (<type>) <value>\n"
 				));
 				src_lexer.append(define_ver);
@@ -1364,7 +1413,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 				Code define_ver = untyped_str(token_fmt(
 						"name",  var->Name
 					,	"value", var->Value->Content
-					,	"type",  var->ValueType.to_string().to_strc()
+					,	"type",  var->ValueType.to_strbuilder().to_str()
 					,	"#define <name> (<type>) <value>\n"
 				));
 				src_parser.append(define_ver);
@@ -1416,13 +1465,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 	Code r_header_timing       = refactor(header_timing);
 	Code rf_header_parsing     = refactor_and_format(header_parsing);
 
-	Code rf_types      = refactor_and_format(types);
+	Code rf_types        = refactor_and_format(types);
-	Code rf_ecode      = refactor_and_format(ecode);
+	Code rf_parser_types = refactor_and_format(parser_types); 
-	Code rf_eoperator  = refactor_and_format(eoperator);
+	Code rf_ecode        = refactor_and_format(ecode);
-	Code rf_especifier = refactor_and_format(especifier);
+	Code rf_eoperator    = refactor_and_format(eoperator);
-	Code rf_ast        = refactor_and_format(ast);
+	Code rf_especifier   = refactor_and_format(especifier);
-	Code rf_code_types = refactor_and_format(code_types);
+	Code rf_ast          = refactor_and_format(ast);
-	Code rf_ast_types  = refactor_and_format(ast_types);
+	Code rf_code_types   = refactor_and_format(code_types);
+	Code rf_ast_types    = refactor_and_format(ast_types);
 
 	Code rf_interface = refactor_and_format(interface);
 	Code rf_inlines   = refactor_and_format(inlines);
@@ -1458,7 +1508,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
  	Code rf_src_parser          = refactor_and_format(src_parser);
 	Code r_src_parsing          = refactor(src_parsing_interface);
 	Code r_src_untyped          = refactor(src_untyped);
-	
+
 	CodeBody etoktype    = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv", helper_use_c_definition );
 	Code     rf_etoktype = refactor_and_format(etoktype);
 
@@ -1481,9 +1531,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print_fmt( roll_own_dependencies_guard_start );
 		header.print( r_header_platform );
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
-
 		header.print( r_header_macros );
 		header.print( header_generic_macros );
+
+		header.print_fmt( "GEN_API_C_BEGIN\n" );
+
 		header.print( r_header_basic_types );
 		header.print( r_header_debug );
 		header.print( rf_header_memory );
@@ -1497,7 +1549,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( r_header_timing );
 		header.print(rf_header_parsing );
 
-		header.print_fmt( "\nGEN_NS_END\n" );
+		header.print_fmt( "\nGEN_API_C_END\n" );
+		header.print_fmt( "GEN_NS_END\n" );
 		header.print_fmt( roll_own_dependencies_guard_end );
 	#pragma endregion Print Dependencies
 
@@ -1515,6 +1568,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( rf_eoperator );
 		header.print( fmt_newline );
 		header.print( rf_especifier );
+		header.print( rf_etoktype );
+		header.print( rf_parser_types );
 		header.print_fmt("#pragma endregion Types\n\n");
 
 		header.print_fmt("#pragma region AST\n");
@@ -1523,6 +1578,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( rf_ast_types );
 		header.print_fmt("\n#pragma endregion AST\n");
 
+		header.print( fmt_newline);
+		header.print( rf_array_arena );
+		header.print( fmt_newline);
+		header.print( rf_array_pool);
+		header.print( fmt_newline);
+		header.print( rf_array_string_cached );
+
 		header.print( rf_interface );
 		header.print(fmt_newline);
 
@@ -1531,7 +1593,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print_fmt("#pragma endregion Inlines\n");
 
 		header.print(fmt_newline);
-		header.print( rf_array_string_cached );
 
 		header.print( rf_header_end );
 		header.print( rf_header_builder );
@@ -1548,7 +1609,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 
 	#pragma region Print Dependencies
 		header.print_fmt( roll_own_dependencies_guard_start );
-		header.print_fmt( "GEN_NS_BEGIN\n");
+		header.print_fmt( "\nGEN_NS_BEGIN\n");
 		header.print_fmt( "GEN_API_C_BEGIN\n" );
 
 		header.print( r_src_dep_start );
@@ -1562,17 +1623,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( r_src_timing );
 		header.print( rf_src_parsing );
 
+		header.print_fmt( "\nGEN_API_C_END\n" );
 		header.print_fmt( "GEN_NS_END\n");
 		header.print_fmt( roll_own_dependencies_guard_end );
 	#pragma endregion Print Dependencies
 
 	#pragma region Print Components
 		header.print_fmt( "\nGEN_NS_BEGIN\n");
-
+		header.print_fmt( "GEN_API_C_BEGIN\n" );
-		header.print( fmt_newline);
-		header.print( rf_array_arena );
-		header.print( fmt_newline);
-		header.print( rf_array_pool);
 
 		header.print( r_src_static_data );
 		header.print( fmt_newline);
@@ -1587,7 +1645,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( r_src_interface );
 		header.print( r_src_upfront );
 		header.print_fmt( "\n#pragma region Parsing\n\n" );
-		header.print( rf_etoktype );
 		header.print( r_src_lexer );
 		header.print( fmt_newline);
 		header.print( rf_array_code_typename );
@@ -1596,12 +1653,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( r_src_parsing );
 		header.print_fmt( "\n#pragma endregion Parsing\n" );
 		header.print( r_src_untyped );
-		header.print_fmt( "\n#pragma endregion Interface\n\n");
+		header.print_fmt( "\n#pragma endregion Interface\n");
 
 		header.print( rf_src_builder );
 		header.print( rf_src_scanner );
 
-		header.print_fmt( "GEN_API_C_END\n" );
+		header.print_fmt( "\nGEN_API_C_END\n" );
+		header.print_fmt( "GEN_NS_END\n");
 	#pragma endregion Print Components
 
 		header.print_fmt( implementation_guard_end );
@@ -1641,7 +1699,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 	{
 		Builder src = Builder::open( "gen/gen.dep.c" );
 		src.print_fmt( "GEN_NS_BEGIN\n");
-		src.print_fmt( "GEN_API_C_BEGIN\n" );
 
 		builder_print_fmt(src, generation_notice );
 		builder_print_fmt( src, "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
@@ -1679,6 +1736,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		header.print( rf_eoperator );
 		header.print( fmt_newline );
 		header.print( rf_especifier );
+		header.print( rf_etoktype );
+		header.print( rf_parser_types );
 		header.print_fmt("#pragma endregion Types\n\n");
 
 		header.print_fmt("#pragma region AST\n");
@@ -1732,7 +1791,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		src.print( r_src_interface );
 		src.print( r_src_upfront );
 		src.print_fmt( "\n#pragma region Parsing\n\n" );
-		src.print( rf_etoktype );
 		src.print( r_src_lexer );
 		src.print( fmt_newline);
 		src.print( rf_array_code_typename );
@@ -1746,11 +1804,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
 		src.print( rf_src_builder );
 		src.print( rf_src_scanner );
 
-		src.print_fmt( "GEN_API_C_END\n" );
+		src.print_fmt( "\nGEN_NS_END\n");
 		src.write();
 	}
 #pragma endregion Segmented
 
-	gen::deinit();
+	gen::deinit( & ctx);
 	return 0;
 }

gen_c_library/c_library.refactor

@@ -167,7 +167,7 @@ namespace pool_, gen_pool_
 
 // Printing
 
-namespace str_, gen_str_
+namespace c_str_, gen_c_str_
 
 word PrintF_Buffer,     gen_PrintF_Buffer
 word Msg_Invalid_Value, gen_Msg_Invalid_Value
@@ -211,20 +211,20 @@ word crc64, gen_crc64
 
 // Strings
 
-word StrC, gen_StrC
+word Str, gen_Str
 
-word to_strc_from_c_str, gen_to_strc_from_c_str
+word to_str_from_c_str, gen_to_str_from_c_str
 
-namespace strc_, gen_strc_
+namespace str_, gen_str_
 
-word cast_to_strc, gen_cast_to_strc
+word cast_to_str, gen_cast_to_str
 
-word StringHeader, gen_StringHeader
+word StrBuilderHeader, gen_StrBuilderHeader
-word String,       gen_String
+word StrBuilder,       gen_StrBuilder
 
-namespace string_, gen_string_
+namespace strbuilder_, gen_strbuilder_
 
-word StringCached, gen_StringCached
+word StrCached, gen_StrCached
 
 word StringTable, gen_StringTable
 
@@ -308,7 +308,7 @@ word operator_to_str, gen_operator_to_str
 word Specifier,        gen_Specifier
 word spec_to_str,      gen_spec_to_str
 word spec_is_trailing, gen_spec_is_trailing
-// word strc_to_specifier, gen_strc_to_specifier
+// word str_to_specifier, gen_str_to_specifier
 
 // AST
 
@@ -401,7 +401,7 @@ word init,   gen_init
 word deinit, gen_deinit
 word reset,  gen_reset
 
-word get_cached_string, gen_get_cached_string
+word cache_str, gen_cache_str
 
 word make_code, gen_make_code
 
@@ -414,20 +414,6 @@ namespace untyped_, gen_untyped_
 
 // Constants
 
-word TokenMap_FixedArena, gen_TokenMap_FixedArena
-word InitSize_DataArrays, gen_InitSize_DataArrays
-
-word Global_BucketSize,   gen_Global_BucketSize
-word CodePool_NumBlocks,  gen_CodePool_NumBlocks
-word SizePer_StringArena, gen_SizePer_StringArena
-
-word MaxCommentLineLength, gen_MaxCommentLineLength
-word MaxNameLength,        gen_MaxNameLength
-word MaxUntypedStrLength,  gen_MaxUntypedStrLength
-
-word LexAllocator_Size,        gen_LexAllocator_Size
-word Builder_StrBufferReserve, gen_Builder_StrBufferReserve
-
 word access_public,    gen_access_public
 word access_protected, gen_access_protected
 word access_private,   gen_access_private
@@ -446,28 +432,17 @@ word preprocess_else, gen_preprocess_else
 namespace spec_, gen_spec_
 namespace t_,    gen_t_
 
-word PreprocessorDefines, gen_PreprocessorDefines
-
 // Backend
 
-word GlobalAllocator,         gen_GlobalAllocator
-word Global_AllocatorBuckets, gen_Global_AllocatorBuckets
-word CodePools,               gen_CodePools
-word StringArenas,            gen_StringArenas
-word StringCache,             gen_StringCache
-word LexArena,                gen_LexArena
-word Allocator_DataArrays,    gen_Allocator_DataArrays
-word Allocator_CodePool,      gen_Allocator_CodePool
-word Allocator_Lexer,         gen_Allocator_Lexer
-word Allocator_StringArena,   gen_Allocator_StringArena
-word Allocator_StringTable,   gen_Allocator_StringTable
-word Allocator_TypeTable,     gen_Allocator_TypeTable
-
 // Builder
 
 word      Builder,  gen_Builder
 namespace builder_, gen_builder_
 
+// Scanner
+
+word scan_file, gen_scan_file
+
 // Implementation (prviate)
 
 word _format_info, gen__format_info
@@ -514,7 +489,7 @@ word _adt_get_field, gen__adt_get_field
 word _csv_write_record, gen__csv_write_record
 word _csv_write_header, gen__csv_write_header
 
-word Global_Allocator_Proc, gen_Global_Allocator_Proc
+word fallback_allocator_proc, gen_Global_Allocator_Proc
 word define_constants,      gen_define_constants
 word operator__validate,    gen_operator__validate
 
@@ -523,7 +498,6 @@ word parser_deinit, gen_parser_deinit
 
 word TokType,         gen_TokType
 word toktype_to_str,  gen_toktype_to_str
-// word strc_to_toktype, gen_strc_to_toktype
 word NullToken,       gen_NullToken
 
 namespace tok_, gen_tok_

gen_c_library/components/containers.array.hpp

@@ -40,11 +40,11 @@ CodeBody gen_array_base()
 	));
 };
 
-CodeBody gen_array( StrC type, StrC array_name )
+CodeBody gen_array( Str type, Str array_name )
 {
-	String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	StrBuilder array_type = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
-	String fn         = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	StrBuilder fn         = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
-	// str_to_lower(fn.Data);
+	// c_str_to_lower(fn.Data);
 
 #pragma push_macro( "GEN_ASSERT" )
 #pragma push_macro( "rcast" )
@@ -56,7 +56,7 @@ CodeBody gen_array( StrC type, StrC array_name )
 #undef cast
 #undef typeof
 #undef forceinline
-	CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
+	CodeBody result = parse_global_body( token_fmt( "array_type", (Str)array_type, "fn", (Str)fn, "type", (Str)type
 	, stringize(
 		typedef <type>* <array_type>;
 
@@ -375,9 +375,9 @@ CodeBody gen_array( StrC type, StrC array_name )
 #pragma pop_macro( "forceinline" )
 
 	++ Array_DefinitionCounter;
-	StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", Array_DefinitionCounter).to_strc();
+	Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", Array_DefinitionCounter).to_str();
 
-	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (StrC)array_type, "slot", (StrC)slot_str,
+	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (Str)array_type, "slot", (Str)slot_str,
 R"(#define GENERIC_SLOT_<slot>__array_init         <type>,        <array_type>_init
 #define GENERIC_SLOT_<slot>__array_init_reserve    <type>,        <array_type>_init_reserve
 #define GENERIC_SLOT_<slot>__array_append          <array_type>,  <array_type>_append
@@ -399,13 +399,13 @@ R"(#define GENERIC_SLOT_<slot>__array_init         <type>,        <array_type>_i
 	));
 
 	return def_global_body( args(
-		def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", array_type ))),
+		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", 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 ))),
+		def_pragma( strbuilder_to_str(strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", array_type ))),
 		fmt_newline
 	));
 };

gen_c_library/components/containers.hashtable.hpp

@@ -27,24 +27,24 @@ R"(#define HashTable(_type) struct _type
 	return def_global_body(args(struct_def, define_type, define_critical_load_scale));
 }
 
-CodeBody gen_hashtable( StrC type, StrC hashtable_name )
+CodeBody gen_hashtable( Str type, Str hashtable_name )
 {
 
-	String tbl_type = {(char*) hashtable_name.duplicate(GlobalAllocator).Ptr};
+	StrBuilder tbl_type = {(char*) hashtable_name.duplicate(_ctx->Allocator_Temp).Ptr};
-	String fn       = tbl_type.duplicate(GlobalAllocator);
+	StrBuilder fn       = tbl_type.duplicate(_ctx->Allocator_Temp);
-	// str_to_lower(fn.Data);
+	// c_str_to_lower(fn.Data);
 
-	String name_lower = String::make( GlobalAllocator, hashtable_name );
+	StrBuilder name_lower = StrBuilder::make( _ctx->Allocator_Temp, hashtable_name );
-	// str_to_lower( name_lower.Data );
+	// c_str_to_lower( name_lower.Data );
 
-	String hashtable_entry   = String::fmt_buf( GlobalAllocator, "HTE_%.*s",     hashtable_name.Len, hashtable_name.Ptr );
+	StrBuilder hashtable_entry   = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "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 );
+	StrBuilder entry_array_name  = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
-	String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
+	StrBuilder entry_array_fn_ns = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
 
 	CodeBody hashtable_types = parse_global_body( token_fmt(
-		"type",        (StrC) type,
+		"type",        (Str) type,
-		"tbl_name",    (StrC) hashtable_name,
+		"tbl_name",    (Str) hashtable_name,
-		"tbl_type",    (StrC) tbl_type,
+		"tbl_type",    (Str) tbl_type,
 	stringize(
 		typedef struct HashTable_<type> <tbl_type>;
 		typedef struct HTE_<tbl_name> HTE_<tbl_name>;
@@ -74,13 +74,13 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 #undef typeof
 #undef forceinline
 	CodeBody hashtable_def = parse_global_body( token_fmt(
-		"type",           (StrC) type,
+		"type",           (Str) type,
-		"tbl_name",       (StrC) hashtable_name,
+		"tbl_name",       (Str) hashtable_name,
-		"tbl_type",       (StrC) tbl_type,
+		"tbl_type",       (Str) tbl_type,
-		"fn",             (StrC) fn,
+		"fn",             (Str) fn,
-		"entry_type",     (StrC) hashtable_entry,
+		"entry_type",     (Str) hashtable_entry,
-		"array_entry",    (StrC) entry_array_name,
+		"array_entry",    (Str) entry_array_name,
-		"fn_array",       (StrC) entry_array_fn_ns,
+		"fn_array",       (Str) entry_array_fn_ns,
 	stringize(
 		struct HashTable_<type> {
 			Array_ssize   Hashes;
@@ -372,9 +372,9 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
 #pragma pop_macro( "forceinline" )
 
 	++ HashTable_DefinitionCounter;
-	StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", HashTable_DefinitionCounter).to_strc();
+	Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", HashTable_DefinitionCounter).to_str();
 
-	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (StrC)tbl_type, "slot", (StrC)slot_str,
+	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (Str)tbl_type, "slot", (Str)slot_str,
 R"(#define GENERIC_SLOT_<slot>__hashtable_init          <type>,      <tbl_type>_init
 #define GENERIC_SLOT_<slot>__hashtable_init_reserve     <type>,      <tbl_type>_init_reserve
 #define GENERIC_SLOT_<slot>__hashtable_clear            <tbl_type>,  <tbl_type>_clear
@@ -395,12 +395,12 @@ R"(#define GENERIC_SLOT_<slot>__hashtable_init          <type>,      <tbl_type>_
 )"
 	));
 
-	char const* cmt_str = str_fmt_buf( "Name: %.*s Type: %.*s"
+	char const* cmt_str = c_str_fmt_buf( "Name: %.*s Type: %.*s"
 		, tbl_type.length(), tbl_type.Data
 		, type.Len, type.Ptr );
 
 	return def_global_body(args(
-		def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", tbl_type ))),
+		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", tbl_type ))),
 		fmt_newline,
 		generic_interface_slot,
 		fmt_newline,
@@ -409,7 +409,7 @@ R"(#define GENERIC_SLOT_<slot>__hashtable_init          <type>,      <tbl_type>_
 		entry_array,
 		hashtable_def,
 		fmt_newline,
-		def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "endregion %S", tbl_type ))),
+		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", tbl_type ))),
 		fmt_newline
 	));
 }

gen_c_library/components/generic_macros.h

@@ -3,9 +3,9 @@
 //   ____                       _        ______                _   _                ____                  _                 __ _
 //  / ___}                     (_)      |  ____}              | | (_)              / __ \                | |               | |(_)
 // | | ___  ___ _ __   ___ _ __ _  ___  | |__ _   _ _ __   ___| |_ _  ___  _ __   | |  | |_   _____ _ __ | | ___   __ _  __| | _ _ __   __ _
-// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| |  __} | | | '_ \ / __} __} |/ _ \| '_ \  | |  | \ \ / / _ \ '_ \| |/ _ \ / _` |/ _` || | '_ \ / _` |
+// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| |  __} | | | '_ \ / __} __} |/ _ \| '_ \  | |  | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
-// | |__j |  __/ | | |  __/ |  | | (__  | |  | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V /  __/ | | | | (_) | (_| | (_| || | | | | (_| |
+// | |__j |  __/ | | |  __/ |  | | (__  | |  | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V /  __/ |   | | (_) | (_| | (_| || | | | | (_| |
-//  \____/ \___}_l l_l\___}_l  l_l\___| l_l   \__,_l_l l_l\___}\__}_l\___/l_l l_l  \____/  \_/ \___}_l l_l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
+//  \____/ \___}_l l_l\___}_l  l_l\___| l_l   \__,_l_l l_l\___}\__}_l\___/l_l l_l  \____/  \_/ \___}_l   l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
 // This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in:                                            __| |
 // https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md                            {___/
 // Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible.
@@ -30,7 +30,7 @@
 // Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
 #define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , )
 //                                                          ^ Selects the comma                              ^ is the type                             ^ is the function                             ^ Insert a comma
-// The slot won't exist if that comma is not found.                                                                                                                                                  |
+// The slot won't exist if that comma is not found.
 
 // For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to:
 typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION;
@@ -43,12 +43,12 @@ GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = {0};
 
 // Below are generated on demand for an overlaod depdendent on a type:
 // ----------------------------------------------------------------------------------------------------------------------------------
-#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic(       \
+#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic(             \
-(selector_arg), /* Select Via Expression*/                           \
+(selector_arg), /* Select Via Expression*/                                 \
-  /* Extendibility slots: */                                         \
+  /* Extendibility slots: */                                               \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
-	default: gen_generic_selection_fail                              \
+	default: gen_generic_selection_fail                                    \
 ) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
 // ----------------------------------------------------------------------------------------------------------------------------------
 
@@ -68,20 +68,21 @@ size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
 #define GENERIC_SLOT_2_gen_example_hash  long long, gen_example_hash__P_long_long
 size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
 
-// If using an Editor with support for syntax hightlighting macros: HASH__ARGS_SIG_1 and HASH_ARGS_SIG_2 should show color highlighting indicating the slot is enabled,
+// If using an Editor with support for syntax hightlighting macros:
+// GENERIC_SLOT_1_gen_example_hash and GENERIC_SLOT_2_gen_example_hash should show color highlighting indicating the slot is enabled,
 // or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
-#define gen_hash_example( function_arguments ) _Generic(       \
+#define gen_hash_example( function_arguments ) _Generic(                      \
-(function_arguments), /* Select Via Expression*/               \
+(function_arguments), /* Select Via Expression*/                              \
-  /* Extendibility slots: */                                   \
+  /* Extendibility slots: */                                                  \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_2 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_3 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_3_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_4 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_4_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_5 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_5_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_6 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_6_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_7 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_7_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_8 ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_8_gen_example_hash ) \
-	default: gen_generic_selection_fail                        \
+	default: gen_generic_selection_fail                                       \
 ) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
 
 // Additional Variations:
@@ -89,20 +90,20 @@ size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761u
 // If the function takes more than one argument the following is used:
 #define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
 (selector_arg),                                                             \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 )        \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig )  \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 )        \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig )  \
 	/* ... */                                                               \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N )         \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig )   \
 	default: gen_generic_selection_fail                                     \
 ) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ )
 
 // If the function does not take the arugment as a parameter:
 #define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
 ( GEN_TYPE_TO_EXP(selector_arg) ),                                         \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 )       \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 )       \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
 	/* ... */                                                              \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N )        \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig )  \
 	default: gen_generic_selection_fail                                    \
 ) GEN_RESOLVED_FUNCTION_CALL()
 

gen_c_library/components/misc.hpp

@@ -18,13 +18,13 @@ void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
 #pragma pop_macro("enum_underlying")
 }
 
-b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
+b32 ignore_preprocess_cond_block( Str cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
 {
 	b32 found = false;
 	CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
 	if ( cond->Content.is_equal(cond_sig) )
 	{
-		//log_fmt("Preprocess cond found: %SC\n", cond->Content);
+		//log_fmt("Preprocess cond found: %S\n", cond->Content);
 		found = true;
 
 		s32 depth = 1;
@@ -72,7 +72,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& par
 
 constexpr bool GenericSel_One_Arg = true;
 enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
-Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
+Code gen_generic_selection_function_macro( s32 num_slots, Str macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
 {
 /* Implements:
 	#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic(      \
@@ -84,18 +84,18 @@ Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, Gener
 	) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
 */
 	local_persist
-	String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64));
+	StrBuilder define_builder = StrBuilder::make_reserve(_ctx->Allocator_Temp, kilobytes(64));
 	define_builder.clear();
 
-	StrC macro_begin;
+	Str macro_begin;
 	if (opts == GenericSel_Direct_Type) {
-		macro_begin = token_fmt( "macro_name", (StrC)macro_name,
+		macro_begin = token_fmt( "macro_name", (Str)macro_name,
 R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \
 )"
 		);
 	}
 	else {
-		macro_begin = token_fmt( "macro_name", (StrC)macro_name,
+		macro_begin = token_fmt( "macro_name", (Str)macro_name,
 R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
 )"
 		);
@@ -104,73 +104,56 @@ R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
 
 	for ( s32 slot = 1; slot <= num_slots; ++ slot )
 	{
-		StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
+		Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", slot).to_str();
-		if (slot == num_slots && false)
-		{
-			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> ) \
-)"
-			));
-			// if ( one_arg )
-			// 	define_builder.append(token_fmt( "macro_name", macro_name, stringize(
-			// 		default: static_assert(false, "<macro_name>: Failed to select correct function signature (Did you pass the type?)")
-			// 	)));
-			// else
-			// 	define_builder.append(token_fmt( "macro_name", macro_name, stringize(
-			// 		default: static_assert(false, "<macro_name>: Failed to select correct function signature")
-			// 	)));
-			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> ) \
+R"(GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
 )"
 		));
 	}
 
-	define_builder.append( txt("default: gen_generic_selection_fail") );
+	define_builder.append( txt("default: gen_generic_selection_fail\\\n") );
 
 	if ( ! one_arg )
 	{
 		if (opts == GenericSel_By_Ref)
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
 		else if (opts == GenericSel_Direct_Type)
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
 		else
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
 	}
 	else
 	{
 		if (opts == GenericSel_By_Ref)
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
 		else if (opts == GenericSel_Direct_Type)
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL()"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL()"));
 		else
-			define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
+			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
 	}
 
 	// Add gap for next definition
 	define_builder.append(txt("\n\n"));
 
-	Code macro = untyped_str(define_builder.to_strc());
+	Code macro = untyped_str(define_builder.to_str());
 	return macro;
 }
 
-CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""))
+CodeFn rename_function_to_unique_symbol(CodeFn fn, Str optional_prefix = txt(""))
 {
     // Get basic components for the name
-    StrC old_name = fn->Name;
+    Str        old_name = fn->Name;
-    String new_name;
+    StrBuilder new_name;
 
     // Add prefix if provided
     if (optional_prefix.Len)
-        new_name = string_fmt_buf(GlobalAllocator, "%SC_%SC_", optional_prefix, old_name);
+        new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_%S_", optional_prefix, old_name);
     else
-        new_name = string_fmt_buf(GlobalAllocator, "%SC_", old_name);
+        new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_", old_name);
 
     // Add return type to the signature
     if (fn->ReturnType)
-        new_name.append_fmt("_%SC", fn->ReturnType->Name);
+        new_name.append_fmt("_%S", fn->ReturnType->Name);
 
     // Add parameter types to create a unique signature
     bool first_param = true;
@@ -198,11 +181,11 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
 						continue;
 					}
 
-                    new_name.append_fmt("%SC_", spec_to_str(spec));
+                    new_name.append_fmt("%S_", spec_to_str(spec));
                 }
             }
 
-            new_name.append_fmt("%SC", param->ValueType->Name);
+            new_name.append_fmt("%S", param->ValueType->Name);
         }
     }
 
@@ -214,7 +197,7 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
              spec != end(fn->Specs);
              ++spec)
         {
-            new_name.append_fmt("%SC_", spec_to_str(*spec));
+            new_name.append_fmt("%S_", spec_to_str(*spec));
         }
     }
 
@@ -223,13 +206,13 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
 }
 
 using SwapContentProc = CodeBody(void);
-bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
+bool swap_pragma_region_implementation( Str region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
 {
 	bool found = false;
 	CodePragma possible_region = cast(CodePragma, entry_iter);
 
-	String region_sig    = string_fmt_buf(GlobalAllocator, "region %s",    region_name.Ptr);
+	StrBuilder region_sig    = strbuilder_fmt_buf(_ctx->Allocator_Temp, "region %s",    region_name.Ptr);
-	String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
+	StrBuilder endregion_sig = strbuilder_fmt_buf(_ctx->Allocator_Temp, "endregion %s", region_name.Ptr);
 	if ( possible_region->Content.contains(region_sig))
 	{
 		found = true;

gen_c_library/gen.c

@@ -1,5 +1,5 @@
 #define GEN_IMPLEMENTATION
-#include "gen/gen.c"
+#include "gen/gen_singleheader.h"
 
 int main()
 {

gen_segmented/segmented.cpp

@@ -32,7 +32,10 @@ Code format( Code code ) {
 
 int gen_main()
 {
-	gen::init();
+	Context ctx {
+		
+	};
+	gen::init(& ctx);
 
 	Code push_ignores = scan_file( (path_base "helpers/push_ignores.inline.hpp") );
 	Code pop_ignores  = scan_file( (path_base "helpers/pop_ignores.inline.hpp") );
@@ -117,13 +120,14 @@ int gen_main()
 		def_include(txt("components/types.hpp")),
 		preprocess_endif,
 		fmt_newline,
-		untyped_str( to_strc_from_c_str(generation_notice) )
+		untyped_str( to_str_from_c_str(generation_notice) )
 	));
 
 	// gen.hpp
 	{
 		Code header_start = scan_file( path_base "components/header_start.hpp" );
 		Code types        = scan_file( path_base "components/types.hpp" );
+		Code parser_types = scan_file( path_base "components/parser_types.hpp" );
 		Code ast          = scan_file( path_base "components/ast.hpp" );
 		Code ast_types    = scan_file( path_base "components/ast_types.hpp" );
 		Code code_types   = scan_file( path_base "components/code_types.hpp" );
@@ -134,6 +138,7 @@ int gen_main()
 		CodeBody ecode       = gen_ecode     ( path_base "enums/ECodeTypes.csv" );
 		CodeBody eoperator   = gen_eoperator ( path_base "enums/EOperator.csv" );
 		CodeBody especifier  = gen_especifier( path_base "enums/ESpecifier.csv" );
+		CodeBody etoktype    = gen_etoktype  ( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
 		CodeBody ast_inlines = gen_ast_inlines();
 
 		Builder _header = builder_open( "gen/gen.hpp" );
@@ -153,6 +158,8 @@ int gen_main()
 		builder_print( header, fmt_newline);
 		builder_print( header, format(especifier) );
 		builder_print( header, fmt_newline);
+		builder_print( header, format(etoktype));
+		builder_print( header, parser_types);
 		builder_print_fmt( header, "#pragma endregion Types\n\n" );
 
 		builder_print_fmt( header, "#pragma region AST\n" );
@@ -171,7 +178,7 @@ int gen_main()
 		builder_print_fmt( header, "#pragma endregion Inlines\n" );
 
 		builder_print( header, header_end );
-		builder_print_fmt( header, "GEN_NS_END\n\n" );
+		builder_print_fmt( header, "\nGEN_NS_END\n\n" );
 		builder_print( header, pop_ignores );
 		builder_write(header);
 	}
@@ -190,12 +197,6 @@ int gen_main()
 		Code 	    parsing_interface  = scan_file( path_base "components/interface.parsing.cpp" );
 		Code        untyped 	       = scan_file( path_base "components/interface.untyped.cpp" );
 
-		CodeBody etoktype         = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
-		CodeBody nspaced_etoktype = def_global_body( args(
-			etoktype
-		));
-		Code formatted_toktype = format(nspaced_etoktype);
-
 		Builder _src = builder_open( "gen/gen.cpp" );
 		Builder* src = & _src;
 		builder_print_fmt( src, generation_notice );
@@ -215,7 +216,6 @@ int gen_main()
 		builder_print( src, interface );
 		builder_print( src, upfront );
 		builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
-		builder_print( src, formatted_toktype );
 		builder_print( src, lexer );
 		builder_print( src, parser );
 		builder_print( src, parsing_interface );
@@ -238,7 +238,7 @@ int gen_main()
 		builder_print( & header, def_include( txt("gen.hpp") ));
 		builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
 		builder_print( & header, builder );
-		builder_print_fmt( & header, "GEN_NS_END\n" );
+		builder_print_fmt( & header, "\nGEN_NS_END\n" );
 		builder_write( & header);
 	}
 
@@ -278,10 +278,10 @@ int gen_main()
 		builder_print( & src, def_include( txt("gen.scanner.hpp") ) );
 		builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
 		builder_print( & src, scanner );
-		builder_print_fmt( & src, "GEN_NS_END\n" );
+		builder_print_fmt( & src, "\nGEN_NS_END\n" );
 		builder_write( & src);
 	}
 
-	gen::deinit();
+	gen::deinit( & ctx);
 	return 0;
 }

gen_singleheader/singleheader.cpp

@@ -17,24 +17,24 @@ constexpr char const* generation_notice =
 "// This file was generated automatially by gencpp's singleheader.cpp"
 "(See: https://github.com/Ed94/gencpp)\n\n";
 
-constexpr StrC implementation_guard_start = txt(R"(
+constexpr Str implementation_guard_start = txt(R"(
 #pragma region GENCPP IMPLEMENTATION GUARD
 #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
 #	define GEN_IMPLEMENTED
 )");
 
-constexpr StrC implementation_guard_end = txt(R"(
+constexpr Str implementation_guard_end = txt(R"(
 #endif
 #pragma endregion GENCPP IMPLEMENTATION GUARD
 )");
 
-constexpr StrC roll_own_dependencies_guard_start = txt(R"(
+constexpr Str roll_own_dependencies_guard_start = txt(R"(
 //! 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
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 )");
 
-constexpr StrC roll_own_dependencies_guard_end = txt(R"(
+constexpr Str roll_own_dependencies_guard_end = txt(R"(
 // GEN_ROLL_OWN_DEPENDENCIES
 #endif
 )");
@@ -54,7 +54,8 @@ Code format( Code code ) {
 
 int gen_main()
 {
-	gen::init();
+	Context ctx {};
+	gen::init( & ctx);
 
 	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
 	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
@@ -77,7 +78,7 @@ int gen_main()
 			Code basic_types  = scan_file( path_base "dependencies/basic_types.hpp" );
 			Code debug        = scan_file( path_base "dependencies/debug.hpp" );
 			Code memory	      = scan_file( path_base "dependencies/memory.hpp" );
-			Code string_ops   = scan_file( path_base "dependencies/string_ops.hpp" );
+			Code stirng_ops   = scan_file( path_base "dependencies/string_ops.hpp" );
 			Code printing     = scan_file( path_base "dependencies/printing.hpp" );
 			Code containers   = scan_file( path_base "dependencies/containers.hpp" );
 			Code hashing 	  = scan_file( path_base "dependencies/hashing.hpp" );
@@ -93,7 +94,7 @@ int gen_main()
 			header.print( basic_types );
 			header.print( debug );
 			header.print( memory );
-			header.print( string_ops );
+			header.print( stirng_ops );
 			header.print( printing );
 			header.print( containers );
 			header.print( hashing );
@@ -105,22 +106,25 @@ int gen_main()
 				header.print( scan_file( path_base "dependencies/parsing.hpp" ) );
 			}
 
+			header.print(fmt_newline);
 			header.print_fmt( "GEN_NS_END\n" );
 			header.print_fmt( roll_own_dependencies_guard_end );
 			header.print( fmt_newline );
 		}
 
-		Code types      = scan_file( path_base "components/types.hpp" );
+		Code types        = scan_file( path_base "components/types.hpp" );
-		Code ast        = scan_file( path_base "components/ast.hpp" );
+		Code parser_types = scan_file( path_base "components/parser_types.hpp");
-		Code ast_types  = scan_file( path_base "components/ast_types.hpp" );
+		Code ast          = scan_file( path_base "components/ast.hpp" );
-		Code code_types = scan_file( path_base "components/code_types.hpp" );
+		Code ast_types    = scan_file( path_base "components/ast_types.hpp" );
-		Code interface  = scan_file( path_base "components/interface.hpp" );
+		Code code_types   = scan_file( path_base "components/code_types.hpp" );
-		Code inlines 	= scan_file( path_base "components/inlines.hpp" );
+		Code interface    = scan_file( path_base "components/interface.hpp" );
-		Code header_end = scan_file( path_base "components/header_end.hpp" );
+		Code inlines 	  = scan_file( path_base "components/inlines.hpp" );
+		Code header_end   = scan_file( path_base "components/header_end.hpp" );
 
 		CodeBody ecode       = gen_ecode     ( path_base "enums/ECodeTypes.csv" );
 		CodeBody eoperator   = gen_eoperator ( path_base "enums/EOperator.csv" );
 		CodeBody especifier  = gen_especifier( path_base "enums/ESpecifier.csv" );
+		CodeBody etoktype    = gen_etoktype  ( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
 		CodeBody ast_inlines = gen_ast_inlines();
 
 		header.print_fmt( "GEN_NS_BEGIN\n\n" );
@@ -134,6 +138,9 @@ int gen_main()
 		header.print( fmt_newline );
 		header.print( format( especifier ));
 		header.print( fmt_newline );
+		header.print( format( etoktype ));
+		header.print( parser_types );
+		header.print( fmt_newline );
 		header.print_fmt("#pragma endregion Types\n\n");
 
 		header.print_fmt("#pragma region AST\n");
@@ -155,7 +162,11 @@ int gen_main()
 		if ( generate_builder ) {
 			header.print( scan_file( path_base "auxillary/builder.hpp" ) );
 		}
+		if ( generate_scanner ) {
+			header.print( scan_file( path_base "auxillary/scanner.hpp" ) );
+		}
 
+		header.print(fmt_newline);
 		header.print_fmt( "GEN_NS_END\n" );
 	}
 
@@ -176,9 +187,10 @@ int gen_main()
 			Code timing     = scan_file( path_base "dependencies/timing.cpp" );
 
 			header.print_fmt( roll_own_dependencies_guard_start );
-			header.print_fmt( "GEN_NS_BEGIN\n\n");
-
 			header.print( impl_start );
+			header.print( fmt_newline );
+			header.print_fmt( "GEN_NS_BEGIN\n");
+
 			header.print( debug );
 			header.print( string_ops );
 			header.print( printing );
@@ -209,11 +221,9 @@ int gen_main()
 		Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
 		Code untyped           = scan_file( path_base "components/interface.untyped.cpp" );
 
-		CodeBody etoktype      = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
-		CodeNS   parser_nspace = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
-
 		header.print_fmt( "\nGEN_NS_BEGIN\n");
 		header.print( static_data );
+		header.print( fmt_newline);
 
 		header.print_fmt( "#pragma region AST\n\n" );
 		header.print( ast_case_macros );
@@ -225,27 +235,24 @@ int gen_main()
 		header.print( interface );
 		header.print( upfront );
 		header.print_fmt( "\n#pragma region Parsing\n\n" );
-		header.print( format(parser_nspace) );
 		header.print( lexer );
 		header.print( parser );
 		header.print( parsing_interface );
 		header.print_fmt( "\n#pragma endregion Parsing\n" );
+		header.print_fmt("\n#pragma region Untyped\n");
 		header.print( untyped );
-		header.print_fmt( "\n#pragma endregion Interface\n\n");
+		header.print_fmt("\n#pragma endregion Untyped\n");
+		header.print_fmt( "\n#pragma endregion Interface\n");
 
 		if ( generate_builder ) {
 			header.print( scan_file( path_base "auxillary/builder.cpp"  ) );
 		}
 
-		// Scanner header depends on implementation
-		if ( generate_scanner ) {
-			header.print( scan_file( path_base "auxillary/scanner.hpp" ) );
-		}
-
 		if ( generate_scanner ) {
 			header.print( scan_file( path_base "auxillary/scanner.cpp" ) );
 		}
 
+		header.print( fmt_newline);
 		header.print_fmt( "GEN_NS_END\n");
 
 		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
@@ -254,6 +261,6 @@ int gen_main()
 	header.print( pop_ignores );
 	header.write();
 
-	gen::deinit();
+	gen::deinit( & ctx);
 	return 0;
 }

gen_unreal_engine/components/header_start.hpp

@@ -7,12 +7,20 @@
 	https://github.com/Ed94/gencpp
 
 	This is a variant intended for use with Unreal Engine 5
-
+	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
-	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha !
+	|   _____                               _____ _                       _                        |
-	! ============================================================================================ !
+	|  / ____)                             / ____} |                     | |                       |
-	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 !
+	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
-	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL !
+	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
-	! ============================================================================================ !
+	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
+	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
+	|  Unreal Engine         | |   | |                      __} |                                  |
+	|                        l_l   l_l                     {___/                                   |
+	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
+	! ============================================================================================ |
+	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
+	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
+	! ============================================================================================ /
 */
 #if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
 #	error Gen.hpp : GEN_TIME not defined

gen_unreal_engine/unreal.cpp

@@ -17,25 +17,25 @@ constexpr char const* generation_notice =
 "// This file was generated automatially by gencpp's unreal.cpp "
 "(See: https://github.com/Ed94/gencpp)\n\n";
 
-constexpr StrC implementation_guard_start = txt(R"(
+constexpr Str implementation_guard_start = txt(R"(
 #pragma region GENCPP IMPLEMENTATION GUARD
 #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
 #	define GEN_IMPLEMENTED
 )");
 
-constexpr StrC implementation_guard_end = txt(R"(
+constexpr Str implementation_guard_end = txt(R"(
 #endif
 #pragma endregion GENCPP IMPLEMENTATION GUARD
 )");
 
-constexpr StrC roll_own_dependencies_guard_start = txt(R"(
+constexpr Str roll_own_dependencies_guard_start = txt(R"(
 //! 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
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 
 )");
 
-constexpr StrC roll_own_dependencies_guard_end = txt(R"(
+constexpr Str roll_own_dependencies_guard_end = txt(R"(
 // GEN_ROLL_OWN_DEPENDENCIES
 #endif
 )");
@@ -55,7 +55,8 @@ Code format( Code code ) {
 
 int gen_main()
 {
-	gen::init();
+	Context ctx {};
+	gen::init( & ctx);
 
 	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
 	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
@@ -67,8 +68,8 @@ int gen_main()
 	{
 		CodeBody macros = def_body( CT_Global_Body );
 		{
-			FileContents content    = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" );
+			FileContents content    = file_read_contents( ctx.Allocator_Temp, file_zero_terminate, path_base "dependencies/macros.hpp" );
-			CodeBody     ori_macros = parse_global_body( StrC { content.size, (char const*)content.data });
+			CodeBody     ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
 
 			for (Code	code =  ori_macros.begin();
 						code != ori_macros.end();
@@ -175,6 +176,7 @@ int gen_main()
 	{
 		Code header_start = scan_file(           "components/header_start.hpp" );
 		Code types        = scan_file( path_base "components/types.hpp" );
+		Code parser_types = scan_file( path_base "components/parser_types.hpp");
 		Code ast          = scan_file( path_base "components/ast.hpp" );
 		Code ast_types    = scan_file( path_base "components/ast_types.hpp" );
 		Code code_types   = scan_file( path_base "components/code_types.hpp" );
@@ -187,6 +189,11 @@ int gen_main()
 		CodeBody especifier  = gen_especifier( path_base "enums/ESpecifier.csv" );
 		CodeBody ast_inlines = gen_ast_inlines();
 
+		// Note(Ed): The Attribute tokens need to be expanded and regenerated on a per-project/installation of this library for a specific codebase of Unreal.
+		// We can support an arbitrary set of modules or plugin apis for parsing
+		// but its up to the user to define them all (This will just provide whats I've used up till now).
+		CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", "enums/AttributeTokens.csv" );
+
 		Builder
 		header = Builder::open( "gen/gen.hpp" );
 		header.print_fmt( generation_notice );
@@ -205,6 +212,8 @@ int gen_main()
 		header.print( fmt_newline );
 		header.print( format(especifier) );
 		header.print( fmt_newline );
+		header.print( format(etoktype) );
+		header.print( parser_types );
 		header.print_fmt( "#pragma endregion Types\n\n" );
 
 		header.print_fmt( "#pragma region AST\n" );
@@ -223,14 +232,14 @@ int gen_main()
 		header.print_fmt( "#pragma endregion Inlines\n" );
 
 		header.print( header_end );
-		header.print_fmt( "GEN_NS_END\n\n" );
+		header.print_fmt( "\nGEN_NS_END\n\n" );
 		header.print( pop_ignores );
 		header.write();
 	}
 
 	// gen.cpp
 	{
-		Code        src_start          = scan_file(             "components/src_start.cpp" );
+		Code        src_start          = scan_file(           "components/src_start.cpp" );
 		Code        static_data 	   = scan_file( path_base "components/static_data.cpp" );
 		Code        ast_case_macros    = scan_file( path_base "components/ast_case_macros.cpp" );
 		Code        ast			       = scan_file( path_base "components/ast.cpp" );
@@ -242,11 +251,6 @@ int gen_main()
 		Code 	    parsing_interface  = scan_file( path_base "components/interface.parsing.cpp" );
 		Code        untyped 	       = scan_file( path_base "components/interface.untyped.cpp" );
 
-		// Note(Ed): The Attribute tokens need to be expanded and regenerated on a per-project/installation of this library for a specific codebase of Unreal.
-		// We can support an arbitrary set of modules or plugin apis for parsing
-		// but its up to the user to define them all (This will just provide whats I've used up till now).
-		CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-
 		Builder
 		src = Builder::open( "gen/gen.cpp" );
 		src.print_fmt( generation_notice );
@@ -268,7 +272,6 @@ int gen_main()
 		src.print( interface );
 		src.print( upfront );
 		src.print_fmt( "\n#pragma region Parsing\n\n" );
-		src.print( format(etoktype) );
 		src.print( lexer );
 		src.print( parser );
 		src.print( parsing_interface );
@@ -294,7 +297,7 @@ int gen_main()
 		header.print( def_include( txt("gen.hpp") ));
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 		header.print( builder );
-		header.print_fmt( "GEN_NS_END\n" );
+		header.print_fmt( "\nGEN_NS_END\n" );
 		header.print( fmt_newline );
 		header.print( pop_ignores );
 		header.write();
@@ -333,7 +336,7 @@ int gen_main()
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 		header.print( parsing );
 		header.print( scanner );
-		header.print_fmt( "GEN_NS_END\n" );
+		header.print_fmt( "\nGEN_NS_END\n" );
 		header.print( fmt_newline );
 		header.print( pop_ignores );
 		header.write();
@@ -353,7 +356,7 @@ int gen_main()
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
 		src.print( parsing );
 		// src.print( scanner );
-		src.print_fmt( "GEN_NS_END\n" );
+		src.print_fmt( "\nGEN_NS_END\n" );
 		src.print( fmt_newline );
 		src.print( pop_ignores );
 		src.write();

gencpp.sln.DotSettings.user

@@ -1,3 +1,3 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:StrBuilder x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:StrBuilder>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:String></wpf:ResourceDictionary>
+	<s:StrBuilder x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:StrBuilder></wpf:ResourceDictionary>

scripts/.clang-format

@@ -1,8 +1,9 @@
 # Format Style Options - Created with Clang Power Tools
 ---
 
-# AttributeMacros: [
+AttributeMacros: [
-# ]
+  GEN_API
+]
 StatementMacros: [
   GEN_NS_BEGIN, 
   GEN_NS_END, 
@@ -15,6 +16,8 @@ StatementMacros: [
 Macros:
 - enum_underlying(type)=type
 - gen_enum_underlying(type)=type
+# WhitespaceSensitiveMacros: [
+# ]
 
 TypenameMacros: [Array, Hashtable]
 SkipMacroDefinitionBody: false

scripts/build.ci.ps1

@@ -17,8 +17,10 @@ Push-Location $path_root
 #region Arguments
        $vendor       = $null
        $release      = $null
-	   $verbose      = $false
+[bool] $verbose      = $false
-	   $base         = $false
+[bool] $shared       = $false
+[bool] $dyn_link     = $false
+[bool] $base         = $false
 [bool] $segmented    = $false
 [bool] $singleheader = $false
 [bool] $c_library    = $false
@@ -35,8 +37,10 @@ if ( $args ) { $args | ForEach-Object {
 		"verbose"			  { $verbose      = $true }
 		"release"             { $release      = $true }
 		"debug"               { $release      = $false }
+		"shared"              { $shared       = $true }
+		"dyn_link"            { $dyn_link     = $true }
 		"base"                { $base         = $true }
-		"segmented"          { $segmented     = $true }
+		"segmented"           { $segmented    = $true }
 		"singleheader"        { $singleheader = $true }
 		"c_library"           { $c_library    = $true }
 		"unreal"              { $unreal       = $true }

scripts/genccp.natstepfilter

@@ -21,10 +21,10 @@
 		<Action>NoStepInto</Action>
 	</Function>
 	<Function>
-		<Name>gen::Code.*::to_string</Name>
+		<Name>gen::Code.*::to_strbuilder</Name>
 		<Action>NoStepInto</Action>
 	</Function>
 	<Function>
-		<Name>gen::String::operator .*</Name>
+		<Name>gen::StrBuilder::operator .*</Name>
 	</Function>
 </StepFilter>

scripts/gencpp.natvis

@@ -36,11 +36,11 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::StrC">
+	<Type Name="gen::Str">
 		<DisplayString>Len:{Len} Ptr:{Ptr, [Len]s}</DisplayString>
 	</Type>
 
-	<Type Name="gen::String">
+	<Type Name="gen::StrBuilder">
 		<DisplayString Condition="Data == nullptr">null</DisplayString>
 		<DisplayString>{Data,na}</DisplayString>
 		<Expand>
@@ -55,7 +55,7 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::String::Header">
+	<Type Name="gen::StrBuilder::Header">
 		<DisplayString>Length: {Length}, Capacity: {Capacity}</DisplayString>
 		<Expand>
 			<Item Name="Allocator">Allocator</Item>