Add GEN_PARSER_TYPENAME_ALLOWED_SUFFIX_SPECIFIER_CASES to gen_urneal_engine's case macros

UE vod

.gitignore

@@ -32,3 +32,12 @@ test/gen/original
 singleheader/gen/scratch.hpp
 test/gen/scratch.cpp
 gen_c_library/gen
+
+**/*.sln
+**/*.sln.DotSettings.user
+**/*.10x
+**/*.vcxproj
+**/*.vcxproj.filters
+**/*.vcxproj.user
+test/c_library/gen
+test/cpp_library/gen

.vscode/c_cpp_properties.json

@@ -28,27 +28,6 @@
                 "/FC"
             ]
         },
-        {
-            "name": "Win32 msvc c_library",
-            "includePath": [
-                "${workspaceFolder}/gen_c_library/**"
-            ],
-            "defines": [
-                "_DEBUG",
-                "UNICODE",
-                "_UNICODE",
-                "GEN_TIME",
-                "GEN_IMPLEMENTATION",
-                // "GEN_DONT_USE_NAMESPACE"
-                "GEN_INTELLISENSE_DIRECTIVES",
-                "INTELLISENSE_DIRECTIVES"
-            ],
-            "cppStandard": "c++17",
-            "windowsSdkVersion": "10.0.19041.0",
-            "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
-            "intelliSenseMode": "msvc-x64",
-            "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
-        },
         {
             "name": "Win32 clang",
             "includePath": [
@@ -64,10 +43,56 @@
                 "GEN_INTELLISENSE_DIRECTIVES",
                 "INTELLISENSE_DIRECTIVES"
             ],
+            "cStandard": "c11",
+            "cppStandard": "c++17",
             "windowsSdkVersion": "10.0.19041.0",
             "compilerPath": "clang++.exe",
             "intelliSenseMode": "windows-clang-x64",
             "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
+        },
+        {
+            "name": "Win32 msvc c_library",
+            "includePath": [
+                "${workspaceFolder}/gen_c_library/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE",
+                "GEN_TIME",
+                "GEN_IMPLEMENTATION",
+                // "GEN_DONT_USE_NAMESPACE"
+                "GEN_INTELLISENSE_DIRECTIVES",
+                "INTELLISENSE_DIRECTIVES"
+            ],
+            "cStandard": "c11",
+            "cppStandard": "c++17",
+            "windowsSdkVersion": "10.0.19041.0",
+            "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
+            "intelliSenseMode": "msvc-x64",
+            "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
+        },
+        {
+            "name": "Win32 msvc c_library test",
+            "includePath": [
+                "${workspaceFolder}/test/c_library/**",
+                "${workspaceFolder}/gen_c_library/gen/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE",
+                "GEN_TIME",
+                "GEN_IMPLEMENTATION",
+                // "GEN_DONT_USE_NAMESPACE"
+                "GEN_INTELLISENSE_DIRECTIVES",
+                "INTELLISENSE_DIRECTIVES"
+            ],
+            "cStandard": "c11",
+            "windowsSdkVersion": "10.0.19041.0",
+            "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
+            "intelliSenseMode": "msvc-x64",
+            "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
         }
     ],
     "version": 4

.vscode/settings.json

@@ -56,7 +56,8 @@
 		"new": "cpp",
 		"typeinfo": "cpp",
 		"unordered_map": "cpp",
-		"xstddef": "cpp"
+		"xstddef": "cpp",
+		"gen_singleheader.h": "c"
 	},
 	"C_Cpp.intelliSenseEngineFallback": "disabled",
 	"mesonbuild.configureOnOpen": true,
@@ -72,5 +73,25 @@
 	},
 	"autoHide.autoHidePanel": false,
 	"autoHide.autoHideSideBar": false,
-	"dimmer.enabled": false
+	"dimmer.enabled": false,
+	"workbench.colorCustomizations": {
+		"activityBar.activeBackground": "#fa1b49",
+		"activityBar.background": "#fa1b49",
+		"activityBar.foreground": "#e7e7e7",
+		"activityBar.inactiveForeground": "#e7e7e799",
+		"activityBarBadge.background": "#155e02",
+		"activityBarBadge.foreground": "#e7e7e7",
+		"commandCenter.border": "#e7e7e799",
+		"sash.hoverBorder": "#fa1b49",
+		"statusBar.background": "#dd0531",
+		"statusBar.foreground": "#e7e7e7",
+		"statusBarItem.hoverBackground": "#fa1b49",
+		"statusBarItem.remoteBackground": "#dd0531",
+		"statusBarItem.remoteForeground": "#e7e7e7",
+		"titleBar.activeBackground": "#dd0531",
+		"titleBar.activeForeground": "#e7e7e7",
+		"titleBar.inactiveBackground": "#dd053199",
+		"titleBar.inactiveForeground": "#e7e7e799"
+	},
+	"peacock.color": "#dd0531"
 }

LICENSE

@@ -26,3 +26,19 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Source URL: https://github.com/Ed94/gencpp
+
+Acknowledgements
+
+* The dependencies for gencpp source are derived from the zpl library: https://github.com/zpl-c/zpl
+
+Special thanks to:
+
+* The Handmade Community.
+
+* Casey Muratori, Ginger Bill (Bill Hall), Mr. 4th (Allen Webster), Ryan Fluery: Influnced conceptually how to handle staged metaprograming.
+
+* Jonathan Blow: Jai's metaprogramming influenced the design of this library.
+
+* My friends for putting up with discord spam on this library.

Readme.md

@@ -1,44 +1,44 @@
 # gencpp
 
-An attempt at simple staged metaprogramming for C/C++.
+An attempt at simple staged metaprogramming for C/C++. Reflect and generate code for your codebase at runtime!
+
+![splash-cpp](./docs/assets/Code_-_Insiders_2024-12-15_23-04-07.gif)
+![splash-c](./docs/assets/Code_-_Insiders_2024-12-15_22-57-58.gif)
 
 The library API is a composition of code element constructors, and a non-standards-compliant single-pass C/C++ parser.  
 These build up a code AST to then serialize with a file builder, or can be traversed for staged-reflection of C/C++ code.
 
-This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto).
-Its not meant to be a black box metaprogramming utility, it should be easy to intergrate into a user's project domain.
+This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto).  
+Its not meant to be a black box metaprogramming utility, it should be easy to integrate into a user's project domain.
 
 ## Documentation
 
 * [docs - General](./docs/Readme.md): Overview and additional docs
-  * [AST_Design](./docs/AST_Design.md): Overvie of ASTs
+  * [AST_Design](./docs/AST_Design.md): Overview of ASTs
   * [AST Types](./docs/AST_Types.md): Listing of all AST types along with their Code type interface.
   * [Parsing](./docs/Parsing.md): Overview of the parsing interface.
   * [Parser Algo](./docs/Parser_Algo.md): In-depth breakdown of the parser's implementation.
 * [base](./base/Readme.md): Essential (base) library.
-* [gen_c_library](./gen_c_library/): C11 library variant generation (single header and segmeented).
-* [gen_segmented](./gen_segmented/): Segemented C++ (`gen.<hpp/cpp>`, `gen.dep.<hpp/cpp>`) generation
+* [gen_c_library](./gen_c_library/): C11 library variant generation (single header and segmented).
+* [gen_segmented](./gen_segmented/): Segmented C++ (`gen.<hpp/cpp>`, `gen.dep.<hpp/cpp>`) generation
 * [gen_singleheader](./gen_singleheader/): Singlehader C++ generation `gen.hpp`
 * [gen_unreal_engine](./gen_unreal_engine/): Unreal Engine thirdparty code generation.
 
 ## Notes
 
-**On Partial Hiatus: Life has got me tackling other issues..**
-I will be passively updating the library with bug fixes and minor improvements as I use it for my personal projects.  
-There won't be any major reworks or features to this thing for a while.
-
 This project is still in development (very much an alpha state), so expect bugs and missing features.  
 See [issues](https://github.com/Ed94/gencpp/issues) for a list of known bugs or todos.
 
 The library can already be used to generate code just fine, but the parser is where the most work is needed. If your C++ isn't "down to earth" expect issues.
 
-A `natvis` and `natstepfilter` are provided in the scripts directory (its outdated, I'll update this readme when its not).
+A `natvis` and `natstepfilter` are provided in the scripts directory (its outdated, I'll update this readme when its not).  
+*Minor update: I've been using [RAD Debugger](https://github.com/EpicGamesExt/raddebugger) with this and the code structures should be easy to debug even without natvis.*
 
 ## Usage
 
 A metaprogram is built to generate files before the main program is built. We'll term runtime for this program as `GEN_TIME`. The metaprogram's core implementation are within `gen.hpp` and `gen.cpp` in the project directory.
 
-`gen.cpp` \`s  `main()` is defined as `gen_main()` which the user will have to define once for their program. There they will dictate everything that should be generated.
+`gen.cpp` \`s  `main()` is defined as `gen_main()` which the user will have to define once for their program. There they may reflect and/or generate code.
 
 In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't the best to use):
 
@@ -52,7 +52,11 @@ Within `program.cpp` :
 
 u32 gen_main()
 {
+    gen::Context ctx;
+    gen::init(& ctx);
     ...
+    gen::deinit(& ctx);
+    return 0;
 }
 #endif
 
@@ -98,8 +102,8 @@ Validation through ast construction.
 Code header = parse_struct( code(
     struct ArrayHeader
     {
-        usize        Num;
-        usize        Capacity;
+        usize     Num;
+        usize     Capacity;
         allocator Allocator;
     };
 ));
@@ -114,8 +118,8 @@ No validation, just glorified text injection.
 Code header = code_str(
     struct ArrayHeader
     {
-        usize        Num;
-        usize        Capacity;
+        usize     Num;
+        usize     Capacity;
         allocator Allocator;
     };
 );
@@ -124,15 +128,15 @@ Code header = code_str(
 `name` is a helper macro for providing a string literal with its size, intended for the name parameter of functions.  
 `code` is a helper macro for providing a string literal with its size, but intended for code string parameters.  
 `args` is a helper macro for providing the number of arguments to varadic constructors.  
-`code_str` is a helper macro for writting `untyped_str( code( <content> ))`
+`code_str` is a helper macro for writing `untyped_str( code( <content> ))`
 
-All three constrcuton interfaces will generate the following C code:
+All three construction interfaces will generate the following C code:
 
 ```cpp
 struct ArrayHeader
 {
-    usize        Num;
-    usize        Capacity;
+    usize     Num;
+    usize     Capacity;
     allocator Allocator;
 };
 ```
@@ -143,3 +147,13 @@ struct ArrayHeader
 ## Building
 
 See the [scripts directory](scripts/).
+
+## Gallery
+
+### Listing definitions in the Cuik Compiler
+
+https://github.com/user-attachments/assets/2302240c-01f1-4e1b-a4b5-292eb3186648
+
+### Unreal: Generating a UAttributeSet from a UDataTable
+
+https://github.com/user-attachments/assets/2a07b743-825d-4f9f-beaf-3559e8748a4d

base/Readme.md

@@ -8,16 +8,22 @@
 
 The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a standard target format, or a user's desires.
 
-Standard formats:
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> base
+```
+
+## Content Overview
 
 * **base**: Files are in granular pieces separated into four directories:
   * **dependencies**: Originally from the c-zpl library and modified thereafter.
   * **components**: The essential definitions of the library.
-  * **helpers**: Contains helper functionality used by base and other libraries to regenerate or generate the other library formats.
+  * **helpers**: Contains helper functionality used by base and the variant library generators.
     * `base_codegen.hpp`: Helps with self-hosted code generation of enums, and operator overload inlines of the code types.
-    * `<push/pop>.<name>.inline.<hpp>`: macros that are meant to be injected at specific locations of the library.
+    * `<push/pop>.<name>.inline.<hpp>`: macros that are meant to be injected at specific locations of the library file/s.
     * `misc.hpp`: Misc functionality used by the library generation metaprograms.
-    * `undef.macros.h`: Undefines all macros from library that original were intended to leak into user code.
+    * `undef.macros.h`: Undefines all macros from library.
   * **auxillary**: Non-essential tooling:
     * `Builder`: Similar conceptually to Jai programming language's *builder*, just opens a file and prepares a string buffer to serialize code into (`builder_print`, `builder_print_fmt`). Then write & close the file when completed (`builder_write`).
     * **`Scanner`**: Interface to load up `Code` from files two basic funcctions are currently provided.
@@ -27,7 +33,7 @@ Standard formats:
 * **gen_segemetned**: Dependencies go into gen.dep.{hpp/cpp} and components into gen.{hpp/cpp}
 * **gen_singleheader**: Everything into a single file: gen.hpp
 * **gen_unreal_engine**: Like gen_segemented but the library is modified slightly to compile as a thirdparty library within an Unreal Engine plugin or module.
-* **gen_c_library**: The library is heavily modifed into C11 compliant code. A segemented and single-header set of variants are generatd.
+* **gen_c_library**: The library is heavily modifed into C11 compliant code. A segemented and single-header set of variants are generated.
 
 Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
 
@@ -117,15 +123,23 @@ The vast majority of macros should be single-line subsitutions that either add:
 
 There are ***five*** header files which are automatically generated using [base_codegen.hpp](./helpers/base_codegen.hpp) by [base.cpp](./base.cpp). They are all located in [components/gen](./components/gen/).
 
-* [`ecodetypes.hpp`](./components/gen/ecode.hpp): `CodeType` enum definition and related implementaiton. Generation is based off of [`ECodeType.csv](./enums/ECodeTypes.csv).
-* [`especifier.hpp`](./components/gen/especifier.hpp): `Specifier` enum definition, etc. Generated using [`ESpecifier.csv`](./enums/ESpecifier.csv).
-* [`eoperator.hpp`](./components/gen/eoperator.hpp): `Operator` enum definition, etc. Generated using [`EOperator.hpp`](./enums/EOperator.csv).
-* [`etoktype.cpp`](./components/gen/etoktype.cpp): `TokType` enum defininition, etc. Used by the lexer and parser backend. Uses two csvs:
-  * [`ETokType.csv`](./enums/ETokType.csv): Provides the enum entries and their strinng ids.
-  * [`AttributeTokens.csv`](./enums/AttributeTokens.csv): Provides tokens entries that should be considered as attributes  by the lexer and parser. Sspecfiically macro attributes such as those use for exporting symbols.
-* [`ast_inlines.hpp`](./components/gen/ast_inlines.hpp): Member trivial `operator` definitions for C++ code types. Does not use a csv.
+* [ecodetypes.hpp](./components/gen/ecode.hpp): `CodeType` enum definition and related implementaiton. Generation is based off of [ECodeType.csv](./enums/ECodeTypes.csv).
+* [especifier.hpp](./components/gen/especifier.hpp): `Specifier` enum definition, etc. Generated using [ESpecifier.csv](./enums/ESpecifier.csv).
+* [eoperator.hpp](./components/gen/eoperator.hpp): `Operator` enum definition, etc. Generated using [EOperator.hpp](./enums/EOperator.csv).
+* [etoktype.cpp](./components/gen/etoktype.cpp): `TokType` enum defininition, etc. Used by the lexer and parser backend. Uses two csvs:
+  * [ETokType.csv](./enums/ETokType.csv): Provides the enum entries and their strinng ids.
+  * [AttributeTokens.csv](./enums/AttributeTokens.csv): Provides tokens entries that should be considered as attributes  by the lexer and parser. Sspecfiically macro attributes such as those use for exporting symbols.
+* [ast_inlines.hpp](./components/gen/ast_inlines.hpp): Member trivial `operator` definitions for C++ code types. Does not use a csv.
 
-[`misc.hpp`](./helpers/misc.hpp): Has shared functions used by the library generation meta-programs throughout this codebase.
+[misc.hpp](./helpers/misc.hpp): Has shared functions used by the library generation meta-programs throughout this codebase.
+
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> base
+```
+
+Will refresh those files.
 
 ## On multi-threading
 
@@ -140,15 +154,59 @@ 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.
 
-The parser is documented under [`docs/Parsing.md`](../docs/Parsing.md) and [`docs/Parser_Algo.md`](../docs/Parser_Algo.md). Extending it is more serious.
+The parser is documented under [`docs/Parsing.md`](../docs/Parsing.md) and [`docs/Parser_Algo.md`](../docs/Parser_Algo.md). Read that and the entire library if you want to extend it.
+
+### Attributes
+
+To add additional macro attributes, all that has to be done is modifying [`AttributeTokens.csv`](./enums/AttributeTokens.csv).
+
+### Specifiers
+
+To add additional macro specifiers, the following needs to be done:
+
+1. Adjust [especifier.hpp](./components/gen/especifier.hpp)
+2. Adjust [etoktype.cpp](./components/gen/etoktype.cpp)
+3. Adjust [parser_case_macros.cpp](./components/parser_case_macros.cpp)
+
+If the specifier is a new trailing specifier on function definitions:
+
+Head into [base_codegen.hpp](./helpers/base_codegen.hpp): `gen_especifier`. There will be an `is_trailing` function that needs to be adjusted with an additional case for the user's new trailing specifier.
+
+### Code Types
+
+These require the following to be handled to the equivalent extent as the other types:
+
+1. Adjust [ECodeTypes.csv](./enums/ECodeTypes.csv) with the new types
+2. Define a new `AST_<Name>` and `Code<Name>`. See
+    * [ast.hpp](./components/ast.hpp): Initial forwards and user defined conversion for Code.
+    * [ast_types.hpp](./components/ast_types.hpp): Define the `AST_<Name>` struct.
+    * [code_types.hpp](./components/code_types.hpp): Defne the `CodeType` struct. If its needs an iterator see: `struct CodeBody` & `struct CodeParams`.
+3. [ast_case_macros.cpp](./components/ast_case_macros.cpp): Review cases here if the new code type needs to be considered.
+4. [ast.cpp](./components/ast.cpp): Need to review
+    * `code_debug_str`
+    * `code_is_equal`
+    * `code_to_strbuilder_ptr`
+    * `code_validate_body`
+5. [code_serialization.cpp](./components/code_serialization.cpp): Define serialization here.
+6. [inlines.hpp](./components/inlines.hpp): Any inline definitions for the `struct Code<Name>` are defined here.
+7. [interface.cpp](./components/interface.hpp): Define the `Code<Name>` upfront and parsing interface.
+8. [interface.upfront.cpp](./components/interface.upfront.cpp): Define the upfront constructor implementation.
+9. [interface.parsing.cpp](./components/interface.parsing.cpp): Define the parsing interface implementation.
+10. [lexer.cpp](./components/lexer.cpp): Adjust the lexer as needed.
+11. [parser.cpp](./components/parser.cpp): Adjust the parser as needed.
 
 ## A note on compilation and runtime generation speed
 
-The library is designed to be fast to compile and generate code at runtime as fast as resonable possible on a debug build.
+The library is designed to be fast to compile and generate code at runtime as fast as possible on a debug build.
 Its recommended that your metaprogam be compiled using a single translation unit (unity build).
+
+## Whats with the expression / executions support #ifd and enums?
+
+The library is a *work in progress* and those are unfinished hypotheticals for adding the ability to manage or parse the AST of expresions or execution scope code.
+They are entirely untested and not meant to be used yet, futher there is no parsing support or an upfront interface for what CodeTypes are defined so far.

base/auxillary/builder.cpp

@@ -15,7 +15,9 @@ Builder builder_open( char const* path )
 		return result;
 	}
 
-	result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+	Context* ctx = get_context();
+	GEN_ASSERT_NOT_NULL(ctx);
+	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 +25,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 +41,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

@@ -25,18 +25,19 @@ Builder builder_open        ( char const* path );
 void    builder_pad_lines   ( Builder* builder, s32 num );
 void    builder_print       ( Builder* builder, Code code );
 void    builder_print_fmt_va( Builder* builder, char const* fmt, va_list va );
-void    builder_print_fmt   ( Builder* builder, char const* fmt, ... ) {
+void    builder_write       ( Builder* builder );
+
+forceinline void builder_print_fmt   ( Builder* builder, char const* fmt, ... ) {
 	va_list va;
 	va_start( va, fmt );
 	builder_print_fmt_va( builder, fmt, va );
 	va_end( va );
 }
-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); }
@@ -56,10 +57,10 @@ struct Builder
 };
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-void    builder_pad_lines( Builder& builder, s32 num )    { return builder_pad_lines(& builder, num); }
-void    builder_print    ( Builder& builder, Code code )  { return builder_print(& builder, code); }
-void    builder_write    ( Builder& builder )             { return builder_write(& builder ); }
-void    builder_print_fmt( Builder& builder, char const* fmt, ...) {
+forceinline void    builder_pad_lines( Builder& builder, s32 num )    { return builder_pad_lines(& builder, num); }
+forceinline void    builder_print    ( Builder& builder, Code code )  { return builder_print(& builder, code); }
+forceinline void    builder_write    ( Builder& builder )             { return builder_write(& builder ); }
+forceinline void    builder_print_fmt( Builder& builder, char const* fmt, ...) {
 	va_list va;
 	va_start( va, fmt );
 	builder_print_fmt_va( & builder, fmt, va );

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( get_context()->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 StrC directive_end   = txt( "endif" );
-		const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
+		const Str directive_start = txt( "ifdef" );
+		const Str directive_end   = txt( "endif" );
+		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 );
-	StrC         content = { file.size, (char const*)file.data };
+	FileContents file    = file_read_contents( get_context()->Allocator_Temp, true, path );
+	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

@@ -1,6 +1,5 @@
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
 #define GEN_C_LIKE_CPP 1
 #include "gen.cpp"
 #include "helpers/push_ignores.inline.hpp"
@@ -27,7 +26,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 +35,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 +58,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

@@ -26,6 +26,7 @@ struct AST_Constructor;
 // struct AST_BaseClass;
 struct AST_Class;
 struct AST_Define;
+struct AST_DefineParams;
 struct AST_Destructor;
 struct AST_Enum;
 struct AST_Exec;
@@ -42,7 +43,7 @@ struct AST_Pragma;
 struct AST_PreprocessCond;
 struct AST_Specifiers;
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct AST_Expr;
 struct AST_Expr_Assign;
 struct AST_Expr_Alignof;
@@ -98,6 +99,7 @@ typedef AST_Comment*        CodeComment;
 typedef AST_Class*          CodeClass;
 typedef AST_Constructor*    CodeConstructor;
 typedef AST_Define*         CodeDefine;
+typedef AST_DefineParams*   CodeDefineParams;
 typedef AST_Destructor*     CodeDestructor;
 typedef AST_Enum*           CodeEnum;
 typedef AST_Exec*           CodeExec;
@@ -120,6 +122,7 @@ struct CodeComment;
 struct CodeClass;
 struct CodeConstructor;
 struct CodeDefine;
+struct CodeDefineParams;
 struct CodeDestructor;
 struct CodeEnum;
 struct CodeExec;
@@ -137,7 +140,7 @@ struct CodePragma;
 struct CodeSpecifiers;
 #endif
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 
 #if GEN_COMPILER_C
 typedef AST_Expr*                CodeExpr;
@@ -230,40 +233,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 );
-StrC   code_debug_str    (Code code);
-Code   code_duplicate    (Code code);
-Code*  code_entry        (Code code, u32 idx );
-bool   code_has_entries  (Code code);
-bool   code_is_body      (Code code);
-bool   code_is_equal     (Code code, Code other);
-bool   code_is_valid     (Code code);
-void   code_set_global   (Code code);
-String code_to_string    (Code self );
-void   code_to_string_ptr(Code self, String* result );
-StrC   code_type_str     (Code self );
-bool   code_validate_body(Code self );
+GEN_API void       code_append           (Code code, Code other );
+GEN_API Str        code_debug_str        (Code code);
+GEN_API Code       code_duplicate        (Code code);
+GEN_API Code*      code_entry            (Code code, u32 idx );
+GEN_API bool       code_has_entries      (Code code);
+GEN_API bool       code_is_body          (Code code);
+GEN_API bool       code_is_equal         (Code code, Code other);
+GEN_API bool       code_is_valid         (Code code);
+GEN_API void       code_set_global       (Code code);
+GEN_API StrBuilder code_to_strbuilder    (Code self );
+GEN_API void       code_to_strbuilder_ptr(Code self, StrBuilder* result );
+GEN_API Str        code_type_str         (Code self );
+GEN_API bool       code_validate_body    (Code self );
 
 #pragma endregion Code C-Interface
 
@@ -278,7 +266,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 +283,17 @@ struct Code
 
 #if ! GEN_C_LIKE_CPP
 	Using_Code( Code );
-	forceinline void   append(Code other)        { return code_append(* this, other); }
-	forceinline Code*  entry(u32 idx)            { return code_entry(* this, idx); }
-	forceinline bool   has_entries()             { return code_has_entries(* this); }
-	forceinline String to_string()               { return code_to_string(* this); }
-	forceinline void   to_string(String& result) { return code_to_string_ptr(* this, & result); }
-	forceinline StrC   type_str()                { return code_type_str(* this); }
-	forceinline bool   validate_body()           { return code_validate_body(*this); }
+	forceinline void       append(Code other)                { return code_append(* this, other); }
+	forceinline Code*      entry(u32 idx)                    { return code_entry(* this, idx); }
+	forceinline bool       has_entries()                     { return code_has_entries(* this); }
+	forceinline StrBuilder to_strbuilder()                   { return code_to_strbuilder(* this); }
+	forceinline void       to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
+	forceinline Str        type_str()                        { return code_type_str(* 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 ++();
@@ -319,6 +308,7 @@ struct Code
 	operator CodeClass() const;
 	operator CodeConstructor() const;
 	operator CodeDefine() const;
+	operator CodeDefineParams() const;
 	operator CodeDestructor() const;
 	operator CodeExec() const;
 	operator CodeEnum() const;
@@ -367,7 +357,7 @@ int AST_ArrSpecs_Cap =
 (
 	AST_POD_Size
 	- sizeof(Code)
-	- sizeof(StringCached)
+	- sizeof(StrCached)
 	- sizeof(Code) * 2
 	- sizeof(Token*)
 	- sizeof(Code)
@@ -379,6 +369,7 @@ int AST_ArrSpecs_Cap =
 
 /*
 	Simple AST POD with functionality to seralize into C++ syntax.
+	TODO(Ed): Eventually haven't a transparent AST like this will longer be viable once statements & expressions are in (most likely....)
 */
 struct AST
 {
@@ -386,7 +377,7 @@ struct AST
 		struct
 		{
 			Code      InlineCmt;       // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
-			Code      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+			Code      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable // TODO(Ed): Parameters can have attributes
 			Code      Specs;           // Destructor, Function, Operator, Typename, Variable
 			union {
 				Code  InitializerList; // Constructor
@@ -398,12 +389,12 @@ struct AST
 			union {
 				Code  Macro;               // Parameter
 				Code  BitfieldSize;        // Variable (Class/Struct Data Member)
-				Code  Params;              // Constructor, Function, Operator, Template, Typename
+				Code  Params;              // Constructor, Define, Function, Operator, Template, Typename
 				Code  UnderlyingTypeMacro; // Enum
 			};
 			union {
 				Code  ArrExpr;          // Typename
-				Code  Body;             // Class, Constructor, Destructor, Enum, Friend, Function, Namespace, Struct, Union
+				Code  Body;             // Class, Constructor, Define, Destructor, Enum, Friend, Function, Namespace, Struct, Union
 				Code  Declaration;      // Friend, Template
 				Code  Value;            // Parameter, Variable
 			};
@@ -413,13 +404,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_case_macros.cpp

@@ -1,4 +1,6 @@
-#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES \
+// These macros are used in the swtich cases within ast.cpp, inteface.upfront.cpp, parser.cpp
+
+#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES_CASES    \
 	case CT_PlatformAttributes:                  \
 	case CT_Class_Body:                          \
 	case CT_Enum_Body:                           \
@@ -13,10 +15,10 @@
 	case CT_Parameters:                          \
 	case CT_Specifiers:                          \
 	case CT_Struct_Body:                         \
-	case CT_Typename:
-#	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
+	case CT_Typename
+#	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES_CASES GEN_AST_BODY_CLASS_UNALLOWED_TYPES_CASES
 
-#	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES \
+#	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES_CASES \
 	case CT_Access_Public:                          \
 	case CT_Access_Protected:                       \
 	case CT_Access_Private:                         \
@@ -37,9 +39,9 @@
 	case CT_Parameters:                             \
 	case CT_Specifiers:                             \
 	case CT_Struct_Body:                            \
-	case CT_Typename:
+	case CT_Typename
 
-#	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES     \
+#	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES     \
 	case CT_Access_Public:                         \
 	case CT_Access_Protected:                      \
 	case CT_Access_Private:                        \
@@ -55,11 +57,11 @@
 	case CT_Parameters:                            \
 	case CT_Specifiers:                            \
 	case CT_Struct_Body:                           \
-	case CT_Typename:
-#	define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES         GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
-#	define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
+	case CT_Typename
+#	define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES_CASES         GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES
+#	define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES_CASES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES
 
-#	define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES \
+#	define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES_CASES \
 	case CT_Access_Public:                        \
 	case CT_Access_Protected:                     \
 	case CT_Access_Private:                       \
@@ -75,4 +77,4 @@
 	case CT_Parameters:                           \
 	case CT_Specifiers:                           \
 	case CT_Struct_Body:                          \
-	case CT_Typename:
+	case CT_Typename

base/components/ast_types.hpp

@@ -29,26 +29,27 @@
 struct AST_Body
 {
 	union {
-		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
+		char  _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached      Name;
-	Code              Front;
-	Code              Back;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char              _PAD_UNUSED_[ sizeof(ModuleFlag) ];
-	s32 			  NumEntries;
+	StrCached Name;
+	Code      Front;
+	Code      Back;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32       NumEntries;
 };
 static_assert( sizeof(AST_Body) == sizeof(AST), "ERROR: AST_Body is not the same size as AST");
 
+// TODO(Ed): Support chaining attributes (Use parameter linkage pattern)
 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 +65,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 +80,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;
@@ -99,14 +100,14 @@ struct AST_Class
 		{
 			CodeComment     InlineCmt; // Only supported by forward declarations
 			CodeAttributes  Attributes;
-			char 	        _PAD_SPECS_ [ sizeof(AST*) ];
+			char            _PAD_SPECS_ [ sizeof(AST*) ];
 			CodeTypename    ParentType;
-			char 	        _PAD_PARAMS_[ sizeof(AST*) ];
+			char            _PAD_PARAMS_[ sizeof(AST*) ];
 			CodeBody        Body;
-			char 	        _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char            _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached            Name;
+	StrCached               Name;
 	CodeTypename            Prev;
 	CodeTypename            Next;
 	Token*                  Tok;
@@ -129,10 +130,10 @@ struct AST_Constructor
 			Code           InitializerList;
 			CodeParams     Params;
 			Code           Body;
-			char 		   _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
+			char           _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
 		};
 	};
-	StringCached      Name;
+	StrCached         Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
@@ -146,17 +147,39 @@ struct AST_Define
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		struct
+		{
+			char              _PAD_PROPERTIES_ [ sizeof(AST*) * 4 ];
+			CodeDefineParams  Params;
+			Code              Body; // Should be completely serialized for now to a: StrCached Content.
+			char              _PAD_PROPERTIES_2_ [ sizeof(AST*) * 1 ];
+		};
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Define) == sizeof(AST), "ERROR: AST_Define is not the same size as AST");
+
+struct AST_DefineParams
+{
+	union {
+		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	StrCached         Name;
+	CodeDefineParams  Last;
+	CodeDefineParams  Next;
 	Token*            Tok;
 	Code              Parent;
 	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32               NumEntries;
 };
-static_assert( sizeof(AST_Define) == sizeof(AST), "ERROR: AST_Define is not the same size as AST");
+static_assert( sizeof(AST_DefineParams) == sizeof(AST), "ERROR: AST_DefineParams is not the same size as AST");
 
 struct AST_Destructor
 {
@@ -169,10 +192,10 @@ struct AST_Destructor
 			CodeSpecifiers Specs;
 			char           _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
 			Code           Body;
-			char 		   _PAD_PROPERTIES_3_ [ sizeof(AST*) ];
+			char           _PAD_PROPERTIES_3_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached              Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -194,10 +217,10 @@ struct AST_Enum
 			CodeTypename   UnderlyingType;
 			Code           UnderlyingTypeMacro;
 			CodeBody       Body;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char           _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached              Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -212,9 +235,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;
@@ -224,13 +247,13 @@ struct AST_Exec
 };
 static_assert( sizeof(AST_Exec) == sizeof(AST), "ERROR: AST_Exec is not the same size as AST");
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 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 +268,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 +283,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 +298,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 +313,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 +328,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 +343,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 +358,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 +373,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 +388,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 +403,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 +418,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 +433,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 +448,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 +463,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 +478,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 +493,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,13 +515,13 @@ struct AST_Extern
 			char      _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
+	StrCached         Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
 	Code              Parent;
 	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_Extern) == sizeof(AST), "ERROR: AST_Extern is not the same size as AST");
 
@@ -506,15 +529,15 @@ struct AST_Include
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_Include) == sizeof(AST), "ERROR: AST_Include is not the same size as AST");
 
@@ -527,16 +550,16 @@ struct AST_Friend
 			CodeComment InlineCmt;
 			char        _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
 			Code        Declaration;
-			char 	    _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char        _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_Friend) == sizeof(AST), "ERROR: AST_Friend is not the same size as AST");
 
@@ -550,19 +573,19 @@ struct AST_Fn
 			CodeAttributes  Attributes;
 			CodeSpecifiers  Specs;
 			CodeTypename    ReturnType;
-			CodeParams 	    Params;
+			CodeParams      Params;
 			CodeBody        Body;
-			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
+			char            _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached            Name;
-	Code                    Prev;
-	Code                    Next;
-	Token*                  Tok;
-	Code                    Parent;
-	CodeType                Type;
-	ModuleFlag              ModuleFlags;
-	char 			        _PAD_UNUSED_[ sizeof(u32) ];
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	char       _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_Fn) == sizeof(AST), "ERROR: AST_Fn is not the same size as AST");
 
@@ -571,14 +594,14 @@ struct AST_Module
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 	};
-	StringCached      Name;
+	StrCached         Name;
 	Code              Prev;
 	Code              Next;
 	Token*            Tok;
 	Code              Parent;
 	CodeType          Type;
 	ModuleFlag        ModuleFlags;
-	char 			  _PAD_UNUSED_[ sizeof(u32) ];
+	char             _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_Module) == sizeof(AST), "ERROR: AST_Module is not the same size as AST");
 
@@ -587,45 +610,45 @@ struct AST_NS
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 		struct {
-			char 	  _PAD_PROPERTIES_[ sizeof(AST*) * 5 ];
+			char      _PAD_PROPERTIES_[ sizeof(AST*) * 5 ];
 			CodeBody  Body;
-			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char      _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	ModuleFlag        ModuleFlags;
-	char 			  _PAD_UNUSED_[ sizeof(u32) ];
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	char       _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_NS) == sizeof(AST), "ERROR: AST_NS is not the same size as AST");
 
 struct AST_Operator
 {
 	union {
-		char                _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
+		char               _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 		struct
 		{
-			CodeComment     InlineCmt;
-			CodeAttributes  Attributes;
-			CodeSpecifiers  Specs;
-			CodeTypename    ReturnType;
-			CodeParams 	    Params;
-			CodeBody        Body;
-			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
+			CodeComment    InlineCmt;
+			CodeAttributes Attributes;
+			CodeSpecifiers Specs;
+			CodeTypename   ReturnType;
+			CodeParams 	   Params;
+			CodeBody       Body;
+			char           _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
 	};
-	StringCached   Name;
-	Code           Prev;
-	Code           Next;
-	Token*         Tok;
-	Code           Parent;
-	CodeType       Type;
-	ModuleFlag     ModuleFlags;
-	Operator       Op;
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	Operator   Op;
 };
 static_assert( sizeof(AST_Operator) == sizeof(AST), "ERROR: AST_Operator is not the same size as AST");
 
@@ -635,22 +658,22 @@ struct AST_OpCast
 		char               _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 		struct
 		{
-			CodeComment     InlineCmt;
-			char 	        _PAD_PROPERTIES_[ sizeof(AST*)  ];
-			CodeSpecifiers  Specs;
-			CodeTypename    ValueType;
-			char 	        _PAD_PROPERTIES_2_[ sizeof(AST*) ];
-			CodeBody        Body;
-			char 	        _PAD_PROPERTIES_3_[ sizeof(AST*) ];
+			CodeComment    InlineCmt;
+			char           _PAD_PROPERTIES_[ sizeof(AST*)  ];
+			CodeSpecifiers Specs;
+			CodeTypename   ValueType;
+			char           _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			CodeBody       Body;
+			char           _PAD_PROPERTIES_3_[ sizeof(AST*) ];
 		};
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_OpCast) == sizeof(AST), "ERROR: AST_OpCast is not the same size as AST");
 
@@ -660,7 +683,8 @@ struct AST_Params
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 		struct
 		{
-			char 	     _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
+			// TODO(Ed): Support attributes for parameters (Some prefix macros can be converted to that...)
+			char         _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
 			CodeTypename ValueType;
 			Code         Macro;
 			Code         Value;
@@ -668,14 +692,14 @@ struct AST_Params
 			// char     _PAD_PROPERTIES_3_[sizeof( AST* )];
 		};
 	};
-	StringCached      Name;
-	CodeParams        Last;
-	CodeParams        Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
-	s32               NumEntries;
+	StrCached  Name;
+	CodeParams Last;
+	CodeParams Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	char       _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32        NumEntries;
 };
 static_assert( sizeof(AST_Params) == sizeof(AST), "ERROR: AST_Params is not the same size as AST");
 
@@ -683,15 +707,15 @@ struct AST_Pragma
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached  Content;
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_Pragma) == sizeof(AST), "ERROR: AST_Pragma is not the same size as AST");
 
@@ -699,40 +723,40 @@ struct AST_PreprocessCond
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
-		StringCached  Content;
+		StrCached     Content;
 	};
-	StringCached      Name;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+	StrCached Name;
+	Code      Prev;
+	Code      Next;
+	Token*    Tok;
+	Code      Parent;
+	CodeType  Type;
+	char      _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
 static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_PreprocessCond is not the same size as AST");
 
 struct AST_Specifiers
 {
-	Specifier         ArrSpecs[ AST_ArrSpecs_Cap ];
-	StringCached      Name;
-	CodeSpecifiers    NextSpecs;
-	Code              Prev;
-	Code              Next;
-	Token*            Tok;
-	Code              Parent;
-	CodeType          Type;
-	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
-	s32               NumEntries;
+	Specifier      ArrSpecs[ AST_ArrSpecs_Cap ];
+	StrCached      Name;
+	CodeSpecifiers NextSpecs;
+	Code           Prev;
+	Code           Next;
+	Token*         Tok;
+	Code           Parent;
+	CodeType       Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32            NumEntries;
 };
 static_assert( sizeof(AST_Specifiers) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 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 +771,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 +786,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 +801,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 +816,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 +831,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 +846,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 +861,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 +876,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 +891,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 +906,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 +921,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 +936,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 +951,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;
@@ -946,14 +970,14 @@ struct AST_Struct
 		{
 			CodeComment    InlineCmt;
 			CodeAttributes Attributes;
-			char 	       _PAD_SPECS_ [ sizeof(AST*) ];
+			char           _PAD_SPECS_ [ sizeof(AST*) ];
 			CodeTypename   ParentType;
-			char 	       _PAD_PARAMS_[ sizeof(AST*) ];
+			char           _PAD_PARAMS_[ sizeof(AST*) ];
 			CodeBody       Body;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char          _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
+	StrCached              Name;
 	CodeTypename           Prev;
 	CodeTypename           Next;
 	Token*                 Tok;
@@ -970,20 +994,20 @@ struct AST_Template
 		char               _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
 		struct
 		{
-			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
+			char           _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
 			CodeParams 	   Params;
 			Code           Declaration;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char           _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
-	Code                   Prev;
-	Code                   Next;
-	Token*                 Tok;
-	Code                   Parent;
-	CodeType               Type;
-	ModuleFlag             ModuleFlags;
-	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	char       _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_Template) == sizeof(AST), "ERROR: AST_Template is not the same size as AST");
 
@@ -1005,13 +1029,13 @@ struct AST_Type
 			// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
 	};
-	StringCached           Name;
+	StrCached              Name;
 	Code                   Prev;
 	Code                   Next;
-	Token*                  Tok;
+	Token*                 Tok;
 	Code                   Parent;
 	CodeType               Type;
-	char 			       _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	char                   _PAD_UNUSED_[ sizeof(ModuleFlag) ];
 	b32                    IsParamPack;
 };
 static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same size as AST");
@@ -1032,13 +1056,13 @@ struct AST_Typename
 			CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
 	Code                   Parent;
 	CodeType               Type;
-	char 			       _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	char                   _PAD_UNUSED_[ sizeof(ModuleFlag) ];
 	struct {
 		b16                IsParamPack;   // Used by typename to know if type should be considered a parameter pack.
 		ETypenameTag       TypeTag;       // Used by typename to keep track of explicitly declared tags for the identifier (enum, struct, union)
@@ -1053,12 +1077,12 @@ struct AST_Typedef
 		struct
 		{
 			CodeComment    InlineCmt;
-			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
+			char           _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
 			Code           UnderlyingType;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
+			char           _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
 		};
 	};
-	StringCached           Name;
+	StrCached           Name;
 	Code                   Prev;
 	Code                   Next;
 	Token*                 Tok;
@@ -1077,19 +1101,19 @@ struct AST_Union
 		{
 			char           _PAD_INLINE_CMT_[ sizeof(AST*) ];
 			CodeAttributes Attributes;
-			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
+			char           _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
 			CodeBody       Body;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			char           _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
 	};
-	StringCached           Name;
-	Code                   Prev;
-	Code                   Next;
-	Token*                 Tok;
-	Code                   Parent;
-	CodeType               Type;
-	ModuleFlag             ModuleFlags;
-	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	char       _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_Union) == sizeof(AST), "ERROR: AST_Union is not the same size as AST");
 
@@ -1101,19 +1125,19 @@ struct AST_Using
 		{
 			CodeComment     InlineCmt;
 			CodeAttributes  Attributes;
-			char 	        _PAD_SPECS_     [ sizeof(AST*) ];
+			char            _PAD_SPECS_     [ sizeof(AST*) ];
 			CodeTypename    UnderlyingType;
-			char 	        _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
+			char            _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
 		};
 	};
-	StringCached            Name;
-	Code                    Prev;
-	Code                    Next;
-	Token*                  Tok;
-	Code                    Parent;
-	CodeType                Type;
-	ModuleFlag              ModuleFlags;
-	char 			        _PAD_UNUSED_[ sizeof(u32) ];
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	char       _PAD_UNUSED_[ sizeof(u32) ];
 };
 static_assert( sizeof(AST_Using) == sizeof(AST), "ERROR: AST_Using is not the same size as AST");
 
@@ -1129,17 +1153,17 @@ struct AST_Var
 			CodeTypename   ValueType;
 			Code           BitfieldSize;
 			Code           Value;
-			CodeVar		   NextVar;
+			CodeVar        NextVar;
 		};
 	};
-	StringCached           Name;
-	Code                   Prev;
-	Code                   Next;
-	Token*                 Tok;
-	Code                   Parent;
-	CodeType               Type;
-	ModuleFlag             ModuleFlags;
-	s32                    VarParenthesizedInit;
+	StrCached  Name;
+	Code       Prev;
+	Code       Next;
+	Token*     Tok;
+	Code       Parent;
+	CodeType   Type;
+	ModuleFlag ModuleFlags;
+	s32        VarParenthesizedInit;
 };
 static_assert( sizeof(AST_Var) == sizeof(AST), "ERROR: AST_Var is not the same size as AST");
 

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,12 +173,28 @@ 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;
 }
 
+inline CodeDefineParams& CodeDefineParams::operator=( Code other )
+{
+	if ( other.ast != nullptr && other->Parent != nullptr )
+	{
+		ast         = rcast( decltype( ast ), code_duplicate( other ).ast );
+		ast->Parent = { nullptr };
+	}
+	ast = rcast( decltype( ast ), other.ast );
+	return *this;
+}
+
+inline CodeDefineParams::operator bool()
+{
+	return ast != nullptr;
+}
+
 inline CodeDestructor& CodeDestructor::operator=( Code other )
 {
 	if ( other.ast != nullptr && other->Parent != nullptr )
@@ -204,7 +220,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 +251,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 +282,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 +313,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 +344,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 +375,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 +406,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 +437,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 +468,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 +499,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 +530,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 +577,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 +608,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 +671,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 +702,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 +733,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 +764,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 +795,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 +826,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;
@@ -851,6 +867,11 @@ forceinline Code::operator CodeDefine() const
 	return { (AST_Define*)ast };
 }
 
+forceinline Code::operator CodeDefineParams() const
+{
+	return { (AST_DefineParams*)ast };
+}
+
 forceinline Code::operator CodeDestructor() const
 {
 	return { (AST_Destructor*)ast };

base/components/gen/ecodetypes.hpp

@@ -46,6 +46,7 @@ enum CodeType : u32
 	CT_Operator_Cast,
 	CT_Operator_Cast_Fwd,
 	CT_Parameters,
+	CT_Parameters_Define,
 	CT_Preprocess_Define,
 	CT_Preprocess_Include,
 	CT_Preprocess_If,
@@ -72,148 +73,150 @@ 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] = {
-		{ sizeof( "Invalid" ),             "Invalid"             },
-		{ sizeof( "Untyped" ),             "Untyped"             },
-		{ sizeof( "NewLine" ),             "NewLine"             },
-		{ sizeof( "Comment" ),             "Comment"             },
-		{ sizeof( "Access_Private" ),      "Access_Private"      },
-		{ sizeof( "Access_Protected" ),    "Access_Protected"    },
-		{ sizeof( "Access_Public" ),       "Access_Public"       },
-		{ sizeof( "PlatformAttributes" ),  "PlatformAttributes"  },
-		{ sizeof( "Class" ),               "Class"               },
-		{ sizeof( "Class_Fwd" ),           "Class_Fwd"           },
-		{ sizeof( "Class_Body" ),          "Class_Body"          },
-		{ sizeof( "Constructor" ),         "Constructor"         },
-		{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"     },
-		{ sizeof( "Destructor" ),          "Destructor"          },
-		{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"      },
-		{ sizeof( "Enum" ),                "Enum"                },
-		{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"            },
-		{ sizeof( "Enum_Body" ),           "Enum_Body"           },
-		{ sizeof( "Enum_Class" ),          "Enum_Class"          },
-		{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"      },
-		{ sizeof( "Execution" ),           "Execution"           },
-		{ sizeof( "Export_Body" ),         "Export_Body"         },
-		{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"      },
-		{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
-		{ sizeof( "Friend" ),              "Friend"              },
-		{ sizeof( "Function" ),            "Function"            },
-		{ sizeof( "Function_Fwd" ),        "Function_Fwd"        },
-		{ sizeof( "Function_Body" ),       "Function_Body"       },
-		{ sizeof( "Global_Body" ),         "Global_Body"         },
-		{ sizeof( "Module" ),              "Module"              },
-		{ sizeof( "Namespace" ),           "Namespace"           },
-		{ sizeof( "Namespace_Body" ),      "Namespace_Body"      },
-		{ sizeof( "Operator" ),            "Operator"            },
-		{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"        },
-		{ sizeof( "Operator_Member" ),     "Operator_Member"     },
-		{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
-		{ sizeof( "Operator_Cast" ),       "Operator_Cast"       },
-		{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"   },
-		{ sizeof( "Parameters" ),          "Parameters"          },
-		{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"   },
-		{ sizeof( "Preprocess_Include" ),  "Preprocess_Include"  },
-		{ sizeof( "Preprocess_If" ),       "Preprocess_If"       },
-		{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"    },
-		{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
-		{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"     },
-		{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"     },
-		{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"    },
-		{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"   },
-		{ sizeof( "Specifiers" ),          "Specifiers"          },
-		{ sizeof( "Struct" ),              "Struct"              },
-		{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"          },
-		{ sizeof( "Struct_Body" ),         "Struct_Body"         },
-		{ sizeof( "Template" ),            "Template"            },
-		{ sizeof( "Typedef" ),             "Typedef"             },
-		{ sizeof( "Typename" ),            "Typename"            },
-		{ sizeof( "Union" ),               "Union"               },
-		{ sizeof( "Union_Fwd" ),           "Union_Fwd"           },
-		{ sizeof( "Union_Body" ),          "Union_Body"          },
-		{ sizeof( "Using" ),               "Using"               },
-		{ sizeof( "Using_Namespace" ),     "Using_Namespace"     },
-		{ sizeof( "Variable" ),            "Variable"            },
+	local_persist Str lookup[] = {
+		{ "Invalid",             sizeof( "Invalid" ) - 1             },
+		{ "Untyped",             sizeof( "Untyped" ) - 1             },
+		{ "NewLine",             sizeof( "NewLine" ) - 1             },
+		{ "Comment",             sizeof( "Comment" ) - 1             },
+		{ "Access_Private",      sizeof( "Access_Private" ) - 1      },
+		{ "Access_Protected",    sizeof( "Access_Protected" ) - 1    },
+		{ "Access_Public",       sizeof( "Access_Public" ) - 1       },
+		{ "PlatformAttributes",  sizeof( "PlatformAttributes" ) - 1  },
+		{ "Class",               sizeof( "Class" ) - 1               },
+		{ "Class_Fwd",           sizeof( "Class_Fwd" ) - 1           },
+		{ "Class_Body",          sizeof( "Class_Body" ) - 1          },
+		{ "Constructor",         sizeof( "Constructor" ) - 1         },
+		{ "Constructor_Fwd",     sizeof( "Constructor_Fwd" ) - 1     },
+		{ "Destructor",          sizeof( "Destructor" ) - 1          },
+		{ "Destructor_Fwd",      sizeof( "Destructor_Fwd" ) - 1      },
+		{ "Enum",                sizeof( "Enum" ) - 1                },
+		{ "Enum_Fwd",            sizeof( "Enum_Fwd" ) - 1            },
+		{ "Enum_Body",           sizeof( "Enum_Body" ) - 1           },
+		{ "Enum_Class",          sizeof( "Enum_Class" ) - 1          },
+		{ "Enum_Class_Fwd",      sizeof( "Enum_Class_Fwd" ) - 1      },
+		{ "Execution",           sizeof( "Execution" ) - 1           },
+		{ "Export_Body",         sizeof( "Export_Body" ) - 1         },
+		{ "Extern_Linkage",      sizeof( "Extern_Linkage" ) - 1      },
+		{ "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
+		{ "Friend",              sizeof( "Friend" ) - 1              },
+		{ "Function",            sizeof( "Function" ) - 1            },
+		{ "Function_Fwd",        sizeof( "Function_Fwd" ) - 1        },
+		{ "Function_Body",       sizeof( "Function_Body" ) - 1       },
+		{ "Global_Body",         sizeof( "Global_Body" ) - 1         },
+		{ "Module",              sizeof( "Module" ) - 1              },
+		{ "Namespace",           sizeof( "Namespace" ) - 1           },
+		{ "Namespace_Body",      sizeof( "Namespace_Body" ) - 1      },
+		{ "Operator",            sizeof( "Operator" ) - 1            },
+		{ "Operator_Fwd",        sizeof( "Operator_Fwd" ) - 1        },
+		{ "Operator_Member",     sizeof( "Operator_Member" ) - 1     },
+		{ "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
+		{ "Operator_Cast",       sizeof( "Operator_Cast" ) - 1       },
+		{ "Operator_Cast_Fwd",   sizeof( "Operator_Cast_Fwd" ) - 1   },
+		{ "Parameters",          sizeof( "Parameters" ) - 1          },
+		{ "Parameters_Define",   sizeof( "Parameters_Define" ) - 1   },
+		{ "Preprocess_Define",   sizeof( "Preprocess_Define" ) - 1   },
+		{ "Preprocess_Include",  sizeof( "Preprocess_Include" ) - 1  },
+		{ "Preprocess_If",       sizeof( "Preprocess_If" ) - 1       },
+		{ "Preprocess_IfDef",    sizeof( "Preprocess_IfDef" ) - 1    },
+		{ "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
+		{ "Preprocess_ElIf",     sizeof( "Preprocess_ElIf" ) - 1     },
+		{ "Preprocess_Else",     sizeof( "Preprocess_Else" ) - 1     },
+		{ "Preprocess_EndIf",    sizeof( "Preprocess_EndIf" ) - 1    },
+		{ "Preprocess_Pragma",   sizeof( "Preprocess_Pragma" ) - 1   },
+		{ "Specifiers",          sizeof( "Specifiers" ) - 1          },
+		{ "Struct",              sizeof( "Struct" ) - 1              },
+		{ "Struct_Fwd",          sizeof( "Struct_Fwd" ) - 1          },
+		{ "Struct_Body",         sizeof( "Struct_Body" ) - 1         },
+		{ "Template",            sizeof( "Template" ) - 1            },
+		{ "Typedef",             sizeof( "Typedef" ) - 1             },
+		{ "Typename",            sizeof( "Typename" ) - 1            },
+		{ "Union",               sizeof( "Union" ) - 1               },
+		{ "Union_Fwd",           sizeof( "Union_Fwd" ) - 1           },
+		{ "Union_Body",          sizeof( "Union_Body" ) - 1          },
+		{ "Using",               sizeof( "Using" ) - 1               },
+		{ "Using_Namespace",     sizeof( "Using_Namespace" ) - 1     },
+		{ "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] = {
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "//" ) - 1,              "//"              },
-		{ sizeof( "private" ) - 1,         "private"         },
-		{ sizeof( "protected" ) - 1,       "protected"       },
-		{ sizeof( "public" ) - 1,          "public"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "class" ) - 1,           "class"           },
-		{ sizeof( "clsss" ) - 1,           "clsss"           },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "enum" ) - 1,            "enum"            },
-		{ sizeof( "enum" ) - 1,            "enum"            },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "enum class" ) - 1,      "enum class"      },
-		{ sizeof( "enum class" ) - 1,      "enum class"      },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "extern" ) - 1,          "extern"          },
-		{ sizeof( "extern" ) - 1,          "extern"          },
-		{ sizeof( "friend" ) - 1,          "friend"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "module" ) - 1,          "module"          },
-		{ sizeof( "namespace" ) - 1,       "namespace"       },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "operator" ) - 1,        "operator"        },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "define" ) - 1,          "define"          },
-		{ sizeof( "include" ) - 1,         "include"         },
-		{ sizeof( "if" ) - 1,              "if"              },
-		{ sizeof( "ifdef" ) - 1,           "ifdef"           },
-		{ sizeof( "ifndef" ) - 1,          "ifndef"          },
-		{ sizeof( "elif" ) - 1,            "elif"            },
-		{ sizeof( "else" ) - 1,            "else"            },
-		{ sizeof( "endif" ) - 1,           "endif"           },
-		{ sizeof( "pragma" ) - 1,          "pragma"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "struct" ) - 1,          "struct"          },
-		{ sizeof( "struct" ) - 1,          "struct"          },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "template" ) - 1,        "template"        },
-		{ sizeof( "typedef" ) - 1,         "typedef"         },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "union" ) - 1,           "union"           },
-		{ sizeof( "union" ) - 1,           "union"           },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
-		{ sizeof( "using" ) - 1,           "using"           },
-		{ sizeof( "using namespace" ) - 1, "using namespace" },
-		{ sizeof( "__NA__" ) - 1,          "__NA__"          },
+	local_persist Str lookup[] = {
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "//",              sizeof( "//" ) - 1              },
+		{ "private",         sizeof( "private" ) - 1         },
+		{ "protected",       sizeof( "protected" ) - 1       },
+		{ "public",          sizeof( "public" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "class",           sizeof( "class" ) - 1           },
+		{ "clsss",           sizeof( "clsss" ) - 1           },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "enum",            sizeof( "enum" ) - 1            },
+		{ "enum",            sizeof( "enum" ) - 1            },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "enum class",      sizeof( "enum class" ) - 1      },
+		{ "enum class",      sizeof( "enum class" ) - 1      },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "extern",          sizeof( "extern" ) - 1          },
+		{ "extern",          sizeof( "extern" ) - 1          },
+		{ "friend",          sizeof( "friend" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "module",          sizeof( "module" ) - 1          },
+		{ "namespace",       sizeof( "namespace" ) - 1       },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "operator",        sizeof( "operator" ) - 1        },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "define",          sizeof( "define" ) - 1          },
+		{ "include",         sizeof( "include" ) - 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           },
+		{ "pragma",          sizeof( "pragma" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "struct",          sizeof( "struct" ) - 1          },
+		{ "struct",          sizeof( "struct" ) - 1          },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "template",        sizeof( "template" ) - 1        },
+		{ "typedef",         sizeof( "typedef" ) - 1         },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "union",           sizeof( "union" ) - 1           },
+		{ "union",           sizeof( "union" ) - 1           },
+		{ "__NA__",          sizeof( "__NA__" ) - 1          },
+		{ "using",           sizeof( "using" ) - 1           },
+		{ "using namespace", sizeof( "using namespace" ) - 1 },
+		{ "__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] = {
-		{ sizeof( "INVALID" ),  "INVALID"  },
-		{ sizeof( "=" ),        "="        },
-		{ sizeof( "+=" ),       "+="       },
-		{ sizeof( "-=" ),       "-="       },
-		{ sizeof( "*=" ),       "*="       },
-		{ sizeof( "/=" ),       "/="       },
-		{ sizeof( "%=" ),       "%="       },
-		{ sizeof( "&=" ),       "&="       },
-		{ sizeof( "|=" ),       "|="       },
-		{ sizeof( "^=" ),       "^="       },
-		{ sizeof( "<<=" ),      "<<="      },
-		{ sizeof( ">>=" ),      ">>="      },
-		{ sizeof( "++" ),       "++"       },
-		{ sizeof( "--" ),       "--"       },
-		{ sizeof( "+" ),        "+"        },
-		{ sizeof( "-" ),        "-"        },
-		{ sizeof( "!" ),        "!"        },
-		{ sizeof( "+" ),        "+"        },
-		{ sizeof( "-" ),        "-"        },
-		{ sizeof( "*" ),        "*"        },
-		{ sizeof( "/" ),        "/"        },
-		{ sizeof( "%" ),        "%"        },
-		{ sizeof( "~" ),        "~"        },
-		{ sizeof( "&" ),        "&"        },
-		{ sizeof( "|" ),        "|"        },
-		{ sizeof( "^" ),        "^"        },
-		{ sizeof( "<<" ),       "<<"       },
-		{ sizeof( ">>" ),       ">>"       },
-		{ sizeof( "&&" ),       "&&"       },
-		{ sizeof( "||" ),       "||"       },
-		{ sizeof( "==" ),       "=="       },
-		{ sizeof( "!=" ),       "!="       },
-		{ sizeof( "<" ),        "<"        },
-		{ sizeof( ">" ),        ">"        },
-		{ sizeof( "<=" ),       "<="       },
-		{ sizeof( ">=" ),       ">="       },
-		{ sizeof( "[]" ),       "[]"       },
-		{ sizeof( "*" ),        "*"        },
-		{ sizeof( "&" ),        "&"        },
-		{ sizeof( "->" ),       "->"       },
-		{ sizeof( "->*" ),      "->*"      },
-		{ sizeof( "()" ),       "()"       },
-		{ sizeof( "," ),        ","        },
-		{ sizeof( "new" ),      "new"      },
-		{ sizeof( "new[]" ),    "new[]"    },
-		{ sizeof( "delete" ),   "delete"   },
-		{ sizeof( "delete[]" ), "delete[]" },
+	local_persist Str lookup[] = {
+		{ "INVALID",  sizeof( "INVALID" ) - 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       },
+		{ "+",        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       },
+		{ ">>",       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       },
+		{ "->*",      sizeof( "->*" ) - 1      },
+		{ "()",       sizeof( "()" ) - 1       },
+		{ ",",        sizeof( "," ) - 1        },
+		{ "new",      sizeof( "new" ) - 1      },
+		{ "new[]",    sizeof( "new[]" ) - 1    },
+		{ "delete",   sizeof( "delete" ) - 1   },
+		{ "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

@@ -23,6 +23,7 @@ enum Specifier : u32
 	Spec_Ptr,
 	Spec_Ref,
 	Spec_Register,
+	Spec_Restrict,
 	Spec_RValue,
 	Spec_Static,
 	Spec_Thread_Local,
@@ -37,51 +38,63 @@ 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] = {
-		{ sizeof( "INVALID" ),       "INVALID"       },
-		{ sizeof( "consteval" ),     "consteval"     },
-		{ sizeof( "constexpr" ),     "constexpr"     },
-		{ sizeof( "constinit" ),     "constinit"     },
-		{ sizeof( "explicit" ),      "explicit"      },
-		{ sizeof( "extern" ),        "extern"        },
-		{ sizeof( "forceinline" ),   "forceinline"   },
-		{ sizeof( "global" ),        "global"        },
-		{ sizeof( "inline" ),        "inline"        },
-		{ sizeof( "internal" ),      "internal"      },
-		{ sizeof( "local_persist" ), "local_persist" },
-		{ sizeof( "mutable" ),       "mutable"       },
-		{ sizeof( "neverinline" ),   "neverinline"   },
-		{ sizeof( "*" ),             "*"             },
-		{ sizeof( "&" ),             "&"             },
-		{ sizeof( "register" ),      "register"      },
-		{ sizeof( "&&" ),            "&&"            },
-		{ sizeof( "static" ),        "static"        },
-		{ sizeof( "thread_local" ),  "thread_local"  },
-		{ sizeof( "virtual" ),       "virtual"       },
-		{ sizeof( "const" ),         "const"         },
-		{ sizeof( "final" ),         "final"         },
-		{ sizeof( "noexcept" ),      "noexcept"      },
-		{ sizeof( "override" ),      "override"      },
-		{ sizeof( "= 0" ),           "= 0"           },
-		{ sizeof( "volatile" ),      "volatile"      },
+	local_persist Str lookup[] = {
+		{ "INVALID",       sizeof( "INVALID" ) - 1       },
+		{ "consteval",     sizeof( "consteval" ) - 1     },
+		{ "constexpr",     sizeof( "constexpr" ) - 1     },
+		{ "constinit",     sizeof( "constinit" ) - 1     },
+		{ "explicit",      sizeof( "explicit" ) - 1      },
+		{ "extern",        sizeof( "extern" ) - 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   },
+		{ "*",             sizeof( "*" ) - 1             },
+		{ "&",             sizeof( "&" ) - 1             },
+		{ "register",      sizeof( "register" ) - 1      },
+		{ "restrict",      sizeof( "restrict" ) - 1      },
+		{ "&&",            sizeof( "&&" ) - 1            },
+		{ "static",        sizeof( "static" ) - 1        },
+		{ "thread_local",  sizeof( "thread_local" ) - 1  },
+		{ "virtual",       sizeof( "virtual" ) - 1       },
+		{ "const",         sizeof( "const" ) - 1         },
+		{ "final",         sizeof( "final" ) - 1         },
+		{ "noexcept",      sizeof( "noexcept" ) - 1      },
+		{ "override",      sizeof( "override" ) - 1      },
+		{ "= 0",           sizeof( "= 0" ) - 1           },
+		{ "volatile",      sizeof( "volatile" ) - 1      },
 	};
 	return lookup[type];
 }
 
 inline bool spec_is_trailing( Specifier specifier )
 {
-	return specifier > Spec_Virtual;
+	switch ( specifier )
+	{
+		case Spec_Const :
+		case Spec_Final :
+		case Spec_NoExceptions :
+		case Spec_Override :
+		case Spec_Pure :
+		case Spec_Volatile :
+			return true;
+		default :
+			return false;
+	}
 }
 
-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 );
-		keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+		Str enum_str  = spec_to_str( (Specifier)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 < Spec_NumSpecifiers; index++ )
@@ -92,14 +105,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,237 @@
+#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_Paren_Open,
+	Tok_Paren_Close,
+	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_Define_Param,
+	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_Expr,
+	Tok_Preprocess_Macro_Stmt,
+	Tok_Preprocess_Macro_Typename,
+	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_Restrict,
+	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               },
+		{ "__define_param__",     sizeof( "__define_param__" ) - 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_expression__", sizeof( "__macro_expression__" ) - 1 },
+		{ "__macro_statment__",   sizeof( "__macro_statment__" ) - 1   },
+		{ "__macro_typename__",   sizeof( "__macro_typename__" ) - 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             },
+		{ "restrict",             sizeof( "restrict" ) - 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
-#	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 Macro enum_underlying_macro;
 
 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/header_start.hpp

@@ -15,7 +15,7 @@
 	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
 	|                        | |   | |                      __} |                                  |
 	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
+	! ----------------------------------------------------------------------- VERSION: v0.23-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 |

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 );
@@ -257,6 +257,25 @@ CodeParams next_CodeParams(CodeParams params, CodeParams param_iter)
 }
 #pragma endregion CodeParams
 
+#pragma region CodeDefineParams
+forceinline void             define_params_append     (CodeDefineParams appendee, CodeDefineParams other ) { params_append( cast(CodeParams, appendee), cast(CodeParams, other) ); }
+forceinline CodeDefineParams define_params_get        (CodeDefineParams self, s32 idx )                    { return (CodeDefineParams) (Code) params_get( cast(CodeParams, self), idx); }
+forceinline bool             define_params_has_entries(CodeDefineParams self)                              { return params_has_entries( cast(CodeParams, self)); }
+
+forceinline CodeDefineParams begin_CodeDefineParams(CodeDefineParams params)                              { return (CodeDefineParams) (Code) begin_CodeParams( cast(CodeParams, (Code)params)); }
+forceinline CodeDefineParams end_CodeDefineParams  (CodeDefineParams params)                              { return (CodeDefineParams) (Code) end_CodeParams  ( cast(CodeParams, (Code)params)); }
+forceinline CodeDefineParams next_CodeDefineParams (CodeDefineParams params, CodeDefineParams entry_iter) { return (CodeDefineParams) (Code) next_CodeParams ( cast(CodeParams, (Code)params), cast(CodeParams, (Code)entry_iter)); }
+
+#if GEN_COMPILER_CPP
+forceinline
+CodeDefineParams& CodeDefineParams::operator ++()
+{
+	* this = ast->Next;
+	return * this;
+}
+#endif
+#pragma endregion CodeDefineParams
+
 #pragma region CodeSpecifiers
 inline
 bool specifiers_append(CodeSpecifiers self, Specifier spec )
@@ -397,7 +416,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 +427,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 ) )
-					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
+					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 ) )
-					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
+					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,318 +149,373 @@ void define_constants()
 	preprocess_endif->Type = CT_Preprocess_EndIf;
 	code_set_global((Code)preprocess_endif);
 
-#	define def_constant_code_type( Type_ )           \
-		do                                           \
-		{                                            \
-			StrC name_str = name(Type_);             \
-			t_##Type_ = def_type( name_str );        \
-			code_set_global( cast(Code, t_##Type_)); \
-		} while(0)
-
-	def_constant_code_type( auto );
-	def_constant_code_type( void );
-	def_constant_code_type( int );
-	def_constant_code_type( bool );
-	def_constant_code_type( char );
-	def_constant_code_type( wchar_t );
-	def_constant_code_type( class );
-	def_constant_code_type( typename );
+	Str auto_str     = txt("auto");     t_auto     = def_type( auto_str );     code_set_global( t_auto );
+	Str void_str     = txt("void");     t_void     = def_type( void_str );     code_set_global( t_void );
+	Str int_str      = txt("int");      t_int      = def_type( int_str );      code_set_global( t_int  );
+	Str bool_str     = txt("bool");     t_bool     = def_type( bool_str );     code_set_global( t_bool );
+	Str char_str     = txt("char");     t_char     = def_type( char_str );     code_set_global( t_char );
+	Str wchar_str    = txt("wchar_t");  t_wchar_t  = def_type( wchar_str );    code_set_global( t_wchar_t );
+	Str class_str    = txt("class");    t_class    = def_type( class_str );    code_set_global( t_class );
+	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) );
+	t_b32 = def_type( name(b32) ); code_set_global( t_b32 );
 
-	def_constant_code_type( s8 );
-	def_constant_code_type( s16 );
-	def_constant_code_type( s32 );
-	def_constant_code_type( s64 );
+	Str s8_str  = txt("s8");  t_s8  = def_type( s8_str ); code_set_global( t_s8 );
+	Str s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
+	Str s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
+	Str s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
 
-	def_constant_code_type( u8 );
-	def_constant_code_type( u16 );
-	def_constant_code_type( u32 );
-	def_constant_code_type( u64 );
+	Str u8_str  = txt("u8");  t_u8  = def_type( u8_str );  code_set_global( t_u8 );
+	Str u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
+	Str u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
+	Str u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
 
-	def_constant_code_type( ssize );
-	def_constant_code_type( usize );
+	Str ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
+	Str usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
 
-	def_constant_code_type( f32 );
-	def_constant_code_type( f64 );
+	Str f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
+	Str f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
 #endif
-#	undef def_constant_code_type
 
 	spec_const            = def_specifier( Spec_Const);            code_set_global( cast(Code, spec_const ));
-	spec_consteval        = def_specifier( Spec_Consteval);        code_set_global( cast(Code, spec_consteval ));;
-	spec_constexpr        = def_specifier( Spec_Constexpr);        code_set_global( cast(Code, spec_constexpr ));;
-	spec_constinit        = def_specifier( Spec_Constinit);        code_set_global( cast(Code, spec_constinit ));;
-	spec_extern_linkage   = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));;
-	spec_final            = def_specifier( Spec_Final);            code_set_global( cast(Code, spec_final ));;
-	spec_forceinline      = def_specifier( Spec_ForceInline);      code_set_global( cast(Code, spec_forceinline ));;
-	spec_global           = def_specifier( Spec_Global);           code_set_global( cast(Code, spec_global ));;
-	spec_inline           = def_specifier( Spec_Inline);           code_set_global( cast(Code, spec_inline ));;
-	spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));;
-	spec_local_persist    = def_specifier( Spec_Local_Persist);    code_set_global( cast(Code, spec_local_persist ));;
-	spec_mutable          = def_specifier( Spec_Mutable);          code_set_global( cast(Code, spec_mutable ));;
-	spec_neverinline      = def_specifier( Spec_NeverInline);      code_set_global( cast(Code, spec_neverinline ));;
-	spec_noexcept         = def_specifier( Spec_NoExceptions);     code_set_global( cast(Code, spec_noexcept ));;
-	spec_override         = def_specifier( Spec_Override);         code_set_global( cast(Code, spec_override ));;
-	spec_ptr              = def_specifier( Spec_Ptr);              code_set_global( cast(Code, spec_ptr ));;
+	spec_consteval        = def_specifier( Spec_Consteval);        code_set_global( cast(Code, spec_consteval ));
+	spec_constexpr        = def_specifier( Spec_Constexpr);        code_set_global( cast(Code, spec_constexpr ));
+	spec_constinit        = def_specifier( Spec_Constinit);        code_set_global( cast(Code, spec_constinit ));
+	spec_extern_linkage   = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));
+	spec_final            = def_specifier( Spec_Final);            code_set_global( cast(Code, spec_final ));
+	spec_forceinline      = def_specifier( Spec_ForceInline);      code_set_global( cast(Code, spec_forceinline ));
+	spec_global           = def_specifier( Spec_Global);           code_set_global( cast(Code, spec_global ));
+	spec_inline           = def_specifier( Spec_Inline);           code_set_global( cast(Code, spec_inline ));
+	spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));
+	spec_local_persist    = def_specifier( Spec_Local_Persist);    code_set_global( cast(Code, spec_local_persist ));
+	spec_mutable          = def_specifier( Spec_Mutable);          code_set_global( cast(Code, spec_mutable ));
+	spec_neverinline      = def_specifier( Spec_NeverInline);      code_set_global( cast(Code, spec_neverinline ));
+	spec_noexcept         = def_specifier( Spec_NoExceptions);     code_set_global( cast(Code, spec_noexcept ));
+	spec_override         = def_specifier( Spec_Override);         code_set_global( cast(Code, spec_override ));
+	spec_ptr              = def_specifier( Spec_Ptr);              code_set_global( cast(Code, spec_ptr ));
 	spec_pure             = def_specifier( Spec_Pure);             code_set_global( cast(Code, spec_pure ));
-	spec_ref              = def_specifier( Spec_Ref);              code_set_global( cast(Code, spec_ref ));;
-	spec_register         = def_specifier( Spec_Register);         code_set_global( cast(Code, spec_register ));;
-	spec_rvalue           = def_specifier( Spec_RValue);           code_set_global( cast(Code, spec_rvalue ));;
-	spec_static_member    = def_specifier( Spec_Static);           code_set_global( cast(Code, spec_static_member ));;
-	spec_thread_local     = def_specifier( Spec_Thread_Local);     code_set_global( cast(Code, spec_thread_local ));;
-	spec_virtual          = def_specifier( Spec_Virtual);          code_set_global( cast(Code, spec_virtual ));;
+	spec_ref              = def_specifier( Spec_Ref);              code_set_global( cast(Code, spec_ref ));
+	spec_register         = def_specifier( Spec_Register);         code_set_global( cast(Code, spec_register ));
+	spec_rvalue           = def_specifier( Spec_RValue);           code_set_global( cast(Code, spec_rvalue ));
+	spec_static_member    = def_specifier( Spec_Static);           code_set_global( cast(Code, spec_static_member ));
+	spec_thread_local     = def_specifier( Spec_Thread_Local);     code_set_global( cast(Code, spec_thread_local ));
+	spec_virtual          = def_specifier( Spec_Virtual);          code_set_global( cast(Code, spec_virtual ));
 	spec_volatile         = def_specifier( Spec_Volatile);         code_set_global( cast(Code, spec_volatile ));
 
 	spec_local_persist = def_specifiers( 1, Spec_Local_Persist );
 	code_set_global(cast(Code, spec_local_persist));
 
-	if (enum_underlying_sig.Len == 0) {
-		enum_underlying_sig = txt("enum_underlying(");
+	if (enum_underlying_macro.Name.Len == 0) {
+		enum_underlying_macro.Name  = txt("enum_underlying");
+		enum_underlying_macro.Type  = MT_Expression;
+		enum_underlying_macro.Flags = MF_Functional;
 	}
-	array_append(PreprocessorDefines, enum_underlying_sig);
-
-#	undef def_constant_spec
+	register_macro(enum_underlying_macro);
 }
 
-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 };
-		GlobalAllocator = becasue_C;
-
-		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 );
+		ctx->Fallback_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
+		if ( ctx->Fallback_AllocatorBuckets == nullptr )
+			GEN_FATAL( "Failed to reserve memory for Fallback_AllocatorBuckets");
 
+		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) {
-		Allocator_DataArrays = GlobalAllocator;
+	if (ctx->Max_CommentLineLength == 0) {
+		ctx->Max_CommentLineLength = 1024;
 	}
-	if (Allocator_CodePool.Proc == nullptr ) {
-		Allocator_CodePool = GlobalAllocator;
+	if (ctx->Max_StrCacheLength == 0) {
+		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) {
-		Allocator_StringArena = GlobalAllocator;
+	if (ctx->InitSize_CodePoolsArray == 0) { 
+		ctx->InitSize_CodePoolsArray = 16; 
 	}
-	if (Allocator_StringTable.Proc == nullptr) {
-		Allocator_StringTable = GlobalAllocator;
+	if (ctx->InitSize_StringArenasArray == 0) {
+		ctx->InitSize_StringArenasArray = 16; 
 	}
-	if (Allocator_TypeTable.Proc == nullptr) {
-		Allocator_TypeTable = GlobalAllocator;
+	if (ctx->CodePool_NumBlocks == 0) {
+		ctx->CodePool_NumBlocks = kilobytes(16);
 	}
 
+	if (ctx->InitSize_LexerTokens == 0 ) {
+		ctx->InitSize_LexerTokens = kilobytes(64);
+	}
+	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 );
-
-		if ( CodePools == nullptr )
+		ctx->CodePools = array_init_reserve(Pool, ctx->Allocator_DyanmicContainers, ctx->InitSize_CodePoolsArray );
+		if ( ctx->CodePools == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
 
-		StringArenas = array_init_reserve(Arena, Allocator_DataArrays, InitSize_DataArrays );
-
-		if ( StringArenas == nullptr )
+		ctx->StringArenas = array_init_reserve(Arena, ctx->Allocator_DyanmicContainers, ctx->InitSize_StringArenasArray );
+		if ( ctx->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 );
-
-		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
-
-		Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
-
-		if ( string_arena.PhysicalStart == nullptr )
+		// 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 );
+		if ( strbuilder_arena.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
-
-		array_append( StringArenas, string_arena );
+		array_append( ctx->StringArenas, strbuilder_arena );
 	}
-
 	// Setup the hash tables
 	{
-		StringCache = hashtable_init(StringCached, Allocator_StringTable);
-
-		if ( StringCache.Entries == nullptr )
+		ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
+		if ( ctx->StrCache.Entries == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
+
+		ctx->Macros = hashtable_init(Macro, ctx->Allocator_DyanmicContainers);
+		if (ctx->Macros.Hashes == nullptr || ctx->Macros.Entries == nullptr) {
+			GEN_FATAL( "gen::init: Failed to initialize the PreprocessMacros table" );
+		}
 	}
 
-	// Preprocessor Defines
-	PreprocessorDefines = array_init_reserve(StringCached, GlobalAllocator, 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_free(string_arena);
+		Arena* strbuilder_arena = & ctx->StringArenas[index];
+		arena_free(strbuilder_arena);
 		index++;
 	}
 	while ( left--, left );
 
-	hashtable_destroy(StringCache);
+	hashtable_destroy(ctx->StrCache);
 
-	array_free( CodePools);
-	array_free( StringArenas);
+	array_free( ctx->CodePools);
+	array_free( ctx->StringArenas);
 
-	arena_free(& LexArena);
+	hashtable_destroy(ctx->Macros);
 
-	array_free(PreprocessorDefines);
-
-	index = 0;
-	left  = array_num(Global_AllocatorBuckets);
-	do
+	left  = array_num( ctx->Fallback_AllocatorBuckets);
+	if (left)
 	{
-		Arena* bucket = & Global_AllocatorBuckets[ index ];
-		arena_free(bucket);
-		index++;
+		index = 0;
+		do
+		{
+			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);
-	GEN_NS_PARSER parser_deinit();
+	if (_ctx == ctx) 
+		_ctx = nullptr;
+	-- context_counter;
+
+	Context wipe = {};
+	* ctx = wipe;
 }
 
-void reset()
+Context* get_context() { 
+	return _ctx;
+}
+
+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];
-		string_arena->TotalUsed = 0;;
+		Arena* strbuilder_arena = & ctx->StringArenas[index];
+		strbuilder_arena->TotalUsed = 0;;
 		index++;
 	}
 	while ( left--, left );
 
-	hashtable_clear(StringCache);
-
+	hashtable_clear(ctx->StrCache);
+	hashtable_clear(ctx->Macros);
 	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);
-
-	usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
-
+	Arena* last     = array_back(_ctx->StringArenas);
+	usize  size_req = str_length + sizeof(StrBuilderHeader) + 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 ) )
-			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
-
-		last = array_back(StringArenas);
+		last = array_back( _ctx->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;
-	u64 key         = crc32( str.Ptr, hash_length );
-	{
-		StringCached* result = hashtable_get(StringCache, key );
-
+	if (str.Len > _ctx->Max_StrCacheLength) {
+		// 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 ));
+		return result;
+	}
+	u64 key = crc32( str.Ptr, str.Len ); {
+		StrCached* result = hashtable_get( _ctx->StrCache, key );
 		if ( result )
 			return * result;
 	}
-
-	StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str ));
-	hashtable_set(StringCache, key, result );
-
+	Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
+	hashtable_set( _ctx->StrCache, 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 )
-{
-	Allocator_DataArrays = allocator;
+Macro* lookup_macro( Str name ) {
+	u32 key = crc32( name.Ptr, name.Len );
+	return hashtable_get( _ctx->Macros, key );
 }
 
-void set_allocator_code_pool( AllocatorInfo allocator )
-{
-	Allocator_CodePool = allocator;
+void register_macro( Macro macro ) {
+	GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
+	GEN_ASSERT(macro.Name.Len > 0);
+	u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
+	macro.Name = cache_str(macro.Name);
+	hashtable_set( _ctx->Macros, key, macro );
 }
 
-void set_allocator_lexer( AllocatorInfo allocator )
+void register_macros( s32 num, ... )
 {
-	Allocator_Lexer = allocator;
+	GEN_ASSERT(num > 0);
+	va_list va;
+	va_start(va, num);
+	do
+	{
+		Macro macro = va_arg(va, Macro);
+		GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
+		GEN_ASSERT(macro.Name.Len > 0);
+		macro.Name = cache_str(macro.Name);
+
+		u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
+		hashtable_set( _ctx->Macros, key, macro );
+	}
+	while (num--, num > 0);
+	va_end(va);
 }
 
-void set_allocator_string_arena( AllocatorInfo allocator )
+void register_macros_arr( s32 num,  Macro* macros )
 {
-	Allocator_StringArena = allocator;
-}
+	GEN_ASSERT(num > 0);
+	do
+	{
+		Macro macro = * macros;
+		GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
+		GEN_ASSERT(macro.Name.Len > 0);
+		macro.Name = cache_str(macro.Name);
 
-void set_allocator_string_table( AllocatorInfo allocator )
-{
-	Allocator_StringArena = allocator;
+		u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
+		hashtable_set( _ctx->Macros, key, macro );
+		++ macros;
+	}
+	while (num--, num > 0);
 }

base/components/interface.hpp

@@ -15,41 +15,138 @@
   \▓▓▓▓▓▓  \▓▓▓▓▓▓▓\▓▓   \▓▓     \▓▓▓▓▓▓\▓▓   \▓▓   \▓▓▓▓  \▓▓▓▓▓▓▓\▓▓      \▓▓       \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
 */
 
-// Initialize the library.
-void init();
+#if 0
+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_LexerTokens;
+	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.
+	MacroTable Macros;
+
+// 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;
+
+	StringTable token_fmt_map;
+
+	// Array(Token) LexerTokens;
+
+	Array(Pool)  CodePools;
+	Array(Arena) StringArenas;
+
+	StringTable StrCache;
+
+	// TODO(Ed): This needs to be just handled by a parser context
+	Array(Token) Lexer_Tokens;
+
+	// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
+	ParseContext parser;
+
+	// TODO(Ed): Formatting - This will eventually be in a separate struct when in the process of serialization of the builder.
+	s32 temp_serialize_indent;
+};
+
+// 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.
+// Retrieves the active context (not usually needed, but here in case...)
+GEN_API Context* get_context();
+
+// 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);
+
+// Mostly intended for the parser
+GEN_API Macro* lookup_macro( Str Name );
+
+// Alternative way to add a preprocess define entry for the lexer & parser to utilize 
+// if the user doesn't want to use def_define
+// Macros are tracked by name so if the name already exists the entry will be overwritten.
+GEN_API void register_macro( Macro macro );
+
+// Ease of use batch registration
+GEN_API void register_macros( s32 num, ... );
+GEN_API void register_macros_arr( s32 num, Macro* macros );
+
+#if GEN_COMPILER_CPP
+forceinline void register_macros( s32 num, Macro* macros ) { return register_macros_arr(num, macros); }
+#endif
 
 // 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 );
-CodeComment    def_comment   ( StrC content );
+GEN_API CodeAttributes def_attributes( Str content );
+GEN_API CodeComment    def_comment   ( Str content );
 
 struct Opts_def_struct {
 	CodeBody       body;
@@ -60,25 +157,28 @@ 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;
+	CodeDefineParams params;
+	Str              content;
+	MacroFlags       flags;
+	b32              dont_register_to_preprocess_macros;
 };
-CodeDefine def_define( StrC name, StrC content, Opts_def_define opts GEN_PARAM_DEFAULT );
+GEN_API CodeDefine def_define( Str name, MacroType type, 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 +188,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 );
-CodeExtern def_extern_link( StrC name, CodeBody body );
-CodeFriend def_friend     ( Code symbol );
+GEN_API CodeExec   def_execution  ( Str content );
+GEN_API CodeExtern def_extern_link( Str name, CodeBody body );
+GEN_API CodeFriend def_friend     ( Code symbol );
 
 struct Opts_def_function {
 	CodeParams      params;
@@ -102,14 +202,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 );
-CodeModule  def_module   ( StrC name,                Opts_def_module    opts GEN_PARAM_DEFAULT );
-CodeNS      def_namespace( StrC name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
+GEN_API CodeInclude def_include  ( Str content,             Opts_def_include   opts GEN_PARAM_DEFAULT );
+GEN_API CodeModule  def_module   ( Str name,                Opts_def_module    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 +219,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 );
-CodePragma def_pragma( StrC directive );
+GEN_API CodeParams  def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
+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 +246,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,61 +275,74 @@ 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, ... );
-CodeBody       def_class_body      ( s32 num, Code* codes );
-CodeBody       def_enum_body       ( s32 num, ... );
-CodeBody       def_enum_body       ( s32 num, Code* codes );
-CodeBody       def_export_body     ( s32 num, ... );
-CodeBody       def_export_body     ( s32 num, Code* codes);
-CodeBody       def_extern_link_body( s32 num, ... );
-CodeBody       def_extern_link_body( s32 num, Code* codes );
-CodeBody       def_function_body   ( s32 num, ... );
-CodeBody       def_function_body   ( s32 num, Code* codes );
-CodeBody       def_global_body     ( s32 num, ... );
-CodeBody       def_global_body     ( s32 num, Code* codes );
-CodeBody       def_namespace_body  ( s32 num, ... );
-CodeBody       def_namespace_body  ( s32 num, Code* codes );
-CodeParams     def_params          ( s32 num, ... );
-CodeParams     def_params          ( s32 num, CodeParams* params );
-CodeSpecifiers def_specifiers      ( s32 num, ... );
-CodeSpecifiers def_specifiers      ( s32 num, Specifier* specs );
-CodeBody       def_struct_body     ( s32 num, ... );
-CodeBody       def_struct_body     ( s32 num, Code* codes );
-CodeBody       def_union_body      ( s32 num, ... );
-CodeBody       def_union_body      ( s32 num, Code* codes );
+GEN_API CodeBody         def_class_body           ( s32 num, ... );
+GEN_API CodeBody         def_class_body_arr       ( s32 num, Code* codes );
+GEN_API CodeDefineParams def_define_params        ( s32 num, ... );
+GEN_API CodeDefineParams def_define_params_arr    ( s32 num, CodeDefineParams* codes );
+GEN_API CodeBody         def_enum_body            ( s32 num, ... );
+GEN_API CodeBody         def_enum_body_arr        ( s32 num, Code* codes );
+GEN_API CodeBody         def_export_body          ( s32 num, ... );
+GEN_API CodeBody         def_export_body_arr      ( s32 num, Code* codes);
+GEN_API CodeBody         def_extern_link_body     ( s32 num, ... );
+GEN_API CodeBody         def_extern_link_body_arr ( s32 num, Code* codes );
+GEN_API CodeBody         def_function_body        ( s32 num, ... );
+GEN_API CodeBody         def_function_body_arr    ( s32 num, Code* codes );
+GEN_API CodeBody         def_global_body          ( s32 num, ... );
+GEN_API CodeBody         def_global_body_arr      ( s32 num, Code* codes );
+GEN_API CodeBody         def_namespace_body       ( s32 num, ... );
+GEN_API CodeBody         def_namespace_body_arr   ( s32 num, Code* codes );
+GEN_API CodeParams       def_params               ( s32 num, ... );
+GEN_API CodeParams       def_params_arr           ( s32 num, CodeParams* params );
+GEN_API CodeSpecifiers   def_specifiers           ( s32 num, ... );
+GEN_API CodeSpecifiers   def_specifiers_arr       ( s32 num, Specifier* specs );
+GEN_API CodeBody         def_struct_body          ( s32 num, ... );
+GEN_API CodeBody         def_struct_body_arr      ( s32 num, Code* codes );
+GEN_API CodeBody         def_union_body           ( s32 num, ... );
+GEN_API CodeBody         def_union_body_arr       ( s32 num, Code* codes );
+
+#if GEN_COMPILER_CPP
+forceinline CodeBody         def_class_body      ( s32 num, Code* codes )             { return def_class_body_arr(num, codes); }
+forceinline CodeDefineParams def_define_params   ( s32 num, CodeDefineParams* codes ) { return def_define_params_arr(num, codes); }
+forceinline CodeBody         def_enum_body       ( s32 num, Code* codes )             { return def_enum_body_arr(num, codes); }
+forceinline CodeBody         def_export_body     ( s32 num, Code* codes)              { return def_export_body_arr(num, codes); }
+forceinline CodeBody         def_extern_link_body( s32 num, Code* codes )             { return def_extern_link_body_arr(num, codes); }
+forceinline CodeBody         def_function_body   ( s32 num, Code* codes )             { return def_function_body_arr(num, codes); }
+forceinline CodeBody         def_global_body     ( s32 num, Code* codes )             { return def_global_body_arr(num, codes); }
+forceinline CodeBody         def_namespace_body  ( s32 num, Code* codes )             { return def_namespace_body_arr(num, codes); }
+forceinline CodeParams       def_params          ( s32 num, CodeParams* params )      { return def_params_arr(num, params); }
+forceinline CodeSpecifiers   def_specifiers      ( s32 num, Specifier* specs )        { return def_specifiers_arr(num, specs); }
+forceinline CodeBody         def_struct_body     ( s32 num, Code* codes )             { return def_struct_body_arr(num, codes); }
+forceinline CodeBody         def_union_body      ( s32 num, Code* codes )             { return def_union_body_arr(num, codes); }
+#endif
 
 #pragma endregion Upfront
 
 #pragma region Parsing
 
-// 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 +356,41 @@ 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       );
-CodeConstructor parse_constructor  ( StrC constructor_def );
-CodeDestructor  parse_destructor   ( StrC destructor_def  );
-CodeEnum        parse_enum         ( StrC enum_def        );
-CodeBody        parse_export_body  ( StrC export_def      );
-CodeExtern      parse_extern_link  ( StrC exten_link_def  );
-CodeFriend      parse_friend       ( StrC friend_def      );
-CodeFn          parse_function     ( StrC fn_def          );
-CodeBody        parse_global_body  ( StrC body_def        );
-CodeNS          parse_namespace    ( StrC namespace_def   );
-CodeOperator    parse_operator     ( StrC operator_def    );
-CodeOpCast      parse_operator_cast( StrC operator_def    );
-CodeStruct      parse_struct       ( StrC struct_def      );
-CodeTemplate    parse_template     ( StrC template_def    );
-CodeTypename    parse_type         ( StrC type_def        );
-CodeTypedef     parse_typedef      ( StrC typedef_def     );
-CodeUnion       parse_union        ( StrC union_def       );
-CodeUsing       parse_using        ( StrC using_def       );
-CodeVar         parse_variable     ( StrC var_def         );
+GEN_API CodeClass       parse_class        ( Str class_def       );
+GEN_API CodeConstructor parse_constructor  ( Str constructor_def );
+GEN_API CodeDefine      parse_define       ( Str define_def      );
+GEN_API CodeDestructor  parse_destructor   ( Str destructor_def  );
+GEN_API CodeEnum        parse_enum         ( Str enum_def        );
+GEN_API CodeBody        parse_export_body  ( Str export_def      );
+GEN_API CodeExtern      parse_extern_link  ( Str exten_link_def  );
+GEN_API CodeFriend      parse_friend       ( Str friend_def      );
+GEN_API CodeFn          parse_function     ( Str fn_def          );
+GEN_API CodeBody        parse_global_body  ( Str body_def        );
+GEN_API CodeNS          parse_namespace    ( Str namespace_def   );
+GEN_API CodeOperator    parse_operator     ( Str operator_def    );
+GEN_API CodeOpCast      parse_operator_cast( Str operator_def    );
+GEN_API CodeStruct      parse_struct       ( Str struct_def      );
+GEN_API CodeTemplate    parse_template     ( Str template_def    );
+GEN_API CodeTypename    parse_type         ( Str type_def        );
+GEN_API CodeTypedef     parse_typedef      ( Str typedef_def     );
+GEN_API CodeUnion       parse_union        ( Str union_def       );
+GEN_API CodeUsing       parse_using        ( Str using_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);
-Code untyped_fmt      ( char const* fmt, ... );
-Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
+GEN_API Code untyped_str( Str content);
+GEN_API Code untyped_fmt      ( char const* fmt, ... );
+GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
 
 #pragma endregion Untyped text
 
@@ -289,12 +403,20 @@ 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_) }
+#	if GEN_COMPILER_C
+#		define name( Id_ ) (Str){ stringize(Id_), sizeof(stringize( Id_ )) - 1 }
+#	else
+#		define name( Id_ )  Str { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
+#	endif
 #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__ ) }
+#	if GEN_COMPILER_C
+#		define code( ... ) (Str){ stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
+#	else
+#		define code( ... )  Str { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
+#	endif
 #endif
 
 #ifndef args
@@ -317,21 +439,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,
-		"name", strc_for_name,
+		"type", str_for_type,
+		"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
-	,	"name", strc_for_name
+		"type", str_for_type
+	,	"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( currtok.Text );
 
 		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) );
-				parser_pop(& Context);
+				log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
+				parser_pop(& _ctx->parser);
 				return InvalidCode;
 		}
 
@@ -75,18 +73,32 @@ CodeConstructor parse_constructor( StrC def )
 
 	if ( NumSpecifiers )
 	{
-		specifiers = def_specifiers( NumSpecifiers, specs_found );
+		specifiers = def_specifiers_arr( NumSpecifiers, specs_found );
 		// <specifiers> ...
 	}
 
-	Context.Tokens         = toks;
+	_ctx->parser.Tokens         = toks;
 	CodeConstructor result = parser_parse_constructor( specifiers );
 	return result;
 }
 
-CodeDestructor parse_destructor( StrC def )
+CodeDefine parse_define( Str def )
+{
+	check_parse_args( def );
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	_ctx->parser.Tokens = toks;
+	push_scope();
+	CodeDefine result = parser_parse_define();
+	parser_pop(& _ctx->parser);
+	return result;
+}
+
+CodeDestructor parse_destructor( Str def )
 {
-	GEN_USING_NS_PARSER;
 	check_parse_args( def );
 
 	TokArray toks = lex( def );
@@ -96,225 +108,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,24 +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
-	TokenMap_FixedArena tok_map_arena;
-	fixed_arena_init( & tok_map_arena);
-
-	local_persist
-	StringTable tok_map;
+	if (_ctx->token_fmt_map.Hashes == nullptr) {
+		_ctx->token_fmt_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers );
+	}
+	// Populate token pairs
 	{
-		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) );
-			hashtable_set( tok_map, key, value );
+			u32 key = crc32( token, c_str_len(token) );
+			hashtable_set( _ctx->token_fmt_map, key, value );
 		}
 	}
 
@@ -60,8 +56,8 @@ 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 );
+			u32      key   = crc32( token, tok_len );
+			Str*     value = hashtable_get(_ctx->token_fmt_map, key );
 
 			if ( value )
 			{
@@ -90,16 +86,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);
-
+	hashtable_clear(_ctx->token_fmt_map);
 	ssize result = buf_size - remaining;
-
 	return result;
 }
 
-Code untyped_str( StrC content )
+Code untyped_str( Str content )
 {
 	if ( content.Len == 0 )
 	{
@@ -109,7 +101,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 +127,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);
-
-	StrC buf_str      = { str_len_capped(fmt, MaxNameLength), fmt };
-    StrC uncapped_str = { length, buf };
+    Str content = { buf, length };
 
 	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 +161,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/parser_case_macros.cpp

@@ -0,0 +1,112 @@
+// These macros are used in the swtich cases within parser.cpp
+
+#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
+case Tok_Spec_Consteval:   \
+case Tok_Spec_Constexpr:   \
+case Tok_Spec_Constinit:   \
+case Tok_Spec_Explicit:    \
+case Tok_Spec_ForceInline: \
+case Tok_Spec_Inline:      \
+case Tok_Spec_Mutable:     \
+case Tok_Spec_NeverInline: \
+case Tok_Spec_Static:      \
+case Tok_Spec_Volatile:    \
+case Tok_Spec_Virtual
+
+#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_SPECIFIER_CASES \
+case Spec_Constexpr:   \
+case Spec_Constinit:   \
+case Spec_Explicit:    \
+case Spec_Inline:      \
+case Spec_ForceInline: \
+case Spec_Mutable:     \
+case Spec_NeverInline: \
+case Spec_Static:      \
+case Spec_Volatile:    \
+case Spec_Virtual
+
+#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
+case Tok_Spec_Consteval:        \
+case Tok_Spec_Constexpr:        \
+case Tok_Spec_Constinit:        \
+case Tok_Spec_Extern:           \
+case Tok_Spec_ForceInline:      \
+case Tok_Spec_Global:           \
+case Tok_Spec_Inline:           \
+case Tok_Spec_Internal_Linkage: \
+case Tok_Spec_NeverInline:      \
+case Tok_Spec_Static
+
+#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \
+case Spec_Constexpr:        \
+case Spec_Constinit:        \
+case Spec_ForceInline:      \
+case Spec_Global:           \
+case Spec_External_Linkage: \
+case Spec_Internal_Linkage: \
+case Spec_Inline:           \
+case Spec_Mutable:          \
+case Spec_NeverInline:      \
+case Spec_Static:           \
+case Spec_Volatile
+
+#define GEN_PARSER_FRIEND_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:       \
+case Spec_Inline:      \
+case Spec_ForceInline
+
+#define GEN_PARSER_FUNCTION_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:            \
+case Spec_Consteval:        \
+case Spec_Constexpr:        \
+case Spec_External_Linkage: \
+case Spec_Internal_Linkage: \
+case Spec_ForceInline:      \
+case Spec_Inline:           \
+case Spec_NeverInline:      \
+case Spec_Static
+
+#define GEN_PARSER_OPERATOR_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:       \
+case Spec_Constexpr:   \
+case Spec_ForceInline: \
+case Spec_Inline:      \
+case Spec_NeverInline: \
+case Spec_Static
+
+#define GEN_PARSER_TEMPLATE_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:            \
+case Spec_Constexpr:        \
+case Spec_Constinit:        \
+case Spec_External_Linkage: \
+case Spec_Global:           \
+case Spec_Inline:           \
+case Spec_ForceInline:      \
+case Spec_Local_Persist:    \
+case Spec_Mutable:          \
+case Spec_Static:           \
+case Spec_Thread_Local:     \
+case Spec_Volatile
+
+#define GEN_PARSER_VARIABLE_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:            \
+case Spec_Constexpr:        \
+case Spec_Constinit:        \
+case Spec_External_Linkage: \
+case Spec_Global:           \
+case Spec_Inline:           \
+case Spec_Local_Persist:    \
+case Spec_Mutable:          \
+case Spec_Restrict:         \
+case Spec_Static:           \
+case Spec_Thread_Local:     \
+case Spec_Volatile
+
+#define GEN_PARSER_TYPENAME_ALLOWED_SUFFIX_SPECIFIER_CASES \
+case Spec_Const:    \
+case Spec_Ptr:      \
+case Spec_Restrict: \
+case Spec_Ref:      \
+case Spec_RValue
+
+

base/components/parser_types.hpp

@@ -0,0 +1,216 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "types.hpp"
+#include "gen/ecode.hpp"
+#include "gen/eoperator.hpp"
+#include "gen/especifier.hpp"
+#include "gen/etoktype.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_Macro_Functional      = bit(13),
+	TF_Macro_Expects_Body    = bit(14),
+
+	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
+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_set( u32, tok.Flags, TF_AccessOperator );
+}
+
+forceinline
+bool tok_is_access_specifier(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_AccessSpecifier );
+}
+
+forceinline
+bool tok_is_attribute(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_Attribute );
+}
+
+forceinline
+bool tok_is_operator(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_Operator );
+}
+
+forceinline
+bool tok_is_preprocessor(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_Preprocess );
+}
+
+forceinline
+bool tok_is_preprocess_cond(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_Preprocess_Cond );
+}
+
+forceinline
+bool tok_is_specifier(Token tok) {
+	return bitfield_is_set( u32, tok.Flags, TF_Specifier );
+}
+
+forceinline
+bool tok_is_end_definition(Token tok) {
+	return bitfield_is_set( 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;
+};
+
+enum MacroType : u16
+{
+	MT_Expression,     // A macro is assumed to be a expression if not resolved.
+	MT_Statement,      
+	MT_Typename,
+	MT_Block_Start,    // Not Supported yet
+	MT_Block_End,      // Not Supported yet
+	MT_Case_Statement, // Not Supported yet
+
+	MT_UnderlyingType = GEN_U16_MAX,
+};
+
+forceinline
+TokType macrotype_to_toktype( MacroType type ) {
+	switch ( type ) {
+		case MT_Statement  : return Tok_Preprocess_Macro_Stmt;
+		case MT_Expression : return Tok_Preprocess_Macro_Expr;
+		case MT_Typename   : return Tok_Preprocess_Macro_Typename;
+	}
+	// All others unsupported for now.
+	return Tok_Invalid;
+}
+
+inline
+Str macrotype_to_str( MacroType type )
+{
+	local_persist
+	Str lookup[] = {
+		{ "Statement",        sizeof("Statement")        - 1 },
+		{ "Expression",       sizeof("Expression")       - 1 },
+		{ "Typename",         sizeof("Typename")         - 1 },
+		{ "Block_Start",      sizeof("Block_Start")      - 1 },
+		{ "Block_End",        sizeof("Block_End")        - 1 },
+		{ "Case_Statement",   sizeof("Case_Statement")   - 1 },
+	};
+	local_persist
+	Str invalid = { "Invalid", sizeof("Invalid") };
+	if ( type > MT_Case_Statement )
+		return invalid;
+
+	return lookup[ type ];
+}
+
+enum EMacroFlags : u16
+{
+	MF_Functional          = bit(0), // Macro has parameters (args expected to be passed)
+	MF_Expects_Body        = bit(1), // Expects to assign a braced scope to its body.
+
+	// lex__eat wil treat this macro as an identifier if the parser attempts to consume it as one.
+	//  ^^^ This is a kludge because we don't support push/pop macro pragmas rn.
+	MF_Allow_As_Identifier = bit(2), 
+
+	// lex__eat wil treat this macro as an attribute if the parser attempts to consume it as one.
+	//  ^^^ This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc)
+	// TODO(Ed): We can keep the MF_Allow_As_Attribute flag for macros, however, we need to add the ability of AST_Attributes to chain themselves.
+	// Its thats already a thing in the standard language anyway
+	// & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/varaible definition
+	MF_Allow_As_Attribute  = bit(3),
+
+	// When a macro is encountered after attributs and specifiers while parsing a function, or variable:
+	// It will consume the macro and treat it as resolving the definition. (Yes this is for Unreal Engine)
+	// (MUST BE OF MT_Statement TYPE)
+	MF_Allow_As_Definition = bit(4),
+
+	MF_Null           = 0,
+	MF_UnderlyingType = GEN_U16_MAX,
+};
+typedef u16 MacroFlags;
+
+struct Macro
+{
+	StrCached  Name;
+	MacroType  Type;
+	MacroFlags Flags;
+};
+
+forceinline
+b32 macro_is_functional( Macro macro ) {
+	return bitfield_is_set( b16, macro.Flags, MF_Functional );
+}
+
+forceinline
+b32 macro_expects_body( Macro macro ) {
+	return bitfield_is_set( b16, macro.Flags, MF_Expects_Body );
+}
+
+#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
+forceinline b32 is_functional( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Functional ); }
+forceinline b32 expects_body ( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Expects_Body ); }
+#endif
+
+typedef HashTable(Macro) MacroTable;

base/components/static_data.cpp

@@ -4,31 +4,14 @@
 #endif
 
 #pragma region StaticData
-
-// 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
+global Context* _ctx;
+global u32      context_counter;
 
 #pragma region Constants
+global Macro enum_underlying_macro;
 
-global StrC enum_underlying_sig;
+global Code Code_Global;
+global Code Code_Invalid;
 
 global Code access_public;
 global Code access_protected;
@@ -84,8 +67,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 +88,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 ] = {
-		{ sizeof("") - 1,          "" },
-		{ sizeof("prviate") - 1,   "private" },
-		{ sizeof("protected") - 1, "private" },
-		{ sizeof("public") - 1,    "public" },
+	Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
+		{ "",        sizeof( "" )        - 1 },
+		{ "private", sizeof("prviate")   - 1 },
+		{ "private", sizeof("protected") - 1 },
+		{ "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 ] = {
-		{ sizeof("__none__"), "__none__" },
-		{ sizeof("export"), "export" },
-		{ sizeof("import"), "import" },
+	Str lookup[ (u32)Num_ModuleFlags ] = {
+		{ "__none__", sizeof("__none__") - 1 },
+		{ "export",   sizeof("export")   - 1 },
+		{ "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, 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_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> 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         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         set_capacity(Array<Type>& array, usize new_capacity)                  { return set_capacity( & array, new_capacity); }
+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* 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* 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> 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 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> forceinline Type* begin(Array<Type>& array)             { return array;      }
 template<class Type> forceinline Type* end(Array<Type>& array)               { return array + array_get_header(array)->Num; }
@@ -143,13 +143,14 @@ Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity)
 	return {rcast(Type*, header + 1)};
 }
 
+forceinline
 usize array_grow_formula(ssize value) {
 	return 2 * value + 8;
 }
 
 template<class Type> inline
 bool array_append_array(Array<Type>* array, Array<Type> other) {
-	return array_append_items(array, (Type*)other, num(other));
+	return array_append_items(array, (Type*)other, array_num(other));
 }
 
 template<class Type> inline
@@ -179,13 +180,13 @@ bool array_append_items(Array<Type>* array, Type* items, usize item_num)
 	GEN_ASSERT(* array != nullptr);
 	GEN_ASSERT(items != nullptr);
 	GEN_ASSERT(item_num > 0);
-	ArrayHeader* header = array_get_header(array);
+	ArrayHeader* header = array_get_header(* array);
 
 	if (header->Num + item_num > header->Capacity)
 	{
-		if ( ! grow(array, header->Capacity + item_num))
+		if ( ! array_grow(array, header->Capacity + item_num))
 			return false;
-		header = array_get_header(array);
+		header = array_get_header(* array);
 	}
 
 	mem_copy((Type*)array + header->Num, items, item_num * sizeof(Type));
@@ -202,7 +203,7 @@ bool array_append_at(Array<Type>* array, Type item, usize idx)
 	ArrayHeader* header = array_get_header(* array);
 
 	ssize slot = idx;
-	if (slot >= header->Num)
+	if (slot >= (ssize)(header->Num))
 		slot = header->Num - 1;
 
 	if (slot < 0)
@@ -281,10 +282,9 @@ bool array_fill(Array<Type> array, usize begin, usize end, Type value)
 	ArrayHeader* header = array_get_header(array);
 
 	if (begin < 0 || end > header->Num)
-	return false;
+		return false;
 
-	for (ssize idx = ssize(begin); idx < ssize(end); idx++)
-	{
+	for (ssize idx = ssize(begin); idx < ssize(end); idx++) {
 		array[idx] = value;
 	}
 
@@ -354,7 +354,6 @@ bool array_reserve(Array<Type>* array, usize new_capacity)
 {
 	GEN_ASSERT(  array != nullptr);
 	GEN_ASSERT(* array != nullptr);
-	GEN_ASSERT(num > 0)
 	ArrayHeader* header = array_get_header(array);
 
 	if (header->Capacity < new_capacity)
@@ -754,7 +753,7 @@ HashTableFindResult hashtable__find(HashTable<Type> table, u64 key)
 			if (table.Entries[result.EntryIndex].Key == key)
 				break;
 
-			result.PrevIndex = result.EntryIndex;
+			result.PrevIndex  = result.EntryIndex;
 			result.EntryIndex = table.Entries[result.EntryIndex].Next;
 		}
 	}
@@ -763,7 +762,7 @@ HashTableFindResult hashtable__find(HashTable<Type> table, u64 key)
 }
 
 template<typename Type> forceinline
-bool hashtable_full(HashTable<Type> table) {
+b32 hashtable_full(HashTable<Type> table) {
 	GEN_ASSERT_NOT_NULL(table.Hashes);
 	GEN_ASSERT_NOT_NULL(table.Entries);
 	usize critical_load = usize(HashTable_CriticalLoadScale * f32(array_num(table.Hashes)));

base/dependencies/debug.hpp

@@ -8,16 +8,23 @@
 
 #pragma region Debug
 
-#if defined( _MSC_VER )
-#	if _MSC_VER < 1300
-#		define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
+#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 )
+#		define GEN_DEBUG_TRAP() process_exit( 1 )
 #	else
-#		define GEN_DEBUG_TRAP() __debugbreak()
+#		define GEN_DEBUG_TRAP() __builtin_trap()
 #	endif
-#elif defined( GEN_COMPILER_TINYC )
-#	define GEN_DEBUG_TRAP() process_exit( 1 )
 #else
-#	define GEN_DEBUG_TRAP() __builtin_trap()
+// #pragma message("GEN_BUILD_DEBUG: omitted")
+#	define GEN_DEBUG_TRAP()
 #endif
 
 #define GEN_ASSERT( cond ) GEN_ASSERT_MSG( cond, NULL )
@@ -37,14 +44,14 @@
 // NOTE: Things that shouldn't happen with a message!
 #define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
 
-#if Build_Debug
+#if GEN_BUILD_DEBUG
 	#define GEN_FATAL( ... )                               \
 	do                                                     \
 	{                                                      \
 		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)
@@ -53,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_DYN_EXPORT
+            #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
@@ -16,8 +34,8 @@
 #endif
 
 #ifndef bit
-#define bit( Value )                             ( 1 << Value )
-#define bitfield_is_equal( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) )
+#define bit( Value )                         ( 1 << Value )
+#define bitfield_is_set( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) )
 #endif
 
 // Mainly intended for forcing the base library to utilize only C-valid constructs or type coercion
@@ -68,8 +86,16 @@
 #define stringize( ... )    stringize_va( __VA_ARGS__ )
 #endif
 
+#define src_line_str stringize(__LINE__)
+
 #ifndef do_once
-#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
+#define do_once()                                                                            \
+	local_persist int __do_once_counter_##src_line_str  = 0;                                 \
+    for(;      __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 ) \
+
+#define do_once_defer( expression )                                                                 \
+    local_persist int __do_once_counter_##src_line_str  = 0;                                        \
+    for(;__do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1, (expression)) \
 
 #define do_once_start      \
 	do                     \
@@ -224,9 +250,9 @@
 #	if ! GEN_COMPILER_C
 #		define typeof decltype
 #	elif defined(_MSC_VER)
-#		define typeof(x) __typeof__(x)
+#		define typeof __typeof__
 #	elif defined(__GNUC__) || defined(__clang__)
-#		define typeof(x) __typeof__(x)
+#		define typeof __typeof__
 #	else
 #		error "Compiler not supported"
 #	endif

base/dependencies/memory.cpp

@@ -346,25 +346,25 @@ void* arena_allocator_proc( void* allocator_data, AllocType type, ssize size, ss
 	switch ( type )
 	{
 		case EAllocation_ALLOC :
+		{
+			void* end        = pointer_add( arena->PhysicalStart, arena->TotalUsed );
+			ssize total_size = align_forward_s64( size, alignment );
+
+			// NOTE: Out of memory
+			if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize )
 			{
-				void* end        = pointer_add( arena->PhysicalStart, arena->TotalUsed );
-				ssize total_size = align_forward_s64( size, alignment );
-
-				// NOTE: Out of memory
-				if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize )
-				{
-					// zpl__printf_err("%s", "Arena out of memory\n");
-					GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
-					return nullptr;
-				}
-
-				ptr              = align_forward( end, alignment );
-				arena->TotalUsed += total_size;
-
-				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
-					zero_size( ptr, size );
+				// zpl__printf_err("%s", "Arena out of memory\n");
+				GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
 			}
-			break;
+			
+
+			ptr              = align_forward( end, alignment );
+			arena->TotalUsed += total_size;
+
+			if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				zero_size( ptr, size );
+		}
+		break;
 
 		case EAllocation_FREE :
 			// NOTE: Free all at once

base/dependencies/memory.hpp

@@ -225,11 +225,10 @@ forceinline ssize         size_remaining(Arena& arena, ssize alignment) { return
 // This id is defined by Unreal for asserts
 #pragma push_macro("check")
 #undef check
-forceinline void check(Arena& arena) { return arena_check(& arena); };
+forceinline void check(Arena& arena) { return arena_check(& arena); }
 #pragma pop_macro("check")
 #endif
 
-
 inline
 AllocatorInfo arena_allocator_info( Arena* arena ) {
 	GEN_ASSERT(arena != nullptr);
@@ -392,9 +391,9 @@ void          pool_clear(Pool* pool);
 void          pool_free(Pool* pool);
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); }
-void          clear(Pool& pool)          { return pool_clear(& pool); }
-void          free(Pool& pool)           { return pool_free(& pool); }
+forceinline AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); }
+forceinline void          clear(Pool& pool)          { return pool_clear(& pool); }
+forceinline void          free(Pool& pool)           { return pool_free(& pool); }
 #endif
 
 struct Pool

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, '/' );
-	char* buf = str_fmt_buf( "%.*s", ( int )( e - b ), b );
+	p = e     = ( char* )c_str_skip( p, '/' );
+	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_e2 = ( char* )str_skip( l_p, ']' );
+		l_e  = ( char* )c_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;
-		while ( *base_string_off++ == '0' )
+		char* base_strbuilder_off = base_string2;
+		while ( *base_strbuilder_off++ == '0' )
 			base2_offset++;
 
-		base  = ( s32 )str_to_i64( q, 0, 0 );
-		base2 = ( s32 )str_to_i64( base_string2, 0, 0 );
+		base  = ( s32 )c_str_to_i64( q, 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);
-					info.precision = gen_str.Len;
-					len            = _print_string( text, remaining, &info, gen_str.Ptr );
+					StrBuilder gen_str = { va_arg( va, char*) };
+
+					info.precision = strbuilder_length(gen_str);
+					len            = _print_string( text, remaining, &info, gen_str );
 					break;
 				}
 
-				String gen_str = { va_arg( va, char*) };
-
-				info.precision = string_length(gen_str);
-				len            = _print_string( text, remaining, &info, gen_str );
+				Str gen_str    = va_arg( va, Str);
+				info.precision = gen_str.Len;
+				len            = _print_string( text, remaining, &info, gen_str.Ptr );
 			}
 			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*  str_fmt_buf_va    ( char const* fmt, va_list va );
-ssize  str_fmt           ( char* str, ssize n, char const* fmt, ... );
-ssize  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  str_fmt_out_err   ( char const* fmt, ... );
-ssize  str_fmt_out_err_va( char const* fmt, va_list va );
-ssize  str_fmt_file      ( FileInfo* f, char const* fmt, ... );
-ssize  str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+char*  c_str_fmt_buf       ( char const* fmt, ... );
+char*  c_str_fmt_buf_va    ( char const* fmt, va_list va );
+ssize  c_str_fmt           ( char* str, ssize n, char const* fmt, ... );
+ssize  c_str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
+ssize  c_str_fmt_out_va    ( char const* fmt, va_list va );
+ssize  c_str_fmt_out_err   ( char const* fmt, ... );
+ssize  c_str_fmt_out_err_va( char const* fmt, va_list va );
+ssize  c_str_fmt_file      ( FileInfo* f, char const* fmt, ... );
+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 _printf_err( fmt, ... )   str_fmt_out_err( fmt, __VA_ARGS__ )
-#			define _printf_err_va( fmt, va ) str_fmt_out_err_va( fmt, va )
+#			define _strlen                   c_str_len
+#			define _printf_err( fmt, ... )   c_str_fmt_out_err( fmt, __VA_ARGS__ )
+#			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         str_compare_len( const char* s1, const char* s2, ssize len );
-char*       str_copy( char* dest, const char* source, ssize len );
-ssize       str_copy_nulpad( char* dest, const char* source, ssize len );
-ssize       str_len( const char* str );
-ssize       str_len_capped( const char* str, ssize max_len );
-char*       str_reverse( char* str );    // NOTE: ASCII only
-char const* str_skip( char const* str, char c );
-char const* str_skip_any( char const* str, char const* char_list );
-char const* str_trim( char const* str, b32 catch_newline );
+s32         c_str_compare( const char* s1, const char* s2 );
+s32         c_str_compare_len( const char* s1, const char* s2, ssize len );
+char*       c_str_copy( char* dest, const char* source, ssize len );
+ssize       c_str_copy_nulpad( char* dest, const char* source, ssize len );
+ssize       c_str_len( const char* str );
+ssize       c_str_len_capped( const char* str, ssize max_len );
+char*       c_str_reverse( char* str );    // NOTE: ASCII only
+char const* c_str_skip( char const* str, char c );
+char const* c_str_skip_any( char const* str, char const* char_list );
+char const* c_str_trim( char const* str, b32 catch_newline );
 
 // NOTE: ASCII only
-void str_to_lower( char* str );
-void str_to_upper( char* str );
+void c_str_to_lower( 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 ) ));
-	ssize       char_list_count = str_len( char_list );
+	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), c_str_len( str ) ));
+	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*
-	header = rcast(StringHeader*, allocation);
+	StrBuilderHeader*
+	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*
-	header            = rcast(StringHeader*, allocation);
+	StrBuilderHeader*
+	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);
-bool        strc_are_equal           (StrC lhs, StrC rhs);
-char const* strc_back                (StrC str);
-bool        strc_contains            (StrC str, StrC substring);
-StrC        strc_duplicate           (StrC str, AllocatorInfo allocator);
-b32         strc_starts_with         (StrC str, StrC substring);
-StrC        strc_visualize_whitespace(StrC str, AllocatorInfo allocator);
+Str         to_str_from_c_str       (char const* bad_string);
+bool        str_are_equal           (Str lhs, Str rhs);
+char const* str_back                (Str str);
+bool        str_contains            (Str str, Str substring);
+Str         str_duplicate           (Str str, AllocatorInfo allocator);
+b32         str_starts_with         (Str str, Str substring);
+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 char const* back                ()                        const { return strc_back(* this); }
-	forceinline bool        contains            (StrC substring)          const { return strc_contains(* this, substring); }
-	forceinline StrC        duplicate           (AllocatorInfo allocator) const { return strc_duplicate(* this, allocator); }
-	forceinline b32         starts_with         (StrC substring)          const { return strc_starts_with(* this, substring); }
-	forceinline StrC        visualize_whitespace(AllocatorInfo allocator) const { return strc_visualize_whitespace(* this, allocator); }
+	forceinline bool        is_equal            (Str rhs)                 const { return str_are_equal(* this, rhs); }
+	forceinline char const* back                ()                        const { return str_back(* this); }
+	forceinline bool        contains            (Str substring)           const { return str_contains(* this, substring); }
+	forceinline Str         duplicate           (AllocatorInfo allocator) const { return str_duplicate(* this, allocator); }
+	forceinline b32         starts_with         (Str substring)           const { return str_starts_with(* this, substring); }
+	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 )          GEN_NS Str { ( text ), sizeof( text ) - 1 }
 #	else
-#		define txt( text )         (StrC){ sizeof( text ) - 1, ( text ) }
+#		define txt( text )         (GEN_NS Str){ ( text ), sizeof( text ) - 1 }
 #	endif
 #endif
 
 GEN_API_C_BEGIN
-forceinline char const* strc_begin(StrC str)                   { return str.Ptr; }
-forceinline char const* strc_end  (StrC str)                   { return str.Ptr + str.Len; }
-forceinline char const* strc_next (StrC str, char const* iter) { return iter + 1; }
+forceinline char const* str_begin(Str str)                   { return str.Ptr; }
+forceinline char const* str_end  (Str str)                   { return str.Ptr + str.Len; }
+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* end  (StrC str)                   { return str.Ptr + str.Len; }
-forceinline char const* next (StrC str, char const* iter) { return iter + 1; }
+forceinline char const* begin(Str str)                   { return str.Ptr; }
+forceinline char const* end  (Str str)                   { return str.Ptr + str.Len; }
+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 ) {
-	StrC result = { str_len( bad_str ), bad_str };
+Str to_str_from_c_str( char const* 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
-struct StringHeader;
+#pragma region StrBuilder
+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);
-String        string_make_strc           (AllocatorInfo allocator, StrC         str);
-String        string_make_reserve        (AllocatorInfo allocator, ssize        capacity);
-String        string_make_length         (AllocatorInfo allocator, char const*  str,   ssize length);
-String        string_fmt                 (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
-String        string_fmt_buf             (AllocatorInfo allocator, char const*  fmt, ...);
-String        string_join                (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
-bool          string_are_equal           (String const lhs, String const rhs);
-bool          string_are_equal_strc      (String const lhs, StrC rhs);
-bool          string_make_space_for      (String*      str, char const*  to_append, ssize add_len);
-bool          string_append_char         (String*      str, char         c);
-bool          string_append_c_str        (String*      str, char const*  str_to_append);
-bool          string_append_c_str_len    (String*      str, char const*  str_to_append, ssize length);
-bool          string_append_strc         (String*      str, StrC         str_to_append);
-bool          string_append_string       (String*      str, String const other);
-bool          string_append_fmt          (String*      str, char const*  fmt, ...);
-ssize         string_avail_space         (String const str);
-char*         string_back                (String       str);
-bool          string_contains_strc       (String const str, StrC         substring);
-bool          string_contains_string     (String const str, String const substring);
-ssize         string_capacity            (String const str);
-void          string_clear               (String       str);
-String        string_duplicate           (String const str, AllocatorInfo allocator);
-void          string_free                (String*      str);
-StringHeader* string_get_header          (String       str);
-ssize         string_length              (String const str);
-b32           string_starts_with_strc    (String const str, StrC   substring);
-b32           string_starts_with_string  (String const str, String substring);
-void          string_skip_line           (String       str);
-void          string_strip_space         (String       str);
-StrC          string_to_strc             (String       str);
-void          string_trim                (String       str, char const* cut_set);
-void          string_trim_space          (String       str);
-String        string_visualize_whitespace(String const str);
+StrBuilder        strbuilder_make_c_str          (AllocatorInfo allocator, char const*  str);
+StrBuilder        strbuilder_make_str            (AllocatorInfo allocator, Str         str);
+StrBuilder        strbuilder_make_reserve        (AllocatorInfo allocator, ssize        capacity);
+StrBuilder        strbuilder_make_length         (AllocatorInfo allocator, char const*  str,   ssize length);
+StrBuilder        strbuilder_fmt                 (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
+StrBuilder        strbuilder_fmt_buf             (AllocatorInfo allocator, char const*  fmt, ...);
+StrBuilder        strbuilder_join                (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
+bool              strbuilder_are_equal           (StrBuilder const lhs, StrBuilder const rhs);
+bool              strbuilder_are_equal_str       (StrBuilder const lhs, Str rhs);
+bool              strbuilder_make_space_for      (StrBuilder*      str, char const*  to_append, ssize add_len);
+bool              strbuilder_append_char         (StrBuilder*      str, char         c);
+bool              strbuilder_append_c_str        (StrBuilder*      str, char const*  c_str_to_append);
+bool              strbuilder_append_c_str_len    (StrBuilder*      str, char const*  c_str_to_append, ssize length);
+bool              strbuilder_append_str          (StrBuilder*      str, Str         c_str_to_append);
+bool              strbuilder_append_string       (StrBuilder*      str, StrBuilder const other);
+bool              strbuilder_append_fmt          (StrBuilder*      str, char const*  fmt, ...);
+ssize             strbuilder_avail_space         (StrBuilder const str);
+char*             strbuilder_back                (StrBuilder       str);
+bool              strbuilder_contains_str        (StrBuilder const str, Str         substring);
+bool              strbuilder_contains_string     (StrBuilder const str, StrBuilder const substring);
+ssize             strbuilder_capacity            (StrBuilder const str);
+void              strbuilder_clear               (StrBuilder       str);
+StrBuilder        strbuilder_duplicate           (StrBuilder const str, AllocatorInfo allocator);
+void              strbuilder_free                (StrBuilder*      str);
+StrBuilderHeader* strbuilder_get_header          (StrBuilder       str);
+ssize             strbuilder_length              (StrBuilder const str);
+b32               strbuilder_starts_with_str     (StrBuilder const str, Str   substring);
+b32               strbuilder_starts_with_string  (StrBuilder const str, StrBuilder substring);
+void              strbuilder_skip_line           (StrBuilder       str);
+void              strbuilder_strip_space         (StrBuilder       str);
+Str               strbuilder_to_str              (StrBuilder       str);
+void              strbuilder_trim                (StrBuilder       str, char const* cut_set);
+void              strbuilder_trim_space          (StrBuilder       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; }
-	friend forceinline bool operator==(std::nullptr_t, const String str) { return str.Data == nullptr; }
-	friend forceinline bool operator!=(std::nullptr_t, const String str) { return str.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 StrBuilder 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 String make(AllocatorInfo allocator, StrC str)                       { return string_make_strc(allocator, str); }
-	forceinline static String make_reserve(AllocatorInfo allocator, ssize cap)              { return string_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 String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return string_join(a, p, n, g); }
-	forceinline static usize  grow_formula(usize value)                                     { return string_grow_formula(value); }
+	forceinline static StrBuilder make(AllocatorInfo allocator, char const* str)                { return strbuilder_make_c_str(allocator, str); }
+	forceinline static StrBuilder make(AllocatorInfo allocator, Str str)                        { return strbuilder_make_str(allocator, str); }
+	forceinline static StrBuilder make_reserve(AllocatorInfo allocator, ssize cap)              { return strbuilder_make_reserve(allocator, cap); }
+	forceinline static StrBuilder make_length(AllocatorInfo a, char const* s, ssize l)          { return strbuilder_make_length(a, s, l); }
+	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 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          append(char c)                                 { return string_append_char(this, c); }
-	forceinline bool          append(char const* str)                        { return string_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(StrC str)                               { return string_append_strc(this, str); }
-	forceinline bool          append(const String other)                     { return string_append_string(this, other); }
-	forceinline ssize         avail_space() const                            { return string_avail_space(* this); }
-	forceinline char*         back()                                         { return string_back(* this); }
-	forceinline bool          contains(StrC substring) const                 { return string_contains_strc(* this, substring); }
-	forceinline bool          contains(String const& substring) const        { return string_contains_string(* this, substring); }
-	forceinline ssize         capacity() const                               { return string_capacity(* this); }
-	forceinline void          clear()                                        {        string_clear(* this); }
-	forceinline String        duplicate(AllocatorInfo allocator) const       { return string_duplicate(* this, allocator); }
-	forceinline void          free()                                         {        string_free(this); }
-	forceinline bool          is_equal(String const& other) const            { return string_are_equal(* this, other); }
-	forceinline bool          is_equal(StrC other) const                     { return string_are_equal_strc(* this, other); }
-	forceinline ssize         length() const                                 { return string_length(* this); }
-	forceinline b32           starts_with(StrC substring) const              { return string_starts_with_strc(* this, substring); }
-	forceinline b32           starts_with(String substring) const            { return string_starts_with_string(* this, substring); }
-	forceinline void          skip_line()                                    {        string_skip_line(* this); }
-	forceinline void          strip_space()                                  {        string_strip_space(* this); }
-	forceinline StrC          to_strc()                                      { return { string_length(*this), Data}; }
-	forceinline void          trim(char const* cut_set)                      {        string_trim(* this, cut_set); }
-	forceinline void          trim_space()                                   {        string_trim_space(* this); }
-	forceinline String        visualize_whitespace() const                   { return string_visualize_whitespace(* this); }
-	forceinline StringHeader& get_header()                                   { return * string_get_header(* this); }
+	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 strbuilder_append_char(this, c); }
+	forceinline bool              append(char const* str)                        { return strbuilder_append_c_str(this, str); }
+	forceinline bool              append(char const* str, ssize length)          { return strbuilder_append_c_str_len(this, str, length); }
+	forceinline bool              append(Str str)                                { return strbuilder_append_str(this, str); }
+	forceinline bool              append(const StrBuilder other)                 { return strbuilder_append_string(this, other); }
+	forceinline ssize             avail_space() const                            { return strbuilder_avail_space(* this); }
+	forceinline char*             back()                                         { return strbuilder_back(* this); }
+	forceinline bool              contains(Str substring) const                  { return strbuilder_contains_str(* this, substring); }
+	forceinline bool              contains(StrBuilder const& substring) const    { return strbuilder_contains_string(* this, substring); }
+	forceinline ssize             capacity() const                               { return strbuilder_capacity(* this); }
+	forceinline void              clear()                                        {        strbuilder_clear(* this); }
+	forceinline StrBuilder        duplicate(AllocatorInfo allocator) const       { return strbuilder_duplicate(* this, allocator); }
+	forceinline void              free()                                         {        strbuilder_free(this); }
+	forceinline bool              is_equal(StrBuilder const& other) const        { return strbuilder_are_equal(* this, other); }
+	forceinline bool              is_equal(Str other) const                      { return strbuilder_are_equal_str(* this, other); }
+	forceinline ssize             length() const                                 { return strbuilder_length(* this); }
+	forceinline b32               starts_with(Str substring) const               { return strbuilder_starts_with_str(* this, substring); }
+	forceinline b32               starts_with(StrBuilder substring) const        { return strbuilder_starts_with_string(* this, substring); }
+	forceinline void              skip_line()                                    {        strbuilder_skip_line(* this); }
+	forceinline void              strip_space()                                  {        strbuilder_strip_space(* this); }
+	forceinline Str               to_str()                                       { return { Data, strbuilder_length(*this) }; }
+	forceinline void              trim(char const* cut_set)                      {        strbuilder_trim(* this, cut_set); }
+	forceinline void              trim_space()                                   {        strbuilder_trim_space(* this); }
+	forceinline StrBuilder        visualize_whitespace() const                   { return strbuilder_visualize_whitespace(* this); }
+	forceinline StrBuilderHeader& get_header()                                   { return * strbuilder_get_header(* this); }
 
 	bool append_fmt(char const* fmt, ...) {
 		ssize res;
@@ -255,163 +255,164 @@ 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* string_end  (String str)                   { return ((char*) str + string_length(str)); }
-forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); }
+forceinline char* strbuilder_begin(StrBuilder str)                   { return ((char*) str); }
+forceinline char* strbuilder_end  (StrBuilder str)                   { return ((char*) str + strbuilder_length(str)); }
+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* end  (String str)             { return ((char*) str + string_length(str)); }
-forceinline char* next (String str, char* iter) { return ((char*) iter + 1); }
+forceinline char* begin(StrBuilder str)             { return ((char*) str); }
+forceinline char* end  (StrBuilder str)             { return ((char*) str + strbuilder_length(str)); }
+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  append(String& str, char c);
-forceinline bool  append(String& str, char const* str_to_append);
-forceinline bool  append(String& str, char const* str_to_append, ssize length);
-forceinline bool  append(String& str, StrC str_to_append);
-forceinline bool  append(String& str, const String other);
-forceinline bool  append_fmt(String& str, char const* fmt, ...);
-forceinline char& back(String& str);
-forceinline void  clear(String& str);
-forceinline void  free(String& str);
+forceinline bool  make_space_for(StrBuilder& str, char const* to_append, ssize add_len);
+forceinline bool  append(StrBuilder& str, char c);
+forceinline bool  append(StrBuilder& str, char const* c_str_to_append);
+forceinline bool  append(StrBuilder& str, char const* c_str_to_append, ssize length);
+forceinline bool  append(StrBuilder& str, Str c_str_to_append);
+forceinline bool  append(StrBuilder& str, const StrBuilder other);
+forceinline bool  append_fmt(StrBuilder& str, char const* fmt, ...);
+forceinline char& back(StrBuilder& str);
+forceinline void  clear(StrBuilder& 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) {
-	ssize length = str ? str_len(str) : 0;
-	return string_make_length(allocator, str, length);
+StrBuilder strbuilder_make_c_str(AllocatorInfo allocator, char const* str) {
+	ssize length = str ? c_str_len(str) : 0;
+	return strbuilder_make_length(allocator, str, length);
 }
 
 forceinline
-String string_make_strc(AllocatorInfo allocator, StrC str) {
-	return string_make_length(allocator, str.Ptr, str.Len);
+StrBuilder strbuilder_make_str(AllocatorInfo allocator, Str str) {
+	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, ...) {
+inline
+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 +420,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 +433,20 @@ bool string_are_equal_strc(String const lhs, StrC rhs)
 }
 
 forceinline
-ssize string_avail_space(String const str) {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+ssize strbuilder_avail_space(StrBuilder const str) {
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 	return header->Capacity - header->Length;
 }
 
 forceinline
-char* string_back(String str) {
-	return & (str)[string_length(str) - 1];
+char* strbuilder_back(StrBuilder str) {
+	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 +456,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 +464,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 +484,47 @@ bool string_contains_string(String const str, String const substring)
 }
 
 forceinline
-ssize string_capacity(String const str) {
-	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+ssize strbuilder_capacity(StrBuilder const str) {
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
 	return header->Capacity;
 }
 
 forceinline
-void string_clear(String str) {
-	string_get_header(str)->Length = 0;
+void strbuilder_clear(StrBuilder str) {
+	strbuilder_get_header(str)->Length = 0;
 }
 
 forceinline
-String string_duplicate(String const str, AllocatorInfo allocator) {
-	return string_make_length(allocator, str, string_length(str));
+StrBuilder strbuilder_duplicate(StrBuilder const str, AllocatorInfo allocator) {
+	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) {
-	return (StringHeader*)(scast(char*, str) - sizeof(StringHeader));
+StrBuilderHeader* strbuilder_get_header(StrBuilder str) {
+	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 +535,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;
-		StringHeader* header    = nullptr;
+		AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator;
+		StrBuilderHeader* header    = nullptr;
 
-		new_len  = string_grow_formula(string_length(* str) + add_len);
-		ptr      = string_get_header(* str);
-		old_size = size_of(StringHeader) + string_length(* str) + 1;
-		new_size = size_of(StringHeader) + new_len + 1;
+		new_len  = strbuilder_grow_formula(strbuilder_length(* str) + add_len);
+		ptr      = strbuilder_get_header(* str);
+		old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 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 +560,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) {
-	if (substring.Len > string_length(str))
+b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) {
+	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) {
-	if (string_length(substring) > string_length(str))
+b32 strbuilder_starts_with_string(StrBuilder const str, StrBuilder substring) {
+	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 +594,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 strbuilder_strip_space(StrBuilder str)
 {
 	char* write_pos = str;
 	char* read_pos  = str;
@@ -616,22 +617,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) {
-	StrC result = { string_length(str), (char const*)str };
+Str strbuilder_to_str(StrBuilder 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 +647,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) {
-	string_trim(str, " \t\r\n\v\f");
+void strbuilder_trim_space(StrBuilder str) {
+	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));
-	String        result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements.
+	StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader));
+	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) {
-	StrC result = string_to_strc( string_make_length(allocator, str.Ptr, str.Len));
+Str str_duplicate(Str str, AllocatorInfo allocator) {
+	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.
-	for (char const* c = strc_begin(str); c != strc_end(str); c = strc_next(str, c))
+	StrBuilder result = strbuilder_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
+	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
-API_Import, GEN_API_Import_Code
+GEN_API,    GEN_API

base/enums/ECodeTypes.csv

@@ -37,6 +37,7 @@ Operator_Member_Fwd, "operator"
 Operator_Cast,       "operator"
 Operator_Cast_Fwd,   "operator"
 Parameters,          "__NA__"
+Parameters_Define,   "__NA__"
 Preprocess_Define,   "define"
 Preprocess_Include,  "include"
 Preprocess_If,       "if"

base/enums/ESpecifier.csv

@@ -14,6 +14,7 @@ NeverInline,      neverinline
 Ptr,              *
 Ref,              &
 Register,         register
+Restrict,         restrict
 RValue,           &&
 Static,           static
 Thread_Local,     thread_local

base/enums/ETokType.csv

@@ -1,95 +1,99 @@
-Invalid,                "__invalid__"
-Access_Private,         "private"
-Access_Protected,       "protected"
-Access_Public,          "public"
-Access_MemberSymbol,    "."
-Access_StaticSymbol,    "::"
-Ampersand,              "&"
-Ampersand_DBL,          "&&"
-Assign_Classifer,       ":"
-Attribute_Open,         "[["
-Attribute_Close,        "]]"
-BraceCurly_Open,        "{"
-BraceCurly_Close,       "}"
-BraceSquare_Open,       "["
-BraceSquare_Close,      "]"
-Capture_Start,          "("
-Capture_End,            ")"
-Comment,                "__comment__"
-Comment_End,            "__comment_end__"
-Comment_Start,          "__comment_start__"
-Char,                   "__character__"
-Comma,                  ","
-Decl_Class,             "class"
-Decl_GNU_Attribute,     "__attribute__"
-Decl_MSVC_Attribute,    "__declspec"
-Decl_Enum,              "enum"
-Decl_Extern_Linkage,    "extern"
-Decl_Friend,            "friend"
-Decl_Module,            "module"
-Decl_Namespace,         "namespace"
-Decl_Operator,          "operator"
-Decl_Struct,            "struct"
-Decl_Template,          "template"
-Decl_Typedef,           "typedef"
-Decl_Using,             "using"
-Decl_Union,             "union"
-Identifier,             "__identifier__"
-Module_Import,          "import"
-Module_Export,          "export"
-NewLine,                "__new_line__"
-Number,                 "__number__"
-Operator,               "__operator__"
-Preprocess_Hash,        "#"
-Preprocess_Define,      "define"
-Preprocess_If,          "if"
-Preprocess_IfDef,       "ifdef"
-Preprocess_IfNotDef,    "ifndef"
-Preprocess_ElIf,        "elif"
-Preprocess_Else,        "else"
-Preprocess_EndIf,       "endif"
-Preprocess_Include,     "include"
-Preprocess_Pragma,      "pragma"
-Preprocess_Content,	    "__macro_content__"
-Preprocess_Macro,       "__macro__"
-Preprocess_Unsupported, "__unsupported__"
-Spec_Alignas,           "alignas"
-Spec_Const,             "const"
-Spec_Consteval,         "consteval"
-Spec_Constexpr,         "constexpr"
-Spec_Constinit,         "constinit"
-Spec_Explicit,          "explicit"
-Spec_Extern,            "extern"
-Spec_Final,             "final"
-Spec_ForceInline,	    "forceinline"
-Spec_Global,            "global"
-Spec_Inline,            "inline"
-Spec_Internal_Linkage,  "internal"
-Spec_LocalPersist,      "local_persist"
-Spec_Mutable,           "mutable"
-Spec_NeverInline,       "neverinline"
-Spec_Override,          "override"
-Spec_Static,            "static"
-Spec_ThreadLocal,       "thread_local"
-Spec_Volatile,          "volatile"
-Spec_Virtual,           "virtual"
-Star,                   "*"
-Statement_End,          ";"
-StaticAssert,           "static_assert"
-String,                 "__string__"
-Type_Typename,          "typename"
-Type_Unsigned,          "unsigned"
-Type_Signed,            "signed"
-Type_Short,             "short"
-Type_Long,              "long"
-Type_bool,              "bool"
-Type_char,              "char"
-Type_int,               "int"
-Type_double,            "double"
-Type_MS_int8,           "__int8"
-Type_MS_int16,          "__int16"
-Type_MS_int32,          "__int32"
-Type_MS_int64,          "__int64"
-Type_MS_W64,            "_W64"
-Varadic_Argument,       "..."
-__Attributes_Start,     "__attrib_start__"
+Invalid,                    "__invalid__"
+Access_Private,             "private"
+Access_Protected,           "protected"
+Access_Public,              "public"
+Access_MemberSymbol,        "."
+Access_StaticSymbol,        "::"
+Ampersand,                  "&"
+Ampersand_DBL,              "&&"
+Assign_Classifer,           ":"
+Attribute_Open,             "[["
+Attribute_Close,            "]]"
+BraceCurly_Open,            "{"
+BraceCurly_Close,           "}"
+BraceSquare_Open,           "["
+BraceSquare_Close,          "]"
+Paren_Open,                 "("
+Paren_Close,                ")"
+Comment,                    "__comment__"
+Comment_End,                "__comment_end__"
+Comment_Start,              "__comment_start__"
+Char,                       "__character__"
+Comma,                      ","
+Decl_Class,                 "class"
+Decl_GNU_Attribute,         "__attribute__"
+Decl_MSVC_Attribute,        "__declspec"
+Decl_Enum,                  "enum"
+Decl_Extern_Linkage,        "extern"
+Decl_Friend,                "friend"
+Decl_Module,                "module"
+Decl_Namespace,             "namespace"
+Decl_Operator,              "operator"
+Decl_Struct,                "struct"
+Decl_Template,              "template"
+Decl_Typedef,               "typedef"
+Decl_Using,                 "using"
+Decl_Union,                 "union"
+Identifier,                 "__identifier__"
+Module_Import,              "import"
+Module_Export,              "export"
+NewLine,                    "__new_line__"
+Number,                     "__number__"
+Operator,                   "__operator__"
+Preprocess_Hash,            "#"
+Preprocess_Define,          "define"
+Preprocess_Define_Param,    "__define_param__"
+Preprocess_If,              "if"
+Preprocess_IfDef,           "ifdef"
+Preprocess_IfNotDef,        "ifndef"
+Preprocess_ElIf,            "elif"
+Preprocess_Else,            "else"
+Preprocess_EndIf,           "endif"
+Preprocess_Include,         "include"
+Preprocess_Pragma,          "pragma"
+Preprocess_Content,         "__macro_content__"
+Preprocess_Macro_Expr,      "__macro_expression__"
+Preprocess_Macro_Stmt,      "__macro_statment__"
+Preprocess_Macro_Typename,  "__macro_typename__"
+Preprocess_Unsupported,     "__unsupported__"
+Spec_Alignas,               "alignas"
+Spec_Const,                 "const"
+Spec_Consteval,             "consteval"
+Spec_Constexpr,             "constexpr"
+Spec_Constinit,             "constinit"
+Spec_Explicit,              "explicit"
+Spec_Extern,                "extern"
+Spec_Final,                 "final"
+Spec_ForceInline,           "forceinline"
+Spec_Global,                "global"
+Spec_Inline,                "inline"
+Spec_Internal_Linkage,      "internal"
+Spec_LocalPersist,          "local_persist"
+Spec_Mutable,               "mutable"
+Spec_NeverInline,           "neverinline"
+Spec_Override,              "override"
+Spec_Restrict,              "restrict"
+Spec_Static,                "static"
+Spec_ThreadLocal,           "thread_local"
+Spec_Volatile,              "volatile"
+Spec_Virtual,               "virtual"
+Star,                       "*"
+Statement_End,              ";"
+StaticAssert,               "static_assert"
+String,                     "__string__"
+Type_Typename,              "typename"
+Type_Unsigned,              "unsigned"
+Type_Signed,                "signed"
+Type_Short,                 "short"
+Type_Long,                  "long"
+Type_bool,                  "bool"
+Type_char,                  "char"
+Type_int,                   "int"
+Type_double,                "double"
+Type_MS_int8,               "__int8"
+Type_MS_int16,              "__int16"
+Type_MS_int32,              "__int32"
+Type_MS_int64,              "__int64"
+Type_MS_W64,                "_W64"
+Varadic_Argument,           "..."
+__Attributes_Start,         "__attrib_start__"

base/gen.cpp

@@ -31,8 +31,8 @@ GEN_NS_BEGIN
 
 #include "components/interface.cpp"
 #include "components/interface.upfront.cpp"
-#include "components/gen/etoktype.cpp"
 #include "components/lexer.cpp"
+#include "components/parser_case_macros.cpp"
 #include "components/parser.cpp"
 #include "components/interface.parsing.cpp"
 #include "components/interface.untyped.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,55 @@ using namespace gen;
 
 CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 {
-	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 );
-	String enum_entries           = string_make_reserve( GlobalAllocator, kilobytes(1) );
-	String to_str_entries         = string_make_reserve( GlobalAllocator, kilobytes(1) );
-	String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	CSV_Columns2 csv_enum                 = parse_csv_two_columns( _ctx->Allocator_Temp, path );
+	StrBuilder   enum_entries             = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
+	StrBuilder   to_c_str_entries         = strbuilder_make_reserve( _ctx->Allocator_Temp, 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.
-		string_append_fmt( & enum_entries,           "CT_%s,\n", code );
-		string_append_fmt( & to_str_entries,         "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
-		string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword );
+		// TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
+		strbuilder_append_fmt( & enum_entries,             "CT_%s,\n", code );
+		strbuilder_append_fmt( & to_c_str_entries,         "{ \"%s\",  sizeof(\"%s\") - 1 },\n", code,    code );
+		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) ));
-	CodeBody to_str_fns = parse_global_body( token_fmt(
-		"entries",  string_to_strc(to_str_entries)
-	,	"keywords", string_to_strc(to_keyword_str_entries)
+	Str      lookup_size  = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
+	CodeBody to_c_str_fns = parse_global_body( token_fmt(
+		"entries",  strbuilder_to_str(to_c_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[] = {
 				<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[] = {
 				<keywords>
 			};
 			return lookup[ type ];
@@ -76,14 +73,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 StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
+			forceinline Str to_str        (CodeType type) { return codetype_to_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 +90,15 @@ 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);
-	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
-
-	CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
-	String enum_entries   = string_make_reserve( GlobalAllocator, 32 );
-	String to_str_entries = string_make_reserve( GlobalAllocator, 32 );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns( _ctx->Allocator_Temp, path );
+	StrBuilder enum_entries     = strbuilder_make_reserve( _ctx->Allocator_Temp, 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;
-
-		string_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		strbuilder_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);
 	}
 
 	CodeEnum  enum_code;
@@ -113,7 +106,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 +118,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 +130,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[] = {
 				<entries>
 			};
 
@@ -169,7 +162,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 +172,16 @@ 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);
-	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
-
-	CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
-	String enum_entries   = string_make_reserve( scratch_info, kilobytes(1) );
-	String to_str_entries = string_make_reserve( scratch_info, kilobytes(1) );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns( _ctx->Allocator_Temp, path );
+	StrBuilder enum_entries     = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
+	StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 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;
-
-		string_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		strbuilder_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);
 	}
 
 	CodeEnum enum_code;
@@ -200,7 +189,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 +201,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,12 +210,22 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 			};
 		)));
 	}
-
-	CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize(
+	CodeFn is_trailing = parse_function(token_fmt("specifier", strbuilder_to_str(to_c_str_entries), stringize(
 		inline
 		bool spec_is_trailing( Specifier specifier )
 		{
-			return specifier > Spec_Virtual;
+			switch (specifier) {
+				case Spec_Const:
+				case Spec_Final:
+				case Spec_NoExceptions:
+				case Spec_Override:
+				case Spec_Pure:
+				case Spec_Volatile:
+					return true;
+		
+				default:
+					return false;
+			}
 		}
 	)));
 
@@ -240,16 +239,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[] = {
 				<entries>
 			};
 
@@ -257,20 +256,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
 
@@ -295,7 +294,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	body_append(result, enum_code);
 	if (use_c_definition)
 	{
-		CodeTypedef specifier_t = parse_typedef( code(typedef u32 Specifier; ));
+		CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier Specifier; ));
 		body_append(result, specifier_t);
 	}
 
@@ -308,8 +307,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 Specifier to_type( StrC str )                { return strc_to_specifier(str); }
+			forceinline Str      to_str (Specifier spec)            { return spec_to_str(spec); }
+			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,64 +319,59 @@ 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);
-	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
-
-	FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
-
+	FileContents enum_content = file_read_contents( _ctx->Allocator_Temp, file_zero_terminate, etok_path );
 	CSV_Object csv_enum_nodes;
-	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), scratch_info, false );
-
-	FileContents attrib_content = file_read_contents( scratch_info, file_zero_terminate, attr_path );
+	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), _ctx->Allocator_Temp, false );
 
+	FileContents attrib_content = file_read_contents( _ctx->Allocator_Temp, file_zero_terminate, attr_path );
 	CSV_Object csv_attr_nodes;
-	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
+	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), _ctx->Allocator_Temp, false );
 
-	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> attribute_strs     = csv_attr_nodes.nodes[0].nodes;
-	Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes;
+	Array<ADT_Node> enum_strs            = csv_enum_nodes.nodes[0].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_c_str_strs = csv_attr_nodes.nodes[1].nodes;
 
-	String enum_entries             = string_make_reserve( scratch_info, kilobytes(2) );
-	String to_str_entries           = string_make_reserve( scratch_info, kilobytes(4) );
-	String attribute_entries        = string_make_reserve( scratch_info, kilobytes(2) );
-	String to_str_attributes        = string_make_reserve( scratch_info, kilobytes(4) );
-	String attribute_define_entries = string_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder enum_entries             = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(2) );
+	StrBuilder to_c_str_entries         = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
+	StrBuilder attribute_entries        = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(2) );
+	StrBuilder to_c_str_attributes      = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
+	StrBuilder attribute_define_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 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 );
-		string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		strbuilder_append_fmt( & enum_entries,     "Tok_%s,\n",                         enum_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 );
-		string_append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\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_entries,        "Tok_Attribute_%s,\n",               attribute_str );
+		strbuilder_append_fmt( & to_c_str_attributes,      "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_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), MT_Statement, { {}, 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 +383,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 +399,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 +413,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 +446,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 +455,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 +500,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 +510,60 @@ 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_body     = parse_global_body( token_fmt( "typename", StrC name(CodeBody),           code_impl_tmpl ));
-	CodeBody impl_code_attr     = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes),     code_impl_tmpl ));
-	CodeBody impl_code_cmt      = parse_global_body( token_fmt( "typename", StrC name(CodeComment),        code_impl_tmpl ));
-	CodeBody impl_code_constr   = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor),    code_impl_tmpl ));
-	CodeBody impl_code_class    = parse_global_body( token_fmt( "typename", StrC name(CodeClass),          code_impl_tmpl ));
-	CodeBody impl_code_define   = parse_global_body( token_fmt( "typename", StrC name(CodeDefine),         code_impl_tmpl ));
-	CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor),     code_impl_tmpl ));
-	CodeBody impl_code_enum     = parse_global_body( token_fmt( "typename", StrC name(CodeEnum),           code_impl_tmpl ));
-	CodeBody impl_code_exec     = parse_global_body( token_fmt( "typename", StrC name(CodeExec),           code_impl_tmpl ));
-	CodeBody impl_code_extern   = parse_global_body( token_fmt( "typename", StrC name(CodeExtern),         code_impl_tmpl ));
-	CodeBody impl_code_include  = parse_global_body( token_fmt( "typename", StrC name(CodeInclude),        code_impl_tmpl ));
-	CodeBody impl_code_friend   = parse_global_body( token_fmt( "typename", StrC name(CodeFriend),         code_impl_tmpl ));
-	CodeBody impl_code_fn	    = parse_global_body( token_fmt( "typename", StrC name(CodeFn),             code_impl_tmpl ));
-	CodeBody impl_code_module   = parse_global_body( token_fmt( "typename", StrC name(CodeModule),         code_impl_tmpl ));
-	CodeBody impl_code_ns       = parse_global_body( token_fmt( "typename", StrC name(CodeNS),             code_impl_tmpl ));
-	CodeBody impl_code_op       = parse_global_body( token_fmt( "typename", StrC name(CodeOperator),       code_impl_tmpl ));
-	CodeBody impl_code_opcast   = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast),         code_impl_tmpl ));
-	CodeBody impl_code_params   = parse_global_body( token_fmt( "typename", StrC name(CodeParams),         code_impl_tmpl ));
-	CodeBody impl_code_pragma   = parse_global_body( token_fmt( "typename", StrC name(CodePragma),         code_impl_tmpl ));
-	CodeBody impl_code_precond  = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl ));
-	CodeBody impl_code_specs    = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers),     code_impl_tmpl ));
-	CodeBody impl_code_struct   = parse_global_body( token_fmt( "typename", StrC name(CodeStruct),         code_impl_tmpl ));
-	CodeBody impl_code_tmpl     = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate),       code_impl_tmpl ));
-	CodeBody impl_code_type     = parse_global_body( token_fmt( "typename", StrC name(CodeTypename),       code_impl_tmpl ));
-	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef),        code_impl_tmpl ));
-	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", StrC name(CodeUnion),          code_impl_tmpl ));
-	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", StrC name(CodeUsing),          code_impl_tmpl ));
-	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", StrC name(CodeVar),            code_impl_tmpl ));
+	CodeBody impl_code               = parse_global_body( token_fmt( "typename", name(Code),               code_impl_tmpl ));
+	CodeBody impl_code_body          = parse_global_body( token_fmt( "typename", name(CodeBody),           code_impl_tmpl ));
+	CodeBody impl_code_attr          = parse_global_body( token_fmt( "typename", name(CodeAttributes),     code_impl_tmpl ));
+	CodeBody impl_code_cmt           = parse_global_body( token_fmt( "typename", name(CodeComment),        code_impl_tmpl ));
+	CodeBody impl_code_constr        = parse_global_body( token_fmt( "typename", name(CodeConstructor),    code_impl_tmpl ));
+	CodeBody impl_code_class         = parse_global_body( token_fmt( "typename", name(CodeClass),          code_impl_tmpl ));
+	CodeBody impl_code_define        = parse_global_body( token_fmt( "typename", name(CodeDefine),         code_impl_tmpl ));
+	CodeBody impl_code_define_params = parse_global_body( token_fmt( "typename", name(CodeDefineParams),   code_impl_tmpl ));
+	CodeBody impl_code_destruct      = parse_global_body( token_fmt( "typename", name(CodeDestructor),     code_impl_tmpl ));
+	CodeBody impl_code_enum          = parse_global_body( token_fmt( "typename", name(CodeEnum),           code_impl_tmpl ));
+	CodeBody impl_code_exec          = parse_global_body( token_fmt( "typename", name(CodeExec),           code_impl_tmpl ));
+	CodeBody impl_code_extern        = parse_global_body( token_fmt( "typename", name(CodeExtern),         code_impl_tmpl ));
+	CodeBody impl_code_include       = parse_global_body( token_fmt( "typename", name(CodeInclude),        code_impl_tmpl ));
+	CodeBody impl_code_friend        = parse_global_body( token_fmt( "typename", name(CodeFriend),         code_impl_tmpl ));
+	CodeBody impl_code_fn	         = parse_global_body( token_fmt( "typename", name(CodeFn),             code_impl_tmpl ));
+	CodeBody impl_code_module        = parse_global_body( token_fmt( "typename", name(CodeModule),         code_impl_tmpl ));
+	CodeBody impl_code_ns            = parse_global_body( token_fmt( "typename", name(CodeNS),             code_impl_tmpl ));
+	CodeBody impl_code_op            = parse_global_body( token_fmt( "typename", name(CodeOperator),       code_impl_tmpl ));
+	CodeBody impl_code_opcast        = parse_global_body( token_fmt( "typename", name(CodeOpCast),         code_impl_tmpl ));
+	CodeBody impl_code_params        = parse_global_body( token_fmt( "typename", name(CodeParams),         code_impl_tmpl ));
+	CodeBody impl_code_pragma        = parse_global_body( token_fmt( "typename", name(CodePragma),         code_impl_tmpl ));
+	CodeBody impl_code_precond       = parse_global_body( token_fmt( "typename", name(CodePreprocessCond), code_impl_tmpl ));
+	CodeBody impl_code_specs         = parse_global_body( token_fmt( "typename", name(CodeSpecifiers),     code_impl_tmpl ));
+	CodeBody impl_code_struct        = parse_global_body( token_fmt( "typename", name(CodeStruct),         code_impl_tmpl ));
+	CodeBody impl_code_tmpl          = parse_global_body( token_fmt( "typename", name(CodeTemplate),       code_impl_tmpl ));
+	CodeBody impl_code_type          = parse_global_body( token_fmt( "typename", name(CodeTypename),       code_impl_tmpl ));
+	CodeBody impl_code_typedef       = parse_global_body( token_fmt( "typename", name(CodeTypedef),        code_impl_tmpl ));
+	CodeBody impl_code_union         = parse_global_body( token_fmt( "typename", name(CodeUnion),          code_impl_tmpl ));
+	CodeBody impl_code_using         = parse_global_body( token_fmt( "typename", name(CodeUsing),          code_impl_tmpl ));
+	CodeBody impl_code_var           = parse_global_body( token_fmt( "typename", 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_cmt,      parse_global_body( token_fmt( "typename", StrC 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_define,   parse_global_body( token_fmt( "typename", StrC 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_enum,     parse_global_body( token_fmt( "typename", StrC 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_extern,   parse_global_body( token_fmt( "typename", StrC 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_friend,   parse_global_body( token_fmt( "typename", StrC 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_module,   parse_global_body( token_fmt( "typename", StrC 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_op,       parse_global_body( token_fmt( "typename", StrC 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_pragma,   parse_global_body( token_fmt( "typename", StrC 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_tmpl,     parse_global_body( token_fmt( "typename", StrC 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_typedef,  parse_global_body( token_fmt( "typename", StrC 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_using,    parse_global_body( token_fmt( "typename", StrC 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_attr,     parse_global_body( token_fmt( "typename", name(Attributes),     codetype_impl_tmpl )));
+	body_append(impl_code_cmt,      parse_global_body( token_fmt( "typename", name(Comment),        codetype_impl_tmpl )));
+	body_append(impl_code_constr,   parse_global_body( token_fmt( "typename", name(Constructor),    codetype_impl_tmpl )));
+	body_append(impl_code_define,   parse_global_body( token_fmt( "typename", name(Define),         codetype_impl_tmpl )));
+	body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", name(Destructor),     codetype_impl_tmpl )));
+	body_append(impl_code_enum,     parse_global_body( token_fmt( "typename", name(Enum),           codetype_impl_tmpl )));
+	body_append(impl_code_exec,     parse_global_body( token_fmt( "typename", name(Exec),           codetype_impl_tmpl )));
+	body_append(impl_code_extern,   parse_global_body( token_fmt( "typename", name(Extern),         codetype_impl_tmpl )));
+	body_append(impl_code_include,  parse_global_body( token_fmt( "typename", name(Include),        codetype_impl_tmpl )));
+	body_append(impl_code_friend,   parse_global_body( token_fmt( "typename", name(Friend),         codetype_impl_tmpl )));
+	body_append(impl_code_fn,       parse_global_body( token_fmt( "typename", name(Fn),             codetype_impl_tmpl )));
+	body_append(impl_code_module,   parse_global_body( token_fmt( "typename", name(Module),         codetype_impl_tmpl )));
+	body_append(impl_code_ns,       parse_global_body( token_fmt( "typename", name(NS),             codetype_impl_tmpl )));
+	body_append(impl_code_op,       parse_global_body( token_fmt( "typename", name(Operator),       codetype_impl_tmpl )));
+	body_append(impl_code_opcast,   parse_global_body( token_fmt( "typename", name(OpCast),         codetype_impl_tmpl )));
+	body_append(impl_code_pragma,   parse_global_body( token_fmt( "typename", name(Pragma),         codetype_impl_tmpl )));
+	body_append(impl_code_precond,  parse_global_body( token_fmt( "typename", name(PreprocessCond), codetype_impl_tmpl )));
+	body_append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", name(Template),       codetype_impl_tmpl )));
+	body_append(impl_code_type,     parse_global_body( token_fmt( "typename", name(Typename),       codetype_impl_tmpl )));
+	body_append(impl_code_typedef,  parse_global_body( token_fmt( "typename", name(Typedef),        codetype_impl_tmpl )));
+	body_append(impl_code_union,    parse_global_body( token_fmt( "typename", name(Union),          codetype_impl_tmpl )));
+	body_append(impl_code_using,    parse_global_body( token_fmt( "typename", name(Using),          codetype_impl_tmpl )));
+	body_append(impl_code_var,      parse_global_body( token_fmt( "typename", name(Var),            codetype_impl_tmpl )));
 
 	#pragma push_macro("forceinline")
 	#undef forceinline
@@ -582,34 +575,35 @@ 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_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes),     cast_tmpl ));
-	CodeBody impl_cast_cmt       = parse_global_body( token_fmt( "typename", StrC name(Comment),        cast_tmpl ));
-	CodeBody impl_cast_constr    = parse_global_body( token_fmt( "typename", StrC name(Constructor),    cast_tmpl ));
-	CodeBody impl_cast_class     = parse_global_body( token_fmt( "typename", StrC name(Class),          cast_tmpl ));
-	CodeBody impl_cast_define    = parse_global_body( token_fmt( "typename", StrC name(Define),         cast_tmpl ));
-	CodeBody impl_cast_destruct  = parse_global_body( token_fmt( "typename", StrC name(Destructor),     cast_tmpl ));
-	CodeBody impl_cast_enum      = parse_global_body( token_fmt( "typename", StrC name(Enum),           cast_tmpl ));
-	CodeBody impl_cast_exec      = parse_global_body( token_fmt( "typename", StrC name(Exec),           cast_tmpl ));
-	CodeBody impl_cast_extern    = parse_global_body( token_fmt( "typename", StrC name(Extern),         cast_tmpl ));
-	CodeBody impl_cast_friend    = parse_global_body( token_fmt( "typename", StrC name(Friend),         cast_tmpl ));
-	CodeBody impl_cast_fn        = parse_global_body( token_fmt( "typename", StrC name(Fn),             cast_tmpl ));
-	CodeBody impl_cast_include   = parse_global_body( token_fmt( "typename", StrC name(Include),        cast_tmpl ));
-	CodeBody impl_cast_module    = parse_global_body( token_fmt( "typename", StrC name(Module),         cast_tmpl ));
-	CodeBody impl_cast_ns        = parse_global_body( token_fmt( "typename", StrC name(NS),             cast_tmpl ));
-	CodeBody impl_cast_op        = parse_global_body( token_fmt( "typename", StrC name(Operator),       cast_tmpl ));
-	CodeBody impl_cast_opcast    = parse_global_body( token_fmt( "typename", StrC name(OpCast),         cast_tmpl ));
-	CodeBody impl_cast_params    = parse_global_body( token_fmt( "typename", StrC name(Params),         cast_tmpl ));
-	CodeBody impl_cast_pragma    = parse_global_body( token_fmt( "typename", StrC name(Pragma),         cast_tmpl ));
-	CodeBody impl_cast_precond   = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl ));
-	CodeBody impl_cast_specs     = parse_global_body( token_fmt( "typename", StrC name(Specifiers),     cast_tmpl ));
-	CodeBody impl_cast_struct    = parse_global_body( token_fmt( "typename", StrC name(Struct),         cast_tmpl ));
-	CodeBody impl_cast_tmpl      = parse_global_body( token_fmt( "typename", StrC name(Template),       cast_tmpl ));
-	CodeBody impl_cast_type      = parse_global_body( token_fmt( "typename", StrC name(Typename),       cast_tmpl ));
-	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", StrC name(Typedef),        cast_tmpl ));
-	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", StrC name(Union),          cast_tmpl ));
-	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", StrC name(Using),          cast_tmpl ));
-	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", StrC name(Var),            cast_tmpl ));
+	CodeBody impl_cast_body          = parse_global_body( token_fmt( "typename", name(Body),           cast_tmpl ));
+	CodeBody impl_cast_attribute     = parse_global_body( token_fmt( "typename", name(Attributes),     cast_tmpl ));
+	CodeBody impl_cast_cmt           = parse_global_body( token_fmt( "typename", name(Comment),        cast_tmpl ));
+	CodeBody impl_cast_constr        = parse_global_body( token_fmt( "typename", name(Constructor),    cast_tmpl ));
+	CodeBody impl_cast_class         = parse_global_body( token_fmt( "typename", name(Class),          cast_tmpl ));
+	CodeBody impl_cast_define        = parse_global_body( token_fmt( "typename", name(Define),         cast_tmpl ));
+	CodeBody impl_cast_define_params = parse_global_body( token_fmt( "typename", name(DefineParams),   cast_tmpl ));
+	CodeBody impl_cast_destruct      = parse_global_body( token_fmt( "typename", name(Destructor),     cast_tmpl ));
+	CodeBody impl_cast_enum          = parse_global_body( token_fmt( "typename", name(Enum),           cast_tmpl ));
+	CodeBody impl_cast_exec          = parse_global_body( token_fmt( "typename", name(Exec),           cast_tmpl ));
+	CodeBody impl_cast_extern        = parse_global_body( token_fmt( "typename", name(Extern),         cast_tmpl ));
+	CodeBody impl_cast_friend        = parse_global_body( token_fmt( "typename", name(Friend),         cast_tmpl ));
+	CodeBody impl_cast_fn            = parse_global_body( token_fmt( "typename", name(Fn),             cast_tmpl ));
+	CodeBody impl_cast_include       = parse_global_body( token_fmt( "typename", name(Include),        cast_tmpl ));
+	CodeBody impl_cast_module        = parse_global_body( token_fmt( "typename", name(Module),         cast_tmpl ));
+	CodeBody impl_cast_ns            = parse_global_body( token_fmt( "typename", name(NS),             cast_tmpl ));
+	CodeBody impl_cast_op            = parse_global_body( token_fmt( "typename", name(Operator),       cast_tmpl ));
+	CodeBody impl_cast_opcast        = parse_global_body( token_fmt( "typename", name(OpCast),         cast_tmpl ));
+	CodeBody impl_cast_params        = parse_global_body( token_fmt( "typename", name(Params),         cast_tmpl ));
+	CodeBody impl_cast_pragma        = parse_global_body( token_fmt( "typename", name(Pragma),         cast_tmpl ));
+	CodeBody impl_cast_precond       = parse_global_body( token_fmt( "typename", name(PreprocessCond), cast_tmpl ));
+	CodeBody impl_cast_specs         = parse_global_body( token_fmt( "typename", name(Specifiers),     cast_tmpl ));
+	CodeBody impl_cast_struct        = parse_global_body( token_fmt( "typename", name(Struct),         cast_tmpl ));
+	CodeBody impl_cast_tmpl          = parse_global_body( token_fmt( "typename", name(Template),       cast_tmpl ));
+	CodeBody impl_cast_type          = parse_global_body( token_fmt( "typename", name(Typename),       cast_tmpl ));
+	CodeBody impl_cast_typedef       = parse_global_body( token_fmt( "typename", name(Typedef),        cast_tmpl ));
+	CodeBody impl_cast_union         = parse_global_body( token_fmt( "typename", name(Union),          cast_tmpl ));
+	CodeBody impl_cast_using         = parse_global_body( token_fmt( "typename", name(Using),          cast_tmpl ));
+	CodeBody impl_cast_var           = parse_global_body( token_fmt( "typename", name(Var),            cast_tmpl ));
 
 	CodeBody result = def_global_body( args(
 		def_pragma( txt("region generated code inline implementation")),
@@ -621,6 +615,7 @@ CodeBody gen_ast_inlines()
 		impl_code_constr,
 		impl_code_class,
 		impl_code_define,
+		impl_code_define_params,
 		impl_code_destruct,
 		impl_code_enum,
 		impl_code_exec,
@@ -655,6 +650,7 @@ CodeBody gen_ast_inlines()
 		impl_cast_constr,
 		impl_cast_class,
 		impl_cast_define,
+		impl_cast_define_params,
 		impl_cast_destruct,
 		impl_cast_enum,
 		impl_cast_exec,

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));
-	String style_arg;
+	StrBuilder resolved_path = strbuilder_make_str(_ctx->Allocator_Temp, to_str_from_c_str(path));
+	StrBuilder style_arg;
 	if (style_path) {
-		style_arg = string_make_strc(GlobalAllocator, txt("-style=file:"));
-		string_append_fmt( & style_arg, "%s ", style_path );
+		style_arg = strbuilder_make_str(_ctx->Allocator_Temp, txt("-style=file:"));
+		strbuilder_append_fmt( & style_arg, "%s ", style_path );
 	}
 
-	StrC clang_format      = txt("clang-format ");
-	StrC cf_format_inplace = txt("-i ");
-	StrC cf_verbose        = txt("-verbose ");
+	Str clang_format      = txt("clang-format ");
+	Str cf_format_inplace = txt("-i ");
+	Str cf_verbose        = txt("-verbose ");
 
-	String command = string_make_strc( GlobalAllocator, clang_format );
-	string_append_strc( & command, cf_format_inplace );
-	string_append_strc( & command, cf_verbose );
-	string_append_string( & command, style_arg );
-	string_append_string( & command, resolved_path );
+	StrBuilder command = strbuilder_make_str( _ctx->Allocator_Temp, clang_format );
+	strbuilder_append_str( & command, cf_format_inplace );
+	strbuilder_append_str( & command, cf_verbose );
+	strbuilder_append_string( & command, style_arg );
+	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 "));
-	// string_append_strc( & command, txt("-debug ") );
-	string_append_strc( & command, txt("-num=1 ") );
-	string_append_fmt( & command, "-src=%s ", path );
-	string_append_fmt( & command,"-spec=%s ", refactor_script );
+	StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, txt("refactor "));
+	// strbuilder_append_str( & command, txt("-debug ") );
+	strbuilder_append_str( & command, txt("-num=1 ") );
+	strbuilder_append_fmt( & command, "-src=%s ", path );
+	strbuilder_append_fmt( & command,"-spec=%s ", refactor_script );
 	system(command);
 	log_fmt("\n");
 }

base/helpers/undef.macros.h

@@ -41,7 +41,7 @@
 #undef local_persist
 
 #undef bit
-#undef bitfield_is_equal
+#undef bitfield_is_set
 
 #undef cast
 
@@ -173,12 +173,12 @@
 
 #undef GEN_DEFINE_ATTRIBUTE_TOKENS
 
-#undef GEN_AST_BODY_CLASS_UNALLOWED_TYPES
-#undef GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
-#undef GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
-#undef GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
-#undef GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
-#undef GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
+#undef GEN_AST_BODY_CLASS_UNALLOWED_TYPES_CASES
+#undef GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES_CASES
+#undef GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES
+#undef GEN_AST_BODY_EXPORT_UNALLOWED_TYPES_CASES
+#undef GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES_CASES
+#undef GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES_CASES
 
 #undef GEN_GLOBAL_BUCKET_SIZE
 #undef GEN_CODEPOOL_NUM_BLOCKS

docs/AST_Design.md

@@ -37,7 +37,7 @@ The full definitions of all asts are within:
 
 * [`ast.hpp`](../base/components/ast.hpp)
 * [`ast_types.hpp`](../base/components/ast_types.hpp)
-* [`code_types.hpp`](../base/components/ast_types.hpp)
+* [`code_types.hpp`](../base/components/code_types.hpp)
 
 The C/C++ interface procedures are located with `ast.hpp` (for the Code type), and `code_types.hpp` for all others.
 
@@ -46,13 +46,14 @@ 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.cpp`](../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,13 +25,13 @@ These are containers representing a scope body of a definition that can be of th
 Fields:
 
 ```cpp
-StringCached   Name;
-Code           Front;
-Code           Back;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
-s32            NumEntries;
+StrCached Name;
+Code      Front;
+Code      Back;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
+s32       NumEntries;
 ```
 
 The `Front` member represents the start of the link list and `Back` the end.
@@ -56,13 +56,13 @@ Represent standard or vendor specific C/C++ attributes.
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -80,13 +80,13 @@ Stores a comment.
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -109,12 +109,12 @@ CodeComment    InlineCmt;  // Only supported by forward declarations
 CodeAttributes Attributes;
 CodeType       ParentType;
 CodeBody       Body;
-StringCached   Name;
+StrCached      Name;
 CodeType       Prev;
 CodeType       Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 AccessSpec     ParentAccess;
 ```
@@ -139,16 +139,16 @@ You'll notice that only one parent type is supported only with parent access. Th
 Fields:
 
 ```cpp
-CodeComment    InlineCmt;  // Only supported by forward declarations
-Code           InitializerList;
-CodeParams     Params;
-Code           Body;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+CodeComment InlineCmt;  // Only supported by forward declarations
+Code        InitializerList;
+CodeParams  Params;
+Code        Body;
+StrCached   Name;
+Code        Prev;
+Code        Next;
+Token*      Tok;
+Code        Parent;
+CodeType    Type;
 ```
 
 Serialization:
@@ -178,13 +178,14 @@ Represents a preprocessor define
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+CodeDefineParams Params;
+Code             Body;
+StrCached        Name;
+Code             Prev;
+Code             Next;
+Token*           Tok;
+Code             Parent;
+CodeType         Type;
 ```
 
 Serialization:
@@ -193,6 +194,28 @@ Serialization:
 #define <Name> <Content>
 ```
 
+## DefineParams
+
+Preprocessor define's parameters.
+
+Fields:
+
+```cpp
+StrCached Name;
+Code      Last;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
+s32       NumEntries;
+```
+
+Serialization:
+
+```cpp
+<Name>, <Next> ...
+```
+
 ## Destructor
 
 Fields:
@@ -201,12 +224,12 @@ Fields:
 CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 Code           Body;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ```
 
 Serialization:
@@ -242,13 +265,13 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-StringCached   Name;
-CodeT          Type;
+StrCached      Name;
+CodeType       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,13 +294,13 @@ Will be obsolute when function body parsing is implemented.
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -286,18 +309,18 @@ Serialization:
 <Content>
 ```
 
-## External Linkage
+## External Linkage (Extern)
 
 Fields:
 
 ```cpp
-CodeBody       Body;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+CodeBody  Body;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -314,13 +337,13 @@ extern "<Name>"
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Code           Parent;
-Token*         Tok;
-CodeT          Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Code      Parent;
+Token*    Tok;
+CodeType  Type;
 ```
 
 Serialization:
@@ -336,14 +359,14 @@ This library (until its necessary become some third-party library to do otherwis
 Fields:
 
 ```cpp
-CodeComment    InlineCmt;
-Code           Declaration;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+CodeComment InlineCmt;
+Code        Declaration;
+StrCached   Name;
+Code        Prev;
+Code        Next;
+Token*      Tok;
+Code        Parent;
+CodeType    Type;
 ```
 
 Serialization:
@@ -363,12 +386,12 @@ CodeSpecifiers Specs;
 CodeType       ReturnType;
 CodeParams     Params;
 CodeBody       Body;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -390,13 +413,13 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
-ModuleFlag     ModuleFlags;
+StrCached  Name;
+Code       Prev;
+Code       Next;
+Token*     Tok;
+Code       Parent;
+CodeType   Type;
+ModuleFlag ModuleFlags;
 ```
 
 Serialization:
@@ -410,14 +433,14 @@ Serialization:
 Fields:
 
 ```cpp
-CodeBody       Body;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
-ModuleFlag     ModuleFlags;
+CodeBody   Body;
+StrCached  Name;
+Code       Prev;
+Code       Next;
+Token*     Tok;
+Code       Parent;
+CodeType   Type;
+ModuleFlag ModuleFlags;
 ```
 
 Serialization:
@@ -440,12 +463,12 @@ CodeSpecifiers Specs;
 CodeType       ReturnType;
 CodeParams     Params;
 CodeBody       Body;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 OperatorT      Op;
 ```
@@ -472,12 +495,12 @@ CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 CodeType       ValueType;
 CodeBody       Body;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ```
 
 Serialization:
@@ -498,17 +521,17 @@ Serialization:
 Fields:
 
 ```cpp
-CodeType       ValueType;
-Code           Macro;
-Code           Value;
-Code           PostNameMacro;
-StringCached   Name;
-CodeParams     Last;
-CodeParams     Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
-s32            NumEntries;
+CodeType   ValueType;
+Code       Macro;
+Code       Value;
+Code       PostNameMacro;
+StrCached  Name;
+CodeParams Last;
+CodeParams Next;
+Token*     Tok;
+Code       Parent;
+CodeType   Type;
+s32        NumEntries;
 ```
 
 Serialization:
@@ -524,13 +547,13 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached   Content;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -544,13 +567,13 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached  Content;
-StringCached  Name;
-Code          Prev;
-Code          Next;
-Token*        Tok;
-Code          Parent;
-CodeT         Type;
+StrCached Content;
+StrCached Name;
+Code      Prev;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
 ```
 
 Serialization:
@@ -566,12 +589,12 @@ Fields:
 ```cpp
 SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
 CodeSpecifiers NextSpecs;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 s32            NumEntries;
 ```
 
@@ -586,15 +609,15 @@ Serialization:
 Fields:
 
 ```cpp
-CodeParams     Params;
-Code           Declaration;
-StringCached   Name;
-Code           Prev;
-Code           Next;
-Token*         Tok;
-Code           Parent;
-CodeT          Type;
-ModuleFlag     ModuleFlags;
+CodeParams  Params;
+Code        Declaration;
+StrCached   Name;
+Code        Prev;
+Code        Next;
+Token*      Tok;
+Code        Parent;
+CodeType    Type;
+ModuleFlag  ModuleFlags;
 ```
 
 Serialization:
@@ -621,8 +644,8 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-StringCached   Name;
-CodeT          Type;
+StrCached      Name;
+CodeType       Type;
 b32            IsParamPack;
 ETypenameTag   TypeTag;
 ```
@@ -637,7 +660,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
 
@@ -647,16 +670,16 @@ Those (macros) don't use the underlying type field as everything was serialized
 Fields:
 
 ```cpp
-CodeComment   InlineCmt;
-Code          UnderlyingType;
-StringCached  Name;
-Code          Prev;
-Code          Next;
-Token*        Tok
-Code          Parent;
-CodeT         Type;
-ModuleFlag    ModuleFlags;
-b32           IsFunction;
+CodeComment InlineCmt;
+Code        UnderlyingType;
+StrCached   Name;
+Code        Prev;
+Code        Next;
+Token*      Tok
+Code        Parent;
+CodeType    Type;
+ModuleFlag  ModuleFlags;
+b32         IsFunction;
 ```
 
 Serialization:
@@ -682,12 +705,12 @@ Fields:
 ```cpp
 CodeAttributes Attributes;
 CodeBody       Body;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -708,12 +731,12 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
-StringCached   Name;
+StrCached      Name;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -740,13 +763,13 @@ CodeSpecifiers Specs;
 CodeType       ValueType;
 Code           BitfieldSize;
 Code           Value;
-StringCached   Name;
+StrCached      Name;
 CodeVar        NextVar;
 Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 s32            VarParenthesizedInit;
 ```

docs/Parsing.md

@@ -6,34 +6,35 @@
 
 # Parsing
 
-The library features a naive single-pass parser tailored for only what the library needs to construct the supported syntax of C++ into its AST for *"front-end"* meta-programming purposes.
+The library features a naive single-pass parser, tailored for only what the library needs; for construction of C++ code into gencpp's AST for *"front-end"* meta-programming purposes.
 
-This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~7000 loc. I hope to keep it under 10k loc worst case.
+This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~7000 loc. I hope to keep it under 10-15k loc worst case.
 
 You can think of this parser as *frontend parser* vs a *semantic parser*. Its intuitively similar to WYSIWYG. What you ***precerive*** as the syntax from the user-side before the compiler gets a hold of it, is what you get.
 
 User exposed interface:
 
 ```cpp
-CodeClass       parse_class        ( StrC class_def       );
-CodeConstructor parse_constructor  ( StrC constructor_def );
-CodeDestructor  parse_destructor   ( StrC destructor_def  );
-CodeEnum        parse_enum         ( StrC enum_def        );
-CodeBody        parse_export_body  ( StrC export_def      );
-CodeExtern      parse_extern_link  ( StrC exten_link_def  );
-CodeFriend      parse_friend       ( StrC friend_def      );
-CodeFn          parse_function     ( StrC fn_def          );
-CodeBody        parse_global_body  ( StrC body_def        );
-CodeNS          parse_namespace    ( StrC namespace_def   );
-CodeOperator    parse_operator     ( StrC operator_def    );
-CodeOpCast      parse_operator_cast( StrC operator_def    );
-CodeStruct      parse_struct       ( StrC struct_def      );
-CodeTemplate    parse_template     ( StrC template_def    );
-CodeType        parse_type         ( StrC type_def        );
-CodeTypedef     parse_typedef      ( StrC typedef_def     );
-CodeUnion       parse_union        ( StrC union_def       );
-CodeUsing       parse_using        ( StrC using_def       );
-CodeVar         parse_variable     ( StrC var_def         );
+CodeClass       parse_class        ( Str class_def       );
+CodeConstructor parse_constructor  ( Str constructor_def );
+CodeDefine      parse_define       ( Str define_def      );
+CodeDestructor  parse_destructor   ( Str destructor_def  );
+CodeEnum        parse_enum         ( Str enum_def        );
+CodeBody        parse_export_body  ( Str export_def      );
+CodeExtern      parse_extern_link  ( Str exten_link_def  );
+CodeFriend      parse_friend       ( Str friend_def      );
+CodeFn          parse_function     ( Str fn_def          );
+CodeBody        parse_global_body  ( Str body_def        );
+CodeNS          parse_namespace    ( Str namespace_def   );
+CodeOperator    parse_operator     ( Str operator_def    );
+CodeOpCast      parse_operator_cast( Str operator_def    );
+CodeStruct      parse_struct       ( Str struct_def      );
+CodeTemplate    parse_template     ( Str template_def    );
+CodeType        parse_type         ( Str type_def        );
+CodeTypedef     parse_typedef      ( Str typedef_def     );
+CodeUnion       parse_union        ( Str union_def       );
+CodeUsing       parse_using        ( Str using_def       );
+CodeVar         parse_variable     ( Str var_def         );
 ```
 
 To parse file buffers, use the `parse_global_body` function.
@@ -53,38 +54,98 @@ The keywords supported for the preprocessor are:
 * endif
 * pragma
 
-Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. 
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST node.
 If a directive is used with an unsupported keyword its will be processed as an untyped AST.
 
-The preprocessor lines are stored as members of their associated scope they are parsed within. ( Global, Namespace, Class/Struct )  
-***Again (Its not standard): These ASTs will be considered members or entries of braced scope they reside within***
+The preprocessor lines are stored as members of their associated scope they are parsed within ( Global, Namespace, Class/Struct ).
+***Again: These ASTs will be considered members or entries of braced scope they reside within***
 
 Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).  
 Exceptions:
 
-* function signatures are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
+* varaible definitions are allowed for a preprocessed macro `extern MACRO();`
+* function definitions are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES`
 * typedefs allow for a preprocessed macro: `typedef MACRO();`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_TYPEDEF`
 * Macros can behave as typenames
-* There is some macro support in paramters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
+* There is some macro support in parameters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
 
 *(Exceptions are added on an on-demand basis)*
 *(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
 
 Adding your own exceptions is possible by simply modifying the parser to allow for the syntax you need.
 
-*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase some some egregious preprocessor abuse.*
+*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase contains some egregious preprocessor abuse.*
 
-If a macro is not defined withint e scope of parsing a set of files, it can be defined beforehand by:
+Macros used within a file should be registered by the user before parsing. This can be done two ways:
 
-* Appending the [`PreprocessorDefines`](https://github.com/Ed94/gencpp/blob/a18b5b97aa5cfd20242065cbf53462a623cd18fa/base/components/header_end.hpp#L137) array.
-  * For functional macros a "(" just needs to be added after the name like: `<name>(` so that it will tokenize its arguments as part of the token during lexing.
-* Defining a CodeDefine using `def_define`. The definition will be processed by the interface for user into `PreprocessorDefines`.
-  * This can be prevented by setting the optional prameter `dont_append_preprocess_defines`.
+1. The register macro interface within [interface.hpp](../base/components/interface.hpp).
+2. Using `def_define` to create a CodeDefine and making sure to not set `opts.dont_register_to_preprocess_macros` to `true`.
 
-The lexing and parsing takes shortcuts from whats expected in the standard.
+## Registering macros
 
+While the registeration of macros in the meta-program's side for parsing can be considered tedius, its necessary for the parser to accurately resolve the macros intent in one pass (and it provides some hygenics by verifying that they are used as intended).
+
+The following can be used to register a macro:
+
+```c
+GEN_API void register_macro( Macro macro );
+GEN_API void register_macros( s32 num, ... );
+GEN_API void register_macros_arr( s32 num, Macro* macros );
+```
+
+The Macro typename is defined with the following in [parser_types.hpp](../base/components/parser_types.hpp):
+
+```c
+struct Macro
+{
+    StrCached  Name;
+    MacroType  Type;
+    MacroFlags Flags;
+};
+```
+
+The macro can be designated one of the following types:
+
+* `MT_Expression`: Intended to resolve to an expression expansion.
+* `MT_Statement`: Intended to resolve an statement expansion.
+* `MT_Typename`: Intended to resolve to a typename.
+
+Additioonally tthe following flags may be set:
+
+* `MF_Functional`: The macro intended to be passed arguments are at least have the calling `()` as part of its usage.
+* `MF_Expects_Body`: The parser should expect a braced-body `{ ... }` after the macro signature `<name> <params>`
+* `MF_Allow_As_Identifier`: Will allow the macro to be an acceptable token/s when an `Tok_Identifier` is expected.
+* `MF_Allow_As_Attribute`: Will allow the macro to be an acceptable token/s when an attribute token/s is expected.
+* `MF_Allow_As_Definition`: Will allow the macro be an acceptable token/s when the parser expects a declartion or definition to resolve after attributes or specifiers have been identified beforehand.
+  * This flag requires that the macro is of type `MT_Statement` to make any sense of usage.
+
+If a macro is not defined the following warning will be issued if `GEN_BUILD_DEBUG=1` during lexing within [lexer.cpp](../base/components/lexer.cpp) - `lex_preprocessor_define`:
+
+```c
+log_fmt("Warning: '%S' was not registered before the lexer processed its #define directive, it will be registered as a expression macro\n"
+    , name.Text 
+);
+```
+
+Further within the same scope, the lexer will issue a warning if it detects a macro was not flagged as function but has an open parenthesis `(` token right after is name with no whitespace:
+
+```c
+log_fmt("Warning: %S registered macro is not flagged as functional yet the definition detects opening parenthesis '(' for arguments\n"
+    , name.Text
+);
+```
+
+Macros are tracked using a `MacroTable Macros;` defined as a member of the library's `Context`.
+
+```c
+typedef HashTable(Macro) MacroTable;
+```
+
+## Notes
+
+* Empty lines used throughout the file are preserved for formatting purposes during ast serialization (they have a dedicated Token: `Tok_NewLine`).
 * Numeric literals are not checked for validity.
 * The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs. (There is a [todo](https://github.com/Ed94/gencpp/issues/49) to add support)
   * *This includes the assignment of variables.*
@@ -95,4 +156,4 @@ The lexing and parsing takes shortcuts from whats expected in the standard.
 * Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
   * This is useful for example: parsing Unreal `Module_API` macros.
 
-Empty lines used throughout the file are preserved for formatting purposes during ast serialization.
+**The lexer & parser do not gracefully attempt to continue when it comes across incorrect code, and doesn't properly track errors into a listing (yet).**

docs/Readme.md

@@ -4,7 +4,7 @@
 
 Contains:
 
-* [AST_Design](./AST_Design.md): Overvie of ASTs
+* [AST_Design](./AST_Design.md): Overview of ASTs
 * [AST Types](./AST_Types.md): Listing of all AST types along with their Code type interface.
 * [Parsing](./Parsing.md): Overview of the parsing interface.
 * [Parser Algo](./Parser_Algo.md): In-depth breakdown of the parser's implementation.
@@ -26,7 +26,7 @@ This means that the typename entry for the parameter AST would be either:
 ***Concepts and Constraints are not supported***  
 Its a [todo](https://github.com/Ed94/gencpp/issues/21)
 
-### Feature Macros:
+### Feature Macros
 
 * `GEN_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing.
   * This can be generated using base.cpp.
@@ -36,10 +36,41 @@ Its a [todo](https://github.com/Ed94/gencpp/issues/21)
 * `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
 * `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
 * `GEN_DONT_ALLOW_INVALID_CODE` (Not implemented yet) : Will fail when an invalid code is constructed, parsed, or serialized.
-* `GEN_C_LIKE_PP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
+* `GEN_C_LIKE_CPP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
 
 ### The Data & Interface
 
+The library's persistent state is managed tracked by a context struct: `global Context* _ctx;` defined within [static_data.cpp](../base/components/static_data.cpp)
+
+https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/interface.hpp#L39-L97
+
+The interface for the context:
+
+* `init`: Initializtion
+* `deinit`: De-initialization.
+* `reset`: Clears the allocations, but doesn't free the memoery, then calls `init()` on `_ctx` again.
+* `get_context`: Retreive the currently tracked context.
+* `set_context`: Swap out the current tracked context.
+
+
+#### Allocato usage
+
+* `Allocator_DyanmicContainers`: Growing arrays, hash tables. (Unbounded sized containers)
+* `Allocator_Pool`: Fixed-sized object allocations (ASTs, etc)
+* `Allocator_StrCache`: StrCached allocations
+* `Allocator_Temp`: Temporary alloations mostly intended for StrBuilder usage. Manually cleared by the user by their own discretion.
+
+The allocator definitions used are exposed to the user incase they want to dictate memory usage
+
+* 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:
+
+```cpp
+    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
+```
+
+For any allocator above that the user does not define before `init`, a fallback allocator will be assigned that utiizes the `fallback_allocator_proc` wtihin [interface.cpp](../base/components/interface.cpp).
+
 As mentioned in root readme, the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
 
 The AST is managed by the library and provided to the user via its interface.  
@@ -47,14 +78,14 @@ However, the user may specifiy memory configuration.
 
 [Data layout of AST struct (Subject to heavily change with upcoming todos)](../base/components/ast.hpp#L396-461)  
 
-https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
+https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/ast.hpp#L369-L435
 
+*`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`*  
-*`StringCahced` is a typedef for `String const`, to denote it is an interned string*  
-*`String` is the dynamically allocated string type for the library*  
+*`StrBuilder` is the dynamically allocating string builder type for the library*  
 
-AST widths are setup to be AST_POD_Size.  
+AST widths are setup to be AST_POD_Size (128 bytes by default).
 The width dictates how much the static array can hold before it must give way to using an allocated array:
 
 ```cpp
@@ -63,7 +94,7 @@ int AST_ArrSpecs_Cap =
 (
     AST_POD_Size
     - sizeof(Code)
-    - sizeof(StringCached)
+    - sizeof(StrCached)
     - sizeof(Code) * 2
     - sizeof(Token*)
     - sizeof(Code)
@@ -73,41 +104,16 @@ int AST_ArrSpecs_Cap =
 )
 / sizeof(Specifier) - 1;
 ```
-
-*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
-
 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`.
-  * 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:
-
-```cpp
-    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
-```
-
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
 * Code types have member symbols but their data layout is enforced to be POD types.
 * This library treats memory failures as fatal.
 * 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).
-  * 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.
+  * `_ctx->Allocator_Temp` is used.
 * Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
-* Allocations can be tuned by defining the folloiwng macros (will be moved to runtime configuration in the future):
-  * `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
-  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
-  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
-  * `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
-  * `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
-  * `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
-  * `TokenMap_FixedArena` : token_fmt_va uses local_persit memory of this arena type for the hashtable.
-  * `GEN_LEX_ALLOCATOR_SIZE`
-  * `GEN_BUILDER_STR_BUFFER_RESERVE`
+  * Any modifcations to an existing AST should be to just construct another with the modifications done on-demand while traversing the AST (non-destructive).
 
 The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
 
@@ -117,6 +123,7 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeClass
 * CodeConstructor
 * CodeDefine
+* CodeDefineParams
 * CodeDestructor
 * CodeEnum
 * CodeExec
@@ -127,7 +134,7 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeModule
 * CodeNS
 * CodeOperator
-* CodeOpCast
+* CodeOpCast : User defined member operator conversion
 * CodeParams : Has support for `for : range` iterating across parameters.
 * CodePreprocessCond
 * CodePragma
@@ -140,11 +147,15 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeUsing
 * CodeVar
 
-Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
+Each `struct Code<Name>` has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
 Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
-Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
 
-## There are three sets of interfaces for Code AST generation the library provides
+For the interface related to these code types see:
+
+* [ast.hpp](../base/components/ast.hpp): Under the region pragma `Code C-Interface`
+* [code_types.hpp](../base/components/code_types.hpp): Under the region pragma `Code C-Interface`. Additional functionlity for c++ will be within the struct definitions or at the end of the file.
+
+## There are three categories of interfaces for Code AST generation & reflection
 
 * Upfront
 * Parsing
@@ -164,6 +175,7 @@ Interface :``
 * def_class
 * def_constructor
 * def_define
+* def_define_params
 * def_destructor
 * def_enum
 * def_execution
@@ -218,6 +230,27 @@ Code <name>
 
 ```
 
+All optional parmeters are defined within `struct Opts_def_<functon name>`. This was done to setup a [macro trick](https://x.com/vkrajacic/status/1749816169736073295) for default optional parameers in the C library:
+
+```cpp
+struct gen_Opts_def_struct
+{
+	gen_CodeBody       body;
+	gen_CodeTypename   parent;
+	gen_AccessSpec     parent_access;
+	gen_CodeAttributes attributes;
+	gen_CodeTypename*  interfaces;
+	gen_s32            num_interfaces;
+	gen_ModuleFlag     mflags;
+};
+typedef struct gen_Opts_def_struct gen_Opts_def_struct;
+
+GEN_API gen_CodeClass gen_def__struct( gen_Str name, gen_Opts_def_struct opts GEN_PARAM_DEFAULT );
+#define gen_def_struct( name, ... ) gen_def__struct( name, ( gen_Opts_def_struct ) { __VA_ARGS__ } )
+```
+
+In the C++ library, the `def_<funtion name>` is not wrapped in a macro.
+
 When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
 
 ```cpp
@@ -228,7 +261,7 @@ def_global_body( 3, ht_entry, array_ht_entry, hashtable );
 ```
 
 If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.
-When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
+When the members have been populated use: `code_validate_body` to verify that the members are valid entires for that type.
 
 ### Parse construction
 
@@ -238,12 +271,12 @@ Interface :
 
 * parse_class
 * parse_constructor
+* parse_define
 * parse_destructor
 * parse_enum
 * parse_export_body
 * parse_extern_link
 * parse_friend
-  * Purposefully are only support forward declares with this constructor.
 * parse_function
 * parse_global_body
 * parse_namespace
@@ -308,7 +341,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
@@ -322,6 +355,7 @@ Code        <name>       = parse_<function name>( gen_code_str );
 
 The following are provided predefined by the library as they are commonly used:
 
+* `enum_underlying_macro`
 * `access_public`
 * `access_protected`
 * `access_private`
@@ -403,7 +437,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

@@ -1,7 +1,5 @@
 ## Navigation
 
-# base
-
 [Top](../Readme.md)
 
 * [docs](../docs/Readme.md)
@@ -15,9 +13,133 @@ The output will be in the `gen_segmented/gen` directory (if the directory does n
 If using the library's provided build scripts:
 
 ```ps1
-.\build.ps1 <compiler> <debug or omit> c_library
+.\build.ps1 <compiler> <debug or omit> c_lib
 ```
 
-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.
+To generate a static or dynamic library:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> c_lib_static c_lib_dyn
+```
+
+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.**
+
+## Generation structure
+
+1. Files are scanned in or parsed.
+    * If they are parsed, its dude to requiring some changes to either naming, or adding additonal definitions (container generation, typedefs, etc).
+2. All scanned or parsed code is refactored (identifiers substs) and/or formatted.
+3. Singleheader generated.
+4. Segemented headers and source generated.
+
+## Templated container generation
+
+The array and hashtable containers used across this library are generated using the following implementatioon:
+
+* [containers.array.hpp](./components/containers.array.hpp)
+* [containers.hashtable.hpp](./components/containers.hashtable.hpp)
+
+These are functionally (and interface wise) equivalent to the library's `Array<Type>` `HashTable<Type>` within [containers.hpp](../base/dependencies/containers.hpp)
+
+Both files follow the same patter of providing three procedures:
+
+* `gen_<container>_base` : Intended to be called once, defines universal "base" definitions.
+* `gen_<container>` : Called per instatiation of the container for a given set of dependent args.
+* `gen_<container>_generic_selection_interface` : Intended to be called once after all of the instantiated containers have finished generating. It will generate a set of generic selection macros as described by Macro Usage section below.
+
+A simple `<container>_DefinitionCounter` is used to know how many instantiations of the template have occured. This is used to determine how to define `GENERIC_SLOT_<ID>_<functionID>` for the generic interface along with how many slots the `_Generic` macro will need to have generated.
+
+## Macro Usage
+
+For the most part macros are kept minimal with exception to `_Generic`...  
+*(I will be explaining this thing for the rest of this seciton along with gencpp c library's usage of it)*
+
+The `_Generic` macro plays a key role in reducing direct need of the user to wrangle with mangled definition identifiers of 'templated' containers or for type coercion to map distinct data types to a common code path.
+
+Because of its lack of use in many C11 libraries.. and, of those that do; they usually end up obfuscating it with excessive preprocessor abuse; Effort was put into minimizing how much of these macros are handled by the preprocessor vs gencpp itself.
+
+The usual presentation (done bare) is the following:
+
+```c
+#define macro_that_selects_typeof_arg(arg, y) \
+_Generic( (arg),                              \
+    int            : some expression,         \
+    double         : some other expression,   \
+    struct Whatnot : something else again,    \
+    default        : fallback expression      \
+)
+```
+
+Where `_Generic` can be considered the follwoing (psuedo-C):
+
+```c
+#define type_expr_pair(type, expr) type: expr
+
+C_Expression _Generic( selector_arg, a_type_expr_pair, ... ) {
+    switch( typeof(selector_arg)) {
+        case a_type_expr_pair:
+            return a_type_expr_pari.expr;
+        ...
+        default:
+            return default.expr;
+    }
+}
+```
+
+The first `arg` of _Generic behaves as the "controlling expression" or the expression that resolves to a type which will dictate which of the following expressions provided after to `_Generic` will be resolved as the one used inline for the implemenation.
+
+
+For this library's purposes we'll be using the functional macro equivalent *(if there is an exception I'll link it at the end of this section)*:
+
+```c
+#define macro_that_uses_selector_arg_for_resolving_a_fucntion( selecting_exp) \
+_Generic( (arg),                                                              \
+    int            : func_use_int,                                            \
+    double         : func_use_double,                                         \
+    struct Whatnot : func_use_Whatnot,                                        \
+    default        : struct SIGNALS_FAILURE                                   \
+) (selecting_exp)
+```
+
+In this case, we directly added `(selecting_exp)` to the end there.. as we want to directly have the macro resolve to calling a resolved procedure. A default has been set to a struct as that leads to a neat compiler message that would otherwise be impossible beause static_assert is a statement and thus cannot be used within a slot.
+
+Now, even with gencpp generating this type-expression table, we still need wrapper macros to achieve function 'overloading' for the templated containers as _Generic has a [significant drawback](https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/c11-generic/):  
+
+> Discarded expressions still have to be semantically valid.
+
+The only way to absolve this issue [(without resorting to nasty preprocessor hacks)](https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md) is with wrapping expressions in 'slot' resolving macros that do not expand if the slot is not defined:
+
+```c
+GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig )
+```
+
+`GENERIC_SLOT_1__function_sig` is our warpper of a "`int, func_use_int`" pair. The `GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT` is a verbse named macro to indicate that that pair will be expanded ***ONLY IF*** its defined.
+
+So for any given templated container interface. Expect the follwoing (taken straight from generation, and just cleaned up formatting):
+
+```c
+#define gen_array_append( selector_arg, ... ) _Generic(                         \
+(selector_arg ),                                                                \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_1__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_2__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_3__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_4__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_5__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_6__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_7__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_8__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_9__array_append )  \
+    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_10__array_append ) \
+    default: gen_generic_selection_fail                                         \
+) GEN_RESOLVED_FUNCTION_CALL( &selector_arg, __VA_ARGS__ )
+
+```
+
+*Note(Ed): Unfortunately I cannot get clang-format to output these macros sanely like the above..*  
+*Eventually I'll add some basic builtin formatting but if the user has suggestions for something better I'm open ears...*
+
+`GEN_RESOLVED_FUNCTION_CALL` is an empty define, its just to indicate that its intended to expand to a function call.
+
+To see the the actual macro definitions used - see: [generic_macros.h](./components/generic_macros.h). They'll be injected right after the usual macros in the generated header file.

gen_c_library/c_library.refactor

@@ -21,7 +21,7 @@ word global,                       gen_global
 word internal,                     gen_internal
 word local_persist,                gen_local_persist
 word bit,                          gen_bit
-word bitfield_is_equal,            gen_bitfield_is_equal
+word bitfield_is_set,              gen_bitfield_is_set
 word cast,                         gen_cast
 word ccast,                        gen_ccast
 word pcast,                        gen_pcast
@@ -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 String,       gen_String
+word StrBuilderHeader, gen_StrBuilderHeader
+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,15 @@ 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
+
+word MacroType,   gen_MacroType
+word EMacroFlags, gen_EMacroFlags
+word MacroFlags,  gen_MacroFlags
+word Macro,       gen_Macro
+
+namespace macro_,    gen_macro_
+namespace macrotype, gen_macrotype_
 
 // AST
 
@@ -325,6 +333,7 @@ word CodeComment,        gen_CodeComment
 word CodeClass,          gen_CodeClass
 word CodeConstructor,    gen_CodeConstructor
 word CodeDefine,         gen_CodeDefine
+word CodeDefineParams,   gen_CodeDefineParams
 word CodeDestructor,     gen_CodeDestructor
 word CodeEnum,           gen_CodeEnum
 word CodeExec,           gen_CodeExec
@@ -340,6 +349,7 @@ word CodePragma,         gen_CodePragma
 word CodeParams,         gen_CodeParams
 word CodePreprocessCond, gen_CodePreprocessCond
 word CodeSpecifiers,     gen_CodeSpecifiers
+word CodeStruct,         gen_CodeStruct
 word CodeTemplate,       gen_CodeTemplate
 word CodeTypename,       gen_CodeTypename
 word CodeTypedef,        gen_CodeTypedef
@@ -349,6 +359,8 @@ word CodeVar,            gen_CodeVar
 
 // Code Interface
 
+word Context, gen_Context
+
 namespace code_, gen_code_
 
 word Code_Global,  gen_Code_Global
@@ -396,16 +408,24 @@ namespace var_,        gen_var_
 
 // Gen Interface
 
+word _ctx, gen__ctx
+
 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
 
 namespace set_allocator_, gen_set_allocator_
 
+word register_macro,      gen_register_macro
+word register_macros,     gen_register_macros
+word register_macros_arr, gen_register_macros_arr
+
+namespace Opts_, gen_Opts_
+
 namespace def_,     gen_def_
 namespace parse_,   gen_parse_
 namespace token_,   gen_token_
@@ -413,20 +433,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
@@ -445,28 +451,20 @@ 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
+
+word CSV_Column,   gen_CSV_Column
+word CSV_Columns2, gen_CSV_Columns2
+
 // Implementation (prviate)
 
 word _format_info, gen__format_info
@@ -513,7 +511,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
 
@@ -522,7 +520,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

@@ -22,9 +22,9 @@ CodeBody gen_array_base()
 	Code get_header   = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" ));
 	Code type_define  = untyped_str( txt( "#define Array(Type) gen_Array_##Type\n"));
 
-	Code array_begin = def_define(txt("array_begin(array)"),       code( (array) ));
-	Code array_end   = def_define(txt("array_end(array)"),         code( (array + array_get_header(array)->Num ) ));
-	Code array_next  = def_define(txt("array_next(array, entry)"), code( (entry + 1) ));
+	Code array_begin = def_define(txt("array_begin(array)"),       MT_Expression, { {}, code( (array) ) } );
+	Code array_end   = def_define(txt("array_end(array)"),         MT_Expression, { {}, code( (array + array_get_header(array)->Num ) ) } );
+	Code array_next  = def_define(txt("array_next(array, entry)"), MT_Expression, { {}, code( (entry + 1) ) } );
 
 	return def_global_body( args(
 		fmt_newline,
@@ -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 );
-	String fn         = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
-	// str_to_lower(fn.Data);
+	StrBuilder array_type = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
+	StrBuilder fn         = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
+	// 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>;
 
@@ -238,10 +238,10 @@ CodeBody gen_array( StrC type, StrC array_name )
 			GEN_ASSERT(begin <= end);
 			ArrayHeader* header = array_get_header( self );
 
-			if ( begin < 0 || end >= header->Num )
+			if ( begin < 0 || end > header->Num )
 				return false;
 
-			for ( ssize idx = begin; idx < end; idx ++ )
+			for ( ssize idx = (ssize)begin; idx < (ssize)end; idx ++ )
 				self[ idx ] = value;
 
 			return true;
@@ -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

@@ -19,7 +19,7 @@ CodeBody gen_hashtable_base()
 	));
 
 	Code define_type = untyped_str(txt(
-R"(#define HashTable(_type) struct _type
+R"(#define HashTable(_type) struct gen_HashTable_##_type
 )"
 	));
 
@@ -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};
-	String fn       = tbl_type.duplicate(GlobalAllocator);
-	// str_to_lower(fn.Data);
+	StrBuilder tbl_type = {(char*) hashtable_name.duplicate(_ctx->Allocator_Temp).Ptr};
+	StrBuilder fn       = tbl_type.duplicate(_ctx->Allocator_Temp);
+	// c_str_to_lower(fn.Data);
 
-	String name_lower = String::make( GlobalAllocator, hashtable_name );
-	// str_to_lower( name_lower.Data );
+	StrBuilder name_lower = StrBuilder::make( _ctx->Allocator_Temp, hashtable_name );
+	// c_str_to_lower( name_lower.Data );
 
-	String hashtable_entry   = String::fmt_buf( GlobalAllocator, "HTE_%.*s",     hashtable_name.Len, hashtable_name.Ptr );
-	String entry_array_name  = String::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
-	String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
+	StrBuilder hashtable_entry   = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "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 );
+	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,
-		"tbl_name",    (StrC) hashtable_name,
-		"tbl_type",    (StrC) tbl_type,
+		"type",        (Str) type,
+		"tbl_name",    (Str) hashtable_name,
+		"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,
-		"tbl_name",       (StrC) hashtable_name,
-		"tbl_type",       (StrC) tbl_type,
-		"fn",             (StrC) fn,
-		"entry_type",     (StrC) hashtable_entry,
-		"array_entry",    (StrC) entry_array_name,
-		"fn_array",       (StrC) entry_array_fn_ns,
+		"type",           (Str) type,
+		"tbl_name",       (Str) hashtable_name,
+		"tbl_type",       (Str) tbl_type,
+		"fn",             (Str) fn,
+		"entry_type",     (Str) hashtable_entry,
+		"array_entry",    (Str) entry_array_name,
+		"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 /  __/ | | | | (_) | (_| | (_| || | | | | (_| |
-//  \____/ \___}_l l_l\___}_l  l_l\___| l_l   \__,_l_l l_l\___}\__}_l\___/l_l l_l  \____/  \_/ \___}_l l_l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
+// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| |  __} | | | '_ \ / __} __} |/ _ \| '_ \  | |  | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
+// | |__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|_|_| |_|\__, |
 // 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(       \
-(selector_arg), /* Select Via Expression*/                           \
-  /* Extendibility slots: */                                         \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
-	default: gen_generic_selection_fail                              \
+#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic(             \
+(selector_arg), /* Select Via Expression*/                                 \
+  /* Extendibility slots: */                                               \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
+	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(       \
-(function_arguments), /* Select Via Expression*/               \
-  /* Extendibility slots: */                                   \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_2 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_3 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_4 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_5 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_6 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_7 ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_8 ) \
-	default: gen_generic_selection_fail                        \
+#define gen_hash_example( function_arguments ) _Generic(                      \
+(function_arguments), /* Select Via Expression*/                              \
+  /* Extendibility slots: */                                                  \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_3_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_4_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_5_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_6_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_7_gen_example_hash ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_8_gen_example_hash ) \
+	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( FunctionID__ARGS_SIG_2 )        \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig )  \
+	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( FunctionID__ARGS_SIG_2 )       \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
+	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/header_start.hpp

@@ -13,7 +13,7 @@
 	|  \_____|\___}_l |_|\___} .__/| .__/ {_____/ \__\__/_l\__. |\___/\__,_l   \____}{_____}{_____} |
 	|                        | |   | |                      __} |                                   |
 	|                        l_l   l_l                     {___/                                    |
-	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha  |
+	! ----------------------------------------------------------------------- VERSION: v0.23-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  |

gen_c_library/components/memory.fixed_arena.hpp

@@ -89,7 +89,14 @@ CodeBody gen_fixed_arenas()
 	result.append(arena_interface_2mb);
 	result.append(arena_interface_4mb);
 
-	CodeDefine def = def_define(txt("fixed_arena_allocator_info(fixed_arena)"), txt("( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )"));
+	register_macros( args(
+		( Macro { txt("fixed_arena_allocator_info"), MT_Expression, MF_Functional }),
+		( Macro { txt("fixed_arena_init"),           MT_Expression, MF_Functional }),
+		( Macro { txt("fixed_arena_free"),           MT_Expression, MF_Functional }),
+		( Macro { txt("fixed_arena_size_remaining"), MT_Expression, MF_Functional })
+	));
+
+	CodeDefine def = parse_define(txt("#define fixed_arena_allocator_info(fixed_arena) ( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )\n"));
 	result.append(def);
 	result.append(fmt_newline);
 

gen_c_library/components/misc.hpp

@@ -7,30 +7,30 @@ void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
 {
 #pragma push_macro("enum_underlying")
 #undef enum_underlying
+	StrCached type = to_convert->UnderlyingType ? to_convert->UnderlyingType.to_strbuilder().to_str() : to_convert->Name;
+	CodeTypedef tdef = parse_typedef(token_fmt("type", type, "name", to_convert->Name, stringize( typedef enum <type> <name>; )));
 	if (to_convert->UnderlyingType)
 	{
 		to_convert->UnderlyingTypeMacro = untyped_str(token_fmt("type", to_convert->UnderlyingType->Name, stringize(enum_underlying(<type>))));
 		to_convert->UnderlyingType      = CodeTypename{nullptr};
 	}
-	CodeTypedef tdef = parse_typedef(token_fmt("name", to_convert->Name, stringize( typedef enum <name> <name>; )));
 	to_append.append(to_convert);
 	to_append.append(tdef);
 #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;
-		++ entry_iter;
-		for(b32 continue_for = true; continue_for && entry_iter != parsed_body.end(); ) switch
-		(entry_iter->Type) {
+		s32 depth = 0;
+		for(b32 continue_for = true; continue_for && entry_iter != parsed_body.end(); ) switch (entry_iter->Type)
+		{
 			case CT_Preprocess_If:
 			case CT_Preprocess_IfDef:
 			case CT_Preprocess_IfNotDef:
@@ -40,20 +40,18 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& par
 
 			case CT_Preprocess_Else:
 				++ entry_iter;
-				for(; continue_for && entry_iter != parsed_body.end(); ++ entry_iter)
+				if (depth == 1) for(; entry_iter != parsed_body.end(); ++ entry_iter)
 				{
-					if (entry_iter->Type == CT_Preprocess_EndIf)
-					{
-						continue_for = false;
+					if ( entry_iter->Type == CT_Preprocess_EndIf)
 						break;
-					}
+
 					body.append(entry_iter);
 				}
 			break;
 
 			case CT_Preprocess_EndIf:
 			{
-				depth --;
+				-- depth;
 				if (depth == 0) {
 					continue_for = false;
 					break;
@@ -72,7 +70,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 +82,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 +102,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();
-		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;
-		}
-
+		Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", slot).to_str();
 		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;
-    String new_name;
+    Str        old_name = fn->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 +179,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 +195,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 +204,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);
-	String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
+	StrBuilder region_sig    = strbuilder_fmt_buf(_ctx->Allocator_Temp, "region %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,8 +0,0 @@
-#define GEN_IMPLEMENTATION
-#include "gen/gen.c"
-
-int main()
-{
-	// init();
-	__debugbreak();
-}

gen_c_library/gen_c_lib.c

@@ -0,0 +1,3 @@
+#define GEN_IMPLEMENTATION
+#define GEN_DONT_ENFORCE_GEN_TIME_GUARD
+#include "gen/gen_singleheader.h"

gen_segmented/Readme.md

@@ -8,11 +8,13 @@
 
 # Segemented Library Generation
 
+Create a segemented library using `segemented.cpp`
+
 The principal (user) files are `gen.hpp` and `gen.cpp`.
 They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
 
 Dependencies are bundled into `gen.dep.<hpp/cpp>`. They are included in `gen.<hpp/cpp>` before component includes.
-Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`
+Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`. The auxillary content (builder & scanner) is given their own files.
 
 If using the library's provided build scripts:
 

gen_segmented/segmented.cpp

@@ -2,7 +2,6 @@
 
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
 #define GEN_C_LIKE_CPP 1
 #include "gen.cpp"
 #include "helpers/push_ignores.inline.hpp"
@@ -32,7 +31,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 +119,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 +137,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 +157,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 +177,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);
 	}
@@ -186,16 +192,11 @@ int gen_main()
 		Code        interface	       = scan_file( path_base "components/interface.cpp" );
 		Code        upfront 	       = scan_file( path_base "components/interface.upfront.cpp" );
 		Code        lexer              = scan_file( path_base "components/lexer.cpp" );
+		Code        parser_case_macros = scan_file( path_base "components/parser_case_macros.cpp" );
 		Code        parser             = scan_file( path_base "components/parser.cpp" );
 		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,8 +216,8 @@ 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_case_macros );
 		builder_print( src, parser );
 		builder_print( src, parsing_interface );
 		builder_print_fmt( src, "\n#pragma endregion Parsing\n\n" );
@@ -238,7 +239,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 +279,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/components/header_start.hpp

@@ -15,7 +15,7 @@
 	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
 	|     Singleheader       | |   | |                      __} |                                  |
 	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
+	! ----------------------------------------------------------------------- VERSION: v0.23-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 |

gen_singleheader/singleheader.cpp

@@ -1,6 +1,5 @@
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
 #include "gen.cpp"
 #include "helpers/push_ignores.inline.hpp"
 
@@ -17,24 +16,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 +53,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 +77,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 +93,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 +105,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 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" );
-		Code interface  = scan_file( path_base "components/interface.hpp" );
-		Code inlines 	= scan_file( path_base "components/inlines.hpp" );
-		Code header_end = scan_file( path_base "components/header_end.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" );
+		Code interface    = scan_file( path_base "components/interface.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 +137,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 +161,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 +186,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 );
@@ -198,22 +209,21 @@ int gen_main()
 			header.print_fmt( roll_own_dependencies_guard_end );
 		}
 
-		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" );
-		Code code              = scan_file( path_base "components/code_serialization.cpp" );
-		Code interface         = scan_file( path_base "components/interface.cpp" );
-		Code upfront           = scan_file( path_base "components/interface.upfront.cpp" );
-		Code lexer             = scan_file( path_base "components/lexer.cpp" );
-		Code parser            = scan_file( path_base "components/parser.cpp" );
-		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)) );
+		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" );
+		Code code               = scan_file( path_base "components/code_serialization.cpp" );
+		Code interface          = scan_file( path_base "components/interface.cpp" );
+		Code upfront            = scan_file( path_base "components/interface.upfront.cpp" );
+		Code lexer              = scan_file( path_base "components/lexer.cpp" );
+		Code parser_case_macros = scan_file( path_base "components/parser_case_macros.cpp" );
+		Code parser             = scan_file( path_base "components/parser.cpp" );
+		Code parsing_interface  = scan_file( path_base "components/interface.parsing.cpp" );
+		Code untyped            = scan_file( path_base "components/interface.untyped.cpp" );
 
 		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,25 @@ 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_case_macros );
 		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 +262,6 @@ int gen_main()
 	header.print( pop_ignores );
 	header.write();
 
-	gen::deinit();
+	gen::deinit( & ctx);
 	return 0;
 }

gen_unreal_engine/Readme.md

@@ -15,3 +15,20 @@ If using the library's provided build scripts:
 ```ps1
 .\build.ps1 <compiler> <debug or omit> unreal
 ```
+
+## Notables
+
+For the most part this follows the same conventions as `gen_segmented`.
+
+This generator uses a separate enumeration definitions for the following:
+
+* [AttributeTokens.csv](./enums/AttributeTokens.csv) : Add your own <MODULE>_API attributes, etc here that are encountered within the Engine.
+* [ESpecifier.csv](./enums/ESpecifier.csv) : Adds the `FORCEINLINE` & `FORCEINLINE_DEBUGGABLE` specfiers (additions are made as they are encountered)
+* [ETokType.csv](./enums/ETokType.csv) : Same modifications as ESpecifier.csv.
+
+A separate [parser_case_macros.cpp](./components/parser_case_macros.cpp) is used to accomodate for the new forceinline specifiers.
+
+The `global` macro the library uses is redefined as an empty substiution.
+
+
+The expected usage of this library is to put into into a third-party plugin module to then use either in editor modules or in shell script done in some stage of hot-reloading or building the Unreal Engine or Project.

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
-
-	! ----------------------------------------------------------------------- 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 !
-	! ============================================================================================ !
+	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
+	|   _____                               _____ _                       _                        |
+	|  / ____)                             / ____} |                     | |                       |
+	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
+	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
+	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
+	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
+	|  Unreal Engine         | |   | |                      __} |                                  |
+	|                        l_l   l_l                     {___/                                   |
+	! ----------------------------------------------------------------------- VERSION: v0.23-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/components/parser_case_macros.cpp

@@ -0,0 +1,114 @@
+// These macros are used in the swtich cases within parser.cpp
+
+#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
+case Tok_Spec_Consteval:              \
+case Tok_Spec_Constexpr:              \
+case Tok_Spec_Constinit:              \
+case Tok_Spec_Explicit:               \
+case Tok_Spec_ForceInline:            \
+case Tok_Spec_ForceInline_Debuggable: \
+case Tok_Spec_Inline:                 \
+case Tok_Spec_Mutable:                \
+case Tok_Spec_NeverInline:            \
+case Tok_Spec_Static:                 \
+case Tok_Spec_Volatile:               \
+case Tok_Spec_Virtual
+
+#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_SPECIFIER_CASES \
+case Spec_Constexpr:              \
+case Spec_Constinit:              \
+case Spec_Explicit:               \
+case Spec_Inline:                 \
+case Spec_ForceInline:            \
+case Spec_ForceInline_Debuggable: \
+case Spec_Mutable:                \
+case Spec_NeverInline:            \
+case Spec_Static:                 \
+case Spec_Volatile:               \
+case Spec_Virtual
+
+#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
+case Tok_Spec_Consteval:              \
+case Tok_Spec_Constexpr:              \
+case Tok_Spec_Constinit:              \
+case Tok_Spec_Extern:                 \
+case Tok_Spec_ForceInline:            \
+case Tok_Spec_ForceInline_Debuggable: \
+case Tok_Spec_Global:                 \
+case Tok_Spec_Inline:                 \
+case Tok_Spec_Internal_Linkage:       \
+case Tok_Spec_NeverInline:            \
+case Tok_Spec_Static
+
+#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \
+case Spec_Constexpr:              \
+case Spec_Constinit:              \
+case Spec_ForceInline:            \
+case Spec_ForceInline_Debuggable: \
+case Spec_Global:                 \
+case Spec_External_Linkage:       \
+case Spec_Internal_Linkage:       \
+case Spec_Inline:                 \
+case Spec_Mutable:                \
+case Spec_NeverInline:            \
+case Spec_Static:                 \
+case Spec_Volatile
+
+#define GEN_PARSER_FRIEND_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:       \
+case Spec_Inline:      \
+case Spec_ForceInline
+
+#define GEN_PARSER_FUNCTION_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:                  \
+case Spec_Consteval:              \
+case Spec_Constexpr:              \
+case Spec_External_Linkage:       \
+case Spec_Internal_Linkage:       \
+case Spec_ForceInline:            \
+case Spec_ForceInline_Debuggable: \
+case Spec_Inline:                 \
+case Spec_NeverInline:            \
+case Spec_Static
+
+#define GEN_PARSER_OPERATOR_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:       \
+case Spec_Constexpr:   \
+case Spec_ForceInline: \
+case Spec_Inline:      \
+case Spec_NeverInline: \
+case Spec_Static
+
+#define GEN_PARSER_TEMPLATE_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:                  \
+case Spec_Constexpr:              \
+case Spec_Constinit:              \
+case Spec_External_Linkage:       \
+case Spec_Global:                 \
+case Spec_Inline:                 \
+case Spec_ForceInline:            \
+case Spec_ForceInline_Debuggable: \
+case Spec_Local_Persist:          \
+case Spec_Mutable:                \
+case Spec_Static:                 \
+case Spec_Thread_Local:           \
+case Spec_Volatile
+
+#define GEN_PARSER_VARIABLE_ALLOWED_SPECIFIER_CASES \
+case Spec_Const:            \
+case Spec_Constexpr:        \
+case Spec_Constinit:        \
+case Spec_External_Linkage: \
+case Spec_Global:           \
+case Spec_Inline:           \
+case Spec_Local_Persist:    \
+case Spec_Mutable:          \
+case Spec_Static:           \
+case Spec_Thread_Local:     \
+case Spec_Volatile
+
+#define GEN_PARSER_TYPENAME_ALLOWED_SUFFIX_SPECIFIER_CASES \
+case Spec_Const:    \
+case Spec_Ptr:      \
+case Spec_Ref:      \
+case Spec_RValue

gen_unreal_engine/enums/AttributeTokens.csv

@@ -4,4 +4,4 @@ COREUOBJECT_API,       COREUOBJECT_API
 ENGINE_API,            ENGINE_API
 GAMEPLAYABILITIES_API, GAMEPLAYABILITIES_API
 UMG_API,               UMG_API
-UE_DEPRECATED,         UE_DEPRECATED
+GASA_API,              GASA_API

gen_unreal_engine/enums/ESpecifier.csv

@@ -0,0 +1,27 @@
+Invalid,                INVALID
+Consteval,              consteval
+Constexpr,              constexpr
+Constinit,              constinit
+Explicit,               explicit
+External_Linkage,       extern
+ForceInline, 	        FORCEINLINE
+ForceInline_Debuggable, FORCEINLINE_DEBUGGABLE
+Global,                 global
+Inline,                 inline
+Internal_Linkage,       internal
+Local_Persist,          local_persist
+Mutable,                mutable
+NeverInline,            neverinline
+Ptr,                    *
+Ref,                    &
+Register,               register
+RValue,                 &&
+Static,                 static
+Thread_Local,           thread_local
+Virtual,                virtual
+Const,                  const
+Final,                  final
+NoExceptions,           noexcept
+Override,               override
+Pure,                   = 0
+Volatile,               volatile

gen_unreal_engine/enums/ETokType.csv

@@ -0,0 +1,99 @@
+Invalid,                     "__invalid__"
+Access_Private,              "private"
+Access_Protected,            "protected"
+Access_Public,               "public"
+Access_MemberSymbol,         "."
+Access_StaticSymbol,         "::"
+Ampersand,                   "&"
+Ampersand_DBL,               "&&"
+Assign_Classifer,            ":"
+Attribute_Open,              "[["
+Attribute_Close,             "]]"
+BraceCurly_Open,             "{"
+BraceCurly_Close,            "}"
+BraceSquare_Open,            "["
+BraceSquare_Close,           "]"
+Paren_Open,                  "("
+Paren_Close,                 ")"
+Comment,                     "__comment__"
+Comment_End,                 "__comment_end__"
+Comment_Start,               "__comment_start__"
+Char,                        "__character__"
+Comma,                       ","
+Decl_Class,                  "class"
+Decl_GNU_Attribute,          "__attribute__"
+Decl_MSVC_Attribute,         "__declspec"
+Decl_Enum,                   "enum"
+Decl_Extern_Linkage,         "extern"
+Decl_Friend,                 "friend"
+Decl_Module,                 "module"
+Decl_Namespace,              "namespace"
+Decl_Operator,               "operator"
+Decl_Struct,                 "struct"
+Decl_Template,               "template"
+Decl_Typedef,                "typedef"
+Decl_Using,                  "using"
+Decl_Union,                  "union"
+Identifier,                  "__identifier__"
+Module_Import,               "import"
+Module_Export,               "export"
+NewLine,                     "__new_line__"
+Number,                      "__number__"
+Operator,                    "__operator__"
+Preprocess_Hash,             "#"
+Preprocess_Define,           "define"
+Preprocess_Define_Param,     "__define_param__"
+Preprocess_If,               "if"
+Preprocess_IfDef,            "ifdef"
+Preprocess_IfNotDef,         "ifndef"
+Preprocess_ElIf,             "elif"
+Preprocess_Else,             "else"
+Preprocess_EndIf,            "endif"
+Preprocess_Include,          "include"
+Preprocess_Pragma,           "pragma"
+Preprocess_Content,          "__macro_content__"
+Preprocess_Macro_Expr,      "__macro_expression__"
+Preprocess_Macro_Stmt,      "__macro_statment__"
+Preprocess_Macro_Typename,  "__macro_typename__"
+Preprocess_Unsupported,      "__unsupported__"
+Spec_Alignas,                "alignas"
+Spec_Const,                  "const"
+Spec_Consteval,              "consteval"
+Spec_Constexpr,              "constexpr"
+Spec_Constinit,              "constinit"
+Spec_Explicit,               "explicit"
+Spec_Extern,                 "extern"
+Spec_Final,                  "final"
+Spec_ForceInline,            "FORCEINLINE"
+Spec_ForceInline_Debuggable, "FORCEINLINE_DEBUGGABLE"
+Spec_Global,                 "global"
+Spec_Inline,                 "inline"
+Spec_Internal_Linkage,       "internal"
+Spec_LocalPersist,           "local_persist"
+Spec_Mutable,                "mutable"
+Spec_NeverInline,            "neverinline"
+Spec_Override,               "override"
+Spec_Static,                 "static"
+Spec_ThreadLocal,            "thread_local"
+Spec_Volatile,               "volatile"
+Spec_Virtual,                "virtual"
+Star,                        "*"
+Statement_End,               ";"
+StaticAssert,                "static_assert"
+String,                      "__string__"
+Type_Typename,               "typename"
+Type_Unsigned,               "unsigned"
+Type_Signed,                 "signed"
+Type_Short,                  "short"
+Type_Long,                   "long"
+Type_bool,                   "bool"
+Type_char,                   "char"
+Type_int,                    "int"
+Type_double,                 "double"
+Type_MS_int8,                "__int8"
+Type_MS_int16,               "__int16"
+Type_MS_int32,               "__int32"
+Type_MS_int64,               "__int64"
+Type_MS_W64,                 "_W64"
+Varadic_Argument,            "..."
+__Attributes_Start,          "__attrib_start__"

gen_unreal_engine/unreal.cpp

@@ -1,6 +1,5 @@
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
 #include "gen.cpp"
 #include "helpers/push_ignores.inline.hpp"
 
@@ -17,25 +16,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 +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" );
@@ -63,12 +63,52 @@ int gen_main()
 	Code ue_forceinline = code_str(FORCEINLINE);
 	// Code
 
+	register_macros( args(
+		(Macro { txt("bit"),                          MT_Expression, MF_Functional }),
+		(Macro { txt("bitfield_is_set"),              MT_Expression, MF_Functional }),
+		(Macro { txt("GEN_C_LIKE_CPP"),               MT_Expression, MF_Null       }),
+		(Macro { txt("cast"),                         MT_Expression, MF_Functional }),
+		(Macro { txt("ccast"),                        MT_Expression, MF_Functional }),
+		(Macro { txt("rcast"),                        MT_Expression, MF_Functional }),
+		(Macro { txt("pcast"),                        MT_Expression, MF_Functional }),
+		(Macro { txt("scast"),                        MT_Expression, MF_Functional }),
+		(Macro { txt("stringize_va"),                 MT_Expression, MF_Functional }),
+		(Macro { txt("stringize"),                    MT_Expression, MF_Functional }),
+		(Macro { txt("do_once"),                      MT_Expression, MF_Functional }), 
+		(Macro { txt("do_once_defer"),                MT_Expression, MF_Functional }),
+		(Macro { txt("do_once_start"),                MT_Statement,  MF_Null       }), 
+		(Macro { txt("do_once_end"),                  MT_Statement,  MF_Null       }), 
+		(Macro { txt("labeled_scope_start"),          MT_Statement,  MF_Null       }), 
+		(Macro { txt("labeled_scope_end"),            MT_Statement,  MF_Null       }), 
+		(Macro { txt("compiler_decorated_func_name"), MT_Expression, MF_Null       }), 
+		(Macro { txt("num_args_impl"),                MT_Expression, MF_Functional }),
+		(Macro { txt("num_args"),                     MT_Expression, MF_Functional }),
+		(Macro { txt("count_of"),                     MT_Expression, MF_Functional }),
+		(Macro { txt("clamp"),                        MT_Expression, MF_Functional }),
+		(Macro { txt("is_between"),                   MT_Expression, MF_Functional }),
+		(Macro { txt("size_of"),                      MT_Expression, MF_Functional }),
+		(Macro { txt("min"),                          MT_Expression, MF_Functional }),
+		(Macro { txt("max"),                          MT_Expression, MF_Functional }),
+		(Macro { txt("offset_of"),                    MT_Expression, MF_Functional }),
+		(Macro { txt("static_assert"),                MT_Statement,  MF_Functional }),
+		(Macro { txt("typeof"),                       MT_Expression, MF_Null       }),
+		(Macro { txt("GEN_API_C_BEGIN"),              MT_Statement,  MF_Null       }),
+		(Macro { txt("GEN_API_C_END"),                MT_Statement,  MF_Null       }),
+		(Macro { txt("nullptr"),                      MT_Expression, MF_Null       }),
+		(Macro { txt("GEN_REMOVE_PTR"),               MT_Expression, MF_Functional }),
+		(Macro { txt("GEN_PARAM_DEFAULT"),            MT_Expression, MF_Null       }),
+		(Macro { txt("struct_init"),                  MT_Expression, MF_Functional }),
+		(Macro { txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"),  MT_Statement,  MF_Null       }),
+		(Macro { txt("GEN_OPITMIZE_MAPPINGS_END"),    MT_Statement,  MF_Null       }),
+		(Macro { txt("src_line_str"),                 MT_Expression, MF_Null       })
+	));
+
 	// gen_dep.hpp
 	{
 		CodeBody macros = def_body( CT_Global_Body );
 		{
-			FileContents content    = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" );
-			CodeBody     ori_macros = parse_global_body( StrC { content.size, (char const*)content.data });
+			FileContents content    = file_read_contents( ctx.Allocator_Temp, file_zero_terminate, path_base "dependencies/macros.hpp" );
+			CodeBody     ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
 
 			for (Code	code =  ori_macros.begin();
 						code != ori_macros.end();
@@ -107,6 +147,7 @@ int gen_main()
 		Code strings      = scan_file( path_base "dependencies/strings.hpp" );
 		Code filesystem   = scan_file( path_base "dependencies/filesystem.hpp" );
 		Code timing       = scan_file( path_base "dependencies/timing.hpp" );
+		Code parsing      = scan_file( path_base "dependencies/parsing.hpp" );
 
 		Builder
 		header = Builder::open("gen/gen.dep.hpp");
@@ -128,6 +169,7 @@ int gen_main()
 		header.print( strings );
 		header.print( filesystem );
 		header.print( timing );
+		header.print(parsing);
 
 		header.print_fmt( "\nGEN_NS_END\n" );
 		header.print( fmt_newline );
@@ -146,6 +188,7 @@ int gen_main()
 		Code strings    = scan_file( path_base "dependencies/strings.cpp" );
 		Code filesystem = scan_file( path_base "dependencies/filesystem.cpp" );
 		Code timing     = scan_file( path_base "dependencies/timing.cpp" );
+		Code parsing    = scan_file( path_base "dependencies/parsing.cpp" );
 
 		Builder
 		src = Builder::open( "gen/gen.dep.cpp" );
@@ -164,6 +207,7 @@ int gen_main()
 		src.print( strings );
 		src.print( filesystem );
 		src.print( timing );
+		src.print( parsing );
 
 		src.print_fmt( "\nGEN_NS_END\n" );
 		src.print( fmt_newline );
@@ -175,6 +219,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" );
@@ -184,9 +229,14 @@ 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 especifier  = gen_especifier(           "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( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
+
 		Builder
 		header = Builder::open( "gen/gen.hpp" );
 		header.print_fmt( generation_notice );
@@ -205,6 +255,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 +275,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" );
@@ -238,15 +290,11 @@ int gen_main()
 		Code        interface	       = scan_file( path_base "components/interface.cpp" );
 		Code        upfront 	       = scan_file( path_base "components/interface.upfront.cpp" );
 		Code        lexer              = scan_file( path_base "components/lexer.cpp" );
+		Code        parser_case_macros = scan_file(           "components/parser_case_macros.cpp" );
 		Code        parser             = scan_file( path_base "components/parser.cpp" );
 		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 );
@@ -266,14 +314,20 @@ int gen_main()
 
 		src.print_fmt( "\n#pragma region Interface\n" );
 		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_case_macros );
 		src.print( parser );
 		src.print( parsing_interface );
-		src.print( untyped );
 		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
+
+		src.print_fmt( "\n#pragma region Untyped\n\n" );
+		src.print( untyped );
+		src.print_fmt( "#pragma endregion \n\n" );
+
 		src.print_fmt( "#pragma endregion Interface\n\n" );
 
 		src.print_fmt( "GEN_NS_END\n\n");
@@ -294,7 +348,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();
@@ -320,7 +374,6 @@ int gen_main()
 
 	// gen_scanner.hpp
 	{
-		Code parsing = scan_file( path_base "dependencies/parsing.hpp" );
 		Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
 
 		Builder
@@ -331,9 +384,8 @@ int gen_main()
 		header.print( fmt_newline );
 		header.print( def_include( txt("gen.hpp") ) );
 		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();
@@ -341,7 +393,6 @@ int gen_main()
 
 	// gen.scanner.cpp
 	{
-		Code parsing = scan_file( path_base "dependencies/parsing.cpp" );
 		Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
 
 		Builder
@@ -351,9 +402,8 @@ int gen_main()
 		src.print( fmt_newline );
 		src.print( def_include( txt("gen.scanner.hpp") ) );
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
-		src.print( parsing );
-		// src.print( scanner );
-		src.print_fmt( "GEN_NS_END\n" );
+		src.print( scanner );
+		src.print_fmt( "\nGEN_NS_END\n" );
 		src.print( fmt_newline );
 		src.print( pop_ignores );
 		src.write();

gencpp.10x

@@ -1,79 +0,0 @@
-<?xml version="1.0"?>
-<N10X>
-	<Workspace>
-		<IncludeFilter>&amp;apos;.&amp;apos;,**/project/**,</IncludeFilter>
-		<ExcludeFilter>*.obj,*.lib,*.pch,*.dll,*.pdb,.vs,Debug,Release,x64,obj,*.user,Intermediate,**/sanity.gen.hpp,**/gen_c_library,**/gen_segmented,**/gen_singlheader,**/test,**/gen_unreal_engine,**/scripts,**/docs,</ExcludeFilter>
-		<SyncFiles>true</SyncFiles>
-		<Recursive>true</Recursive>
-		<ShowEmptyFolders>true</ShowEmptyFolders>
-		<IncludeFilesWithoutExt>false</IncludeFilesWithoutExt>
-		<IsVirtual>false</IsVirtual>
-		<IsFolder>false</IsFolder>
-		<BuildCommand>pwsh ./scripts/build.ps1 msvc debug bootstrap</BuildCommand>
-		<RebuildCommand>pwsh ./scripts/build.ps1 msvc debug c_library</RebuildCommand>
-		<BuildFileCommand></BuildFileCommand>
-		<CleanCommand>pwsh ./scripts/clean.ps1</CleanCommand>
-		<BuildWorkingDirectory></BuildWorkingDirectory>
-		<CancelBuild></CancelBuild>
-		<Exe>./test/gen/build/gencpp.exe</Exe>
-		<Args></Args>
-		<WorkingDirectory></WorkingDirectory>
-		<DebugCommand>pwsh ./scripts/build.ps1</DebugCommand>
-		<DebugSln></DebugSln>
-		<UseVisualStudioEnvBat>true</UseVisualStudioEnvBat>
-		<CaptureExeOutput>false</CaptureExeOutput>
-		<Configurations>
-			<Configuration>Debug</Configuration>
-			<Configuration>Release</Configuration>
-			<Configuration>bootstrap debug</Configuration>
-		</Configurations>
-		<Platforms>
-			<Platform>x64</Platform>
-		</Platforms>
-		<AdditionalIncludePaths>
-			<AdditionalIncludePath>C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Tools\MSVC\14.36.32532\include</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Tools\MSVC\14.36.32532\ATLMFC\include</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\VS\include</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\include\10.0.22621.0\ucrt</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.22621.0\\um</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.22621.0\\shared</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.22621.0\\winrt</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.22621.0\\cppwinrt</AdditionalIncludePath>
-			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\NETFXSDK\4.8\include\um</AdditionalIncludePath>
-		</AdditionalIncludePaths>
-		<Defines>
-			<Define>GEN_TIME</Define>
-			<Define>GEN_SYSTEM_WINDOWS</Define>
-			<Define>GEN_INTELLISENSE_DIRECTIVES</Define>
-			<Define>GEN_EXECUTION_EXPRESSION_SUPPORT</Define>
-			<Define>GEN_BENCHMARK</Define>
-			<Define>GEN_COMPILER_MSVC</Define>
-			<Define>GEN_IMPLEMENTATION</Define>
-		</Defines>
-		<ConfigProperties>
-			<ConfigAndPlatform>
-				<Name>Debug:x64</Name>
-				<Defines></Defines>
-				<ForceIncludes></ForceIncludes>
-			</ConfigAndPlatform>
-			<ConfigAndPlatform>
-				<Name>bootstrap debug:x64</Name>
-				<Defines></Defines>
-				<ForceIncludes></ForceIncludes>
-			</ConfigAndPlatform>
-			<Config>
-				<Name>Debug</Name>
-				<Defines></Defines>
-			</Config>
-			<Config>
-				<Name>bootstrap debug</Name>
-				<Defines></Defines>
-			</Config>
-			<Platform>
-				<Name>x64</Name>
-				<Defines></Defines>
-			</Platform>
-		</ConfigProperties>
-		<Children></Children>
-	</Workspace>
-</N10X>

gencpp.sln

@@ -1,48 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.5.33516.290
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gencpp", "gencpp.vcxproj", "{53AF600D-C09C-4F39-83E0-E022AA9479F2}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		bootstrap debug|x64 = bootstrap debug|x64
-		bootstrap debug|x86 = bootstrap debug|x86
-		bootstrap release|x64 = bootstrap release|x64
-		bootstrap release|x86 = bootstrap release|x86
-		singleheader debug|x64 = singleheader debug|x64
-		singleheader debug|x86 = singleheader debug|x86
-		singleheader release|x64 = singleheader release|x64
-		singleheader release|x86 = singleheader release|x86
-		test debug|x64 = test debug|x64
-		test debug|x86 = test debug|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.ActiveCfg = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.Build.0 = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.ActiveCfg = bootstrap debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.Build.0 = bootstrap debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x64.ActiveCfg = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.ActiveCfg = bootstrap release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.Build.0 = bootstrap release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.ActiveCfg = singleheader debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.Build.0 = singleheader debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.ActiveCfg = singleheader debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.Build.0 = singleheader debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.ActiveCfg = bootstrap debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.Build.0 = bootstrap debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.ActiveCfg = singleheader release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.Build.0 = singleheader release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.ActiveCfg = test debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.Build.0 = test debug|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.ActiveCfg = test debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.Build.0 = test debug|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {B12D2F1D-037C-44E1-B24B-2612E3DE0193}
-	EndGlobalSection
-EndGlobal

gencpp.sln.DotSettings.user

@@ -1,3 +0,0 @@
-<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:String x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:String></wpf:ResourceDictionary>

gencpp.vcxproj

@@ -1,376 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="bootstrap debug|Win32">
-      <Configuration>bootstrap debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="bootstrap debug|x64">
-      <Configuration>bootstrap debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="bootstrap release|Win32">
-      <Configuration>bootstrap release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="bootstrap release|x64">
-      <Configuration>bootstrap release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="singleheader debug|Win32">
-      <Configuration>singleheader debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="singleheader debug|x64">
-      <Configuration>singleheader debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="singleheader release|Win32">
-      <Configuration>singleheader release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="singleheader release|x64">
-      <Configuration>singleheader release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="test debug|Win32">
-      <Configuration>test debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="test debug|x64">
-      <Configuration>test debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>17.0</VCProjectVersion>
-    <ProjectGuid>{53AF600D-C09C-4F39-83E0-E022AA9479F2}</ProjectGuid>
-    <Keyword>MakeFileProj</Keyword>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'">
-    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'">
-    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'">
-    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'">
-    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'">
-    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
-    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug bootstrap</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>
-    </NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)project;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
-    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug test</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine />
-    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
-    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug singleheader</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>
-    </NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
-    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release singleheader</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>
-    </NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
-    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release bootstrap</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>
-    </NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
-    <ClCompile>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
-    <ClCompile>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
-    <ClCompile>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
-    <ClCompile>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
-    <ClCompile>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <None Include=".editorconfig" />
-    <None Include="project\enums\AttributeTokens.csv" />
-    <None Include="project\enums\ECode.csv" />
-    <None Include="project\enums\EOperator.csv" />
-    <None Include="project\enums\ESpecifier.csv" />
-    <None Include="project\enums\ETokType.csv" />
-    <None Include="Readme.md" />
-    <None Include="scripts\.clang-format" />
-    <None Include="scripts\build.ci.ps1" />
-    <None Include="scripts\build.ps1" />
-    <None Include="scripts\clean.ps1" />
-    <None Include="scripts\genccp.natstepfilter" />
-    <None Include="scripts\gencpp.refactor" />
-    <None Include="scripts\helpers\devshell.ps1" />
-    <None Include="scripts\helpers\target_arch.psm1" />
-    <None Include="scripts\package_release.ps1" />
-    <None Include="scripts\refactor.ps1" />
-    <None Include="test\gen\meson.build" />
-    <None Include="test\meson.build" />
-    <None Include="test\Readme.md" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="gen_c_library\gen\gen.h" />
-    <ClInclude Include="project\auxillary\builder.hpp" />
-    <ClInclude Include="project\auxillary\editor.hpp" />
-    <ClInclude Include="project\auxillary\scanner.hpp" />
-    <ClInclude Include="project\components\ast.hpp" />
-    <ClInclude Include="project\components\ast_types.hpp" />
-    <ClInclude Include="project\components\code_types.hpp" />
-    <ClInclude Include="project\components\gen\ast_inlines.hpp" />
-    <ClInclude Include="project\components\gen\ecode.hpp" />
-    <ClInclude Include="project\components\gen\eoperator.hpp" />
-    <ClInclude Include="project\components\gen\especifier.hpp" />
-    <ClInclude Include="project\components\header_end.hpp" />
-    <ClInclude Include="project\components\header_start.hpp" />
-    <ClInclude Include="project\components\inlines.hpp" />
-    <ClInclude Include="project\components\interface.hpp" />
-    <ClInclude Include="project\components\types.hpp" />
-    <ClInclude Include="project\dependencies\basic_types.hpp" />
-    <ClInclude Include="project\dependencies\containers.hpp" />
-    <ClInclude Include="project\dependencies\debug.hpp" />
-    <ClInclude Include="project\dependencies\filesystem.hpp" />
-    <ClInclude Include="project\dependencies\hashing.hpp" />
-    <ClInclude Include="project\dependencies\header_start.hpp" />
-    <ClInclude Include="project\dependencies\macros.hpp" />
-    <ClInclude Include="project\dependencies\memory.hpp" />
-    <ClInclude Include="project\dependencies\parsing.hpp" />
-    <ClInclude Include="project\dependencies\printing.hpp" />
-    <ClInclude Include="project\dependencies\strings.hpp" />
-    <ClInclude Include="project\dependencies\string_ops.hpp" />
-    <ClInclude Include="project\dependencies\timing.hpp" />
-    <ClInclude Include="project\gen.dep.hpp" />
-    <ClInclude Include="project\gen.hpp" />
-    <ClInclude Include="project\helpers\helper.hpp" />
-    <ClInclude Include="project\helpers\pop_ignores.inline.hpp" />
-    <ClInclude Include="project\helpers\push_ignores.inline.hpp" />
-    <ClInclude Include="project\helpers\undef.macros.hpp" />
-    <ClInclude Include="singleheader\components\header_start.hpp" />
-    <ClInclude Include="test\CURSED_TYPEDEF.h" />
-    <ClInclude Include="test\DummyInclude.hpp" />
-    <ClInclude Include="test\Parsed\Buffer.Parsed.hpp" />
-    <ClInclude Include="test\Parsed\HashTable.Parsed.hpp" />
-    <ClInclude Include="test\Parsed\Ring.Parsed.hpp" />
-    <ClInclude Include="test\parsing.hpp" />
-    <ClInclude Include="test\SOA.hpp" />
-    <ClInclude Include="test\upfront.hpp" />
-    <ClInclude Include="test\Upfront\Array.Upfront.hpp" />
-    <ClInclude Include="test\Upfront\Buffer.Upfront.hpp" />
-    <ClInclude Include="test\Upfront\HashTable.Upfront.hpp" />
-    <ClInclude Include="test\Upfront\Ring.Upfront.hpp" />
-    <ClInclude Include="test\Upfront\Sanity.Upfront.hpp" />
-    <ClInclude Include="test\Parsed\Array.Parsed.hpp" />
-    <ClInclude Include="test\Parsed\Sanity.Parsed.hpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="project\auxillary\builder.cpp" />
-    <ClCompile Include="project\auxillary\scanner.cpp" />
-    <ClCompile Include="project\bootstrap.cpp" />
-    <ClCompile Include="project\components\ast.cpp" />
-    <ClCompile Include="project\components\ast_case_macros.cpp" />
-    <ClCompile Include="project\components\code_serialization.cpp" />
-    <ClCompile Include="project\components\gen\etoktype.cpp" />
-    <ClCompile Include="project\components\interface.cpp" />
-    <ClCompile Include="project\components\interface.parsing.cpp" />
-    <ClCompile Include="project\components\interface.untyped.cpp" />
-    <ClCompile Include="project\components\interface.upfront.cpp" />
-    <ClCompile Include="project\components\lexer.cpp" />
-    <ClCompile Include="project\components\parser.cpp" />
-    <ClCompile Include="project\components\src_start.cpp" />
-    <ClCompile Include="project\components\static_data.cpp" />
-    <ClCompile Include="project\dependencies\debug.cpp" />
-    <ClCompile Include="project\dependencies\filesystem.cpp" />
-    <ClCompile Include="project\dependencies\hashing.cpp" />
-    <ClCompile Include="project\dependencies\memory.cpp" />
-    <ClCompile Include="project\dependencies\parsing.cpp" />
-    <ClCompile Include="project\dependencies\printing.cpp" />
-    <ClCompile Include="project\dependencies\src_start.cpp" />
-    <ClCompile Include="project\dependencies\strings.cpp" />
-    <ClCompile Include="project\dependencies\string_ops.cpp" />
-    <ClCompile Include="project\dependencies\timing.cpp" />
-    <ClCompile Include="project\Example.cpp" />
-    <ClCompile Include="project\gen.cpp" />
-    <ClCompile Include="project\gen.dep.cpp" />
-    <ClCompile Include="singleheader\singleheader.cpp" />
-    <ClCompile Include="test\parsed\test.parsing.cpp" />
-    <ClCompile Include="test\parsing.cpp" />
-    <ClCompile Include="test\sanity.cpp" />
-    <ClCompile Include="test\SOA.cpp" />
-    <ClCompile Include="test\test.cpp" />
-    <ClCompile Include="test\test.parsing.cpp" />
-    <ClCompile Include="test\test.singleheader_ast.cpp" />
-    <ClCompile Include="test\test.Upfront.cpp" />
-    <ClCompile Include="test\upfront.cpp" />
-    <ClCompile Include="test\upfront\test.upfront.cpp" />
-    <ClCompile Include="test\validate_bootstrap.cpp" />
-    <ClCompile Include="test\validate_singleheader.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <Natvis Include=".vscode\gencpp.natvis" />
-    <Natvis Include="scripts\gencpp.natvis" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="project\enums\AttributeTokens.csv" />
-    <Content Include="project\enums\ECode.csv" />
-    <Content Include="project\enums\EOperator.csv" />
-    <Content Include="project\enums\ESpecifier.csv" />
-    <Content Include="project\enums\ETokType.csv" />
-    <Content Include="scripts\.clang-format" />
-    <Content Include="scripts\helpers\devshell.ps1" />
-    <Content Include="scripts\helpers\target_arch.psm1" />
-    <Content Include="scripts\refactor.ps1" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="singleheader\gen\" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

gencpp.vcxproj.filters

@@ -1,320 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="project\gen.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\test.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\test.Upfront.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\gen.dep.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\parsing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\sanity.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\SOA.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\upfront.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\test.parsing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\ast.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\ast_case_macros.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\interface.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\interface.parsing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\interface.upfront.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\src_start.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\static_data.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\bootstrap.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\debug.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\filesystem.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\hashing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\memory.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\parsing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\printing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\src_start.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\string_ops.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\strings.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\dependencies\timing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\auxillary\builder.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\auxillary\scanner.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="singleheader\singleheader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\test.singleheader_ast.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\parsed\test.parsing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\upfront\test.upfront.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\validate_singleheader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\validate_bootstrap.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\interface.untyped.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\gen\etoktype.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\Example.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\parser.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\lexer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="project\components\code_serialization.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="project\gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\DummyInclude.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Parsed\Buffer.Parsed.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Parsed\HashTable.Parsed.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Parsed\Ring.Parsed.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\SOA.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Upfront\Array.Upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Upfront\Buffer.Upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Upfront\HashTable.Upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Upfront\Ring.Upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Upfront\Sanity.Upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Parsed\Array.Parsed.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\Parsed\Sanity.Parsed.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\gen.dep.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\parsing.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\upfront.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\ast.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\ast_types.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\header_end.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\header_start.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\inlines.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\interface.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\types.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\helpers\helper.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\helpers\pop_ignores.inline.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\helpers\push_ignores.inline.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\helpers\undef.macros.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\basic_types.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\containers.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\debug.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\filesystem.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\hashing.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\header_start.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\macros.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\memory.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\parsing.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\printing.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\string_ops.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\strings.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\dependencies\timing.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\auxillary\builder.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\auxillary\editor.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\auxillary\scanner.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="singleheader\components\header_start.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\gen\ast_inlines.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\gen\ecode.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\gen\eoperator.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\gen\especifier.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\CURSED_TYPEDEF.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\code_types.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include=".editorconfig" />
-    <None Include="Readme.md" />
-    <None Include="scripts\build.ci.ps1" />
-    <None Include="scripts\build.ps1" />
-    <None Include="scripts\clean.ps1" />
-    <None Include="test\gen\meson.build" />
-    <None Include="test\meson.build" />
-    <None Include="test\Readme.md" />
-    <None Include="scripts\genccp.natstepfilter" />
-    <None Include="scripts\gencpp.refactor" />
-    <None Include="project\enums\AttributeTokens.csv" />
-    <None Include="project\enums\ECode.csv" />
-    <None Include="project\enums\EOperator.csv" />
-    <None Include="project\enums\ESpecifier.csv" />
-    <None Include="project\enums\ETokType.csv" />
-    <None Include="scripts\helpers\devshell.ps1" />
-    <None Include="scripts\helpers\target_arch.psm1" />
-    <None Include="scripts\package_release.ps1" />
-    <None Include="scripts\refactor.ps1" />
-    <None Include="scripts\.clang-format" />
-  </ItemGroup>
-  <ItemGroup>
-    <Natvis Include=".vscode\gencpp.natvis" />
-    <Natvis Include="scripts\gencpp.natvis" />
-  </ItemGroup>
-</Project>