formatting fixes to C library generator

Properly disabled GEN_DEBUG_TRAP in non-debug builds

.vscode/bookmarks.json

@@ -1,14 +0,0 @@
-{
-	"files": [
-		{
-			"path": "project/auxillary/vis_ast/dependencies/temp/raylib-master/src/rcamera.h",
-			"bookmarks": [
-				{
-					"line": 140,
-					"column": 14,
-					"label": ""
-				}
-			]
-		}
-	]
-}

.vscode/c_cpp_properties.json

@@ -3,7 +3,7 @@
         {
             "name": "Bootstrap",
             "includePath": [
-                "${workspaceFolder}/project/**"
+                "${workspaceFolder}/base/**"
             ],
             "defines": [
                 "_DEBUG",
@@ -20,7 +20,7 @@
             "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": "C:\\projects\\gencpp\\.vscode\\tasks.json",
+            "compileCommands": "${workspaceFolder}/.vscode/tasks.json",
             "compilerArgs": [
                 "/EHsc-",
                 "/GR-",
@@ -47,12 +47,12 @@
             "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": "C:\\projects\\gencpp\\.vscode\\tasks.json"
+            "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
         },
         {
             "name": "Win32 clang",
             "includePath": [
-                "${workspaceFolder}/**"
+                "${workspaceFolder}/base/**"
             ],
             "defines": [
                 "_DEBUG",
@@ -65,9 +65,9 @@
                 "INTELLISENSE_DIRECTIVES"
             ],
             "windowsSdkVersion": "10.0.19041.0",
-            "compilerPath": "C:/Users/Ed/scoop/apps/llvm/current/bin/clang++.exe",
+            "compilerPath": "clang++.exe",
             "intelliSenseMode": "windows-clang-x64",
-            "compileCommands": ".vscode/tasks.json"
+            "compileCommands": "${workspaceFolder}/.vscode/tasks.json"
         }
     ],
     "version": 4

.vscode/launch.json

@@ -4,39 +4,20 @@
 	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 	"version": "0.2.0",
 	"configurations": [
-		{
-			"type": "lldb",
-			"request": "launch",
-			"name": "Debug gentime lldb",
-			"program": "${workspaceFolder}/test/test.exe",
-			"args": [],
-			"cwd": "${workspaceFolder}/test/",
-			"postRunCommands": [
-			]
-		},
 		{
 			"type": "cppvsdbg",
 			"request": "launch",
-			"name": "Debug gentime vsdbg",
-			"program": "${workspaceFolder}/test/build/test.exe",
+			"name": "Debug base vsdbg",
+			"program": "${workspaceFolder}/base/build/base.exe",
 			"args": [],
-			"cwd": "${workspaceFolder}/test/",
-			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
-		},
-		{
-			"type": "cppvsdbg",
-			"request": "launch",
-			"name": "Debug bootstrap vsdbg",
-			"program": "${workspaceFolder}/project/build/bootstrap.exe",
-			"args": [],
-			"cwd": "${workspaceFolder}/project/",
+			"cwd": "${workspaceFolder}/base/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
 		},
 		{
 			"type": "cppvsdbg",
 			"request": "launch",
 			"name": "Debug singleheader vsdbg",
-			"program": "${workspaceFolder}/singleheader/build/gencpp_singleheader.exe",
+			"program": "${workspaceFolder}/singleheader/build/singleheader.exe",
 			"args": [],
 			"cwd": "${workspaceFolder}/singleheader/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
@@ -49,24 +30,6 @@
 			"args": [],
 			"cwd": "${workspaceFolder}/unreal_engine/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
-		},
-		{
-			"type": "cppvsdbg",
-			"request": "launch",
-			"name": "Debug raylib refactor vsdbg",
-			"program": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/raylib/build/raylib_refactor.exe",
-			"args": [],
-			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/temp/raylib-master/src/",
-			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
-		},
-		{
-			"type": "cppvsdbg",
-			"request": "launch",
-			"name": "Debug VIS AST",
-			"program": "${workspaceFolder}/project/auxillary/vis_ast/binaries/vis_ast.exe",
-			"args": [],
-			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/binaries/",
-			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
 		}
 	]
 }

Readme.md

@@ -2,34 +2,40 @@
 
 An attempt at simple staged metaprogramming for C/C++.
 
-The library API is a composition of code element constructors, and a non-standards-compliant single-pass C/C++ parser.
+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.  
+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): 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 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).
-
-***The editor and scanner have not been implemented yet. The scanner will come first, then the editor.***
-
-A C variant is hosted [here](https://github.com/Ed94/genc); I will complete it when this library is feature complete, it should be easier to make than this...
+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):
 
@@ -89,8 +95,8 @@ Validation through ast construction.
 Code header = parse_struct( code(
     struct ArrayHeader
     {
-        usize        Num;
-        usize        Capacity;
+        usize     Num;
+        usize     Capacity;
         allocator Allocator;
     };
 ));
@@ -105,8 +111,8 @@ No validation, just glorified text injection.
 Code header = code_str(
     struct ArrayHeader
     {
-        usize        Num;
-        usize        Capacity;
+        usize     Num;
+        usize     Capacity;
         allocator Allocator;
     };
 );
@@ -114,21 +120,21 @@ 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> ))`
+`args` is a helper macro for providing the number of arguments to varadic constructors.  
+`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;
 };
 ```
 
-**Note: The formatting shown here is not how it will look. For your desired formatting its recommended to run a pass through the files with an auto-formatter.**
+**Note: The formatting shown here is not how it will look. For your desired formatting its recommended to run a pass through the files with an auto-formatter.**  
 *(The library currently uses clang-format for formatting, beware its pretty slow...)*
 
 ## Building

base/Readme.md

@@ -0,0 +1,162 @@
+## Navigation
+
+# base
+
+[Top](../Readme.md)
+
+* [docs](../docs/Readme.md)
+
+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:
+
+* **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 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 file/s.
+    * `misc.hpp`: Misc functionality used by the library generation metaprograms.
+    * `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.
+      * `scan_file`: Used mainly by the library format generators to directly scan files into untyped `Code` (raw string content, pre-formatted no AST parsed).
+      * `parse_file`: Used to read file and then parsed to populate a `CodeBody` AST.
+      * CSV parsing via one or two columns simplified.
+* **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.
+
+Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
+
+## Dependencies
+
+The project has no external dependencies beyond:
+
+* `errno.h`
+* `stat.h`
+* `stdarg.h`
+* `stddef.h`
+* `stdio.h`
+* `copyfile.h` (Mac)
+* `types.h`    (Linux)
+* `sys/man.h`  (Linux)
+* `fcntl.h`    (POSXIX Filesystem)
+* `unistd.h`   (Linux/Mac)
+* `intrin.h`   (Windows)
+* `io.h`       (Windows with gcc)
+* `windows.h`  (Windows)
+
+Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).
+The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
+
+See the following files for any updates:
+
+* [`platform.hpp`](./dependencies/platform.hpp)
+* [`src_start.cpp`](./dependencies/src_start.cpp)
+* [`filesystem.cpp`](./dependencies/filesystem.cpp)
+* [`memory.cpp`](./dependencies/memory.cpp)
+
+## Conventions
+
+This library was written in a subset of C++ where the following are not used at all:
+
+* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
+* Language provide dynamic dispatch, RTTI
+* Object-Oriented Inheritance
+* Exceptions
+
+Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.
+The base library itself does not use anything but C-like features to allow for generating a derviative compatiable with C.
+
+Member function support or free-functions with reference object passing are wrapped in `! GEN_C_LIKE CPP` preprocess conditionals.
+
+## C++ template usage
+
+There are only 4 template definitions in the entire library (C++ versions). (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `tmpl_cast<CodeT>(CodeT code)`)
+
+Two generic templated containers are used throughout the library:
+
+* `template< class Type> struct Array`
+* `template< class Type> struct HashTable`
+
+`tmpl_cast<CodeT>(CodeT code)` is just an alternative way to explicitly cast to code. Its usage is wrapped in a macro called `cast` for the base library (needed for interoperability with C).
+
+`template< class Type> swap( Type& a, Type& b)` is used over a macro.
+
+Otherwise the library is free of any templates.
+
+## Macro usage
+
+Since this is a meta-programming library, it was desired to keep both templates and macros (especially macros) usage very limited.
+
+Most macros are defined within [macros.hpp](./dependencies/macros.hpp). 
+
+The most advanced macro usage is `num_args` which is a helper for counting the number of arguments of another macro.
+
+Any large macros used implementing the gen interface or parser are going to be phased out in favor of just forcinlined functions.  
+*(Unless there is a hot-path that requires them)*
+
+The vast majority of macros should be single-line subsitutions that either add:
+
+* Improvements to searching
+* Inteniality of keyword usage
+* A  feature that only the preprocessor has (ex: function name reflection or stringifying)
+* Compatibility of statements or expressions bewteen C & C++ that cannot be parsed by gencpp itself.
+* Masking highly verbose syntax (the latter is getting phased out).
+
+[gen_c_library](../gen_c_library/) has the most advanced set of macros for c11's generic selection.
+
+* A significant amount of explicit code geneeration is utilized to keep abuse of the preprocessor to the absolute minimum.
+* There is a heavy set of documentation inlined wth them; their naming is also highly verbose and explicit.
+* See its documentation for more information.
+
+## On base code generation
+
+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.
+
+[`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
+
+Currently unsupported. I want the library to be *stable* and *correct*, with the addition of exhausting all basic single-threaded optimizations before I consider multi-threading.
+
+## Extending the library
+
+This library is relatively very small (for parsing C++), and can be extended without much hassle.
+
+The convention you'll see used throughout the upfront interface of the library is as follows:
+
+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_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.
+
+`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).
+
+## 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.
+Its recommended that your metaprogam be compiled using a single translation unit (unity build).

base/auxillary/builder.cpp

@@ -0,0 +1,59 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	include "builder.hpp"
+#endif
+
+#pragma region Builder
+
+Builder builder_open( char const* path )
+{
+	Builder result;
+
+	FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
+	if ( error != EFileError_NONE )
+	{
+		log_failure( "gen::File::open - Could not open file: %s", path);
+		return result;
+	}
+
+	result.Buffer = strbuilder_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+
+	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
+	return result;
+}
+
+void builder_pad_lines( Builder* builder, s32 num )
+{
+	strbuilder_append_str( & builder->Buffer, txt("\n") );
+}
+
+void builder_print( Builder* builder, Code 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 );
+	strbuilder_append_string( & builder->Buffer, str );
+}
+
+void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
+{
+	ssize   res;
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	res = c_str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+
+	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, 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 );
+	strbuilder_free(& builder->Buffer);
+}
+
+#pragma endregion Builder

base/auxillary/builder.hpp

@@ -0,0 +1,70 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "helpers/push_ignores.inline.hpp"
+#	include "components/header_start.hpp"
+#	include "components/types.hpp"
+#	include "components/gen/ecode.hpp"
+#	include "components/gen/eoperator.hpp"
+#	include "components/gen/especifier.hpp"
+#	include "components/ast.hpp"
+#	include "components/code_types.hpp"
+#	include "components/ast_types.hpp"
+#	include "components/interface.hpp"
+#	include "components/inlines.hpp"
+#	include "components/gen/ast_inlines.hpp"
+#	include "components/header_end.hpp"
+using namespace gen;
+#endif
+
+#pragma region Builder
+
+struct Builder;
+typedef struct Builder Builder;
+
+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, ... ) {
+	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;
+	StrBuilder   Buffer;
+
+#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
+	forceinline static Builder open( char const* path ) { return builder_open(path); }
+
+	forceinline void pad_lines( s32 num ) { return builder_pad_lines(this, num); }
+
+	forceinline void print( Code code )                { return builder_print(this, code); }
+	forceinline void print_fmt( char const* fmt, ... ) {
+		va_list va;
+		va_start( va, fmt );
+		builder_print_fmt_va( this, fmt, va );
+		va_end( va );
+	}
+
+	forceinline void write() { return builder_write(this); }
+#endif
+};
+
+#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, ...) {
+	va_list va;
+	va_start( va, fmt );
+	builder_print_fmt_va( & builder, fmt, va );
+	va_end( va );
+}
+#endif
+
+#pragma endregion Builder

base/auxillary/gen_template.hpp

@@ -1,6 +1,18 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "../gen.hpp"
+#	include "helpers/push_ignores.inline.hpp"
+#	include "components/header_start.hpp"
+#	include "components/types.hpp"
+#	include "components/gen/ecode.hpp"
+#	include "components/gen/eoperator.hpp"
+#	include "components/gen/especifier.hpp"
+#	include "components/ast.hpp"
+#	include "components/code_types.hpp"
+#	include "components/ast_types.hpp"
+#	include "components/interface.hpp"
+#	include "components/inlines.hpp"
+#	include "components/gen/ast_inlines.hpp"
+#	include "components/header_end.hpp"
 #endif
 
 /*
@@ -20,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

@@ -1,12 +1,9 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "gen.hpp"
+#	include "scanner.hpp"
 #endif
 
-// This is a simple file reader that reads the entire file into memory.
-// It has an extra option to skip the first few lines for undesired includes.
-// This is done so that includes can be kept in dependency and component files so that intellisense works.
-inline
+#pragma region Scanner
+
 Code scan_file( char const* path )
 {
 	FileInfo file;
@@ -23,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( GlobalAllocator, 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.
@@ -34,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;
@@ -52,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;
@@ -60,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;
@@ -80,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;
@@ -97,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;
 				}
@@ -116,44 +113,36 @@ Code scan_file( char const* path )
 	}
 
 	file_close( & file );
-	return untyped_str( string_to_strc(str) );
+	return untyped_str( strbuilder_to_str(str) );
 }
 
-#if 0
-struct CodeFile
-{
-	using namespace Parser;
-
-	String              FilePath;
-	TokArray            Tokens;
-	Array<ParseFailure> ParseFailures;
-	Code                CodeRoot;
-};
-
-namespace Parser
-{
-	struct ParseFailure
-	{
-		String Reason;
-		Code   Node;
-	};
+CodeBody parse_file( const char* path ) {
+	FileContents file    = file_read_contents( GlobalAllocator, true, path );
+	Str          content = { (char const*)file.data, file.size };
+	CodeBody     code    = parse_global_body( content );
+	log_fmt("\nParsed: %s\n", path);
+	return code;
 }
 
-CodeFile scan_file( char const* path )
-{
-	using namespace Parser;
-
-	CodeFile
-	result = {};
-	result.FilePath = String::make( GlobalAllocator, path );
-
-	Code code = scan_file( path );
-	result.CodeRoot = code;
-
-	ParseContext context = parser_get_last_context();
-	result.Tokens        = context.Tokens;
-	result.ParseFailures = context.Failures;
+CSV_Column parse_csv_one_column(AllocatorInfo allocator, char const* path) {
+	FileContents content   = file_read_contents( allocator, file_zero_terminate, path );
+	Arena        csv_arena = arena_init_from_memory(content.data, content.size);
 
+	CSV_Column result;
+	csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
+	result.Content = result.ADT.nodes[0].nodes;
 	return result;
 }
-#endif
+
+CSV_Columns2 parse_csv_two_columns(AllocatorInfo allocator, char const* path) {
+	FileContents content   = file_read_contents( allocator, file_zero_terminate, path );
+	Arena        csv_arena = arena_init_from_memory(content.data, content.size);
+
+	CSV_Columns2 result;
+	csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
+	result.Col_1 = result.ADT.nodes[0].nodes;
+	result.Col_2 = result.ADT.nodes[1].nodes;
+	return result;
+}
+
+#pragma endregion Scanner

base/auxillary/scanner.hpp

@@ -0,0 +1,46 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "helpers/push_ignores.inline.hpp"
+#	include "components/header_start.hpp"
+#	include "components/types.hpp"
+#	include "components/gen/ecode.hpp"
+#	include "components/gen/eoperator.hpp"
+#	include "components/gen/especifier.hpp"
+#	include "components/ast.hpp"
+#	include "components/code_types.hpp"
+#	include "components/ast_types.hpp"
+#	include "components/interface.hpp"
+#	include "components/inlines.hpp"
+#	include "components/gen/ast_inlines.hpp"
+#	include "components/header_end.hpp"
+#endif
+
+#pragma region Scanner
+
+// This is a simple file reader that reads the entire file into memory.
+// It has an extra option to skip the first few lines for undesired includes.
+// This is done so that includes can be kept in dependency and component files so that intellisense works.
+Code scan_file( char const* path );
+
+CodeBody parse_file( const char* path );
+
+// The follow is basic support for light csv parsing (use it as an example)
+// Make something robust if its more serious.
+
+typedef struct CSV_Column CSV_Column;
+struct CSV_Column {
+	CSV_Object      ADT;
+	Array(ADT_Node) Content;
+};
+
+typedef struct CSV_Columns2 CSV_Columns2;
+struct CSV_Columns2 {
+	CSV_Object      ADT;
+	Array(ADT_Node) Col_1;
+	Array(ADT_Node) Col_2;
+};
+
+CSV_Column parse_csv_one_column(AllocatorInfo allocator, char const* path);
+CSV_Columns2 parse_csv_two_columns(AllocatorInfo allocator, char const* path);
+
+#pragma endregion Scanner

base/base.cpp

@@ -0,0 +1,74 @@
+#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"
+
+#include <stdlib.h>
+
+GEN_NS_BEGIN
+#include "helpers/base_codegen.hpp"
+#include "helpers/misc.hpp"
+GEN_NS_END
+
+using namespace gen;
+
+constexpr char const* path_format_style = "../scripts/.clang-format";
+constexpr char const* scratch_file      = "build/scratch.hpp";
+
+Code format( Code code ) {
+	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
+}
+
+constexpr char const* generation_notice =
+"// This file was generated automatially by gencpp's bootstrap.cpp "
+"(See: https://github.com/Ed94/gencpp)\n\n";
+
+int gen_main()
+{
+	gen::init();
+
+	CodeBody gen_component_header = def_global_body( args(
+		def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
+		pragma_once,
+		def_include(txt("components/types.hpp")),
+		preprocess_endif,
+		fmt_newline,
+		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" );
+	builder_print( & header_ecode, gen_component_header );
+	builder_print( & header_ecode, format(ecode) );
+	builder_write( & header_ecode);
+
+	Builder header_eoperator = builder_open( "components/gen/eoperator.hpp" );
+	builder_print( & header_eoperator, gen_component_header );
+	builder_print( & header_eoperator, format(eoperator) );
+	builder_write( & header_eoperator );
+
+	Builder header_especifier = builder_open( "components/gen/especifier.hpp" );
+	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.cpp" );
+	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();
+	return 0;
+}

base/components/ast.hpp

@@ -37,7 +37,7 @@ struct AST_Module;
 struct AST_NS;
 struct AST_Operator;
 struct AST_OpCast;
-struct AST_Param;
+struct AST_Params;
 struct AST_Pragma;
 struct AST_PreprocessCond;
 struct AST_Specifiers;
@@ -85,86 +85,150 @@ struct AST_Union;
 struct AST_Using;
 struct AST_Var;
 
-#if GEN_COMPILER_C
-#define Define_Code(Type) typedef AST_##Type* Code##Type
-#else
-#define Define_Code(Type) struct Code##Type
-#endif
-
 #if GEN_COMPILER_C
 typedef AST* Code;
 #else
 struct Code;
 #endif
 
-Define_Code(Body);
-// These are to offer ease of use and optionally strong type safety for the AST.
-Define_Code(Attributes);
-// struct CodeBaseClass;
-Define_Code(Comment);
-Define_Code(Class);
-Define_Code(Constructor);
-Define_Code(Define);
-Define_Code(Destructor);
-Define_Code(Enum);
-Define_Code(Exec);
-Define_Code(Extern);
-Define_Code(Include);
-Define_Code(Friend);
-Define_Code(Fn);
-Define_Code(Module);
-Define_Code(NS);
-Define_Code(Operator);
-Define_Code(OpCast);
-Define_Code(Param);
-Define_Code(PreprocessCond);
-Define_Code(Pragma);
-Define_Code(Specifiers);
-
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
-Define_Code(Expr);
-Define_Code(Expr_Assign);
-Define_Code(Expr_Alignof);
-Define_Code(Expr_Binary);
-Define_Code(Expr_CStyleCast);
-Define_Code(Expr_FunctionalCast);
-Define_Code(Expr_CppCast);
-Define_Code(Expr_Element);
-Define_Code(Expr_ProcCall);
-Define_Code(Expr_Decltype);
-Define_Code(Expr_Comma);
-Define_Code(Expr_AMS); // Access Member Symbol
-Define_Code(Expr_Sizeof);
-Define_Code(Expr_Subscript);
-Define_Code(Expr_Ternary);
-Define_Code(Expr_UnaryPrefix);
-Define_Code(Expr_UnaryPostfix);
-
-Define_Code(Stmt);
-Define_Code(Stmt_Break);
-Define_Code(Stmt_Case);
-Define_Code(Stmt_Continue);
-Define_Code(Stmt_Decl);
-Define_Code(Stmt_Do);
-Define_Code(Stmt_Expr);
-Define_Code(Stmt_Else);
-Define_Code(Stmt_If);
-Define_Code(Stmt_For);
-Define_Code(Stmt_Goto);
-Define_Code(Stmt_Label);
-Define_Code(Stmt_Switch);
-Define_Code(Stmt_While);
+#if GEN_COMPILER_C
+typedef AST_Body*           CodeBody;
+typedef AST_Attributes*     CodeAttributes;
+typedef AST_Comment*        CodeComment;
+typedef AST_Class*          CodeClass;
+typedef AST_Constructor*    CodeConstructor;
+typedef AST_Define*         CodeDefine;
+typedef AST_Destructor*     CodeDestructor;
+typedef AST_Enum*           CodeEnum;
+typedef AST_Exec*           CodeExec;
+typedef AST_Extern*         CodeExtern;
+typedef AST_Include*        CodeInclude;
+typedef AST_Friend*         CodeFriend;
+typedef AST_Fn*             CodeFn;
+typedef AST_Module*         CodeModule;
+typedef AST_NS*             CodeNS;
+typedef AST_Operator*       CodeOperator;
+typedef AST_OpCast*         CodeOpCast;
+typedef AST_Params*         CodeParams;
+typedef AST_PreprocessCond* CodePreprocessCond;
+typedef AST_Pragma*         CodePragma;
+typedef AST_Specifiers*     CodeSpecifiers;
+#else
+struct CodeBody;
+struct CodeAttributes;
+struct CodeComment;
+struct CodeClass;
+struct CodeConstructor;
+struct CodeDefine;
+struct CodeDestructor;
+struct CodeEnum;
+struct CodeExec;
+struct CodeExtern;
+struct CodeInclude;
+struct CodeFriend;
+struct CodeFn;
+struct CodeModule;
+struct CodeNS;
+struct CodeOperator;
+struct CodeOpCast;
+struct CodeParams;
+struct CodePreprocessCond;
+struct CodePragma;
+struct CodeSpecifiers;
 #endif
 
-Define_Code(Struct);
-Define_Code(Template);
-Define_Code(Typename);
-Define_Code(Typedef);
-Define_Code(Union);
-Define_Code(Using);
-Define_Code(Var);
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
 
-#undef Define_Code
+#if GEN_COMPILER_C
+typedef AST_Expr*                CodeExpr;
+typedef AST_Expr_Assign*         CodeExpr_Assign;
+typedef AST_Expr_Alignof*        CodeExpr_Alignof;
+typedef AST_Expr_Binary*         CodeExpr_Binary;
+typedef AST_Expr_CStyleCast*     CodeExpr_CStyleCast;
+typedef AST_Expr_FunctionalCast* CodeExpr_FunctionalCast;
+typedef AST_Expr_CppCast*        CodeExpr_CppCast;
+typedef AST_Expr_Element*        CodeExpr_Element;
+typedef AST_Expr_ProcCall*       CodeExpr_ProcCall;
+typedef AST_Expr_Decltype*       CodeExpr_Decltype;
+typedef AST_Expr_Comma*          CodeExpr_Comma;
+typedef AST_Expr_AMS*            CodeExpr_AMS; // Access Member Symbol
+typedef AST_Expr_Sizeof*         CodeExpr_Sizeof;
+typedef AST_Expr_Subscript*      CodeExpr_Subscript;
+typedef AST_Expr_Ternary*        CodeExpr_Ternary;
+typedef AST_Expr_UnaryPrefix*    CodeExpr_UnaryPrefix;
+typedef AST_Expr_UnaryPostfix*   CodeExpr_UnaryPostfix;
+#else
+struct CodeExpr;
+struct CodeExpr_Assign;
+struct CodeExpr_Alignof;
+struct CodeExpr_Binary;
+struct CodeExpr_CStyleCast;
+struct CodeExpr_FunctionalCast;
+struct CodeExpr_CppCast;
+struct CodeExpr_Element;
+struct CodeExpr_ProcCall;
+struct CodeExpr_Decltype;
+struct CodeExpr_Comma;
+struct CodeExpr_AMS; // Access Member Symbol
+struct CodeExpr_Sizeof;
+struct CodeExpr_Subscript;
+struct CodeExpr_Ternary;
+struct CodeExpr_UnaryPrefix;
+struct CodeExpr_UnaryPostfix;
+#endif
+
+#if GEN_COMPILER_C
+typedef AST_Stmt*          CodeStmt;
+typedef AST_Stmt_Break*    CodeStmt_Break;
+typedef AST_Stmt_Case*     CodeStmt_Case;
+typedef AST_Stmt_Continue* CodeStmt_Continue;
+typedef AST_Stmt_Decl*     CodeStmt_Decl;
+typedef AST_Stmt_Do*       CodeStmt_Do;
+typedef AST_Stmt_Expr*     CodeStmt_Expr;
+typedef AST_Stmt_Else*     CodeStmt_Else;
+typedef AST_Stmt_If*       CodeStmt_If;
+typedef AST_Stmt_For*      CodeStmt_For;
+typedef AST_Stmt_Goto*     CodeStmt_Goto;
+typedef AST_Stmt_Label*    CodeStmt_Label;
+typedef AST_Stmt_Switch*   CodeStmt_Switch;
+typedef AST_Stmt_While*    CodeStmt_While;
+#else
+struct CodeStmt;
+struct CodeStmt_Break;
+struct CodeStmt_Case;
+struct CodeStmt_Continue;
+struct CodeStmt_Decl;
+struct CodeStmt_Do;
+struct CodeStmt_Expr;
+struct CodeStmt_Else;
+struct CodeStmt_If;
+struct CodeStmt_For;
+struct CodeStmt_Goto;
+struct CodeStmt_Label;
+struct CodeStmt_Switch;
+struct CodeStmt_While;
+#endif
+
+// GEN_EXECUTION_EXPRESSION_SUPPORT
+#endif
+
+#if GEN_COMPILER_C
+typedef AST_Struct*   CodeStruct;
+typedef AST_Template* CodeTemplate;
+typedef AST_Typename* CodeTypename;
+typedef AST_Typedef*  CodeTypedef;
+typedef AST_Union*    CodeUnion;
+typedef AST_Using*    CodeUsing;
+typedef AST_Var*      CodeVar;
+#else
+struct CodeStruct;
+struct CodeTemplate;
+struct CodeTypename;
+struct CodeTypedef;
+struct CodeUnion;
+struct CodeUsing;
+struct CodeVar;
+#endif
 
 GEN_NS_PARSER_BEGIN
 
@@ -178,7 +242,7 @@ GEN_NS_PARSER_END
 // 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
+#undef  ParserTokenType
 #endif
 
 #if GEN_COMPILER_CPP
@@ -187,19 +251,19 @@ template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast(
 
 #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 );
+void       code_append           (Code code, Code other );
+Str        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);
+StrBuilder code_to_strbuilder    (Code self );
+void       code_to_strbuilder_ptr(Code self, StrBuilder* result );
+Str        code_type_str         (Code self );
+bool       code_validate_body    (Code self );
 
 #pragma endregion Code C-Interface
 
@@ -214,7 +278,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); }         \
@@ -231,32 +295,21 @@ 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 ++();
 
-	// TODO(Ed) : Remove this overload.
-	auto& operator*()
-	{
-		local_persist thread_local
-		Code NullRef = { nullptr };
-
-		if ( ast == nullptr )
-			return NullRef;
-
-		return *this;
-	}
-
 #ifdef GEN_ENFORCE_STRONG_CODE_TYPES
 #	define operator explicit operator
 #endif
@@ -278,7 +331,7 @@ struct Code
 	operator CodeNS() const;
 	operator CodeOperator() const;
 	operator CodeOpCast() const;
-	operator CodeParam() const;
+	operator CodeParams() const;
 	operator CodePragma() const;
 	operator CodePreprocessCond() const;
 	operator CodeSpecifiers() const;
@@ -358,7 +411,7 @@ struct AST
 			union {
 				Code  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
 				Code  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
-				Code  PostNameMacro;     // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
+				Code  PostNameMacro;    // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
 			};
 		};
 		StringCached  Content;          // Attributes, Comment, Execution, Include
@@ -391,7 +444,7 @@ struct AST
 		Operator      Op;
 		AccessSpec    ParentAccess;
 		s32           NumEntries;
-		s32           VarConstructorInit;  // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
+		s32           VarParenthesizedInit;  // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
 	};
 };
 static_assert( sizeof(AST) == AST_POD_Size, "ERROR: AST is not size of AST_POD_Size" );

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 are used within ast.cpp, inteface.upfront.cpp, parser.cpp
+
+#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES    \
 	case CT_PlatformAttributes:                  \
 	case CT_Class_Body:                          \
 	case CT_Enum_Body:                           \
@@ -13,7 +15,7 @@
 	case CT_Parameters:                          \
 	case CT_Specifiers:                          \
 	case CT_Struct_Body:                         \
-	case CT_Typename:
+	case CT_Typename
 #	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
 
 #	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES \
@@ -37,7 +39,7 @@
 	case CT_Parameters:                             \
 	case CT_Specifiers:                             \
 	case CT_Struct_Body:                            \
-	case CT_Typename:
+	case CT_Typename
 
 #	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES     \
 	case CT_Access_Public:                         \
@@ -55,7 +57,7 @@
 	case CT_Parameters:                            \
 	case CT_Specifiers:                            \
 	case CT_Struct_Body:                           \
-	case CT_Typename:
+	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
 
@@ -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

@@ -127,7 +127,7 @@ struct AST_Constructor
 			char           _PAD_PROPERTIES_ [ sizeof(AST*) * 1 ];
 			CodeSpecifiers Specs;
 			Code           InitializerList;
-			CodeParam      Params;
+			CodeParams     Params;
 			Code           Body;
 			char 		   _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
 		};
@@ -550,7 +550,7 @@ struct AST_Fn
 			CodeAttributes  Attributes;
 			CodeSpecifiers  Specs;
 			CodeTypename    ReturnType;
-			CodeParam 	    Params;
+			CodeParams 	    Params;
 			CodeBody        Body;
 			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
@@ -613,7 +613,7 @@ struct AST_Operator
 			CodeAttributes  Attributes;
 			CodeSpecifiers  Specs;
 			CodeTypename    ReturnType;
-			CodeParam 	    Params;
+			CodeParams 	    Params;
 			CodeBody        Body;
 			char 	        _PAD_PROPERTIES_ [ sizeof(AST*) ];
 		};
@@ -639,9 +639,9 @@ struct AST_OpCast
 			char 	        _PAD_PROPERTIES_[ sizeof(AST*)  ];
 			CodeSpecifiers  Specs;
 			CodeTypename    ValueType;
-			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
-			CodeBody       Body;
-			char 	       _PAD_PROPERTIES_3_[ sizeof(AST*) ];
+			char 	        _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			CodeBody        Body;
+			char 	        _PAD_PROPERTIES_3_[ sizeof(AST*) ];
 		};
 	};
 	StringCached      Name;
@@ -654,7 +654,7 @@ struct AST_OpCast
 };
 static_assert( sizeof(AST_OpCast) == sizeof(AST), "ERROR: AST_OpCast is not the same size as AST");
 
-struct AST_Param
+struct AST_Params
 {
 	union {
 		char          _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
@@ -669,15 +669,15 @@ struct AST_Param
 		};
 	};
 	StringCached      Name;
-	CodeParam         Last;
-	CodeParam         Next;
+	CodeParams        Last;
+	CodeParams        Next;
 	Token*            Tok;
 	Code              Parent;
 	CodeType          Type;
 	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
 	s32               NumEntries;
 };
-static_assert( sizeof(AST_Param) == sizeof(AST), "ERROR: AST_Param is not the same size as AST");
+static_assert( sizeof(AST_Params) == sizeof(AST), "ERROR: AST_Params is not the same size as AST");
 
 struct AST_Pragma
 {
@@ -971,7 +971,7 @@ struct AST_Template
 		struct
 		{
 			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
-			CodeParam 	   Params;
+			CodeParams 	   Params;
 			Code           Declaration;
 			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
 		};
@@ -1000,7 +1000,7 @@ struct AST_Type
 			CodeSpecifiers  Specs;
 			Code            QualifierID;
 			// CodeTypename ReturnType;      // Only used for function signatures
-			// CodeParam    Params;          // Only used for function signatures
+			// CodeParams    Params;          // Only used for function signatures
 			Code            ArrExpr;
 			// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
@@ -1017,7 +1017,6 @@ struct AST_Type
 static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same size as AST");
 #endif
 
-// TODO(Ed): Add support for preserving the typename's keyword qualifier (struct, class, enum, etc), mostly needed for C.
 struct AST_Typename
 {
 	union {
@@ -1028,7 +1027,7 @@ struct AST_Typename
 			CodeAttributes Attributes;
 			CodeSpecifiers Specs;
 			CodeTypename   ReturnType;      // Only used for function signatures
-			CodeParam      Params;          // Only used for function signatures
+			CodeParams     Params;          // Only used for function signatures
 			Code           ArrExpr;
 			CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
 		};
@@ -1140,7 +1139,7 @@ struct AST_Var
 	Code                   Parent;
 	CodeType               Type;
 	ModuleFlag             ModuleFlags;
-	s32                    VarConstructorInit;
+	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,7 +173,7 @@ inline AST_Define* CodeDefine::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -204,7 +204,7 @@ inline AST_Destructor* CodeDestructor::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -235,7 +235,7 @@ inline AST_Enum* CodeEnum::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -266,7 +266,7 @@ inline AST_Exec* CodeExec::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -297,7 +297,7 @@ inline AST_Extern* CodeExtern::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -328,7 +328,7 @@ inline AST_Friend* CodeFriend::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -359,7 +359,7 @@ inline AST_Fn* CodeFn::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -390,7 +390,7 @@ inline AST_Include* CodeInclude::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -421,7 +421,7 @@ inline AST_Module* CodeModule::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -452,7 +452,7 @@ inline AST_NS* CodeNS::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -483,7 +483,7 @@ inline AST_Operator* CodeOperator::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -514,13 +514,13 @@ 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;
 }
 
-inline CodeParam& CodeParam::operator=( Code other )
+inline CodeParams& CodeParams::operator=( Code other )
 {
 	if ( other.ast != nullptr && other->Parent != nullptr )
 	{
@@ -531,7 +531,7 @@ inline CodeParam& CodeParam::operator=( Code other )
 	return *this;
 }
 
-inline CodeParam::operator bool()
+inline CodeParams::operator bool()
 {
 	return ast != nullptr;
 }
@@ -561,7 +561,7 @@ inline AST_Pragma* CodePragma::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -592,7 +592,7 @@ inline AST_PreprocessCond* CodePreprocessCond::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -655,7 +655,7 @@ inline AST_Template* CodeTemplate::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -686,7 +686,7 @@ inline AST_Typename* CodeTypename::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -717,7 +717,7 @@ inline AST_Typedef* CodeTypedef::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -748,7 +748,7 @@ inline AST_Union* CodeUnion::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -779,7 +779,7 @@ inline AST_Using* CodeUsing::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -810,7 +810,7 @@ inline AST_Var* CodeVar::operator->()
 {
 	if ( ast == nullptr )
 	{
-		log_failure( "Attempt to dereference a nullptr!" );
+		log_failure( "Attempt to dereference a nullptr!\n" );
 		return nullptr;
 	}
 	return ast;
@@ -906,9 +906,9 @@ forceinline Code::operator CodeOpCast() const
 	return { (AST_OpCast*)ast };
 }
 
-forceinline Code::operator CodeParam() const
+forceinline Code::operator CodeParams() const
 {
-	return { (AST_Param*)ast };
+	return { (AST_Params*)ast };
 }
 
 forceinline Code::operator CodePragma() const

base/components/gen/ecodetypes.hpp

@@ -0,0 +1,219 @@
+#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)
+
+enum CodeType : u32
+{
+	CT_Invalid,
+	CT_Untyped,
+	CT_NewLine,
+	CT_Comment,
+	CT_Access_Private,
+	CT_Access_Protected,
+	CT_Access_Public,
+	CT_PlatformAttributes,
+	CT_Class,
+	CT_Class_Fwd,
+	CT_Class_Body,
+	CT_Constructor,
+	CT_Constructor_Fwd,
+	CT_Destructor,
+	CT_Destructor_Fwd,
+	CT_Enum,
+	CT_Enum_Fwd,
+	CT_Enum_Body,
+	CT_Enum_Class,
+	CT_Enum_Class_Fwd,
+	CT_Execution,
+	CT_Export_Body,
+	CT_Extern_Linkage,
+	CT_Extern_Linkage_Body,
+	CT_Friend,
+	CT_Function,
+	CT_Function_Fwd,
+	CT_Function_Body,
+	CT_Global_Body,
+	CT_Module,
+	CT_Namespace,
+	CT_Namespace_Body,
+	CT_Operator,
+	CT_Operator_Fwd,
+	CT_Operator_Member,
+	CT_Operator_Member_Fwd,
+	CT_Operator_Cast,
+	CT_Operator_Cast_Fwd,
+	CT_Parameters,
+	CT_Preprocess_Define,
+	CT_Preprocess_Include,
+	CT_Preprocess_If,
+	CT_Preprocess_IfDef,
+	CT_Preprocess_IfNotDef,
+	CT_Preprocess_ElIf,
+	CT_Preprocess_Else,
+	CT_Preprocess_EndIf,
+	CT_Preprocess_Pragma,
+	CT_Specifiers,
+	CT_Struct,
+	CT_Struct_Fwd,
+	CT_Struct_Body,
+	CT_Template,
+	CT_Typedef,
+	CT_Typename,
+	CT_Union,
+	CT_Union_Fwd,
+	CT_Union_Body,
+	CT_Using,
+	CT_Using_Namespace,
+	CT_Variable,
+	CT_NumTypes,
+	CT_UnderlyingType = GEN_U32_MAX
+};
+
+inline Str codetype_to_str( CodeType type )
+{
+	local_persist Str lookup[61] = {
+		{ "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          },
+		{ "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 Str codetype_to_keyword_str( CodeType type )
+{
+	local_persist Str lookup[61] = {
+		{ "__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          },
+		{ "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 Str to_str( CodeType type )
+{
+	return codetype_to_str( type );
+}
+
+forceinline Str to_keyword_str( CodeType type )
+{
+	return codetype_to_keyword_str( type );
+}

base/components/gen/eoperator.hpp

@@ -0,0 +1,118 @@
+#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)
+
+enum Operator : u32
+{
+	Op_Invalid,
+	Op_Assign,
+	Op_Assign_Add,
+	Op_Assign_Subtract,
+	Op_Assign_Multiply,
+	Op_Assign_Divide,
+	Op_Assign_Modulo,
+	Op_Assign_BAnd,
+	Op_Assign_BOr,
+	Op_Assign_BXOr,
+	Op_Assign_LShift,
+	Op_Assign_RShift,
+	Op_Increment,
+	Op_Decrement,
+	Op_Unary_Plus,
+	Op_Unary_Minus,
+	Op_UnaryNot,
+	Op_Add,
+	Op_Subtract,
+	Op_Multiply,
+	Op_Divide,
+	Op_Modulo,
+	Op_BNot,
+	Op_BAnd,
+	Op_BOr,
+	Op_BXOr,
+	Op_LShift,
+	Op_RShift,
+	Op_LAnd,
+	Op_LOr,
+	Op_LEqual,
+	Op_LNot,
+	Op_Lesser,
+	Op_Greater,
+	Op_LesserEqual,
+	Op_GreaterEqual,
+	Op_Subscript,
+	Op_Indirection,
+	Op_AddressOf,
+	Op_MemberOfPointer,
+	Op_PtrToMemOfPtr,
+	Op_FunctionCall,
+	Op_Comma,
+	Op_New,
+	Op_NewArray,
+	Op_Delete,
+	Op_DeleteArray,
+	Op_NumOps,
+	Op_UnderlyingType = 0xffffffffu
+};
+
+inline Str operator_to_str( Operator op )
+{
+	local_persist Str lookup[47] = {
+		{ "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 Str to_str( Operator op )
+{
+	return operator_to_str( op );
+}

base/components/gen/especifier.hpp

@@ -0,0 +1,108 @@
+#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)
+
+enum Specifier : u32
+{
+	Spec_Invalid,
+	Spec_Consteval,
+	Spec_Constexpr,
+	Spec_Constinit,
+	Spec_Explicit,
+	Spec_External_Linkage,
+	Spec_ForceInline,
+	Spec_Global,
+	Spec_Inline,
+	Spec_Internal_Linkage,
+	Spec_Local_Persist,
+	Spec_Mutable,
+	Spec_NeverInline,
+	Spec_Ptr,
+	Spec_Ref,
+	Spec_Register,
+	Spec_RValue,
+	Spec_Static,
+	Spec_Thread_Local,
+	Spec_Virtual,
+	Spec_Const,
+	Spec_Final,
+	Spec_NoExceptions,
+	Spec_Override,
+	Spec_Pure,
+	Spec_Volatile,
+	Spec_NumSpecifiers,
+	Spec_UnderlyingType = 0xffffffffu
+};
+
+inline Str spec_to_str( Specifier type )
+{
+	local_persist Str lookup[26] = {
+		{ "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      },
+		{ "&&",            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;
+}
+
+inline Specifier str_to_specifier( Str str )
+{
+	local_persist u32 keymap[Spec_NumSpecifiers];
+	do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
+	{
+		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++ )
+	{
+		if ( keymap[index] == hash )
+			return (Specifier)index;
+	}
+	return Spec_Invalid;
+}
+
+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 );
+}

base/components/gen/etoktype.cpp

@@ -0,0 +1,235 @@
+#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 Str toktype_to_str( TokType type )
+{
+	local_persist Str lookup[] = {
+		{ "__invalid__",         sizeof( "__invalid__" ) - 1         },
+		{ "private",             sizeof( "private" ) - 1             },
+		{ "protected",           sizeof( "protected" ) - 1           },
+		{ "public",              sizeof( "public" ) - 1              },
+		{ ".",		           sizeof( "." ) - 1                   },
+		{ "::",		          sizeof( "::" ) - 1                  },
+		{ "&",		           sizeof( "&" ) - 1                   },
+		{ "&&",		          sizeof( "&&" ) - 1                  },
+		{ ":",		           sizeof( ":" ) - 1                   },
+		{ "[[",		          sizeof( "[[" ) - 1                  },
+		{ "]]",		          sizeof( "]]" ) - 1                  },
+		{ "{",		           sizeof( "{" ) - 1                   },
+		{ "}",		           sizeof( "}" ) - 1                   },
+		{ "[",		           sizeof( "[" ) - 1                   },
+		{ "]",		           sizeof( "]" ) - 1                   },
+		{ "(",		           sizeof( "(" ) - 1                   },
+		{ ")",		           sizeof( ")" ) - 1                   },
+		{ "__comment__",         sizeof( "__comment__" ) - 1         },
+		{ "__comment_end__",     sizeof( "__comment_end__" ) - 1     },
+		{ "__comment_start__",   sizeof( "__comment_start__" ) - 1   },
+		{ "__character__",       sizeof( "__character__" ) - 1       },
+		{ ",",		           sizeof( "," ) - 1                   },
+		{ "class",               sizeof( "class" ) - 1               },
+		{ "__attribute__",       sizeof( "__attribute__" ) - 1       },
+		{ "__declspec",          sizeof( "__declspec" ) - 1          },
+		{ "enum",                sizeof( "enum" ) - 1                },
+		{ "extern",              sizeof( "extern" ) - 1              },
+		{ "friend",              sizeof( "friend" ) - 1              },
+		{ "module",              sizeof( "module" ) - 1              },
+		{ "namespace",           sizeof( "namespace" ) - 1           },
+		{ "operator",            sizeof( "operator" ) - 1            },
+		{ "struct",              sizeof( "struct" ) - 1              },
+		{ "template",            sizeof( "template" ) - 1            },
+		{ "typedef",             sizeof( "typedef" ) - 1             },
+		{ "using",               sizeof( "using" ) - 1               },
+		{ "union",               sizeof( "union" ) - 1               },
+		{ "__identifier__",      sizeof( "__identifier__" ) - 1      },
+		{ "import",              sizeof( "import" ) - 1              },
+		{ "export",              sizeof( "export" ) - 1              },
+		{ "__new_line__",        sizeof( "__new_line__" ) - 1        },
+		{ "__number__",          sizeof( "__number__" ) - 1          },
+		{ "__operator__",        sizeof( "__operator__" ) - 1        },
+		{ "#",		           sizeof( "#" ) - 1                   },
+		{ "define",              sizeof( "define" ) - 1              },
+		{ "if",		          sizeof( "if" ) - 1                  },
+		{ "ifdef",               sizeof( "ifdef" ) - 1               },
+		{ "ifndef",              sizeof( "ifndef" ) - 1              },
+		{ "elif",                sizeof( "elif" ) - 1                },
+		{ "else",                sizeof( "else" ) - 1                },
+		{ "endif",               sizeof( "endif" ) - 1               },
+		{ "include",             sizeof( "include" ) - 1             },
+		{ "pragma",              sizeof( "pragma" ) - 1              },
+		{ "__macro_content__",   sizeof( "__macro_content__" ) - 1   },
+		{ "__macro__",           sizeof( "__macro__" ) - 1           },
+		{ "__unsupported__",     sizeof( "__unsupported__" ) - 1     },
+		{ "alignas",             sizeof( "alignas" ) - 1             },
+		{ "const",               sizeof( "const" ) - 1               },
+		{ "consteval",           sizeof( "consteval" ) - 1           },
+		{ "constexpr",           sizeof( "constexpr" ) - 1           },
+		{ "constinit",           sizeof( "constinit" ) - 1           },
+		{ "explicit",            sizeof( "explicit" ) - 1            },
+		{ "extern",              sizeof( "extern" ) - 1              },
+		{ "final",               sizeof( "final" ) - 1               },
+		{ "forceinline",         sizeof( "forceinline" ) - 1         },
+		{ "global",              sizeof( "global" ) - 1              },
+		{ "inline",              sizeof( "inline" ) - 1              },
+		{ "internal",            sizeof( "internal" ) - 1            },
+		{ "local_persist",       sizeof( "local_persist" ) - 1       },
+		{ "mutable",             sizeof( "mutable" ) - 1             },
+		{ "neverinline",         sizeof( "neverinline" ) - 1         },
+		{ "override",            sizeof( "override" ) - 1            },
+		{ "static",              sizeof( "static" ) - 1              },
+		{ "thread_local",        sizeof( "thread_local" ) - 1        },
+		{ "volatile",            sizeof( "volatile" ) - 1            },
+		{ "virtual",             sizeof( "virtual" ) - 1             },
+		{ "*",		           sizeof( "*" ) - 1                   },
+		{ ";",		           sizeof( ";" ) - 1                   },
+		{ "static_assert",       sizeof( "static_assert" ) - 1       },
+		{ "__string__",          sizeof( "__string__" ) - 1          },
+		{ "typename",            sizeof( "typename" ) - 1            },
+		{ "unsigned",            sizeof( "unsigned" ) - 1            },
+		{ "signed",              sizeof( "signed" ) - 1              },
+		{ "short",               sizeof( "short" ) - 1               },
+		{ "long",                sizeof( "long" ) - 1                },
+		{ "bool",                sizeof( "bool" ) - 1                },
+		{ "char",                sizeof( "char" ) - 1                },
+		{ "int",		         sizeof( "int" ) - 1                 },
+		{ "double",              sizeof( "double" ) - 1              },
+		{ "__int8",              sizeof( "__int8" ) - 1              },
+		{ "__int16",             sizeof( "__int16" ) - 1             },
+		{ "__int32",             sizeof( "__int32" ) - 1             },
+		{ "__int64",             sizeof( "__int64" ) - 1             },
+		{ "_W64",                sizeof( "_W64" ) - 1                },
+		{ "...",		         sizeof( "..." ) - 1                 },
+		{ "__attrib_start__",    sizeof( "__attrib_start__" ) - 1    },
+		{ "GEN_API_Export_Code", sizeof( "GEN_API_Export_Code" ) - 1 },
+		{ "GEN_API_Import_Code", sizeof( "GEN_API_Import_Code" ) - 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;
+}
+
+GEN_NS_PARSER_END

base/components/header_end.hpp

@@ -24,8 +24,8 @@
 #ifndef GEN_MAX_UNTYPED_STR_LENGTH
 #	define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
 #endif
-#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
-#	define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(8)
+#ifndef TokenMap_FixedArena
+#	define TokenMap_FixedArena FixedArena_8KB
 #endif
 #ifndef GEN_LEX_ALLOCATOR_SIZE
 #	define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
@@ -49,10 +49,12 @@ 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 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 Str enum_underlying_sig;
+
 extern Code access_public;
 extern Code access_protected;
 extern Code access_private;
@@ -67,7 +69,7 @@ extern Code fmt_newline;
 
 extern CodePragma pragma_once;
 
-extern CodeParam param_varadic;
+extern CodeParams param_varadic;
 
 extern CodePreprocessCond preprocess_else;
 extern CodePreprocessCond preprocess_endif;

base/components/inlines.hpp

@@ -101,7 +101,7 @@ Code& Code::operator ++()
 }
 #endif
 forceinline
-StrC code_type_str(Code self)
+Str code_type_str(Code self)
 {
 	GEN_ASSERT(self != nullptr);
 	return codetype_to_str( self->Type );
@@ -178,9 +178,9 @@ void class_add_interface( CodeClass self, CodeTypename type )
 }
 #pragma endregion CodeClass
 
-#pragma region CodeParam
+#pragma region CodeParams
 inline
-void params_append( CodeParam appendee, CodeParam other )
+void params_append( CodeParams appendee, CodeParams other )
 {
 	GEN_ASSERT(appendee);
 	GEN_ASSERT(other);
@@ -206,37 +206,37 @@ void params_append( CodeParam appendee, CodeParam other )
 	self->NumEntries++;
 }
 inline
-CodeParam params_get(CodeParam self, s32 idx )
+CodeParams params_get(CodeParams self, s32 idx )
 {
 	GEN_ASSERT(self);
-	CodeParam param = self;
+	CodeParams param = self;
 	do
 	{
 		if ( ++ param != nullptr )
 			return NullCode;
 
-		param = cast(CodeParam, cast(Code, param)->Next);
+		param = cast(CodeParams, cast(Code, param)->Next);
 	}
 	while ( --idx );
 
 	return param;
 }
 forceinline
-bool params_has_entries(CodeParam self)
+bool params_has_entries(CodeParams self)
 {
 	GEN_ASSERT(self);
 	return self->NumEntries > 0;
 }
 #if GEN_COMPILER_CPP
 forceinline
-CodeParam& CodeParam::operator ++()
+CodeParams& CodeParams::operator ++()
 {
 	* this = ast->Next;
 	return * this;
 }
 #endif
 forceinline
-CodeParam begin_CodeParam(CodeParam params)
+CodeParams begin_CodeParams(CodeParams params)
 {
 	if ( params != nullptr )
 		return params;
@@ -244,18 +244,18 @@ CodeParam begin_CodeParam(CodeParam params)
 	return NullCode;
 }
 forceinline
-CodeParam end_CodeParam(CodeParam params)
+CodeParams end_CodeParams(CodeParams params)
 {
-	// return { (AST_Param*) rcast( AST*, ast)->Last };
+	// return { (AST_Params*) rcast( AST*, ast)->Last };
 	return NullCode;
 }
 forceinline
-CodeParam next_CodeParam(CodeParam params, CodeParam param_iter)
+CodeParams next_CodeParams(CodeParams params, CodeParams param_iter)
 {
 	GEN_ASSERT(param_iter);
 	return param_iter->Next;
 }
-#pragma endregion CodeParam
+#pragma endregion CodeParams
 
 #pragma region CodeSpecifiers
 inline
@@ -397,7 +397,7 @@ CodeBody def_body( CodeType type )
 }
 
 inline
-StrC token_fmt_impl( ssize num, ... )
+Str token_fmt_impl( ssize num, ... )
 {
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
@@ -408,7 +408,7 @@ StrC token_fmt_impl( ssize num, ... )
 	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
 	va_end(va);
 
-	StrC str = { result, buf };
+	Str str = { buf, result };
 	return str;
 }
 #pragma endregion Interface

base/components/interface.cpp

@@ -101,11 +101,11 @@ void define_constants()
 	access_public->Name = get_cached_string( 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));
 
@@ -131,7 +131,7 @@ void define_constants()
 	pragma_once->Content = pragma_once->Name;
 	code_set_global((Code)pragma_once);
 
-	param_varadic            = (CodeParam) make_code();
+	param_varadic            = (CodeParams) make_code();
 	param_varadic->Type      = CT_Parameters;
 	param_varadic->Name      = get_cached_string( txt("...") );
 	param_varadic->ValueType = t_empty;
@@ -145,96 +145,67 @@ 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
 
-
-#	define def_constant_spec( Type_, ... )                                  \
-		spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
-		code_set_global( cast(Code, spec_##Type_));
-
-#	pragma push_macro("forceinline")
-#	pragma push_macro("global")
-#	pragma push_macro("internal")
-#	pragma push_macro("local_persist")
-#	pragma push_macro("neverinline")
-#	undef forceinline
-#	undef global
-#	undef internal
-#	undef local_persist
-#	undef neverinline
-	def_constant_spec( const,            Spec_Const );
-	def_constant_spec( consteval,        Spec_Consteval );
-	def_constant_spec( constexpr,        Spec_Constexpr );
-	def_constant_spec( constinit,        Spec_Constinit );
-	def_constant_spec( extern_linkage,   Spec_External_Linkage );
-	def_constant_spec( final, 		     Spec_Final );
-	def_constant_spec( forceinline,      Spec_ForceInline );
-	def_constant_spec( global,           Spec_Global );
-	def_constant_spec( inline,           Spec_Inline );
-	def_constant_spec( internal_linkage, Spec_Internal_Linkage );
-	def_constant_spec( local_persist,    Spec_Local_Persist );
-	def_constant_spec( mutable,          Spec_Mutable );
-	def_constant_spec( neverinline,      Spec_NeverInline );
-	def_constant_spec( noexcept,         Spec_NoExceptions );
-	def_constant_spec( override,         Spec_Override );
-	def_constant_spec( ptr,              Spec_Ptr );
-	def_constant_spec( pure,             Spec_Pure )
-	def_constant_spec( ref,              Spec_Ref );
-	def_constant_spec( register,         Spec_Register );
-	def_constant_spec( rvalue,           Spec_RValue );
-	def_constant_spec( static_member,    Spec_Static );
-	def_constant_spec( thread_local,     Spec_Thread_Local );
-	def_constant_spec( virtual, 		 Spec_Virtual );
-	def_constant_spec( volatile, 	     Spec_Volatile)
+	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_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_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));
 
-#	pragma pop_macro("forceinline")
-#	pragma pop_macro("global")
-#	pragma pop_macro("internal")
-#	pragma pop_macro("local_persist")
-#	pragma pop_macro("neverinline")
-
-#	pragma push_macro("enum_underlying")
-	array_append(PreprocessorDefines, txt("enum_underlying("));
-#	pragma pop_macro("enum_underlying")
+	if (enum_underlying_sig.Len == 0) {
+		enum_underlying_sig = txt("enum_underlying(");
+	}
+	array_append(PreprocessorDefines, enum_underlying_sig);
 
 #	undef def_constant_spec
 }
@@ -260,22 +231,22 @@ void init()
 	}
 
 	if (Allocator_DataArrays.Proc == nullptr) {
-		Allocator_DataArrays = heap();
+		Allocator_DataArrays = GlobalAllocator;
 	}
 	if (Allocator_CodePool.Proc == nullptr ) {
-		Allocator_CodePool = heap();
+		Allocator_CodePool = GlobalAllocator;
 	}
 	if (Allocator_Lexer.Proc == nullptr) {
-		Allocator_Lexer = heap();
+		Allocator_Lexer = GlobalAllocator;
 	}
 	if (Allocator_StringArena.Proc == nullptr) {
-		Allocator_StringArena = heap();
+		Allocator_StringArena = GlobalAllocator;
 	}
 	if (Allocator_StringTable.Proc == nullptr) {
-		Allocator_StringTable = heap();
+		Allocator_StringTable = GlobalAllocator;
 	}
 	if (Allocator_TypeTable.Proc == nullptr) {
-		Allocator_TypeTable = heap();
+		Allocator_TypeTable = GlobalAllocator;
 	}
 
 	// Setup the arrays
@@ -302,12 +273,12 @@ void init()
 
 		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
 
-		Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+		Arena strbuilder_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
-		if ( string_arena.PhysicalStart == nullptr )
+		if ( strbuilder_arena.PhysicalStart == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
 
-		array_append( StringArenas, string_arena );
+		array_append( StringArenas, strbuilder_arena );
 	}
 
 	// Setup the hash tables
@@ -341,8 +312,8 @@ void deinit()
 	left  = array_num(StringArenas);
 	do
 	{
-		Arena* string_arena = & StringArenas[index];
-		arena_free(string_arena);
+		Arena* strbuilder_arena = & StringArenas[index];
+		arena_free(strbuilder_arena);
 		index++;
 	}
 	while ( left--, left );
@@ -386,8 +357,8 @@ void reset()
 	left  = array_num(StringArenas);
 	do
 	{
-		Arena* string_arena = & StringArenas[index];
-		string_arena->TotalUsed = 0;;
+		Arena* strbuilder_arena = & StringArenas[index];
+		strbuilder_arena->TotalUsed = 0;;
 		index++;
 	}
 	while ( left--, left );
@@ -397,18 +368,18 @@ void reset()
 	define_constants();
 }
 
-AllocatorInfo get_string_allocator( s32 str_length )
+AllocatorInfo get_strbuilder_allocator( s32 c_str_length )
 {
 	Arena* last = array_back(StringArenas);
 
-	usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
+	usize size_req = c_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 );
 
 		if ( ! array_append( StringArenas, new_arena ) )
-			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
+			GEN_FATAL( "gen::get_strbuilder_allocator: Failed to allocate a new string arena" );
 
 		last = array_back(StringArenas);
 	}
@@ -417,7 +388,7 @@ AllocatorInfo get_string_allocator( s32 str_length )
 }
 
 // Will either make or retrive a code string.
-StringCached get_cached_string( StrC str )
+StringCached get_cached_string( Str str )
 {
 	s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len;
 	u64 key         = crc32( str.Ptr, hash_length );
@@ -428,7 +399,7 @@ StringCached get_cached_string( StrC str )
 			return * result;
 	}
 
-	StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str ));
+	Str result = strbuilder_to_str( strbuilder_make_str( get_strbuilder_allocator( str.Len ), str ));
 	hashtable_set(StringCache, key, result );
 
 	return result;
@@ -471,12 +442,12 @@ void set_allocator_lexer( AllocatorInfo allocator )
 	Allocator_Lexer = allocator;
 }
 
-void set_allocator_string_arena( AllocatorInfo allocator )
+void set_allocator_strbuilder_arena( AllocatorInfo allocator )
 {
 	Allocator_StringArena = allocator;
 }
 
-void set_allocator_string_table( AllocatorInfo allocator )
+void set_allocator_strbuilder_table( AllocatorInfo allocator )
 {
 	Allocator_StringArena = allocator;
 }

base/components/interface.hpp

@@ -28,7 +28,7 @@ void reset();
 
 // 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 );
+StringCached get_cached_string( Str str );
 
 /*
 	This provides a fresh Code AST.
@@ -42,14 +42,14 @@ Code make_code();
 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_strbuilder_arena( AllocatorInfo strbuilder_allocator );
+void set_allocator_strbuilder_table( AllocatorInfo strbuilder_allocator );
 void set_allocator_type_table  ( AllocatorInfo type_reg_allocator );
 
 #pragma region Upfront
 
-CodeAttributes def_attributes( StrC content );
-CodeComment    def_comment   ( StrC content );
+CodeAttributes def_attributes( Str content );
+CodeComment    def_comment   ( Str content );
 
 struct Opts_def_struct {
 	CodeBody       body;
@@ -60,16 +60,19 @@ struct Opts_def_struct {
 	s32            num_interfaces;
 	ModuleFlag     mflags;
 };
-CodeClass def_class( StrC name, Opts_def_struct otps GEN_PARAM_DEFAULT );
+CodeClass def_class( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_constructor {
-	CodeParam params;
+	CodeParams params;
 	Code      initializer_list;
 	Code      body;
 };
 CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
 
-CodeDefine def_define( StrC name, StrC content );
+struct Opts_def_define {
+	b32 dont_append_preprocess_defines;
+};
+CodeDefine def_define( Str name, Str content, Opts_def_define opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_destructor {
 	Code           body;
@@ -83,39 +86,40 @@ struct Opts_def_enum {
 	EnumT          specifier;
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
+	Code           type_macro;
 };
-CodeEnum def_enum( StrC name, Opts_def_enum opts GEN_PARAM_DEFAULT );
+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 );
+CodeExec   def_execution  ( Str content );
+CodeExtern def_extern_link( Str name, CodeBody body );
 CodeFriend def_friend     ( Code symbol );
 
 struct Opts_def_function {
-	CodeParam       params;
+	CodeParams      params;
 	CodeTypename    ret_type;
 	CodeBody        body;
 	CodeSpecifiers  specs;
 	CodeAttributes  attrs;
 	ModuleFlag      mflags;
 };
-CodeFn def_function( StrC name, Opts_def_function opts GEN_PARAM_DEFAULT );
+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 );
+CodeInclude def_include  ( Str content,             Opts_def_include   opts GEN_PARAM_DEFAULT );
+CodeModule  def_module   ( Str name,                Opts_def_module    opts GEN_PARAM_DEFAULT );
+CodeNS      def_namespace( Str name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_operator {
-	CodeParam       params;
+	CodeParams      params;
 	CodeTypename    ret_type;
 	CodeBody        body;
 	CodeSpecifiers  specifiers;
 	CodeAttributes  attributes;
 	ModuleFlag      mflags;
 };
-CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
+CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_operator_cast {
 	CodeBody       body;
@@ -124,17 +128,17 @@ struct Opts_def_operator_cast {
 CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_param { Code value; };
-CodeParam  def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT );
-CodePragma def_pragma( StrC directive );
+CodeParams  def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
+CodePragma def_pragma( Str directive );
 
-CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str content );
 
 CodeSpecifiers def_specifier( Specifier specifier );
 
-CodeStruct def_struct( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
+CodeStruct def_struct( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_template { ModuleFlag mflags; };
-CodeTemplate def_template( CodeParam params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
+CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
 
 struct Opts_def_type {
 	ETypenameTag   type_tag;
@@ -142,27 +146,27 @@ struct Opts_def_type {
 	CodeSpecifiers specifiers;
 	CodeAttributes attributes;
 };
-CodeTypename def_type( StrC name, Opts_def_type opts GEN_PARAM_DEFAULT );
+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 );
+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 );
+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 );
+CodeUsing def_using( Str name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
 
-CodeUsing def_using_namespace( StrC name );
+CodeUsing def_using_namespace( Str name );
 
 struct Opts_def_variable
 {
@@ -171,7 +175,7 @@ struct Opts_def_variable
 	CodeAttributes attributes;
 	ModuleFlag     mflags;
 };
-CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable opts GEN_PARAM_DEFAULT );
+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 );
@@ -193,8 +197,8 @@ 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 );
-CodeParam      def_params          ( s32 num, ... );
-CodeParam      def_params          ( s32 num, CodeParam* params );
+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, ... );
@@ -216,13 +220,13 @@ struct StackNode
 
 	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
@@ -239,28 +243,28 @@ 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         );
+CodeClass       parse_class        ( Str class_def       );
+CodeConstructor parse_constructor  ( Str constructor_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    );
+CodeTypename    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         );
 
 #pragma endregion Parsing
 
@@ -268,61 +272,74 @@ CodeVar         parse_variable     ( StrC var_def         );
 
 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, ... );
+Str token_fmt_impl( ssize, ... );
 
-Code untyped_str      ( StrC content);
+Code untyped_str      ( Str content);
 Code untyped_fmt      ( char const* fmt, ... );
-Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
+Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
 
 #pragma endregion Untyped text
 
 #pragma region Macros
 
+#ifndef gen_main
+#define gen_main main
+#endif
+
+#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_ )   { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
+#endif
+
+#ifndef code
+//  Same as name just used to indicate intention of literal for code instead of names.
+#define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
+#endif
+
+#ifndef args
+// Provides the number of arguments while passing args inplace.
+#define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
+#endif
+
+#ifndef code_str
+// Just wrappers over common untyped code definition constructions.
+#define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
+#endif
+
+#ifndef code_fmt
+#define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
+#endif
+
+#ifndef parse_fmt
+#define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
+#endif
+
 #ifndef token_fmt
-#	define gen_main main
-
-#	define __ NullCode
-
-	//	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_) }
-
-	//  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__ ) }
-
-	// Provides the number of arguments while passing args inplace.
-#	define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
-
-	// Just wrappers over common untyped code definition constructions.
-#	define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
-#	define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
-
-#	define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
-
-	/*
-	Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC 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,
-		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
-		,	stringize(
-			typedef <type> <name> <name>
-		));
-	!----------------------------------------------------------
-	! Note: token_fmt_va is whitespace sensitive for the tokens.
-	! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
-	*/
-#	define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
+/*
+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", 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", str_for_type
+	,	"name", str_for_name
+	,	stringize(
+		typedef <type> <name> <name>
+	));
+!----------------------------------------------------------
+! Note: token_fmt_va is whitespace sensitive for the tokens.
+! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
+*/
+#define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
 #endif
 
 #pragma endregion Macros

base/components/interface.parsing.cpp

@@ -8,7 +8,7 @@
 
 // Publically Exposed Interface
 
-CodeClass parse_class( StrC def )
+CodeClass parse_class( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -19,12 +19,12 @@ CodeClass parse_class( StrC def )
 
 	Context.Tokens = toks;
 	push_scope();
-	CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class );
+	CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
 	parser_pop(& Context);
 	return result;
 }
 
-CodeConstructor parse_constructor( StrC def )
+CodeConstructor parse_constructor( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -35,13 +35,13 @@ CodeConstructor parse_constructor( StrC def )
 
 	// TODO(Ed): Constructors can have prefix attributes
 
-	CodeSpecifiers specifiers;
-	Specifier      specs_found[ 16 ] { Spec_NumSpecifiers };
+	CodeSpecifiers specifiers = NullCode;
+	Specifier      specs_found[ 16 ] = { Spec_NumSpecifiers };
 	s32            NumSpecifiers = 0;
 
 	while ( left && tok_is_specifier(currtok) )
 	{
-		Specifier spec = strc_to_specifier( tok_to_str(currtok) );
+		Specifier spec = str_to_specifier( tok_to_str(currtok) );
 
 		b32 ignore_spec = false;
 
@@ -59,7 +59,7 @@ CodeConstructor parse_constructor( StrC def )
 				break;
 
 			default :
-				log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) );
+				log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(Context) );
 				parser_pop(& Context);
 				return InvalidCode;
 		}
@@ -80,11 +80,11 @@ CodeConstructor parse_constructor( StrC def )
 	}
 
 	Context.Tokens         = toks;
-	CodeConstructor result = parse_constructor( specifiers );
+	CodeConstructor result = parser_parse_constructor( specifiers );
 	return result;
 }
 
-CodeDestructor parse_destructor( StrC def )
+CodeDestructor parse_destructor( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -97,11 +97,11 @@ CodeDestructor parse_destructor( StrC def )
 	// TODO(Ed): Destructors can have virtual
 
 	Context.Tokens        = toks;
-	CodeDestructor result = parse_destructor();
+	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 );
@@ -114,10 +114,10 @@ CodeEnum parse_enum( StrC def )
 	}
 
 	Context.Tokens = toks;
-	return parse_enum( parser_not_inplace_def);
+	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 );
@@ -127,10 +127,10 @@ CodeBody parse_export_body( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_export_body();
+	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 );
@@ -140,10 +140,10 @@ CodeExtern parse_extern_link( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_extern_link();
+	return parser_parse_extern_link();
 }
 
-CodeFriend parse_friend( StrC def )
+CodeFriend parse_friend( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -153,10 +153,10 @@ CodeFriend parse_friend( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_friend();
+	return parser_parse_friend();
 }
 
-CodeFn parse_function( StrC def )
+CodeFn parse_function( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -166,10 +166,10 @@ CodeFn parse_function( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return (CodeFn) parse_function();
+	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 );
@@ -185,7 +185,7 @@ CodeBody parse_global_body( StrC def )
 	return result;
 }
 
-CodeNS parse_namespace( StrC def )
+CodeNS parse_namespace( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -195,10 +195,10 @@ CodeNS parse_namespace( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_namespace();
+	return parser_parse_namespace();
 }
 
-CodeOperator parse_operator( StrC def )
+CodeOperator parse_operator( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -208,10 +208,10 @@ CodeOperator parse_operator( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return (CodeOperator) parse_operator();
+	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 );
@@ -221,10 +221,10 @@ CodeOpCast parse_operator_cast( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_operator_cast();
+	return parser_parse_operator_cast(NullCode);
 }
 
-CodeStruct parse_struct( StrC def )
+CodeStruct parse_struct( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -235,12 +235,12 @@ CodeStruct parse_struct( StrC def )
 
 	Context.Tokens = toks;
 	push_scope();
-	CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct );
+	CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
 	parser_pop(& Context);
 	return result;
 }
 
-CodeTemplate parse_template( StrC def )
+CodeTemplate parse_template( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -250,10 +250,10 @@ CodeTemplate parse_template( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_template();
+	return parser_parse_template();
 }
 
-CodeTypename parse_type( StrC def )
+CodeTypename parse_type( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -263,10 +263,10 @@ CodeTypename parse_type( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_type( parser_not_from_template, nullptr);
+	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 );
@@ -276,10 +276,10 @@ CodeTypedef parse_typedef( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_typedef();
+	return parser_parse_typedef();
 }
 
-CodeUnion parse_union( StrC def )
+CodeUnion parse_union( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -289,10 +289,10 @@ CodeUnion parse_union( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_union( parser_not_inplace_def);
+	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 );
@@ -302,10 +302,10 @@ CodeUsing parse_using( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_using();
+	return parser_parse_using();
 }
 
-CodeVar parse_variable( StrC def )
+CodeVar parse_variable( Str def )
 {
 	GEN_USING_NS_PARSER;
 	check_parse_args( def );
@@ -315,15 +315,31 @@ CodeVar parse_variable( StrC def )
 		return InvalidCode;
 
 	Context.Tokens = toks;
-	return parse_variable();
+	return parser_parse_variable();
 }
 
 // Undef helper macros
-#	undef check_parse_args
-#	undef currtok
-#	undef prevtok
-#   undef nexttok
-#	undef eat
-#	undef left
-#	undef check
-#	undef push_scope
+#undef check_parse_args
+#undef currtok_noskip
+#undef currtok
+#undef peektok
+#undef prevtok
+#undef nexttok
+#undef nexttok_noskip
+#undef eat
+#undef left
+#undef check
+#undef push_scope
+#undef def_assign
+
+// Here for C Variant
+#undef lex_dont_skip_formatting
+#undef lex_skip_formatting
+
+#undef parser_inplace_def
+#undef parser_not_inplace_def
+#undef parser_dont_consume_braces
+#undef parser_consume_braces
+#undef parser_not_from_template
+#undef parser_use_parenthesis
+#undef parser_strip_formatting_dont_preserve_newlines

base/components/interface.untyped.cpp

@@ -9,22 +9,22 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 	ssize       remaining = buf_size;
 
 	local_persist
-	FixedArena<TokenFmt_TokenMap_MemSize> tok_map_arena;
+	TokenMap_FixedArena tok_map_arena;
 	fixed_arena_init( & tok_map_arena);
 
 	local_persist
-	HashTable(StrC) tok_map;
+	StringTable tok_map;
 	{
-		tok_map = hashtable_init(StrC, fixed_arena_allocator_info(& tok_map_arena) );
+		tok_map = hashtable_init(Str, fixed_arena_allocator_info(& tok_map_arena) );
 
 		s32 left = num_tokens - 1;
 
 		while ( left-- )
 		{
 			char const* token = va_arg( va, char const* );
-			StrC        value = va_arg( va, StrC );
+			Str        value = va_arg( va, Str );
 
-			u32 key = crc32( token, str_len(token) );
+			u32 key = crc32( token, c_str_len(token) );
 			hashtable_set( tok_map, key, value );
 		}
 	}
@@ -61,7 +61,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 			char const* token = fmt + 1;
 
 			u32       key   = crc32( token, tok_len );
-			StrC*     value = hashtable_get(tok_map, key );
+			Str*     value = hashtable_get(tok_map, key );
 
 			if ( value )
 			{
@@ -99,7 +99,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 	return result;
 }
 
-Code untyped_str( StrC content )
+Code untyped_str( Str content )
 {
 	if ( content.Len == 0 )
 	{
@@ -113,7 +113,7 @@ Code untyped_str( StrC content )
 	result->Type    = CT_Untyped;
 	result->Content = result->Name;
 
-	if ( result->Name == nullptr )
+	if ( result->Name.Len == 0 )
 	{
 		log_failure( "untyped_str: could not cache string" );
 		return InvalidCode;
@@ -135,16 +135,19 @@ Code untyped_fmt( char const* fmt, ...)
 
 	va_list va;
 	va_start(va, fmt);
-	ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	ssize length = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
 	va_end(va);
 
+	Str buf_str      = { fmt, c_str_len_capped(fmt, MaxNameLength) };
+    Str uncapped_str = { buf, length };
+
 	Code
 	result          = make_code();
-	result->Name    = get_cached_string( { str_len_capped(fmt, MaxNameLength), fmt } );
+	result->Name    = get_cached_string( buf_str );
 	result->Type    = CT_Untyped;
-	result->Content = get_cached_string( { length, buf } );
+	result->Content = get_cached_string( uncapped_str );
 
-	if ( result->Name == nullptr )
+	if ( result->Name.Len == 0 )
 	{
 		log_failure( "untyped_fmt: could not cache string" );
 		return InvalidCode;
@@ -153,7 +156,7 @@ Code untyped_fmt( char const* fmt, ...)
 	return result;
 }
 
-Code untyped_token_fmt( s32 num_tokens, ... )
+Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
 {
 	if ( num_tokens == 0 )
 	{
@@ -165,17 +168,19 @@ Code untyped_token_fmt( s32 num_tokens, ... )
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
 
 	va_list va;
-	va_start(va, num_tokens);
+	va_start(va, fmt);
 	ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
 	va_end(va);
 
+	Str buf_str = { buf, length };
+
 	Code
 	result          = make_code();
-	result->Name    = get_cached_string( { length, buf } );
+	result->Name    = get_cached_string( buf_str );
 	result->Type    = CT_Untyped;
 	result->Content = result->Name;
 
-	if ( result->Name == nullptr )
+	if ( result->Name.Len == 0 )
 	{
 		log_failure( "untyped_fmt: could not cache string" );
 		return InvalidCode;

base/components/static_data.cpp

@@ -1,6 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #pragma once
-#include "gen.hpp"
+#include "../gen.hpp"
 #endif
 
 #pragma region StaticData
@@ -28,6 +28,8 @@ global AllocatorInfo Allocator_TypeTable   = {0};
 
 #pragma region Constants
 
+global Str enum_underlying_sig;
+
 global Code access_public;
 global Code access_protected;
 global Code access_private;
@@ -40,7 +42,7 @@ global Code module_private_fragment;
 
 global Code fmt_newline;
 
-global CodeParam param_varadic;
+global CodeParams param_varadic;
 
 global CodePragma pragma_once;
 

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/basic_types.hpp

@@ -1,6 +1,5 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "platform.hpp"
 #	include "macros.hpp"
 #endif
 

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; }
@@ -440,8 +440,6 @@ bool array_set_capacity(Array<Type>* array, usize new_capacity)
 
 #pragma endregion Array
 
-// TODO(Ed) : This thing needs ALOT of work.
-
 #pragma region HashTable
 #define HashTable(Type) HashTable<Type>
 

base/dependencies/debug.cpp

@@ -1,7 +1,5 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "debug.hpp"
-#	include "basic_types.hpp"
 #   include "src_start.cpp"
 #endif
 

base/dependencies/debug.hpp

@@ -1,20 +1,30 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
+#	include "dependencies/platform.hpp"
+#	include "dependencies/macros.hpp"
 #	include "basic_types.hpp"
+#	include "macros.hpp"
 #endif
 
 #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 )
@@ -34,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_BULD_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)
@@ -50,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_ )
@@ -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

@@ -0,0 +1,287 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#   pragma once
+#	include "platform.hpp"
+#endif
+
+#pragma region Macros
+
+#ifndef global
+#define global        static    // Global variables
+#endif
+#ifndef internal
+#define internal      static    // Internal linkage
+#endif
+#ifndef local_persist
+#define local_persist static    // Local Persisting variables
+#endif
+
+#ifndef bit
+#define bit( Value )                             ( 1 << Value )
+#define bitfield_is_equal( 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
+#ifndef GEN_C_LIKE_CPP
+#define GEN_C_LIKE_CPP 0
+#endif
+
+#if GEN_COMPILER_CPP
+#	ifndef cast
+#	define cast( type, value ) (tmpl_cast<type>( value ))
+#	endif
+#else
+#	ifndef cast
+#	define cast( type, value )  ( (type)(value) )
+#	endif
+#endif
+
+#if GEN_COMPILER_CPP
+#	ifndef ccast
+#	define ccast( type, value ) ( const_cast< type >( (value) ) )
+#	endif
+#	ifndef pcast
+#	define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
+#	endif
+#	ifndef rcast
+#	define rcast( type, value ) reinterpret_cast< type >( value )
+#	endif
+#	ifndef scast
+#	define scast( type, value ) static_cast< type >( value )
+#	endif
+#else
+#	ifndef ccast
+#	define ccast( type, value ) ( (type)(value) )
+#	endif
+#	ifndef pcast
+#	define pcast( type, value ) ( * (type*)(& value) )
+#	endif
+#	ifndef rcast
+#	define rcast( type, value ) ( (type)(value) )
+#	endif
+#	ifndef scast
+#	define scast( type, value ) ( (type)(value) )
+#	endif
+#endif
+
+#ifndef stringize
+#define stringize_va( ... ) #__VA_ARGS__
+#define stringize( ... )    stringize_va( __VA_ARGS__ )
+#endif
+
+#ifndef do_once
+#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
+
+#define do_once_start      \
+	do                     \
+	{                      \
+		local_persist      \
+		bool done = false; \
+		if ( done )        \
+			break;         \
+		done = true;
+
+#define do_once_end        \
+	}                      \
+	while(0);
+#endif
+
+#ifndef labeled_scope_start
+#define labeled_scope_start if ( false ) {
+#define labeled_scope_end   }
+#endif
+
+#ifndef         compiler_decorated_func_name
+#   ifdef COMPILER_CLANG
+#       define  compiler_decorated_func_name __PRETTY_NAME__
+#   elif defined(COMPILER_MSVC)
+#   	define compiler_decorated_func_name __FUNCDNAME__
+#   endif
+#endif
+
+#ifndef num_args_impl
+
+// This is essentially an arg couneter version of GEN_SELECT_ARG macros
+// See section : _Generic function overloading for that usage (explains this heavier case)
+
+#define num_args_impl( _0,                                 \
+		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,   \
+		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20,  \
+		_21, _22, _23, _24, _25, _26, _27, _28, _29, _30,  \
+		_31, _32, _33, _34, _35, _36, _37, _38, _39, _40,  \
+		_41, _42, _43, _44, _45, _46, _47, _48, _49, _50,  \
+		_51, _52, _53, _54, _55, _56, _57, _58, _59, _60,  \
+		_61, _62, _63, _64, _65, _66, _67, _68, _69, _70,  \
+		_71, _72, _73, _74, _75, _76, _77, _78, _79, _80,  \
+		_81, _82, _83, _84, _85, _86, _87, _88, _89, _90,  \
+		_91, _92, _93, _94, _95, _96, _97, _98, _99, _100, \
+		N, ...                                             \
+	) N
+
+// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
+#define num_args(...)                            \
+	num_args_impl(_, ## __VA_ARGS__,             \
+		100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
+		 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, \
+		 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, \
+		 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
+		 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
+		 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
+		 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
+		 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
+		 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
+		 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
+		 0                                       \
+	)
+#endif
+
+#ifndef clamp
+#define clamp( x, lower, upper )      min( max( ( x ), ( lower ) ), ( upper ) )
+#endif
+#ifndef count_of
+#define count_of( x )                 ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( ssize )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
+#endif
+#ifndef is_between
+#define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
+#endif
+#ifndef size_of
+#define size_of( x )                  ( ssize )( sizeof( x ) )
+#endif
+
+#ifndef max
+#define max( a, b ) ( (a > b) ? (a) : (b) )
+#endif
+#ifndef min
+#define min( a, b ) ( (a < b) ? (a) : (b) )
+#endif
+
+#if GEN_COMPILER_MSVC || GEN_COMPILER_TINYC
+#	define offset_of( Type, element ) ( ( GEN_NS( ssize ) ) & ( ( ( Type* )0 )->element ) )
+#else
+#	define offset_of( Type, element ) __builtin_offsetof( Type, element )
+#endif
+
+#ifndef        forceinline
+#	if GEN_COMPILER_MSVC
+#		define forceinline __forceinline
+#		define neverinline __declspec( noinline )
+#	elif GEN_COMPILER_GCC
+#		define forceinline inline __attribute__((__always_inline__))
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	elif GEN_COMPILER_CLANG
+#	if __has_attribute(__always_inline__)
+#		define forceinline inline __attribute__((__always_inline__))
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	else
+#		define forceinline
+#		define neverinline
+#	endif
+#	else
+#		define forceinline
+#		define neverinline
+#	endif
+#endif
+
+#ifndef        neverinline
+#	if GEN_COMPILER_MSVC
+#		define neverinline __declspec( noinline )
+#	elif GEN_COMPILER_GCC
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	elif GEN_COMPILER_CLANG
+#	if __has_attribute(__always_inline__)
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	else
+#		define neverinline
+#	endif
+#	else
+#		define neverinline
+#	endif
+#endif
+
+#if GEN_COMPILER_C
+#ifndef static_assert
+#undef  static_assert
+    #if GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
+        #define static_assert(condition, message) _Static_assert(condition, message)
+    #else
+        #define static_assert(condition, message) typedef char static_assertion_##__LINE__[(condition)?1:-1]
+	#endif
+#endif
+#endif
+
+#if GEN_COMPILER_CPP
+// Already Defined
+#elif GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
+#	define thread_local _Thread_local
+#elif GEN_COMPILER_MSVC
+#	define thread_local __declspec(thread)
+#elif GEN_COMPILER_CLANG
+#	define thread_local __thread
+#else
+#	error "No thread local support"
+#endif
+
+#if ! defined(typeof) && (!GEN_COMPILER_C || __STDC_VERSION__ < 202311L)
+#	if ! GEN_COMPILER_C
+#		define typeof decltype
+#	elif defined(_MSC_VER)
+#		define typeof(x) __typeof__(x)
+#	elif defined(__GNUC__) || defined(__clang__)
+#		define typeof(x) __typeof__(x)
+#	else
+#		error "Compiler not supported"
+#	endif
+#endif
+
+#ifndef GEN_API_C_BEGIN
+#	if GEN_COMPILER_C
+#		define GEN_API_C_BEGIN
+#		define GEN_API_C_END
+#	else
+#		define GEN_API_C_BEGIN extern "C" {
+#		define GEN_API_C_END   }
+#	endif
+#endif
+
+#if GEN_COMPILER_C
+#	if __STDC_VERSION__ >= 202311L
+#		define enum_underlying(type) : type
+#	else
+#		define enum_underlying(type)
+#   endif
+#else
+#	define enum_underlying(type) : type
+#endif
+
+#if GEN_COMPILER_C
+#	ifndef nullptr
+#		define nullptr NULL
+#	endif
+
+#	ifndef GEN_REMOVE_PTR
+#		define GEN_REMOVE_PTR(type) typeof(* ( (type) NULL) )
+#	endif
+#endif
+
+#if ! defined(GEN_PARAM_DEFAULT) && GEN_COMPILER_CPP
+#	define GEN_PARAM_DEFAULT = {}
+#else
+#	define GEN_PARAM_DEFAULT
+#endif
+
+#if GEN_COMPILER_CPP
+    #define struct_init(type, value) {value}
+#else
+    #define struct_init(type, value) {value}
+#endif
+
+#if 0
+#ifndef GEN_OPTIMIZE_MAPPINGS_BEGIN
+#	define GEN_OPTIMIZE_MAPPINGS_BEGIN _pragma(optimize("gt", on))
+#	define GEN_OPITMIZE_MAPPINGS_END   _pragma(optimize("", on))
+#endif
+#else
+#	define GEN_OPTIMIZE_MAPPINGS_BEGIN
+#	define GEN_OPITMIZE_MAPPINGS_END
+#endif
+
+#pragma endregion Macros

base/dependencies/memory.hpp

@@ -215,7 +215,7 @@ struct Arena
 #endif
 };
 
-#if GEN_COMPILER_CPP
+#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
 forceinline AllocatorInfo allocator_info(Arena& arena )                 { return arena_allocator_info(& arena); }
 forceinline Arena         init_sub      (Arena& parent, ssize size)     { return arena_init_sub( & parent, size); }
 forceinline ssize         alignment_of  (Arena& arena, ssize alignment) { return arena_alignment_of( & arena, alignment); }
@@ -319,6 +319,7 @@ struct FixedArena;
 template<s32 Size> FixedArena<Size> fixed_arena_init();
 template<s32 Size> AllocatorInfo    fixed_arena_allocator_info(FixedArena<Size>* fixed_arena );
 template<s32 Size> ssize            fixed_arena_size_remaining(FixedArena<Size>* fixed_arena, ssize alignment);
+template<s32 Size> void             fixed_arena_free(FixedArena<Size>* fixed_arena);
 
 #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
 template<s32 Size> AllocatorInfo    allocator_info( FixedArena<Size>& fixed_arena )                { return allocator_info(& fixed_arena); }

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,9 +1106,11 @@ 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;
 }
 
+#undef _adt_fprintf
+
 #pragma endregion CSV

base/dependencies/parsing.hpp

@@ -1,5 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
+#	include "timing.hpp"
 #endif
 
 #pragma region ADT
@@ -349,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.
@@ -358,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.
@@ -405,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 */
 
@@ -424,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

@@ -29,12 +29,6 @@
 #	ifndef GEN_SYSTEM_MACOS
 #		define GEN_SYSTEM_MACOS 1
 #	endif
-#	include <TargetConditionals.h>
-#	if TARGET_IPHONE_SIMULATOR == 1 || TARGET_OS_IPHONE == 1
-#		ifndef GEN_SYSTEM_IOS
-#			define GEN_SYSTEM_IOS 1
-#		endif
-#	endif
 #elif defined( __unix__ )
 #	ifndef GEN_SYSTEM_UNIX
 #		define GEN_SYSTEM_UNIX 1

base/dependencies/printing.cpp

@@ -1,8 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "filesystem.hpp"
-#	include "strings.hpp"
-#	include "string_ops.cpp"
+#	include "strbuilder_ops.cpp"
 #endif
 
 #pragma region Printing
@@ -50,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;
 	}
 
@@ -58,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 ) )
 	{
@@ -71,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 )
@@ -95,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;
@@ -240,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;
@@ -312,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;
@@ -330,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;
 		}
@@ -421,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;
 
@@ -533,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

@@ -0,0 +1,42 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "strbuilder_ops.hpp"
+#endif
+
+#pragma region Printing
+
+typedef struct FileInfo FileInfo;
+
+#ifndef GEN_PRINTF_MAXLEN
+#	define GEN_PRINTF_MAXLEN kilobytes(128)
+#endif
+typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN];
+
+// NOTE: A locally persisting buffer is used internally
+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";
+
+inline
+ssize log_fmt(char const* fmt, ...)
+{
+	ssize res;
+	va_list va;
+
+	va_start(va, fmt);
+	res = c_str_fmt_out_va(fmt, va);
+	va_end(va);
+
+	return res;
+}
+
+#pragma endregion Printing

base/dependencies/src_start.cpp

@@ -1,4 +1,5 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
 #	include "header_start.hpp"
 #endif
 
@@ -12,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

@@ -1,6 +1,5 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "string_ops.hpp"
 #	include "debug.cpp"
 #endif
 
@@ -19,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 ( ;; )
@@ -54,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;
@@ -101,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 )
@@ -122,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

@@ -0,0 +1,744 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "hashing.hpp"
+#endif
+
+#pragma region Strings
+
+struct Str;
+
+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 Str
+{
+	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            (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_str( str ) * rcast( Str*, (str) - sizeof(ssize) )
+
+#ifndef txt
+#	if GEN_COMPILER_CPP
+#		define txt( text )          Str { ( text ), sizeof( text ) - 1 }
+#	else
+#		define txt( text )         (Str){ ( text ), sizeof( text ) - 1 }
+#	endif
+#endif
+
+GEN_API_C_BEGIN
+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(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 str_are_equal(Str lhs, Str rhs)
+{
+	if (lhs.Len != rhs.Len)
+		return false;
+
+	for (ssize idx = 0; idx < lhs.Len; ++idx)
+		if (lhs.Ptr[idx] != rhs.Ptr[idx])
+			return false;
+
+	return true;
+}
+
+inline
+char const* str_back(Str str) {
+	return & str.Ptr[str.Len - 1];
+}
+
+inline
+bool str_contains(Str str, Str substring)
+{
+	if (substring.Len > str.Len)
+		return false;
+
+	ssize main_len = str.Len;
+	ssize sub_len  = substring.Len;
+	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
+	{
+		if (c_str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
+			return true;
+	}
+	return false;
+}
+
+inline
+b32 str_starts_with(Str str, Str substring) {
+	if (substring.Len > str.Len)
+		return false;
+
+	b32 result = c_str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
+		return result;
+}
+
+inline
+Str to_str_from_c_str( char const* bad_str ) {
+	Str result = { bad_str, c_str_len( bad_str ) };
+	return result;
+}
+
+// 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 StrBuilder
+struct StrBuilderHeader;
+
+#if GEN_COMPILER_C
+typedef char* StrBuilder;
+#else
+struct StrBuilder;
+#endif
+
+forceinline usize strbuilder_grow_formula(usize value);
+
+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 StrBuilderHeader {
+	AllocatorInfo Allocator;
+	ssize         Capacity;
+	ssize         Length;
+};
+
+#if GEN_COMPILER_CPP
+struct StrBuilder
+{
+	char* Data;
+
+	forceinline operator char*()             { return Data; }
+	forceinline operator char const*() const { return Data; }
+	forceinline operator Str()         const { return { Data, strbuilder_length(* this) }; }
+
+	StrBuilder const& operator=(StrBuilder const& other) const {
+		if (this == &other)
+			return *this;
+
+		StrBuilder* this_ = ccast(StrBuilder*, this);
+		this_->Data = other.Data;
+
+		return *this;
+	}
+
+	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 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 + strbuilder_length(* this); }
+
+#pragma region Member Mapping
+	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
+	StrBuilder fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+		va_list va;
+		va_start(va, fmt);
+		ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
+		va_end(va);
+		return strbuilder_make_length(allocator, buf, res);
+	}
+
+	static
+	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 = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
+		va_end(va);
+		return strbuilder_make_length(allocator, buf, res);
+	}
+
+	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;
+		char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+		va_list va;
+		va_start(va, fmt);
+		res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+		va_end(va);
+
+		return strbuilder_append_c_str_len(this, buf, res);
+	}
+#pragma endregion Member Mapping
+#endif
+};
+#endif
+
+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(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(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 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
+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
+StrBuilder strbuilder_make_str(AllocatorInfo allocator, Str str) {
+	return strbuilder_make_length(allocator, str.Ptr, str.Len);
+}
+
+inline
+StrBuilder strbuilder_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+	va_list va;
+	va_start(va, fmt);
+	ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
+	va_end(va);
+
+	return strbuilder_make_length(allocator, buf, res);
+}
+
+inline
+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 = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
+	va_end(va);
+
+	return strbuilder_make_length(allocator, buf, res);
+}
+
+inline
+StrBuilder strbuilder_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
+{
+	StrBuilder result = strbuilder_make_c_str(allocator, "");
+
+	for (ssize idx = 0; idx < num_parts; ++idx)
+	{
+		strbuilder_append_c_str(& result, parts[idx]);
+
+		if (idx < num_parts - 1)
+			strbuilder_append_c_str(& result, glue);
+	}
+
+	return result;
+}
+
+forceinline
+bool strbuilder_append_char(StrBuilder* str, char c) {
+	GEN_ASSERT(str != nullptr);
+	return strbuilder_append_c_str_len( str, (char const*)& c, (ssize)1);
+}
+
+forceinline
+bool strbuilder_append_c_str(StrBuilder* str, char const* c_str_to_append) {
+	GEN_ASSERT(str != nullptr);
+	return strbuilder_append_c_str_len(str, c_str_to_append, c_str_len(c_str_to_append));
+}
+
+inline
+bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length)
+{
+	GEN_ASSERT(str != nullptr);
+	if ( rcast(sptr, c_str_to_append) > 0)
+	{
+		ssize curr_len = strbuilder_length(* str);
+
+		if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length))
+			return false;
+
+		StrBuilderHeader* header = strbuilder_get_header(* str);
+
+		char* Data = * str;
+		mem_copy( Data + curr_len, c_str_to_append, append_length);
+
+		Data[curr_len + append_length] = '\0';
+
+		header->Length = curr_len + append_length;
+	}
+	return c_str_to_append != nullptr;
+}
+
+forceinline
+bool strbuilder_append_str(StrBuilder* str, Str c_str_to_append) {
+	GEN_ASSERT(str != nullptr);
+	return strbuilder_append_c_str_len(str, c_str_to_append.Ptr, c_str_to_append.Len);
+}
+
+forceinline
+bool strbuilder_append_string(StrBuilder* str, StrBuilder const other) {
+	GEN_ASSERT(str != nullptr);
+	return strbuilder_append_c_str_len(str, (char const*)other, strbuilder_length(other));
+}
+
+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 = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+	va_end(va);
+
+	return strbuilder_append_c_str_len(str, (char const*)buf, res);
+}
+
+inline
+bool strbuilder_are_equal_string(StrBuilder const lhs, StrBuilder const rhs)
+{
+	if (strbuilder_length(lhs) != strbuilder_length(rhs))
+		return false;
+
+	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
+		if (lhs[idx] != rhs[idx])
+			return false;
+
+	return true;
+}
+
+inline
+bool strbuilder_are_equal_str(StrBuilder const lhs, Str rhs)
+{
+	if (strbuilder_length(lhs) != (rhs.Len))
+		return false;
+
+	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
+		if (lhs[idx] != rhs.Ptr[idx])
+			return false;
+
+	return true;
+}
+
+forceinline
+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* strbuilder_back(StrBuilder str) {
+	return & (str)[strbuilder_length(str) - 1];
+}
+
+inline
+bool strbuilder_contains_StrC(StrBuilder const str, Str substring)
+{
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
+
+	if (substring.Len > header->Length)
+		return false;
+
+	ssize main_len = header->Length;
+	ssize sub_len  = substring.Len;
+
+	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
+	{
+		if (c_str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+inline
+bool strbuilder_contains_string(StrBuilder const str, StrBuilder const substring)
+{
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
+
+	if (strbuilder_length(substring) > header->Length)
+		return false;
+
+	ssize main_len = header->Length;
+	ssize sub_len  = strbuilder_length(substring);
+
+	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
+	{
+		if (c_str_compare_len(str + idx, substring, sub_len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+forceinline
+ssize strbuilder_capacity(StrBuilder const str) {
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
+	return header->Capacity;
+}
+
+forceinline
+void strbuilder_clear(StrBuilder str) {
+	strbuilder_get_header(str)->Length = 0;
+}
+
+forceinline
+StrBuilder strbuilder_duplicate(StrBuilder const str, AllocatorInfo allocator) {
+	return strbuilder_make_length(allocator, str, strbuilder_length(str));
+}
+
+forceinline
+void strbuilder_free(StrBuilder* str) {
+	GEN_ASSERT(str != nullptr);
+	if (! (* str))
+		return;
+
+	StrBuilderHeader* header = strbuilder_get_header(* str);
+	allocator_free(header->Allocator, header);
+}
+
+forceinline
+StrBuilderHeader* strbuilder_get_header(StrBuilder str) {
+	return (StrBuilderHeader*)(scast(char*, str) - sizeof(StrBuilderHeader));
+}
+
+forceinline
+ssize strbuilder_length(StrBuilder const str)
+{
+	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
+	return header->Length;
+}
+
+inline
+bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len)
+{
+	ssize available = strbuilder_avail_space(* str);
+
+	if (available >= add_len) {
+		return true;
+	}
+	else
+	{
+		ssize new_len, old_size, new_size;
+		void* ptr;
+		void* new_ptr;
+
+		AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator;
+		StrBuilderHeader* header    = nullptr;
+
+		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(StrBuilderHeader*, new_ptr);
+		header->Allocator = allocator;
+		header->Capacity  = new_len;
+
+		char** Data = rcast(char**, str);
+		* Data = rcast(char*, header + 1);
+
+		return true;
+	}
+}
+
+forceinline
+b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) {
+	if (substring.Len > strbuilder_length(str))
+	return false;
+
+	b32 result = c_str_compare_len(str, substring.Ptr, substring.Len) == 0;
+	return result;
+}
+
+forceinline
+b32 strbuilder_starts_with_string(StrBuilder const str, StrBuilder substring) {
+	if (strbuilder_length(substring) > strbuilder_length(str))
+		return false;
+
+	b32 result = c_str_compare_len(str, substring, strbuilder_length(substring) - 1) == 0;
+	return result;
+}
+
+inline
+void strbuilder_skip_line(StrBuilder str)
+{
+#define current (*scanner)
+	char* scanner = str;
+	while (current != '\r' && current != '\n') {
+		++scanner;
+	}
+
+	s32 new_length = scanner - str;
+
+	if (current == '\r') {
+		new_length += 1;
+	}
+
+	mem_move((char*)str, scanner, new_length);
+
+	StrBuilderHeader* header = strbuilder_get_header(str);
+	header->Length = new_length;
+#undef current
+}
+
+inline
+void strip_space(StrBuilder str)
+{
+	char* write_pos = str;
+	char* read_pos  = str;
+
+	while (* read_pos)
+	{
+		if (! char_is_space(* read_pos))
+		{
+   			* write_pos = * read_pos;
+			write_pos++;
+		}
+		read_pos++;
+	}
+   write_pos[0] = '\0';  // Null-terminate the modified string
+
+	// Update the length if needed
+	strbuilder_get_header(str)->Length = write_pos - str;
+}
+
+forceinline
+Str strbuilder_to_str(StrBuilder str) {
+	Str result = { (char const*)str, strbuilder_length(str) };
+	return result;
+}
+
+inline
+void strbuilder_trim(StrBuilder str, char const* cut_set)
+{
+	ssize len = 0;
+
+	char* start_pos = str;
+	char* end_pos   = scast(char*, str) + strbuilder_length(str) - 1;
+
+	while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos))
+	start_pos++;
+
+	while (end_pos > start_pos && char_first_occurence(cut_set, *end_pos))
+	end_pos--;
+
+	len = scast(ssize, (start_pos > end_pos) ? 0 : ((end_pos - start_pos) + 1));
+
+	if (str != start_pos)
+		mem_move(str, start_pos, len);
+
+	str[len] = '\0';
+
+	strbuilder_get_header(str)->Length = len;
+}
+
+forceinline
+void strbuilder_trim_space(StrBuilder str) {
+	strbuilder_trim(str, " \t\r\n\v\f");
+}
+
+inline
+StrBuilder strbuilder_visualize_whitespace(StrBuilder const str)
+{
+	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 = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c))
+	switch ( * c )
+	{
+		case ' ':
+			strbuilder_append_str(& result, txt("·"));
+		break;
+		case '\t':
+			strbuilder_append_str(& result, txt("→"));
+		break;
+		case '\n':
+			strbuilder_append_str(& result, txt("↵"));
+		break;
+		case '\r':
+			strbuilder_append_str(& result, txt("⏎"));
+		break;
+		case '\v':
+			strbuilder_append_str(& result, txt("⇕"));
+		break;
+		case '\f':
+			strbuilder_append_str(& result, txt("⌂"));
+		break;
+		default:
+			strbuilder_append_char(& result, * c);
+		break;
+	}
+
+	return result;
+}
+#pragma endregion StrBuilder
+
+#if GEN_COMPILER_CPP
+struct StrBuilder_POD {
+	char* Data;
+};
+static_assert( sizeof( StrBuilder_POD ) == sizeof( StrBuilder ), "StrBuilder is not a POD" );
+#endif
+
+forceinline
+Str str_duplicate(Str str, AllocatorInfo allocator) {
+	Str result = strbuilder_to_str( strbuilder_make_length(allocator, str.Ptr, str.Len));
+	return result;
+}
+
+inline
+Str str_visualize_whitespace(Str str, AllocatorInfo allocator)
+{
+	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 ' ':
+			strbuilder_append_str(& result, txt("·"));
+		break;
+		case '\t':
+			strbuilder_append_str(& result, txt("→"));
+		break;
+		case '\n':
+			strbuilder_append_str(& result, txt("↵"));
+		break;
+		case '\r':
+			strbuilder_append_str(& result, txt("⏎"));
+		break;
+		case '\v':
+			strbuilder_append_str(& result, txt("⇕"));
+		break;
+		case '\f':
+			strbuilder_append_str(& result, txt("⌂"));
+		break;
+		default:
+			strbuilder_append_char(& result, * c);
+		break;
+}
+	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 Str StringCached;
+
+// Implements basic string interning. Data structure is based off the ZPL Hashtable.
+typedef HashTable(StringCached) StringTable;
+#pragma endregion Strings

base/gen.cpp

@@ -37,6 +37,9 @@ GEN_NS_BEGIN
 #include "components/interface.parsing.cpp"
 #include "components/interface.untyped.cpp"
 
+#include "auxillary/builder.cpp"
+#include "auxillary/scanner.cpp"
+
 GEN_NS_END
 
 #include "helpers/pop_container_defines.inline.hpp"

base/gen.dep.cpp

@@ -13,5 +13,6 @@ GEN_NS_BEGIN
 #include "dependencies/strings.cpp"
 #include "dependencies/filesystem.cpp"
 #include "dependencies/timing.cpp"
+#include "dependencies/parsing.cpp"
 
 GEN_NS_END

base/gen.dep.hpp

@@ -16,5 +16,6 @@ GEN_NS_BEGIN
 #include "dependencies/strings.hpp"
 #include "dependencies/filesystem.hpp"
 #include "dependencies/timing.hpp"
+#include "dependencies/parsing.hpp"
 
 GEN_NS_END

base/gen.hpp

@@ -17,7 +17,7 @@
 GEN_NS_BEGIN
 
 #include "components/types.hpp"
-#include "components/gen/ecode.hpp"
+#include "components/gen/ecodetypes.hpp"
 #include "components/gen/eoperator.hpp"
 #include "components/gen/especifier.hpp"
 
@@ -31,6 +31,9 @@ GEN_NS_BEGIN
 #include "components/gen/ast_inlines.hpp"
 #include "components/header_end.hpp"
 
+#include "auxillary/builder.hpp"
+#include "auxillary/scanner.hpp"
+
 GEN_NS_END
 
 #include "helpers/pop_container_defines.inline.hpp"

base/helpers/base_codegen.hpp

@@ -1,79 +1,66 @@
 #pragma once
 
-#include "gen.hpp"
-
-GEN_NS_BEGIN
-#include "dependencies/parsing.hpp"
-GEN_NS_END
+#if GEN_INTELLISENSE_DIRECTIVES
+#	include "../gen.hpp"
+#	include "misc.hpp"
 
 using namespace gen;
+#endif
 
 CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 {
-	char  scratch_mem[kilobytes(4)];
-	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+	FixedArena_32KB scratch;       fixed_arena_init(& scratch);
+	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	file_read_contents( arena_allocator_info( & scratch), file_zero_terminate, path );
+	CSV_Columns2 csv_enum                 = parse_csv_two_columns( scratch_info, path );
+	StrBuilder   enum_entries             = strbuilder_make_reserve( GlobalAllocator, kilobytes(1) );
+	StrBuilder   to_c_str_entries         = strbuilder_make_reserve( GlobalAllocator, kilobytes(1) );
+	StrBuilder   to_keyword_c_str_entries = strbuilder_make_reserve( GlobalAllocator, kilobytes(1) );
 
-	CSV_Object csv_nodes;
-	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
-
-	Array<ADT_Node> enum_strs    = csv_nodes.nodes[0].nodes;
-	Array<ADT_Node> keyword_strs = csv_nodes.nodes[1].nodes;
-
-	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) );
-
-	for ( ssize idx = 0; idx < array_num(enum_strs); ++ idx )
-	{
-		char const* code    = enum_strs   [idx].string;
-		char const* keyword = keyword_strs[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 );
+	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_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),
+	if (use_c_definition) {
+		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),
+	else {
+		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(enum_strs) ));
-	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(GlobalAllocator, "%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[<num>] = {
 				<entries>
 			};
 			return lookup[ type ];
 		}
 
 		inline
-		StrC codetype_to_keyword_str( CodeType type )
+		Str codetype_to_keyword_str( CodeType type )
 		{
 			local_persist
-			StrC lookup[ <num> ] = {
+			Str lookup[ <num> ] = {
 				<keywords>
 			};
 			return lookup[ type ];
@@ -84,21 +71,19 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 	CodeBody result = def_body(CT_Global_Body);
 	body_append(result, enum_code);
 
-	if (use_c_definition)
-	{
+	if (use_c_definition) {
 		CodeTypedef code_t = parse_typedef(code(typedef enum CodeType CodeType; ));
 		body_append(result, code_t);
 	}
 
-	body_append(result, to_str_fns);
+	body_append(result, to_c_str_fns);
 
-	if (! use_c_definition)
-	{
+	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);
@@ -108,27 +93,18 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
 
 CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 {
-	char scratch_mem[kilobytes(4)];
-	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+	FixedArena_16KB scratch;       fixed_arena_init(& scratch);
+	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	file_read_contents( arena_allocator_info(& scratch), file_zero_terminate, path );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns( scratch_info, path );
+	StrBuilder enum_entries     = strbuilder_make_reserve( GlobalAllocator, 32 );
+	StrBuilder to_c_str_entries = strbuilder_make_reserve( GlobalAllocator, 32 );
 
-	CSV_Object csv_nodes;
-	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
-
-	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
-	Array<ADT_Node> str_strs  = csv_nodes.nodes[1].nodes;
-
-	String enum_entries   = string_make_reserve( GlobalAllocator, kilobytes(1) );
-	String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
-
-	for (usize idx = 0; idx < array_num(enum_strs); idx++)
-	{
-		char const* enum_str     = enum_strs[idx].string;
-		char const* entry_to_str = str_strs [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);
+	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) {
+		char const* enum_str     = csv_enum.Col_1[idx].string;
+		char const* entry_to_str = csv_enum.Col_2[idx].string;
+		strbuilder_append_fmt( & enum_entries,     "Op_%s,\n", enum_str );
+		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
 	}
 
 	CodeEnum  enum_code;
@@ -136,7 +112,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	{
 	#pragma push_macro("enum_underlying")
 	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Operator enum_underlying(u32)
 			{
 				<entries>
@@ -148,7 +124,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Operator : u32
 			{
 				<entries>
@@ -160,16 +136,16 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 
 #pragma push_macro("local_persist")
 #undef local_persist
-	StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
+	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
 	CodeFn to_str   = parse_function(token_fmt(
-		"entries", string_to_strc(to_str_entries)
+		"entries", strbuilder_to_str(to_c_str_entries)
 	,	"num",     lookup_size
 	, stringize(
 		inline
-		StrC operator_to_str( Operator op )
+		Str operator_to_str( Operator op )
 		{
 			local_persist
-			StrC lookup[<num>] = {
+			Str lookup[<num>] = {
 				<entries>
 			};
 
@@ -180,8 +156,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 
 	CodeBody result = def_body(CT_Global_Body);
 	body_append(result, enum_code);
-	if ( use_c_definition )
-	{
+	if ( use_c_definition ) {
 		CodeTypedef operator_t = parse_typedef(code( typedef enum Operator Operator; ));
 		body_append(result, operator_t);
 	}
@@ -193,7 +168,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 	#pragma push_macro("forceinline")
 	#undef forceinline
 		CodeBody alias_mappings = parse_global_body(code(
-			forceinline StrC to_str(Operator op) { return operator_to_str(op); }
+			forceinline Str to_str(Operator op) { return operator_to_str(op); }
 		));
 	#pragma pop_macro("forceinline")
 		body_append(result, alias_mappings);
@@ -203,27 +178,19 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
 
 CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 {
-	char scratch_mem[kilobytes(4)];
-	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+	FixedArena_16KB scratch;       fixed_arena_init(& scratch);
+	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
-	file_read_contents( arena_allocator_info(& scratch), file_zero_terminate, path );
+	CSV_Columns2 csv_enum       = parse_csv_two_columns(   scratch_info, path );
+	StrBuilder enum_entries     = strbuilder_make_reserve( scratch_info, kilobytes(1) );
+	StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
 
-	CSV_Object csv_nodes;
-	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
-
-	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
-	Array<ADT_Node> str_strs  = csv_nodes.nodes[1].nodes;
-
-	String enum_entries   = string_make_reserve( GlobalAllocator, kilobytes(1) );
-	String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
-
-	for (usize idx = 0; idx < array_num(enum_strs); idx++)
+	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++)
 	{
-		char const* enum_str     = enum_strs[idx].string;
-		char const* entry_to_str = str_strs [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);
+		char const* enum_str     = csv_enum.Col_1[idx].string;
+		char const* entry_to_str = csv_enum.Col_2[idx].string;
+		strbuilder_append_fmt( & enum_entries,     "Spec_%s,\n", enum_str );
+		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
 	}
 
 	CodeEnum enum_code;
@@ -231,7 +198,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	{
 	#pragma push_macro("enum_underlying")
 	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Specifier enum_underlying(u32)
 			{
 				<entries>
@@ -243,7 +210,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
 			enum Specifier : u32
 			{
 				<entries>
@@ -252,8 +219,7 @@ 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 )
 		{
@@ -271,16 +237,16 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 #undef do_once_end
 #undef forceinline
 #undef neverinline
-	StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
+	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
 	CodeFn to_str   = parse_function(token_fmt(
-		"entries", string_to_strc(to_str_entries)
+		"entries", strbuilder_to_str(to_c_str_entries)
 	,	"num",     lookup_size
 	, stringize(
 		inline
-		StrC spec_to_str( Specifier type )
+		Str spec_to_str( Specifier type )
 		{
 			local_persist
-			StrC lookup[<num>] = {
+			Str lookup[<num>] = {
 				<entries>
 			};
 
@@ -288,20 +254,20 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
+	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
 		inline
-		Specifier strc_to_specifier( StrC str )
+		Specifier str_to_specifier( Str str )
 		{
 			local_persist
 			u32 keymap[ Spec_NumSpecifiers ];
 			do_once_start
 				for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 				{
-					StrC enum_str = spec_to_str( (Specifier)index );
+					Str enum_str = spec_to_str( (Specifier)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
-					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len  );
 				}
 			do_once_end
 
@@ -339,8 +305,8 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
 	#pragma push_macro("forceinline")
 	#undef forceinline
 		CodeBody alias_mappings = parse_global_body(code(
-			forceinline StrC      to_str (Specifier spec)            { return spec_to_str(spec); }
-			forceinline 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")
@@ -351,66 +317,64 @@ 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 )
 {
-	char  scratch_mem[kilobytes(16)];
-	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
-
-	AllocatorInfo scratch_info = arena_allocator_info(& scratch);
+	FixedArena_64KB scratch;       fixed_arena_init(& scratch);
+	AllocatorInfo   scratch_info = fixed_arena_allocator_info(& scratch);
 
 	FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
 
 	CSV_Object csv_enum_nodes;
-	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), GlobalAllocator, false );
+	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_Object csv_attr_nodes;
-	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), GlobalAllocator, false );
+	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
 
-	Array<ADT_Node> enum_strs          = csv_enum_nodes.nodes[0].nodes;
-	Array<ADT_Node> enum_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( GlobalAllocator, kilobytes(2) );
-	String to_str_entries           = string_make_reserve( GlobalAllocator, kilobytes(4) );
-	String attribute_entries        = string_make_reserve( GlobalAllocator, kilobytes(2) );
-	String to_str_attributes        = string_make_reserve( GlobalAllocator, kilobytes(4) );
-	String attribute_define_entries = string_make_reserve( GlobalAllocator, kilobytes(4) );
+	StrBuilder enum_entries             = strbuilder_make_reserve( scratch_info, kilobytes(2) );
+	StrBuilder to_c_str_entries         = strbuilder_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder attribute_entries        = strbuilder_make_reserve( scratch_info, kilobytes(2) );
+	StrBuilder to_c_str_attributes      = strbuilder_make_reserve( scratch_info, kilobytes(4) );
+	StrBuilder attribute_define_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
 
 	for (usize idx = 0; idx < array_num(enum_strs); idx++)
 	{
 		char const* enum_str     = enum_strs[idx].string;
-		char const* entry_to_str = enum_str_strs [idx].string;
+		char const* entry_to_str = enum_c_str_strs [idx].string;
 
-		string_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
-		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), 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>
@@ -422,7 +386,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 	}
 	else
 	{
-		enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize(
+		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
 			enum TokType : u32
 			{
 				<entries>
@@ -438,12 +402,12 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 #undef local_persist
 #undef do_once_start
 #undef do_once_end
-	CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), "attribute_toks", string_to_strc(to_str_attributes), stringize(
+	CodeFn to_str = parse_function(token_fmt("entries", strbuilder_to_str(to_c_str_entries), "attribute_toks", strbuilder_to_str(to_c_str_attributes), stringize(
 		inline
-		StrC toktype_to_str( TokType type )
+		Str toktype_to_str( TokType type )
 		{
 			local_persist
-			StrC lookup[] = {
+			Str lookup[] = {
 				<entries>
 				<attribute_toks>
 			};
@@ -452,20 +416,20 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
+	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
 		inline
-		TokType strc_to_toktype( StrC str )
+		TokType str_to_toktype( Str str )
 		{
 			local_persist
 			u32 keymap[ Tok_NumTokens ];
 			do_once_start
 				for ( u32 index = 0; index < Tok_NumTokens; index++ )
 				{
-					StrC enum_str = toktype_to_str( (TokType)index );
+					Str enum_str = toktype_to_str( (TokType)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
-					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len);
 				}
 			do_once_end
 
@@ -541,7 +505,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;
@@ -551,59 +515,59 @@ CodeBody gen_ast_inlines()
 #pragma pop_macro("GEN_NS")
 #pragma pop_macro("CodeInvalid")
 
-	CodeBody impl_code          = parse_global_body( token_fmt( "typename", StrC name(Code),               code_impl_tmpl ));
-	CodeBody impl_code_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_param    = parse_global_body( token_fmt( "typename", StrC name(CodeParam),          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", Str name(Code),               code_impl_tmpl ));
+	CodeBody impl_code_body     = parse_global_body( token_fmt( "typename", Str name(CodeBody),           code_impl_tmpl ));
+	CodeBody impl_code_attr     = parse_global_body( token_fmt( "typename", Str name(CodeAttributes),     code_impl_tmpl ));
+	CodeBody impl_code_cmt      = parse_global_body( token_fmt( "typename", Str name(CodeComment),        code_impl_tmpl ));
+	CodeBody impl_code_constr   = parse_global_body( token_fmt( "typename", Str name(CodeConstructor),    code_impl_tmpl ));
+	CodeBody impl_code_class    = parse_global_body( token_fmt( "typename", Str name(CodeClass),          code_impl_tmpl ));
+	CodeBody impl_code_define   = parse_global_body( token_fmt( "typename", Str name(CodeDefine),         code_impl_tmpl ));
+	CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", Str name(CodeDestructor),     code_impl_tmpl ));
+	CodeBody impl_code_enum     = parse_global_body( token_fmt( "typename", Str name(CodeEnum),           code_impl_tmpl ));
+	CodeBody impl_code_exec     = parse_global_body( token_fmt( "typename", Str name(CodeExec),           code_impl_tmpl ));
+	CodeBody impl_code_extern   = parse_global_body( token_fmt( "typename", Str name(CodeExtern),         code_impl_tmpl ));
+	CodeBody impl_code_include  = parse_global_body( token_fmt( "typename", Str name(CodeInclude),        code_impl_tmpl ));
+	CodeBody impl_code_friend   = parse_global_body( token_fmt( "typename", Str name(CodeFriend),         code_impl_tmpl ));
+	CodeBody impl_code_fn	    = parse_global_body( token_fmt( "typename", Str name(CodeFn),             code_impl_tmpl ));
+	CodeBody impl_code_module   = parse_global_body( token_fmt( "typename", Str name(CodeModule),         code_impl_tmpl ));
+	CodeBody impl_code_ns       = parse_global_body( token_fmt( "typename", Str name(CodeNS),             code_impl_tmpl ));
+	CodeBody impl_code_op       = parse_global_body( token_fmt( "typename", Str name(CodeOperator),       code_impl_tmpl ));
+	CodeBody impl_code_opcast   = parse_global_body( token_fmt( "typename", Str name(CodeOpCast),         code_impl_tmpl ));
+	CodeBody impl_code_params   = parse_global_body( token_fmt( "typename", Str name(CodeParams),         code_impl_tmpl ));
+	CodeBody impl_code_pragma   = parse_global_body( token_fmt( "typename", Str name(CodePragma),         code_impl_tmpl ));
+	CodeBody impl_code_precond  = parse_global_body( token_fmt( "typename", Str name(CodePreprocessCond), code_impl_tmpl ));
+	CodeBody impl_code_specs    = parse_global_body( token_fmt( "typename", Str name(CodeSpecifiers),     code_impl_tmpl ));
+	CodeBody impl_code_struct   = parse_global_body( token_fmt( "typename", Str name(CodeStruct),         code_impl_tmpl ));
+	CodeBody impl_code_tmpl     = parse_global_body( token_fmt( "typename", Str name(CodeTemplate),       code_impl_tmpl ));
+	CodeBody impl_code_type     = parse_global_body( token_fmt( "typename", Str name(CodeTypename),       code_impl_tmpl ));
+	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", Str name(CodeTypedef),        code_impl_tmpl ));
+	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", Str name(CodeUnion),          code_impl_tmpl ));
+	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", Str name(CodeUsing),          code_impl_tmpl ));
+	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", Str name(CodeVar),            code_impl_tmpl ));
 
-	body_append(impl_code_attr,     parse_global_body( token_fmt( "typename", StrC name(Attributes),     codetype_impl_tmpl )));
-	body_append(impl_code_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", Str name(Attributes),     codetype_impl_tmpl )));
+	body_append(impl_code_cmt,      parse_global_body( token_fmt( "typename", Str name(Comment),        codetype_impl_tmpl )));
+	body_append(impl_code_constr,   parse_global_body( token_fmt( "typename", Str name(Constructor),    codetype_impl_tmpl )));
+	body_append(impl_code_define,   parse_global_body( token_fmt( "typename", Str name(Define),         codetype_impl_tmpl )));
+	body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", Str name(Destructor),     codetype_impl_tmpl )));
+	body_append(impl_code_enum,     parse_global_body( token_fmt( "typename", Str name(Enum),           codetype_impl_tmpl )));
+	body_append(impl_code_exec,     parse_global_body( token_fmt( "typename", Str name(Exec),           codetype_impl_tmpl )));
+	body_append(impl_code_extern,   parse_global_body( token_fmt( "typename", Str name(Extern),         codetype_impl_tmpl )));
+	body_append(impl_code_include,  parse_global_body( token_fmt( "typename", Str name(Include),        codetype_impl_tmpl )));
+	body_append(impl_code_friend,   parse_global_body( token_fmt( "typename", Str name(Friend),         codetype_impl_tmpl )));
+	body_append(impl_code_fn,       parse_global_body( token_fmt( "typename", Str name(Fn),             codetype_impl_tmpl )));
+	body_append(impl_code_module,   parse_global_body( token_fmt( "typename", Str name(Module),         codetype_impl_tmpl )));
+	body_append(impl_code_ns,       parse_global_body( token_fmt( "typename", Str name(NS),             codetype_impl_tmpl )));
+	body_append(impl_code_op,       parse_global_body( token_fmt( "typename", Str name(Operator),       codetype_impl_tmpl )));
+	body_append(impl_code_opcast,   parse_global_body( token_fmt( "typename", Str name(OpCast),         codetype_impl_tmpl )));
+	body_append(impl_code_pragma,   parse_global_body( token_fmt( "typename", Str name(Pragma),         codetype_impl_tmpl )));
+	body_append(impl_code_precond,  parse_global_body( token_fmt( "typename", Str name(PreprocessCond), codetype_impl_tmpl )));
+	body_append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", Str name(Template),       codetype_impl_tmpl )));
+	body_append(impl_code_type,     parse_global_body( token_fmt( "typename", Str name(Typename),       codetype_impl_tmpl )));
+	body_append(impl_code_typedef,  parse_global_body( token_fmt( "typename", Str name(Typedef),        codetype_impl_tmpl )));
+	body_append(impl_code_union,    parse_global_body( token_fmt( "typename", Str name(Union),          codetype_impl_tmpl )));
+	body_append(impl_code_using,    parse_global_body( token_fmt( "typename", Str name(Using),          codetype_impl_tmpl )));
+	body_append(impl_code_var,      parse_global_body( token_fmt( "typename", Str name(Var),            codetype_impl_tmpl )));
 
 	#pragma push_macro("forceinline")
 	#undef forceinline
@@ -615,34 +579,34 @@ CodeBody gen_ast_inlines()
 	);
 	#pragma pop_macro("forceinline")
 
-	CodeBody impl_cast_body      = parse_global_body( token_fmt( "typename", StrC name(Body),           cast_tmpl ));
-	CodeBody impl_cast_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_param     = parse_global_body( token_fmt( "typename", StrC name(Param),          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", Str name(Body),           cast_tmpl ));
+	CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", Str name(Attributes),     cast_tmpl ));
+	CodeBody impl_cast_cmt       = parse_global_body( token_fmt( "typename", Str name(Comment),        cast_tmpl ));
+	CodeBody impl_cast_constr    = parse_global_body( token_fmt( "typename", Str name(Constructor),    cast_tmpl ));
+	CodeBody impl_cast_class     = parse_global_body( token_fmt( "typename", Str name(Class),          cast_tmpl ));
+	CodeBody impl_cast_define    = parse_global_body( token_fmt( "typename", Str name(Define),         cast_tmpl ));
+	CodeBody impl_cast_destruct  = parse_global_body( token_fmt( "typename", Str name(Destructor),     cast_tmpl ));
+	CodeBody impl_cast_enum      = parse_global_body( token_fmt( "typename", Str name(Enum),           cast_tmpl ));
+	CodeBody impl_cast_exec      = parse_global_body( token_fmt( "typename", Str name(Exec),           cast_tmpl ));
+	CodeBody impl_cast_extern    = parse_global_body( token_fmt( "typename", Str name(Extern),         cast_tmpl ));
+	CodeBody impl_cast_friend    = parse_global_body( token_fmt( "typename", Str name(Friend),         cast_tmpl ));
+	CodeBody impl_cast_fn        = parse_global_body( token_fmt( "typename", Str name(Fn),             cast_tmpl ));
+	CodeBody impl_cast_include   = parse_global_body( token_fmt( "typename", Str name(Include),        cast_tmpl ));
+	CodeBody impl_cast_module    = parse_global_body( token_fmt( "typename", Str name(Module),         cast_tmpl ));
+	CodeBody impl_cast_ns        = parse_global_body( token_fmt( "typename", Str name(NS),             cast_tmpl ));
+	CodeBody impl_cast_op        = parse_global_body( token_fmt( "typename", Str name(Operator),       cast_tmpl ));
+	CodeBody impl_cast_opcast    = parse_global_body( token_fmt( "typename", Str name(OpCast),         cast_tmpl ));
+	CodeBody impl_cast_params    = parse_global_body( token_fmt( "typename", Str name(Params),         cast_tmpl ));
+	CodeBody impl_cast_pragma    = parse_global_body( token_fmt( "typename", Str name(Pragma),         cast_tmpl ));
+	CodeBody impl_cast_precond   = parse_global_body( token_fmt( "typename", Str name(PreprocessCond), cast_tmpl ));
+	CodeBody impl_cast_specs     = parse_global_body( token_fmt( "typename", Str name(Specifiers),     cast_tmpl ));
+	CodeBody impl_cast_struct    = parse_global_body( token_fmt( "typename", Str name(Struct),         cast_tmpl ));
+	CodeBody impl_cast_tmpl      = parse_global_body( token_fmt( "typename", Str name(Template),       cast_tmpl ));
+	CodeBody impl_cast_type      = parse_global_body( token_fmt( "typename", Str name(Typename),       cast_tmpl ));
+	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", Str name(Typedef),        cast_tmpl ));
+	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", Str name(Union),          cast_tmpl ));
+	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", Str name(Using),          cast_tmpl ));
+	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", Str name(Var),            cast_tmpl ));
 
 	CodeBody result = def_global_body( args(
 		def_pragma( txt("region generated code inline implementation")),
@@ -665,7 +629,7 @@ CodeBody gen_ast_inlines()
 		impl_code_ns,
 		impl_code_op,
 		impl_code_opcast,
-		impl_code_param,
+		impl_code_params,
 		impl_code_pragma,
 		impl_code_precond,
 		impl_code_specs,
@@ -699,7 +663,7 @@ CodeBody gen_ast_inlines()
 		impl_cast_ns,
 		impl_cast_op,
 		impl_cast_opcast,
-		impl_cast_param,
+		impl_cast_params,
 		impl_cast_pragma,
 		impl_cast_precond,
 		impl_cast_specs,

base/helpers/misc.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#	define GEN_ENFORCE_STRONG_CODE_TYPES
+#	define GEN_EXPOSE_BACKEND
+#	include "gen.hpp"
+#	include "helpers/push_ignores.inline.hpp"
+#	include "helpers/helper.hpp"
+#	include "auxillary/builder.hpp"
+#	include "auxillary/builder.cpp"
+#	include "auxillary/scanner.hpp"
+
+#include <stdlib.h>
+
+using namespace gen;
+#endif
+
+// Will format a file with the given style at the provided path.
+// Assumes clang-format is defined in an user-exposed or system enviornment PATH.
+void clang_format_file( char const* path, char const* style_path )
+{
+	GEN_ASSERT_NOT_NULL(path);
+	StrBuilder resolved_path = strbuilder_make_str(GlobalAllocator, to_str_from_c_str(path));
+	StrBuilder style_arg;
+	if (style_path) {
+		style_arg = strbuilder_make_str(GlobalAllocator, txt("-style=file:"));
+		strbuilder_append_fmt( & style_arg, "%s ", style_path );
+	}
+
+	Str clang_format      = txt("clang-format ");
+	Str cf_format_inplace = txt("-i ");
+	Str cf_verbose        = txt("-verbose ");
+
+	StrBuilder command = strbuilder_make_str( GlobalAllocator, 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 );
+}
+
+// Will refactor a file with the given script at the provided path.
+// Assumes refactor is defined in an user-exposed or system enviornment PATH.
+// (See: ./gencpp/scripts/build.ci.ps1 for how)
+void refactor_file( char const* path, char const* refactor_script )
+{
+	GEN_ASSERT_NOT_NULL(path);
+	GEN_ASSERT_NOT_NULL(refactor_script);
+
+	StrBuilder command = strbuilder_make_str(GlobalAllocator, 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");
+}
+
+// Does either of the above or both to the provided code.
+// Code returned will be untyped content (its be serialized)
+Code code_refactor_and_format( Code code, char const* scratch_path, char const* refactor_script, char const* clang_format_sytle_path )
+{
+	GEN_ASSERT(code);
+	GEN_ASSERT_NOT_NULL(scratch_path);
+	Builder scratch_file = builder_open( scratch_path );
+	builder_print( & scratch_file, code);
+	builder_write(& scratch_file);
+
+	if (refactor_script) {
+		refactor_file(scratch_path, refactor_script);
+	}
+	if ( clang_format_sytle_path ) {
+		clang_format_file(scratch_path, clang_format_sytle_path);
+	}
+
+	Code result = scan_file( scratch_path );
+	::remove(scratch_path);
+	return result;
+}

base/helpers/undef.macros.h

@@ -0,0 +1,203 @@
+// This undefines the macros used by the gen library
+#undef GEN_TIME
+
+#undef GEN_ARCH_64_BIT
+#undef GEN_ARCH_32_BIT
+
+#undef GEN_SYSTEM_ANDROID
+#undef GEN_SYSTEM_CYGWIN
+#undef GEN_SYSTEM_EMSCRIPTEN
+#undef GEN_SYSTEM_FREEBSD
+#undef GEN_SYSTEM_IOS
+#undef GEN_SYSTEM_LINUX
+#undef GEN_SYSTEM_MACOS
+#undef GEN_SYSTEM_OPENBSD
+#undef GEN_SYSTEM_OSX
+#undef GEN_SYSTEM_UNIX
+#undef GEN_SYSTEM_WINDOWS
+
+#undef GEN_COMPILER_CLANG
+#undef GEN_COMPILER_GCC
+#undef GEN_COMPILER_MSVC
+
+#undef GEN_HAS_ATTRIBUTE
+
+#undef GEN_COMPILER_C
+#undef GEN_COMPILER_CPP
+
+#undef GEN_DONT_USE_NAMESPACE
+#undef GEN_NS_PARSER_BEGIN
+#undef GEN_NS_PARSER_END
+#undef GEN_USING_NS_PARSER
+#undef GEN_NS_PARSER
+#undef GEN_NS
+#undef GEN_NS_BEGIN
+#undef GEN_NS_END
+
+#undef GEN_C_LIKE_CPP
+
+#undef global
+#undef internal
+#undef local_persist
+
+#undef bit
+#undef bitfield_is_equal
+
+#undef cast
+
+#undef ccast
+#undef scast
+#undef rcast
+#undef pcast
+
+#undef stringize
+#undef do_once
+#undef do_once_start
+#undef do_once_end
+#undef labeled_scope_start
+#undef labeled_scope_end
+#undef compiler_decorated_func_name
+#undef num_args_impl
+#undef num_args
+#undef clamp
+#undef count_of
+#undef is_between
+#undef size_of
+#undef max
+#undef min
+#undef offset_of
+#undef forceinline
+#undef neverinline
+#undef static_assert
+#undef thread_local
+#undef typeof
+
+#undef GEN_API_C_BEGIN
+#undef GEN_API_C_END
+
+#undef enum_underlying
+#undef nullptr
+#undef GEN_PARAM_DEFAULT
+#undef struct_init
+
+#undef GEN_OPTIMIZE_MAPPINGS_BEGIN
+#undef GEN_OPITMIZE_MAPPINGS_END
+
+#undef GEN_U8_MIN
+#undef GEN_U8_MAX
+#undef GEN_I8_MIN
+#undef GEN_I8_MAX
+#undef GEN_U16_MIN
+#undef GEN_U16_MAX
+#undef GEN_I16_MIN
+#undef GEN_I16_MAX
+#undef GEN_U32_MIN
+#undef GEN_U32_MAX
+#undef GEN_I32_MIN
+#undef GEN_I32_MAX
+#undef GEN_U64_MIN
+#undef GEN_U64_MAX
+#undef GEN_I64_MIN
+#undef GEN_I64_MAX
+#undef GEN_USIZE_MIN
+#undef GEN_USIZE_MAX
+#undef GEN_ISIZE_MIN
+#undef GEN_ISIZE_MAX
+#undef GEN_USIZE_MIN
+#undef GEN_USIZE_MAX
+#undef GEN_ISIZE_MIN
+#undef GEN_ISIZE_MAX
+#undef GEN_F32_MIN
+#undef GEN_F32_MAX
+#undef GEN_F64_MIN
+#undef GEN_F64_MAX
+
+#undef to_uptr
+#undef to_sptr
+#undef to_mem_ptr
+#undef to_mem_ptr_const
+
+#undef kilobytes
+#undef megabytes
+#undef gigabytes
+#undef terabytes
+
+#undef GEN__ONES
+#undef GEN__HIGHS
+#undef GEN__HAS_ZERO
+#undef GEN_DEFAULT_MEMORY_ALIGNMENT
+#undef GEN_DEFAULT_ALLOCATOR_FLAGS
+
+#undef zero_item
+#undef zero_array
+
+#undef alloc_item
+#undef alloc_array
+
+#undef malloc
+#undef mfree
+
+#undef GEN_DEBUG_TRAP
+#undef GEN_ASSERT
+#undef GEN_ASSERT_MSG
+#undef GEN_ASSERT_NOT_NULL
+#undef GEN_PANIC
+#undef GEN_FATAL
+
+#undef GEN_FILE_OPEN_PROC
+#undef GEN_FILE_READ_AT_PROC
+#undef GEN_FILE_WRITE_AT_PROC
+#undef GEN_FILE_SEEK_PROC
+#undef GEN_FILE_CLOSE_PROC
+
+#undef GEN_PRINTF_MAXLEN
+
+#undef _strlen
+#undef _printf_err
+#undef _printf_err_va
+#undef _strlen
+#undef _printf_err
+#undef _printf_err_va
+
+#undef Array
+#undef get_array_underlying_type
+#undef HashTable
+#undef get_hashtable_underlying_type
+
+#undef txt
+
+#undef NOMINMAX
+#undef VC_EXTRALEAN
+#undef WIN32_LEAN_AND_MEAN
+#undef WIN32_MEAN_AND_LEAN
+
+#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_GLOBAL_BUCKET_SIZE
+#undef GEN_CODEPOOL_NUM_BLOCKS
+#undef GEN_SIZE_PER_STRING_ARENA
+#undef GEN_MAX_COMMENT_LINE_LENGTH
+#undef GEN_MAX_NAME_LENGTH
+#undef GEN_MAX_UNTYPED_STR_LENGTH
+#undef TokenMap_FixedArena
+#undef GEN_LEX_ALLOCATOR_SIZE
+#undef GEN_BUILDER_STR_BUFFER_RESERVE
+
+#undef log_failure
+
+#undef gen_main
+#undef name
+#undef code
+#undef args
+#undef code_str
+#undef code_fmt
+#undef token_fmt
+#undef parse_fmt
+#undef token_fmt

docs/AST_Design.md

@@ -1,44 +1,58 @@
+## Navigation
+
+[Top](../Readme.md)
+
+<- [docs - General](Readme.md)
+
 ## Current Design
 
 `AST` is the actual managed node object for the library.  
 Its raw and really not meant to be used directly.
 
 All user interaction must be with its pointer so the type they deal with is `AST*`.  
-For user-facing code, they should never be giveen a nullptr. Instead, they should be given a designated `Invalid` AST node.
+In order to abstract away constant use of `AST*` its wrapped in a Code type which can be either:
 
-In order to abstract away constant use of `AST*`, I wanted to provide a wrapper for it.
-
-The simpliest being just a type alias.
-
-```cpp
-using Code = AST*;
+When its the [C generated variant of the library](../gen_c_library/)
+```c
+typedef AST* Code;
+tyepdef AST_<name>* Code<name>;
+...
 ```
 
-This is what the genc library would have to use due to its constraints of a langauge.  
-The actual content per type of AST is covered within [AST_Types.md](AST_Types.md).
-
-These are pure PODS that just have the lay members relevant to the type of AST node they represent.  
-Each of them has a Code type alias specific to it.
-
-Again, the simpliest case for these would be a type alias.
+**or**
 
+For C++:
 ```cpp
-using struct AST_Typedef CodeTypedef;
+struct Code {
+    AST* ast;
+};
+struct Code<name> {
+    ...
+
+    AST_<name>* ast;
+};
 ```
 
-As of November 21st, 2023, the AST has had a strict layout for how its content is laid out.  
-This will be abandoned during its redesign that will occur starting with support for statments & expressions for either execution and type declarations.  
-Having a strict layout is too resctrictive vs allowing each AST type to have maximum control over the layout.
+The full definitions of all asts are within:
 
-The redesign will occur after the following todos are addressed:
+* [`ast.hpp`](../base/components/ast.hpp)
+* [`ast_types.hpp`](../base/components/ast_types.hpp)
+* [`code_types.hpp`](../base/components/code_types.hpp)
 
-* [Improvements Lexer & Token struct#27](https://github.com/Ed94/gencpp/issues/27)
-* [Generalize AST Flags to a single 4-byte flag#42](https://github.com/Ed94/gencpp/issues/42)
-* [AST-Code Object Redesign.#38](https://github.com/Ed94/gencpp/issues/38)
-* [Code-AST Documentation#40](https://github.com/Ed94/gencpp/issues/40)
-* [AST::debug_str() improvements#33](https://github.com/Ed94/gencpp/issues/33)
-* [AST::is_equal implemented and works with singleheader-test#31](https://github.com/Ed94/gencpp/issues/31)
-* [Parser : Add ability to have a parse failure and continue with errors recorded.#35](https://github.com/Ed94/gencpp/issues/35)
-* [Scanner : Add CodeFile#29](https://github.com/Ed94/gencpp/issues/29)
-* [Auxiliary : AST visual debugger#36](https://github.com/Ed94/gencpp/issues/36)
+The C/C++ interface procedures are located with `ast.hpp` (for the Code type), and `code_types.hpp` for all others.
 
+## Serialization
+
+All code types can either serialize using a function of the pattern:
+
+```c
+StrBuilder <prefix>_to_strbuilder(Code code);
+// or
+<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_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

@@ -1,10 +1,16 @@
+## Navigation
+
+[Top](../Readme.md)
+
+<- [docs - General](Readme.md)
+
 # AST Types Documentation
 
 While the Readme for docs covers the data layout per AST, this will focus on the AST types avaialble, and their nuances.
 
 ## Body
 
-These are containers representing a scope body of a definition that can be of the following `ECode` type:
+These are containers representing a scope body of a definition that can be of the following `CodeType` type:
 
 * Class_Body
 * Enum_Body
@@ -19,11 +25,11 @@ These are containers representing a scope body of a definition that can be of th
 Fields:
 
 ```cpp
+StringCached   Name;
 Code           Front;
 Code           Back;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 s32            NumEntries;
 ```
@@ -31,14 +37,15 @@ s32            NumEntries;
 The `Front` member represents the start of the link list and `Back` the end.
 NumEntries is the number of entries in the body.
 
-Parent should have a compatible ECode type for the type of defintion used.
+Parent should have a compatible CodeType type for the type of defintion used.
 
 Serialization:
 
 Will output only the entries, the braces are handled by the parent.
 
 ```cpp
-<Front>...
+<Front>
+...
 <Back>
 ```
 
@@ -50,11 +57,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -74,11 +81,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -102,11 +109,11 @@ CodeComment    InlineCmt;  // Only supported by forward declarations
 CodeAttributes Attributes;
 CodeType       ParentType;
 CodeBody       Body;
-CodeType       Prev;       // Used to store references to interfaces
-CodeType       Next;       // Used to store references to interfaces
-parser::Token* Tok;
-Code           Parent;
 StringCached   Name;
+CodeType       Prev;
+CodeType       Next;
+Token*         Tok;
+Code           Parent;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 AccessSpec     ParentAccess;
@@ -125,7 +132,7 @@ Serialization:
 };
 ```
 
-You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest must be done through interfaces.
+You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest are assumed to be interfaces and are given public acess specifiers.
 
 ## Constructor
 
@@ -134,13 +141,13 @@ Fields:
 ```cpp
 CodeComment    InlineCmt;  // Only supported by forward declarations
 Code           InitializerList;
-CodeParam      Params;
+CodeParams     Params;
 Code           Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -172,11 +179,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -194,11 +201,11 @@ Fields:
 CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 Code           Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -229,24 +236,28 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
+Code           UnderlyingTypeMacro;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
+UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment.  
+The `enum_underlying_sig` is a `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:
 
 ```cpp
 // Enum_Fwd
-<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>
+<ModuleFlags> enum class <Name> : <UnderlyingType> or <UnderlyingTypeMacro> ; <InlineCmt>
 
 // Enum
-<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>
+<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType> or <UnderlyingTypeMacro>
 {
     <Body>
 };
@@ -261,11 +272,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -281,11 +292,11 @@ Fields:
 
 ```cpp
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -304,11 +315,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
 Code           Parent;
-parser::Token* Tok;
-StringCached   Name;
+Token*         Tok;
 CodeT          Type;
 ```
 
@@ -327,11 +338,11 @@ Fields:
 ```cpp
 CodeComment    InlineCmt;
 Code           Declaration;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -350,13 +361,13 @@ CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeType       ReturnType;
-CodeParam      Params;
+CodeParams     Params;
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -379,11 +390,11 @@ Serialization:
 Fields:
 
 ```cpp
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -400,11 +411,11 @@ Fields:
 
 ```cpp
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -418,7 +429,7 @@ Serialization:
 }
 ```
 
-## Operator Overload
+## Operator Overload (Operator)
 
 Fields:
 
@@ -427,13 +438,13 @@ CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeType       ReturnType;
-CodeParam      Params;
+CodeParams     Params;
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 OperatorT      Op;
@@ -452,7 +463,7 @@ Serialization:
 }
 ```
 
-## Operator Cast Overload ( User-Defined Type Conversion )
+## Operator Cast Overload ( User-Defined Type Conversion, OpCast )
 
 Fields:
 
@@ -461,11 +472,11 @@ CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 CodeType       ValueType;
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -482,7 +493,7 @@ Serialization:
 }
 ```
 
-## Parameters (AST_Param)
+## Parameters (AST_Params)
 
 Fields:
 
@@ -490,11 +501,12 @@ Fields:
 CodeType       ValueType;
 Code           Macro;
 Code           Value;
-CodeParam      Last;
-CodeParam      Next;
-parser::Token* Tok;
-Code           Parent;
+Code           PostNameMacro;
 StringCached   Name;
+CodeParams     Last;
+CodeParams     Next;
+Token*         Tok;
+Code           Parent;
 CodeT          Type;
 s32            NumEntries;
 ```
@@ -504,7 +516,7 @@ Serialization:
 ```cpp
 <Macro>, <Next> ... <Last>
 
-<Macro> <ValueType> <Name>, <Next>... <Last>
+<Macro> <ValueType> <Name> <PostNameMacro> = <Value>, <Next>... <Last>
 ```
 
 ## Pragma
@@ -513,11 +525,11 @@ Fields:
 
 ```cpp
 StringCached   Content;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ```
 
@@ -533,11 +545,11 @@ Fields:
 
 ```cpp
 StringCached  Content;
+StringCached  Name;
 Code          Prev;
 Code          Next;
-paser::Token* Tok;
+Token*        Tok;
 Code          Parent;
-StringCached  Name;
 CodeT         Type;
 ```
 
@@ -554,11 +566,11 @@ Fields:
 ```cpp
 SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
 CodeSpecifiers NextSpecs;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 s32            NumEntries;
 ```
@@ -574,13 +586,13 @@ Serialization:
 Fields:
 
 ```cpp
-CodeParam      Params;
+CodeParams     Params;
 Code           Declaration;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -603,23 +615,30 @@ Fields:
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeReturnType ReturnType;
-CodeParam      Params;
+CodeParams     Params;
 Code           ArrExpr;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
 b32            IsParamPack;
+ETypenameTag   TypeTag;
 ```
 
 Serialization:
 
 ```cpp
-<Attributes> <Name> <Specs> <IsParamPack ?: ...>
+<Attributes> <TypeTag> <Name> <Specs> <IsParamPack ?: ...> 
+// Function
+<Attributes> <ReturnType> <Name> <Params> <Specs>
 ```
 
+`<Name>` currently has the full serialization of anything with
+
+*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
 
 Behave as usual except function or macro typedefs.  
@@ -630,11 +649,11 @@ Fields:
 ```cpp
 CodeComment   InlineCmt;
 Code          UnderlyingType;
+StringCached  Name;
 Code          Prev;
 Code          Next;
-parse::Token* Tok
+Token*        Tok
 Code          Parent;
-StringCached  Name;
 CodeT         Type;
 ModuleFlag    ModuleFlags;
 b32           IsFunction;
@@ -644,11 +663,16 @@ Serialization:
 
 ```cpp
 // Regular
-<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>
+<ModuleFlags> typedef <UnderlyingType> <Name> <UnderlyingType-ArrExpr>; <InlineCmt>
 
 // Functions
-<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
-<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
+
+// Currently:
+<ModuleFlags> typedef <UnderlyingType (Serialized expression)>; <InlineCmt>
+
+// Desired: Not handled yet
+<ModuleFlags> typedef <UnderlyingType->ReturnType> UnderlyingType->Name> <UnderlyingType-ArrExpr> ( <UnderlyingType->Parameters> ); <InlineCmt>
+<ModuleFlags> typedef <UnderlyingType->ReturnType> ( <Name->Namespace> for<Specs->has(Spec_Ptr) ?: *> <UnderlyingType->Name> <UnderlyingType-ArrExpr> ) ( <UnderlyingType->Parameters> ); <InlineCmt>
 ```
 
 ## Union
@@ -658,11 +682,11 @@ Fields:
 ```cpp
 CodeAttributes Attributes;
 CodeBody       Body;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -684,11 +708,11 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
+StringCached   Name;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
@@ -716,14 +740,15 @@ CodeSpecifiers Specs;
 CodeType       ValueType;
 Code           BitfieldSize;
 Code           Value;
+StringCached   Name;
 CodeVar        NextVar;
 Code           Prev;
 Code           Next;
-parser::Token* Tok;
+Token*         Tok;
 Code           Parent;
-StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
+s32            VarParenthesizedInit;
 ```
 
 Serialization:
@@ -734,4 +759,7 @@ Serialization:
 
 // Bitfield
 <ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
+
+// VarParenthesizedInit
+<Attributes> <Specs> <ValueType> <Name>( <Value>, NextVar ... ); <InlineCmt>
 ```

docs/Parser_Algo.md

@@ -1,3 +1,9 @@
+## Navigation
+
+[Top](../Readme.md)
+
+<- [docs - General](Readme.md)
+
 # Parser's Algorithim
 
 gencpp uses a hand-written recursive descent parser. Both the lexer and parser currently handle a full C/C++ file in a single pass.
@@ -6,8 +12,8 @@ gencpp uses a hand-written recursive descent parser. Both the lexer and parser c
 
 ### Lexer
 
-The lex procedure does the lexical pass of content provided as a `StrC` type.
-The tokens are stored (for now) in `gen::parser::Tokens`.
+The lex procedure does the lexical pass of content provided as a `Str` type.  
+The tokens are stored (for now) in `Lexer_Tokens`.
 
 Fields:
 
@@ -16,7 +22,7 @@ Array<Token> Arr;
 s32          Idx;
 ```
 
-What token types are supported can be found in [ETokType.csv](../project/enums/ETokType.csv) you can also find the token types in [ETokType.h](../project/components/gen/etoktype.cpp) , which is the generated enum from the csv file.
+What token types are supported can be found in [ETokType.csv](../base/enums/ETokType.csv) you can also find the token types in [ETokType.h](../base/components/gen/etoktype.cpp) , which is the generated enum from the csv file.
 
 Tokens are defined with the struct `gen::parser::Token`:
 
@@ -69,7 +75,7 @@ The parser has a limited user interface, only specific types of definitions or s
 Each public user interface procedure has the following format:
 
 ```cpp
-<code type> parse_<definition type>( StrC def )
+<code type> parse_<definition type>( Str def )
 {
     check_parse_args( def );
     using namespace Parser;
@@ -281,7 +287,7 @@ In the future statements and expressions will be parsed.
         1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes`
         2. Specifiers ( consteval, constexpr, constinit, extern, forceinline, global, inline, internal_linkage, neverinline, static )
         3. Is either ( identifier, const specifier, long, short, signed, unsigned, bool, char, double, int)
-            1. Attempt to parse as constrcutor or destructor : `parse_global_nspace_constructor_destructor`
+            1. Attempt to parse as construtor or destructor : `parse_global_nspace_constructor_destructor`
             2. If its an operator cast (definition outside class) : `parse_operator_cast`
             3. Its an operator, function, or varaible : `parse_operator_function_or_varaible`
 4. If its not a global body, consume the closing curly brace

docs/Parsing.md

@@ -1,33 +1,39 @@
+## Navigation
+
+[Top](../Readme.md)
+
+<- [docs - General](Readme.md)
+
 # Parsing
 
-The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.
+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.
 
-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 ~5600 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 10k loc worst case.
 
-You can think of this parser of a 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.
+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 );
+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.
@@ -47,10 +53,11 @@ 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. *These ASTs will be considered members or entries of braced scope they reside within*.  
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. 
 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 )
+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***
 
 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:
@@ -59,6 +66,8 @@ Exceptions:
   * 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)*.
 
 *(Exceptions are added on an on-demand basis)*
 *(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
@@ -67,15 +76,23 @@ Adding your own exceptions is possible by simply modifying the parser to allow f
 
 *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.*
 
+If a macro is not defined withint e scope of parsing a set of files, it can be defined beforehand by:
+
+* 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`.
+
 The lexing and parsing takes shortcuts from whats expected in the standard.
 
 * 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.
+* 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.*
 * Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
   * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function or right afterthe return type.
   * Or in the usual spot for class, structs, (*right after the declaration keyword*)
   * typedefs have attributes with the type (`parse_type`)
 * 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.

docs/Readme.md

@@ -1,64 +1,42 @@
-## Documentation
+# General Docs
 
-The project has no external dependencies beyond:
+[Top](../Readme.md)
 
-* `errno.h`
-* `stat.h`
-* `stdarg.h`
-* `stddef.h`
-* `stdio.h`
-* `copyfile.h` (Mac)
-* `types.h`    (Linux)
-* `unistd.h`   (Linux/Mac)
-* `intrin.h`   (Windows)
-* `io.h`       (Windows with gcc)
-* `windows.h`  (Windows)
+Contains:
 
-Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).  
-The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
+* [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.
 
-This library was written in a subset of C++ where the following are not used at all:
-
-* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
-* Language provide dynamic dispatch, RTTI
-* Object-Oriented Inheritance
-* Exceptions
-
-Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.  
-The base library itself does not use anything but C-like features to allow for generating a derviative compatiable with C (WIP).
-
-There are only 4 template definitions in the entire library. (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `AST/Code::cast<Type>`)
-
-Two generic templated containers are used throughout the library:
-
-* `template< class Type> struct Array`
-* `template< class Type> struct HashTable`
-
-Both Code and AST definitions have a `template< class Type> Code/AST :: cast()`. Its just an alternative way to explicitly cast to each other.
-
-`template< class Type> swap( Type& a, Type& b)` is used over a macro.
-
-Otherwise the library is free of any templates.
-
-### *WHAT IS NOT PROVIDED*
+### *CURRENTLY UNSUPPORTED*
 
 **There is no support for validating expressions.**  
-Its difficult to parse without enough benefits (At the metaprogramming level).  
-I plan to add this only at the tail of the project parsing milestone.
+Its a [todo](https://github.com/Ed94/gencpp/issues/49)
 
-**Only trivial template support is provided.**  
-The intention is for only simple, non-recursive substitution.  
-The parameters of the template are treated like regular parameter AST entries.  
+**Only trivial template support is provided.**
+The intention is for only simple, non-recursive substitution.
+The parameters of the template are treated like regular parameter AST entries.
 This means that the typename entry for the parameter AST would be either:
 
 * `class`
 * `typename`
 * A fundamental type, function, or pointer type.
 
-Anything beyond this usage is not supported by parse_template for arguments (at least not intentionally).  
-Use at your own mental peril.
+***Concepts and Constraints are not supported***  
+Its a [todo](https://github.com/Ed94/gencpp/issues/21)
 
-*Concepts and Constraints are not supported, its usage is non-trivial substitution.*
+### 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.
+* `GEN_DEFINE_LIBRARY_CORE_CONSTANTS` : Optional typename codes as they are non-standard to C/C++ and not necessary to library usage
+* `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
+* `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
+* `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
 
 ### The Data & Interface
 
@@ -67,87 +45,33 @@ As mentioned in root readme, the user is provided Code objects by calling the co
 The AST is managed by the library and provided to the user via its interface.  
 However, the user may specifiy memory configuration.
 
-Data layout of AST struct (Subject to heavily change with upcoming redesign):
+[Data layout of AST struct (Subject to heavily change with upcoming todos)](../base/components/ast.hpp#L396-461)  
 
-```cpp
-union {
-    struct
-    {
-        AST*      InlineCmt;       // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
-        AST*      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
-        AST*      Specs;           // Destructor, Function, Operator, Typename, Variable
-        union {
-            AST*  InitializerList; // Constructor
-            AST*  ParentType;      // Class, Struct, ParentType->Next has a possible list of interfaces.
-            AST*  ReturnType;      // Function, Operator, Typename
-            AST*  UnderlyingType;  // Enum, Typedef
-            AST*  ValueType;       // Parameter, Variable
-        };
-        union {
-            AST*  Macro;           // Parameters
-            AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
-            AST*  Params;          // Constructor, Function, Operator, Template, Typename
-        };
-        union {
-            AST*  ArrExpr;          // Typename
-            AST*  Body;             // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
-            AST*  Declaration;      // Friend, Template
-            AST*  Value;            // Parameter, Variable
-        };
-        union {
-            AST*  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
-            AST*  SpecsFuncSuffix;  // Only used with typenames, to store the function suffix if typename is function signature.
-        };
-    };
-    StringCached  Content;          // Attributes, Comment, Execution, Include
-    struct {
-        SpecifierT ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
-        AST*       NextSpecs;                   // Specifiers
-    };
-};
-union {
-    AST* Prev;
-    AST* Front;
-    AST* Last;
-};
-union {
-    AST* Next;
-    AST* Back;
-};
-AST*              Parent;
-StringCached      Name;
-CodeT             Type;
-ModuleFlag        ModuleFlags;
-union {
-    b32           IsFunction;  // Used by typedef to not serialize the name field.
-    b32           IsParamPack; // Used by typename to know if type should be considered a parameter pack.
-    OperatorT     Op;
-    AccessSpec    ParentAccess;
-    s32           NumEntries;
-};
-s32               Token;       // Handle to the token, stored in the CodeFile (Otherwise unretrivable)
-```
+https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
 
-*`CodeT` is a typedef for `ECode::Type` which has an underlying type of `u32`*  
+*`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 allocated string type for the library*  
 
-AST widths are setup to be AST_POD_Size.
+AST widths are setup to be AST_POD_Size.  
 The width dictates how much the static array can hold before it must give way to using an allocated array:
 
 ```cpp
 constexpr static
-usize ArrSpecs_Cap =
+int AST_ArrSpecs_Cap =
 (
     AST_POD_Size
-    - sizeof(AST*) * 3
+    - sizeof(Code)
     - sizeof(StringCached)
-    - sizeof(CodeT)
+    - sizeof(Code) * 2
+    - sizeof(Token*)
+    - sizeof(Code)
+    - sizeof(CodeType)
     - sizeof(ModuleFlag)
     - sizeof(u32)
 )
-/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
+/ sizeof(Specifier) - 1;
 ```
 
 *Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
@@ -155,8 +79,8 @@ usize ArrSpecs_Cap =
 Data Notes:
 
 * The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
-  * Allocators are defined with the `AllocatorInfo` structure found in `dependencies\memory.hpp`
+  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_strbuilder_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
@@ -164,30 +88,30 @@ Data Notes:
 ```
 
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
-* Both AST and Code have member symbols but their data layout is enforced to be POD types.
+* 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 single arena with a simple slag allocator.
-* Linked lists used children nodes on bodies, and parameters.
+  * 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.
 * 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:
+* 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.
-  * `GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE` : token_fmt_va uses local_persit memory of this size for the hashtable.
+  * `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`
 
 The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
 
-* CodeBody : Has support for `for-range` iterating across Code objects.
+* CodeBody : Has support for `for : range` iterating across Code objects.
 * CodeAttributes
 * CodeComment
 * CodeClass
@@ -204,13 +128,13 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeNS
 * CodeOperator
 * CodeOpCast
-* CodeParam : Has support for `for-range` iterating across parameters.
+* CodeParams : Has support for `for : range` iterating across parameters.
 * CodePreprocessCond
 * CodePragma
-* CodeSpecifiers : Has support for `for-range` iterating across specifiers.
+* CodeSpecifiers : Has support for `for : range` iterating across specifiers.
 * CodeStruct
 * CodeTemplate
-* CodeType
+* CodeTypename
 * CodeTypedef
 * CodeUnion
 * CodeUsing
@@ -295,6 +219,7 @@ Code <name>
 ```
 
 When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
+
 ```cpp
 def_global_body( args( ht_entry, array_ht_entry, hashtable ));
 
@@ -302,7 +227,7 @@ def_global_body( args( ht_entry, array_ht_entry, hashtable ));
 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.  
+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.
 
 ### Parse construction
@@ -354,7 +279,7 @@ Interface :
 * untyped_fmt
 * untyped_token_fmt
 
-During serialization any untyped Code AST has its string value directly injected inline of whatever context the content existed as an entry within.  
+During serialization any untyped Code AST has its string value directly injected inline of whatever context the content existed as an entry within.
 Even though these are not validated from somewhat correct c/c++ syntax or components, it doesn't mean that Untyped code can be added as any component of a Code AST:
 
 * Untyped code cannot have children, thus there cannot be recursive injection this way.
@@ -375,6 +300,7 @@ Code <name> = untyped_str( code(
 ```
 
 Optionally, `code_str`, and `code_fmt` macros can be used so that the code macro doesn't have to be used:
+
 ```cpp
 Code <name> = code_str( <some code without "" quotes > )
 ```
@@ -382,7 +308,7 @@ Code <name> = code_str( <some code without "" quotes > )
 Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
 
 ```cpp
-StrC value = txt("Something");
+Str value = txt("Something");
 
 char const* template_str = txt(
     Code with <key> to replace with token_values
@@ -404,8 +330,8 @@ The following are provided predefined by the library as they are commonly used:
 * `module_global_fragment`
 * `module_private_fragment`
 * `fmt_newline`
-* `param_varaidc` (Used for varadic definitions)
 * `pragma_once`
+* `param_varaidc` (Used for varadic definitions)
 * `preprocess_else`
 * `preprocess_endif`
 * `spec_const`
@@ -421,6 +347,7 @@ The following are provided predefined by the library as they are commonly used:
 * `spec_local_persist` (local_persist macro)
 * `spec_mutable`
 * `spec_neverinline`
+* `spec_noexcept`
 * `spec_override`
 * `spec_ptr`
 * `spec_pure`
@@ -452,8 +379,8 @@ Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` i
 * `t_u16`
 * `t_u32`
 * `t_u64`
-* `t_sw` (ssize_t)
-* `t_uw` (size_t)
+* `t_ssize` (ssize_t)
+* `t_usize` (size_t)
 * `t_f32`
 * `t_f64`
 
@@ -471,15 +398,12 @@ and have the desired specifiers assigned to them beforehand.
 
 ## Code generation and modification
 
-There are three provided auxillary interfaces:
+There are two provided auxillary interfaces:
 
 * Builder
-* Editor
 * Scanner
 
-Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FEATURE_SCANNER` to enable them.
-
-### 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.
@@ -488,4 +412,8 @@ Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FE
 
 ### Scanner Auxillary Interface
 
-Provides *(eventually)* `scan_file` to automatically populate a CodeFile which contains a parsed AST (`Code`) of the file, with any contextual failures that are reported from the parser.
+* The purpose is to scan or parse files
+* Some with two basic functions to convert a fil to code: `scan_file` and `parse_file`
+  * `scan_file`: Merely grabs the file and stores it in an untyped Code.
+  * `parse_file`: Will parse the file using `parse_global_body` and return a `CodeBody`.
+* Two basic functions for grabbing columns from a CSV: `parse_csv_one_column` and `parse_csv_two_columns`

gen_c_library/Readme.md

@@ -0,0 +1,23 @@
+## Navigation
+
+# base
+
+[Top](../Readme.md)
+
+* [docs](../docs/Readme.md)
+
+# C Library Generation
+
+`c_library.cpp` generates both *segemnted* and *singleheader* variants of the library compliant with C11.
+
+The output will be in the `gen_segmented/gen` directory (if the directory does not exist, it will create it).
+
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> c_library
+```
+
+All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying c_library.refactor.
+
+**If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.**

gen_c_library/c_library.refactor

@@ -0,0 +1,548 @@
+ __VERSION 1
+
+// 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
+
+// Gen Macro namespace
+// namespace GEN_, new_namespace_
+
+// c_library.refactor
+// Used to prefix all exposed identifiers with the gen_namespace by c_library.cpp using ./gencpp/scripts/helpers/refactor.exe
+
+// Macros
+
+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 cast,                         gen_cast
+word ccast,                        gen_ccast
+word pcast,                        gen_pcast
+word rcast,                        gen_rcast
+word scast,                        gen_scast
+word stringize_va,                 gen_stringize_va
+word stringize,                    gen_stringize
+word do_once,                      gen_do_once
+word do_once_start,                gen_do_once_start
+word do_once_end,                  gen_do_once_end
+word labeled_scope_start,          gen_labeled_scope_start
+word labeled_scope_end,            gen_labeled_scope_end
+word compiler_decorated_func_name, gen_compiler_decorated_func_name
+word num_args_impl,                gen_num_args_impl
+word num_args,                     gen_num_args
+word clamp,                        gen_clamp
+word count_of,                     gen_count_of
+word is_between,                   gen_is_between
+word size_of,                      gen_size_of
+word max,                          gen_max
+word min,                          gen_min
+word offset_of,                    gen_offset_of
+word forceinline,                  gen_forceinline
+word neverinline,                  gen_neverinline
+word static_assert,                gen_static_assert
+word thread_local,                 gen_thread_local
+word typeof,                       gen_typeof
+word enum_underlying,              gen_enum_underlying
+word nullptr,                      gen_nullptr
+word struct_init,                  gen_struct_init
+word hash,                         gen_hash
+
+// Basic Types
+
+word u8,               gen_u8
+word s8,               gen_s8
+word u16,              gen_u16
+word s16,              gen_s16
+word u32,              gen_u32
+word s32,              gen_s32
+word u64,              gen_u64
+word s64,              gen_s64
+word usize,            gen_usize
+word ssize,            gen_ssize
+word sptr,             gen_sptr
+word uptr,             gen_uptr
+word f32,              gen_f32
+word f64,              gen_f64
+word b8,               gen_b8
+word b16,              gen_b16
+word b32,              gen_b32
+word mem_ptr,          gen_mem_ptr
+word mem_ptr_const,    gen_mem_ptr_const
+word to_uptr,          gen_to_uptr
+word to_sptr,          gen_to_sptr
+word to_mem_ptr,       gen_to_mem_ptr
+word to_mem_ptr_const, gen_to_mem_ptr_const
+
+// Debug
+
+word assert_handler, gen_assert_handler
+word assert_crash,   gen_assert_crash
+word process_exit,   gen_process_exit
+
+// Memory
+
+word kilobytes, gen_kilobytes
+word megabytes, gen_megabytes
+word gigabytes, gen_gigabytes
+word terabytes, gen_terabytes
+
+word swap, gen_swap
+
+word is_power_of_two,        gen_is_power_of_two
+word align_forward,          gen_align_forward
+word align_forward_by_value, gen_align_forward_by_value
+word pointer_add,            gen_pointer_add
+word pointer_add_const,      gen_pointer_add_const
+word pointer_diff,           gen_pointer_diff
+word mem_copy,               gen_mem_copy
+word mem_find,               gen_mem_find
+word mem_move,               gen_mem_move
+word mem_set,                gen_mem_set
+word zero_size,              gen_zero_size
+word zero_item,              gen_zero_item
+word zero_array,             gen_zero_array
+
+word AllocType,     gen_AllocType
+word AllocatorProc, gen_AllocatorProc
+word AllocatorInfo, gen_AllocatorInfo
+word AllocFlag,     gen_AllocFlag
+
+word alloc,          gen_alloc
+word alloc_align,    gen_alloc_align
+word allocator_free, gen_allocator_free
+word free_all,       gen_free_all
+word resize,         gen_resize
+word resize_align,   gen_resize_align
+word alloc_item,     gen_alloc_item
+word alloc_array,    gen_alloc_array
+
+word heap_stats_init,        gen_heap_stats_init
+word heap_stats_used_memory, gen_heap_stats_used_memory
+word heap_stats_alloc_count, gen_heap_stats_alloc_count
+word heap_stats_check,       gen_heap_stats_check
+word default_resize_align,   gen_default_resize_align
+
+word heap_allocator_proc, gen_heap_allocator_proc
+word heap,                gen_heap
+word malloc,              gen_malloc
+word mfree,               gen_mfree
+
+word VirtualMemory,            gen_VirtualMemory
+word vm_from_memory,           gen_vm_from_memory
+word vm_alloc,                 gen_vm_alloc
+word vm_free,                  gen_vm_free
+word vm_trim,                  gen_vm_trim
+word vm_purge,                 gen_vm_purge
+word virtual_memory_page_size, gen_virtual_memory_page_size
+
+// Memory: Arena
+
+word Arena, gen_Arena
+namespace arena_, gen_arena_
+
+// word arena_allocator_info
+// word arena_init_from_memory
+// word arena_init_from_allocator
+// word arena_init_sub
+// word arena_alignment_of
+// word arena_check
+// word arena_size_remaining
+
+// Memory: FixedArena
+
+namespace FixedArena_,  gen_FixedArena_
+namespace fixed_arena_, gen_fixed_arena_
+
+// Memory: Pool
+
+word Pool, gen_Pool
+namespace pool_, gen_pool_
+
+// Printing
+
+namespace c_str_, gen_c_str_
+
+word PrintF_Buffer,     gen_PrintF_Buffer
+word Msg_Invalid_Value, gen_Msg_Invalid_Value
+word log_fmt,           gen_log_fmt
+
+// String Ops
+
+namespace char_, gen_char_
+
+word digit_to_int,      gen_digit_to_int
+word hex_digit_to_init, gen_hex_digit_to_init
+word i64_to_str,        gen_i64_to_str
+word u64_to_str,        gen_u64_to_str
+
+// Containers
+
+namespace GENERIC_SLOT_, GEN_GENERIC_SLOT_
+
+word Array, gen_Array
+word Array_ssize, gen_Array_gen_ssize
+
+word ArrayHeader, gen_ArrayHeader
+
+namespace Array_, gen_Array_
+namespace array_, gen_array_
+
+word HashTable, gen_HashTable
+
+namespace HashTable_, gen_HashTable_
+namespace hashtable_, gen_hashtable_
+
+namespace HT_,      gen_HT_
+namespace HTE_,     gen_HTE_
+namespace arr_hte_, gen_arr_hte_
+namespace Arr_HTE_, gen_Arr_HTE_
+
+// Hashing
+
+word crc32, gen_crc32
+word crc64, gen_crc64
+
+// Strings
+
+word Str, gen_Str
+
+word to_str_from_c_str, gen_to_str_from_c_str
+
+namespace str_, gen_str_
+
+word cast_to_str, gen_cast_to_str
+
+word StrBuilderHeader, gen_StrBuilderHeader
+word StrBuilder,       gen_StrBuilder
+
+namespace strbuilder_, gen_strbuilder_
+
+word StringCached, gen_StringCached
+
+word StringTable, gen_StringTable
+
+namespace StringTable_, gen_StringTable_
+
+// File Handling
+
+word FileModeFlag,   gen_FileModeFlag
+word SeekWhenceType, gen_SeekWhenceType
+word FileError,      gen_FileError
+word FileDescriptor, gen_FileDescriptor
+word FileMode,       gen_FileMode
+word FileOperations, gen_FileOperations
+word FileOperations, gen_FileOperations
+
+default_file_operations
+
+word FileTime, word FileTime
+
+word DirType,          gen_DirType
+word DirInfo,          gen_DirInfo
+word DirEntry,         gen_DirEntry
+word DirInfo,          gen_DirInfo
+word FileInfo,         gen_FileInfo
+word FileStandardType, gen_FileStandardType
+
+namespace file_, gen_file_
+
+word gen_FileContents, gen_FileContents
+
+// Timing
+
+word read_cpu_time_stamp_counter, gen_read_cpu_time_stamp_counter
+word time_rel,                    gen_time_rel
+word time_rel_ms,                 gen_time_rel_ms
+
+// Parsing
+
+// Parsing: ADT
+
+word ADT_Node,        gen_ADT_Node
+word ADT_Type,        gen_ADT_Type
+word ADT_Props,       gen_ADT_Props
+word ADT_NamingStyle, gen_ADT_NamingStyle
+word ADT_AssignStyle, gen_ADT_AssignStyle
+word ADT_DelimStyle,  gen_ADT_DelimStyle
+word ADT_Error,       gen_ADT_Error
+word ADT_Node,        gen_ADT_Node
+
+namespace adt_, gen_adt_
+
+word CSV_Error,  gen_CSV_Error
+word CSV_Object, gen_CSV_Object
+
+namespace csv_, gen_csv_
+
+// Types.hpp
+
+word log_failure, gen_log_failure
+
+word AccessSpec,         gen_AccessSpec
+word access_spec_to_str, gen_access_spec_to_str
+
+word CodeFlag, gen_CodeFlag
+word EnumDecl, gen_EnumDecl
+
+word ModuleFlag,         gen_ModuleFlag
+word module_flag_to_str, gen_module_flag_to_str
+
+word EPreprocessCond, gen_EPreprocessCOnd
+word ETypenameTag,    gen_ETypenameTag
+
+word CodeType, gen_CodeType
+
+word codetype_to_str,         gen_codetype_to_str
+word codetype_to_keyword_str, gen_codetype_to_keyword_str
+
+word Operator,        gen_Operator
+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 str_to_specifier, gen_str_to_specifier
+
+// AST
+
+word AST, gen_AST
+
+namespace AST_, gen_AST_
+
+word Code,  gen_Code
+word Token, gen_Token
+
+word CodeBody,           gen_CodeBody
+word CodeAttributes,     gen_CodeAttributes
+word CodeComment,        gen_CodeComment
+word CodeClass,          gen_CodeClass
+word CodeConstructor,    gen_CodeConstructor
+word CodeDefine,         gen_CodeDefine
+word CodeDestructor,     gen_CodeDestructor
+word CodeEnum,           gen_CodeEnum
+word CodeExec,           gen_CodeExec
+word CodeExtern,         gen_CodeExtern
+word CodeInclude,        gen_CodeInclude
+word CodeFriend,         gen_CodeFriend
+word CodeFn,             gen_CodeFn
+word CodeModule,         gen_CodeModule
+word CodeNS,             gen_CodeNS
+word CodeOperator,       gen_CodeOperator
+word CodeOpCast,         gen_CodeOpCast
+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
+word CodeUnion,          gen_CodeUnion
+word CodeUsing,          gen_CodeUsing
+word CodeVar,            gen_CodeVar
+
+// Code Interface
+
+namespace code_, gen_code_
+
+word Code_Global,  gen_Code_Global
+word Code_Invalid, gen_Code_Invalid
+
+word Code_POD, gen_Code_POD
+
+word AST_POD_Size,     gen_AST_POD_Size
+word AST_ArrSpecs_Cap, gen_AST_ArrSpecs_Cap
+
+word InvalidCode, gen_InvalidCode
+word NullCode,    gen_NullCode
+
+namespace begin_, gen_begin_
+namespace end_,   gen_end_
+namespace next_,  gen_next_
+
+namespace body_,       gen_body_
+namespace class_,      gen_class_
+namespace params_,     gen_params_
+namespace specifiers_, gen_specifiers_
+namespace struct_,     gen_struct_
+namespace attributes_, gen_attributes_
+namespace comment_,    gen_comment_
+namespace constructor, gen_constructor_
+namespace define_,     gen_define_
+namespace destructor,  gen_destructor_
+namespace enum_,       gen_enum_
+namespace exec_,       gen_exec_
+namespace extern_,     gen_extern_
+namespace include_,    gen_include_
+namespace friend_,     gen_friend_
+namespace fn_,         gen_fn_
+namespace module_,     gen_module_
+namespace code_op,     gen_code_op_
+namespace opcast_,     gen_opcast_
+namespace pragma_,     gen_pragma_
+namespace preprocess_, gen_preprocess_
+namespace template_,   gen_template_
+namespace typename_,   gen_typename_
+namespace typedef_,    gen_typedef_
+namesapce union_,      gen_union_
+namespace using_,      gen_using_
+namespace var_,        gen_var_
+
+// Gen Interface
+
+word init,   gen_init
+word deinit, gen_deinit
+word reset,  gen_reset
+
+word get_cached_string, gen_get_cached_string
+
+word make_code, gen_make_code
+
+namespace set_allocator_, gen_set_allocator_
+
+namespace def_,     gen_def_
+namespace parse_,   gen_parse_
+namespace token_,   gen_token_
+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
+
+word attrib_api_export, gen_attrib_api_export
+word attrib_api_import, gen_attrib_api_import
+
+word module_global_fragment,  gen_module_global_fragment
+word module_private_fragment, gen_module_private_fragment
+
+word fmt_newline,     gen_fmt_newline
+word pragma_once,     gen_pragma_once
+word param_varadic,   gen_param_varadic
+word preprocess_else, gen_preprocess_else
+
+namespace spec_, gen_spec_
+namespace t_,    gen_t_
+
+word PreprocessorDefines, gen_PreprocessorDefines
+
+// Backend
+
+word GlobalAllocator,         gen_GlobalAllocator
+word Global_AllocatorBuckets, gen_Global_AllocatorBuckets
+word CodePools,               gen_CodePools
+word StringArenas,            gen_StringArenas
+word StringCache,             gen_StringCache
+word LexArena,                gen_LexArena
+word Allocator_DataArrays,    gen_Allocator_DataArrays
+word Allocator_CodePool,      gen_Allocator_CodePool
+word Allocator_Lexer,         gen_Allocator_Lexer
+word Allocator_StringArena,   gen_Allocator_StringArena
+word Allocator_StringTable,   gen_Allocator_StringTable
+word Allocator_TypeTable,     gen_Allocator_TypeTable
+
+// Builder
+
+word      Builder,  gen_Builder
+namespace builder_, gen_builder_
+
+// Scanner
+
+word scan_file, gen_scan_file
+
+// Implementation (prviate)
+
+word _format_info, gen__format_info
+
+namespace _print_,          gen__print_
+word      _heap_stats,      gen__heap_stats
+word      _heap_alloc_info, gen__heap_alloc_info
+
+word _crc32_table, gen__crc32_table
+word _crc64_table, gen__crc64_table
+
+word _alloc_utf8_to_ucs2, gen__alloc_utf8_to_ucs2
+
+word _win32_file_seek,  gen__win32_file_seek
+word _win32_file_read,  gen__win32_file_read
+word _win32_file_write, gen__win32_file_write
+word _win32_file_close, gen__win32_file_close
+word _win32_file_open,  gen__win32_file_open
+
+word _posix_file_seek,  gen__posix_file_seek
+word _posix_file_read,  gen__posix_file_read
+word _posix_file_write, gen__posix_file_write
+word _posix_file_close, gen__posix_file_close
+word _posix_file_open,  gen__posix_file_open
+
+word _dirinfo_free_entry, gen__dirinfo_free_entry
+word _std_file_set,       gen__std_file_set
+
+word _memory_fd, gen__memory_fd
+
+word _file_stream_fd_make, gen__file_stream_fd_make
+word _file_stream_from_fd, gen__file_stream_from_fd
+word _memory_file_seek,    gen__memory_file_seek
+word _memory_file_read,    gen__memory_file_read
+word _memory_file_write,   gen__memory_file_write
+word _memory_file_close,   gen__memory_file_close
+
+word _unix_gettime, gen__unix_gettime
+word _adt_fprintf,  gen__adt_fprintf
+
+word _adt_get_value, gen__adt_get_value
+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 define_constants,      gen_define_constants
+word operator__validate,    gen_operator__validate
+
+word parser_init,   gen_parser_init
+word parser_deinit, gen_parser_deinit
+
+word TokType,         gen_TokType
+word toktype_to_str,  gen_toktype_to_str
+// word str_to_toktype, gen_str_to_toktype
+word NullToken,       gen_NullToken
+
+namespace tok_, gen_tok_
+
+word TokArray, gen_TokArray
+
+namespace lex_,   gen_lex_
+namespace Lexer_, gen_Lexer_
+
+word LexContext, gen_LexContext
+word lex,        gen_lex
+
+word StackNode,    gen_StackNode
+word ParseContext, gen_ParseContext
+
+// namespace parse_, gen_parse_
+
+namespace parser_, gen_parser_

gen_c_library/components/containers.array.hpp

@@ -1,6 +1,5 @@
 #pragma once
-
-#include "../project/gen.hpp"
+#include "gen.hpp"
 
 using namespace gen;
 
@@ -21,7 +20,7 @@ CodeBody gen_array_base()
 
 	Code grow_formula = untyped_str( txt( "#define array_grow_formula( value ) ( 2 * value + 8 )\n" ));
 	Code get_header   = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" ));
-	Code type_define  = untyped_str( txt( "#define Array(Type) Array_##Type\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 ) ));
@@ -41,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( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	StrBuilder fn         = StrBuilder::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	// c_str_to_lower(fn.Data);
 
 #pragma push_macro( "GEN_ASSERT" )
 #pragma push_macro( "rcast" )
@@ -57,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>;
 
@@ -376,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(GlobalAllocator, "%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
@@ -400,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( GlobalAllocator, "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( GlobalAllocator, "endregion %SB", array_type ))),
 		fmt_newline
 	));
 };

gen_c_library/components/containers.hashtable.hpp

@@ -1,6 +1,5 @@
 #pragma once
-
-#include "../project/gen.hpp"
+#include "gen.hpp"
 #include "containers.array.hpp"
 
 using namespace gen;
@@ -28,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(GlobalAllocator).Ptr};
+	StrBuilder fn       = tbl_type.duplicate(GlobalAllocator);
+	// 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( GlobalAllocator, 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( GlobalAllocator, "HTE_%.*s",     hashtable_name.Len, hashtable_name.Ptr );
+	StrBuilder entry_array_name  = StrBuilder::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
+	StrBuilder entry_array_fn_ns = StrBuilder::fmt_buf( GlobalAllocator, "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>;
@@ -75,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;
@@ -373,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(GlobalAllocator, "%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
@@ -396,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( GlobalAllocator, "region %SB", tbl_type ))),
 		fmt_newline,
 		generic_interface_slot,
 		fmt_newline,
@@ -410,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( GlobalAllocator, "endregion %SB", tbl_type ))),
 		fmt_newline
 	));
 }

gen_c_library/components/generic_macros.h

@@ -0,0 +1,116 @@
+
+#pragma region _Generic Macros
+//   ____                       _        ______                _   _                ____                  _                 __ _
+//  / ___}                     (_)      |  ____}              | | (_)              / __ \                | |               | |(_)
+// | | ___  ___ _ __   ___ _ __ _  ___  | |__ _   _ _ __   ___| |_ _  ___  _ __   | |  | |_   _____ _ __ | | ___   __ _  __| | _ _ __   __ _
+// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| |  __} | | | '_ \ / __} __} |/ _ \| '_ \  | |  | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
+// | |__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.
+
+#define GEN_COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly.
+
+// Helper macros for argument selection
+#define GEN_SELECT_ARG_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
+#define GEN_SELECT_ARG_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
+#define GEN_SELECT_ARG_3( _1, _2, _3, ... ) _3 // etc..
+
+#define GEN_GENERIC_SEL_ENTRY_TYPE             GEN_SELECT_ARG_1 // Use the arg expansion macro to select arg 1 which should have the type.
+#define GEN_GENERIC_SEL_ENTRY_FUNCTION         GEN_SELECT_ARG_2 // Use the arg expansion macro to select arg 2 which should have the function.
+#define GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER  GEN_SELECT_ARG_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','.
+
+#define GEN_RESOLVED_FUNCTION_CALL // Just used to indicate where the call "occurs"
+
+// ----------------------------------------------------------------------------------------------------------------------------------
+// GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name).
+// It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma.
+// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
+// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
+#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_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.
+
+// 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;
+struct GENCPP_NO_RESOLVED_GENERIC_SELECTION {
+	void* _THE_VOID_SLOT_;
+};
+GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = {0};
+// Which will provide the message:  error: called object type 'struct NO_RESOLVED_GENERIC_SELECTION' is not a function or function pointer
+// ----------------------------------------------------------------------------------------------------------------------------------
+
+// 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( 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 )
+// ----------------------------------------------------------------------------------------------------------------------------------
+
+// Then each definiton of a function has an associated define:
+#// #define GENERIC_SLOT_<#>_<generic identifier> <typename>, <function_to_resolve>
+
+// Then somehwere later on
+// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
+
+// Concrete example:
+
+// To add support for long:
+#define GENERIC_SLOT_1_gen_example_hash long, gen_example_hash__P_long
+size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
+
+// To add support for long long:
+#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:
+// 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( 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:
+
+// 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( GENERIC_SLOT_1__function_sig )  \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig )  \
+	/* ... */                                                               \
+	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( GENERIC_SLOT_1__function_sig ) \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
+	/* ... */                                                              \
+	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig )  \
+	default: gen_generic_selection_fail                                    \
+) GEN_RESOLVED_FUNCTION_CALL()
+
+// Used to keep the _Generic keyword happy as bare types are not considered "expressions"
+#define GEN_TYPE_TO_EXP(type) (* (type*)NULL)
+// Instead of using this macro, you'll see it directly expanded by the code generation.
+
+// typedef void* GEN_GenericExampleType;
+// GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( GEN_GenericExampleType );
+#pragma endregion _Generic Macros

gen_c_library/components/header_seg_includes.h

@@ -0,0 +1,9 @@
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.h : GEN_TIME not defined
+#endif
+
+//! 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
+#	include "gen.dep.h"
+#endif

gen_c_library/components/memory.fixed_arena.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "../project/gen.hpp"
+#include "gen.hpp"
 
 using namespace gen;
 
@@ -29,6 +29,11 @@ CodeBody gen_fixed_arenas()
 		{
 			return arena_size_remaining( & fixed_arena->arena, alignment);
 		}
+
+		inline
+		void fixed_arena_free_<Name>(FixedArena_<Name>* fixed_arena) {
+			arena_free( & fixed_arena->arena);
+		}
 	);
 
 	CodeBody arena_struct_1kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"),   "Size", txt("kilobytes(1)"),   template_struct ));
@@ -84,7 +89,7 @@ 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)"), code({ arena_allocator_proc, & fixed_arena.arena }) );
+	CodeDefine def = def_define(txt("fixed_arena_allocator_info(fixed_arena)"), txt("( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )"));
 	result.append(def);
 	result.append(fmt_newline);
 
@@ -103,7 +108,23 @@ CodeBody gen_fixed_arenas()
     FixedArena_2MB*   : fixed_arena_init_2MB,      \
     FixedArena_4MB*   : fixed_arena_init_4MB,      \
 	default           : gen_generic_selection_fail \
-) GEN_RESOLVED_FUNCTION_CALL(& expr)
+) GEN_RESOLVED_FUNCTION_CALL(expr)
+
+#define fixed_arena_free(expr) _Generic((expr),    \
+    FixedArena_1KB*   : fixed_arena_free_1KB,      \
+    FixedArena_4KB*   : fixed_arena_free_4KB,      \
+    FixedArena_8KB*   : fixed_arena_free_8KB,      \
+    FixedArena_16KB*  : fixed_arena_free_16KB,     \
+    FixedArena_32KB*  : fixed_arena_free_32KB,     \
+    FixedArena_64KB*  : fixed_arena_free_64KB,     \
+    FixedArena_128KB* : fixed_arena_free_128KB,    \
+    FixedArena_256KB* : fixed_arena_free_256KB,    \
+    FixedArena_512KB* : fixed_arena_free_512KB,    \
+    FixedArena_1MB*   : fixed_arena_free_1MB,      \
+    FixedArena_2MB*   : fixed_arena_free_2MB,      \
+    FixedArena_4MB*   : fixed_arena_free_4MB,      \
+	default           : gen_generic_selection_fail \
+)	GEN_RESOLVED_FUNCTION_CALL(expr)
 
 #define fixed_arena_size_remaining(expr, alignment) _Generic((expr), \
     FixedArena_1KB*   : fixed_arena_size_remaining_1KB,              \
@@ -119,7 +140,7 @@ CodeBody gen_fixed_arenas()
     FixedArena_2MB*   : fixed_arena_size_remaining_2MB,              \
     FixedArena_4MB*   : fixed_arena_size_remaining_4MB,              \
 	default           : gen_generic_selection_fail                   \
-)	GEN_RESOLVED_FUNCTION_CALL(& expr, alignment)
+)	GEN_RESOLVED_FUNCTION_CALL(expr, alignment)
 )"
 	)));
 

gen_c_library/components/misc.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "../project/gen.hpp"
+#include "gen.hpp"
 
 using namespace gen;
 
@@ -18,13 +18,13 @@ void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
 #pragma pop_macro("enum_underlying")
 }
 
-b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
+b32 ignore_preprocess_cond_block( Str cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
 {
 	b32 found = false;
 	CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
 	if ( cond->Content.is_equal(cond_sig) )
 	{
-		//log_fmt("Preprocess cond found: %SC\n", cond->Content);
+		//log_fmt("Preprocess cond found: %S\n", cond->Content);
 		found = true;
 
 		s32 depth = 1;
@@ -72,7 +72,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& par
 
 constexpr bool GenericSel_One_Arg = true;
 enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
-Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
+Code gen_generic_selection_function_macro( s32 num_slots, Str macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
 {
 /* Implements:
 	#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic(      \
@@ -84,18 +84,18 @@ Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, Gener
 	) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
 */
 	local_persist
-	String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64));
+	StrBuilder define_builder = StrBuilder::make_reserve(GlobalAllocator, 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,7 +104,7 @@ R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
 
 	for ( s32 slot = 1; slot <= num_slots; ++ slot )
 	{
-		StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
+		Str slot_str = StrBuilder::fmt_buf(GlobalAllocator, "%d", slot).to_str();
 		if (slot == num_slots && false)
 		{
 			define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
@@ -152,29 +152,29 @@ R"(		GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> )
 	// 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(GlobalAllocator, "%S_%S_", optional_prefix, old_name);
     else
-        new_name = string_fmt_buf(GlobalAllocator, "%SC_", old_name);
+        new_name = strbuilder_fmt_buf(GlobalAllocator, "%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;
-    for (CodeParam param = fn->Params; param.ast; param = param->Next)
+    for (CodeParams param = fn->Params; param.ast; param = param->Next)
     {
         if (param->ValueType)
         {
@@ -198,11 +198,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 +214,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 +223,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(GlobalAllocator, "region %s",    region_name.Ptr);
+	StrBuilder endregion_sig = strbuilder_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
 	if ( possible_region->Content.contains(region_sig))
 	{
 		found = true;

gen_c_library/components/src_start.c

@@ -0,0 +1,11 @@
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : GEN_TIME not defined
+#endif
+
+#include "gen.h"
+
+//! 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
+#	include "gen.dep.c"
+#endif

gen_c_library/gen.c

@@ -1,7 +1,8 @@
 #define GEN_IMPLEMENTATION
-#include "gen/gen.h"
+#include "gen/gen.c"
 
 int main()
 {
 	// init();
+	__debugbreak();
 }

gen_segmented/Readme.md

@@ -0,0 +1,21 @@
+## Navigation
+
+# base
+
+[Top](../Readme.md)
+
+* [docs](../docs/Readme.md)
+
+# Segemented Library Generation
+
+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>`
+
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> segmented
+```

gen_segmented/segmented.cpp

@@ -0,0 +1,287 @@
+// Includes are exposed to base directory
+
+#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"
+
+#include <stdlib.h>
+
+GEN_NS_BEGIN
+#include "helpers/base_codegen.hpp"
+#include "helpers/misc.hpp"
+GEN_NS_END
+
+using namespace gen;
+
+constexpr char const* generation_notice =
+"// This file was generated automatially by gencpp's bootstrap.cpp "
+"(See: https://github.com/Ed94/gencpp)\n\n";
+
+#include <cstdlib>   // for system()
+
+#define path_format_style "../scripts/.clang-format "
+#define scratch_file      "gen/scratch.hpp"
+#define path_base         "../base/"
+
+Code format( Code code ) {
+	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
+}
+
+int gen_main()
+{
+	gen::init();
+
+	Code push_ignores = scan_file( (path_base "helpers/push_ignores.inline.hpp") );
+	Code pop_ignores  = scan_file( (path_base "helpers/pop_ignores.inline.hpp") );
+
+	// gen_dep.hpp
+	{
+		Code platform     = scan_file( path_base "dependencies/platform.hpp" );
+		Code macros 	  = scan_file( path_base "dependencies/macros.hpp" );
+		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 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" );
+		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");
+		Builder* header = & _header;
+		builder_print_fmt( header, generation_notice );
+		builder_print_fmt( header, "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n" );
+		builder_print( header, platform );
+		builder_print_fmt( header, "\nGEN_NS_BEGIN\n" );
+
+		builder_print( header, macros );
+		builder_print( header, basic_types );
+		builder_print( header, debug );
+		builder_print( header, memory );
+		builder_print( header, string_ops );
+		builder_print( header, printing );
+		builder_print( header, containers );
+		builder_print( header, hashing );
+		builder_print( header, strings );
+		builder_print( header, filesystem );
+		builder_print( header, timing );
+		builder_print( header, parsing );
+
+		builder_print_fmt( header, "\nGEN_NS_END\n" );
+		builder_write(header);
+	}
+
+	// gen_dep.cpp
+	{
+		Code src_start  = scan_file( path_base "dependencies/src_start.cpp" );
+		Code debug      = scan_file( path_base "dependencies/debug.cpp" );
+		Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
+		Code printing   = scan_file( path_base "dependencies/printing.cpp" );
+		Code memory     = scan_file( path_base "dependencies/memory.cpp" );
+		Code hashing    = scan_file( path_base "dependencies/hashing.cpp" );
+		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" );
+		Builder* src = & _src;
+		builder_print_fmt(src, generation_notice );
+		builder_print_fmt( src, "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
+		builder_print( src, src_start );
+		builder_print_fmt( src, "\nGEN_NS_BEGIN\n" );
+
+		builder_print( src, debug );
+		builder_print( src, string_ops );
+		builder_print( src, printing );
+		builder_print( src, hashing );
+		builder_print( src, memory );
+		builder_print( src, strings );
+		builder_print( src, filesystem );
+		builder_print( src, timing );
+		builder_print( src, parsing );
+
+		builder_print_fmt( src, "\nGEN_NS_END\n" );
+		builder_write(src);
+	}
+
+	CodeBody gen_component_header = def_global_body( args(
+		def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
+		pragma_once,
+		def_include(txt("components/types.hpp")),
+		preprocess_endif,
+		fmt_newline,
+		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 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 ast_inlines = gen_ast_inlines();
+
+		Builder _header = builder_open( "gen/gen.hpp" );
+		Builder* header = & _header;
+		builder_print_fmt( header, generation_notice );
+		builder_print_fmt( header, "#pragma once\n\n" );
+		builder_print( header, push_ignores );
+		builder_print( header, header_start );
+		builder_print_fmt( header, "\nGEN_NS_BEGIN\n\n" );
+
+		builder_print_fmt(header, "#pragma region Types\n" );
+		builder_print( header, types );
+		builder_print( header, fmt_newline);
+		builder_print( header, format(ecode) );
+		builder_print( header, fmt_newline);
+		builder_print( header, format(eoperator) );
+		builder_print( header, fmt_newline);
+		builder_print( header, format(especifier) );
+		builder_print( header, fmt_newline);
+		builder_print_fmt( header, "#pragma endregion Types\n\n" );
+
+		builder_print_fmt( header, "#pragma region AST\n" );
+		builder_print( header, ast );
+		builder_print( header, code_types );
+		builder_print( header, ast_types );
+		builder_print_fmt( header, "\n#pragma endregion AST\n" );
+
+		builder_print( header, interface );
+
+		builder_print_fmt( header, "\n#pragma region Inlines\n" );
+		builder_print( header, inlines );
+		builder_print( header, fmt_newline );
+		builder_print( header, format(ast_inlines) );
+		builder_print( header, fmt_newline );
+		builder_print_fmt( header, "#pragma endregion Inlines\n" );
+
+		builder_print( header, header_end );
+		builder_print_fmt( header, "\nGEN_NS_END\n\n" );
+		builder_print( header, pop_ignores );
+		builder_write(header);
+	}
+
+	// gen.cpp
+	{
+		Code        src_start          = scan_file( path_base "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" );
+		Code        code_serialization = 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" );
+		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 );
+		builder_print( src, push_ignores );
+		builder_print( src, src_start );
+		builder_print_fmt( src, "\nGEN_NS_BEGIN\n");
+
+		builder_print( src, static_data );
+
+		builder_print_fmt( src, "\n#pragma region AST\n\n" );
+		builder_print( src, ast_case_macros );
+		builder_print( src, ast );
+		builder_print( src, code_serialization );
+		builder_print_fmt( src, "\n#pragma endregion AST\n" );
+
+		builder_print_fmt( src, "\n#pragma region Interface\n" );
+		builder_print( src, interface );
+		builder_print( src, upfront );
+		builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
+		builder_print( src, formatted_toktype );
+		builder_print( src, lexer );
+		builder_print( src, parser );
+		builder_print( src, parsing_interface );
+		builder_print_fmt( src, "\n#pragma endregion Parsing\n\n" );
+		builder_print( src, untyped );
+		builder_print_fmt( src, "#pragma endregion Interface\n\n" );
+
+		builder_print_fmt( src, "GEN_NS_END\n\n");
+		builder_print( src, pop_ignores );
+		builder_write(src);
+	}
+
+	// gen_builder.hpp
+	{
+		Code builder = scan_file( path_base "auxillary/builder.hpp" );
+
+		Builder header = builder_open( "gen/gen.builder.hpp" );
+		builder_print_fmt( & header, generation_notice );
+		builder_print_fmt( & header, "#pragma once\n\n" );
+		builder_print( & header, def_include( txt("gen.hpp") ));
+		builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
+		builder_print( & header, builder );
+		builder_print_fmt( & header, "\nGEN_NS_END\n" );
+		builder_write( & header);
+	}
+
+	// gen_builder.cpp
+	{
+		Code builder = scan_file( path_base "auxillary/builder.cpp" );
+
+		Builder src = builder_open( "gen/gen.builder.cpp" );
+		builder_print_fmt( & src, generation_notice );
+		builder_print( & src, def_include( txt("gen.builder.hpp") ) );
+		builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
+		builder_print( & src,  builder );
+		builder_print_fmt( & src, "\nGEN_NS_END\n" );
+		builder_write( & src);
+	}
+
+	// gen_scanner.hpp
+	{
+		Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
+
+		Builder header = builder_open( "gen/gen.scanner.hpp" );
+		builder_print_fmt( & header, generation_notice );
+		builder_print_fmt( & header, "#pragma once\n\n" );
+		builder_print( & header, def_include( txt("gen.hpp") ) );
+		builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
+		builder_print( & header, scanner );
+		builder_print_fmt( & header, "\nGEN_NS_END\n" );
+		builder_write(& header);
+	}
+
+	// gen_scanner.cpp
+	{
+		Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
+
+		Builder src = builder_open( "gen/gen.scanner.cpp" );
+		builder_print_fmt( & src, generation_notice );
+		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, "\nGEN_NS_END\n" );
+		builder_write( & src);
+	}
+
+	gen::deinit();
+	return 0;
+}

gen_singleheader/Readme.md

@@ -1,4 +1,18 @@
+## Navigation
+
+# base
+
+[Top](../Readme.md)
+
+* [docs](../docs/Readme.md)
+
 # Singleheader
 
 Creates a single header file version of the library using `singleheader.cpp`.
 Follows the same convention seen in the gb, stb, and zpl libraries.
+
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> singleheader
+```

gen_singleheader/components/header_start.hpp

@@ -3,17 +3,23 @@
 
 	See Readme.md for more information from the project repository.
 
-	Public Address:
-	https://github.com/Ed94/gencpp
-
-	This is a single header variant of the library.
 	Define GEN_IMPLEMENTATION before including this file in a single compilation unit.
 
-	! ----------------------------------------------------------------------- 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 !
-	! ============================================================================================ !
+	Public Address:
+	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
+	|   _____                               _____ _                       _                        |
+	|  / ____)                             / ____} |                     | |                       |
+	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
+	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
+	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
+	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
+	|     Singleheader       | |   | |                      __} |                                  |
+	|                        l_l   l_l                     {___/                                   |
+	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
+	! ============================================================================================ |
+	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
+	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
+	! ============================================================================================ /
 */
 #if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
 #	error Gen.hpp : GEN_TIME not defined

gen_singleheader/singleheader.cpp

@@ -2,44 +2,39 @@
 #define GEN_ENFORCE_STRONG_CODE_TYPES
 #define GEN_EXPOSE_BACKEND
 #include "gen.cpp"
-
 #include "helpers/push_ignores.inline.hpp"
-#include "helpers/helper.hpp"
+
+#include <stdlib.h>
 
 GEN_NS_BEGIN
-#include "dependencies/parsing.cpp"
+#include "helpers/base_codegen.hpp"
+#include "helpers/misc.hpp"
 GEN_NS_END
 
-#include "auxillary/builder.hpp"
-#include "auxillary/builder.cpp"
-#include "auxillary/scanner.hpp"
-
-#include <cstdlib>   // for system()
-
 using namespace gen;
 
 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
 )");
@@ -49,49 +44,20 @@ global bool generate_builder = true;
 global bool generate_editor  = true;
 global bool generate_scanner = true;
 
-void format_file( char const* path )
-{
-	String resolved_path = String::make(GlobalAllocator, to_str(path));
+#define path_format_style "../scripts/.clang-format "
+#define scratch_file      "gen/scratch.hpp"
+#define path_base         "../base/"
 
-	String style_arg = String::make(GlobalAllocator, txt("-style=file:"));
-	style_arg.append("../scripts/.clang-format ");
-
-	// Need to execute clang format on the generated file to get it to match the original.
-	#define clang_format      "clang-format "
-	#define cf_format_inplace "-i "
-	#define cf_verbose        "-verbose "
-	String command = String::make( GlobalAllocator, clang_format );
-	command.append( cf_format_inplace );
-	command.append( cf_verbose );
-	command.append( style_arg );
-	command.append( resolved_path );
-		log_fmt("\tRunning clang-format on file:\n");
-		system( command );
-		log_fmt("\tclang-format finished reformatting.\n");
-	#undef cf_cmd
-	#undef cf_format_inplace
-	#undef cf_style
-	#undef cf_verbse
-}
-
-Code dump_to_scratch_and_retireve( Code code )
-{
-	Builder ecode_file_temp = Builder::open("gen/scratch.hpp");
-	ecode_file_temp.print(code);
-	ecode_file_temp.write();
-	format_file("gen/scratch.hpp");
-	Code result = scan_file( "gen/scratch.hpp" );
-	remove("gen/scratch.hpp");
-	return result;
+Code format( Code code ) {
+	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
 }
 
 int gen_main()
 {
-#define project_dir "../project/"
 	gen::init();
 
-	Code push_ignores        = scan_file( project_dir "helpers/push_ignores.inline.hpp" );
-	Code pop_ignores         = scan_file( project_dir "helpers/pop_ignores.inline.hpp" );
+	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
+	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
 	Code single_header_start = scan_file( "components/header_start.hpp" );
 
 	Builder
@@ -106,18 +72,18 @@ int gen_main()
 
 		if ( generate_gen_dep )
 		{
-			Code platform     = scan_file( project_dir "dependencies/platform.hpp" );
-			Code macros       = scan_file( project_dir "dependencies/macros.hpp" );
-			Code basic_types  = scan_file( project_dir "dependencies/basic_types.hpp" );
-			Code debug        = scan_file( project_dir "dependencies/debug.hpp" );
-			Code memory	      = scan_file( project_dir "dependencies/memory.hpp" );
-			Code string_ops   = scan_file( project_dir "dependencies/string_ops.hpp" );
-			Code printing     = scan_file( project_dir "dependencies/printing.hpp" );
-			Code containers   = scan_file( project_dir "dependencies/containers.hpp" );
-			Code hashing 	  = scan_file( project_dir "dependencies/hashing.hpp" );
-			Code strings      = scan_file( project_dir "dependencies/strings.hpp" );
-			Code filesystem   = scan_file( project_dir "dependencies/filesystem.hpp" );
-			Code timing       = scan_file( project_dir "dependencies/timing.hpp" );
+			Code platform     = scan_file( path_base "dependencies/platform.hpp" );
+			Code macros       = scan_file( path_base "dependencies/macros.hpp" );
+			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 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" );
+			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" );
 
 			header.print_fmt( roll_own_dependencies_guard_start );
 			header.print( platform );
@@ -127,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 );
@@ -135,29 +101,27 @@ int gen_main()
 			header.print( filesystem );
 			header.print( timing );
 
-			if ( generate_scanner )
-			{
-				header.print_fmt( "\n#pragma region Parsing\n" );
-				header.print( scan_file( project_dir "dependencies/parsing.hpp" ) );
-				header.print_fmt( "#pragma endregion Parsing\n\n" );
+			if ( generate_scanner ) {
+				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( project_dir "components/types.hpp" );
-		Code ast        = scan_file( project_dir "components/ast.hpp" );
-		Code ast_types  = scan_file( project_dir "components/ast_types.hpp" );
-		Code code_types = scan_file( project_dir "components/code_types.hpp" );
-		Code interface  = scan_file( project_dir "components/interface.hpp" );
-		Code inlines 	= scan_file( project_dir "components/inlines.hpp" );
-		Code header_end = scan_file( project_dir "components/header_end.hpp" );
+		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" );
 
-		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECodeTypes.csv" );
-		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
-		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		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 ast_inlines = gen_ast_inlines();
 
 		header.print_fmt( "GEN_NS_BEGIN\n\n" );
@@ -165,11 +129,11 @@ int gen_main()
 		header.print_fmt("#pragma region Types\n");
 		header.print( types );
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve( ecode ));
+		header.print( format( ecode ));
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve( eoperator ));
+		header.print( format( eoperator ));
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve( especifier ));
+		header.print( format( especifier ));
 		header.print( fmt_newline );
 		header.print_fmt("#pragma endregion Types\n\n");
 
@@ -183,19 +147,20 @@ int gen_main()
 
 		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
-		header.print( dump_to_scratch_and_retireve( ast_inlines ));
+		header.print( format( ast_inlines ));
 		header.print( fmt_newline );
 		header.print_fmt( "#pragma endregion Inlines\n" );
 
 		header.print( header_end );
 
-		if ( generate_builder )
-		{
-			header.print_fmt( "\n#pragma region Builder\n" );
-			header.print( scan_file( project_dir "auxillary/builder.hpp" ) );
-			header.print_fmt( "#pragma endregion Builder\n" );
+		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" );
 	}
 
@@ -205,20 +170,21 @@ int gen_main()
 
 		if ( generate_gen_dep )
 		{
-			Code impl_start = scan_file( project_dir "dependencies/src_start.cpp" );
-			Code debug      = scan_file( project_dir "dependencies/debug.cpp" );
-			Code string_ops = scan_file( project_dir "dependencies/string_ops.cpp" );
-			Code printing   = scan_file( project_dir "dependencies/printing.cpp" );
-			Code memory     = scan_file( project_dir "dependencies/memory.cpp" );
-			Code hashing    = scan_file( project_dir "dependencies/hashing.cpp" );
-			Code strings    = scan_file( project_dir "dependencies/strings.cpp" );
-			Code filesystem = scan_file( project_dir "dependencies/filesystem.cpp" );
-			Code timing     = scan_file( project_dir "dependencies/timing.cpp" );
+			Code impl_start = scan_file( path_base "dependencies/src_start.cpp" );
+			Code debug      = scan_file( path_base "dependencies/debug.cpp" );
+			Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
+			Code printing   = scan_file( path_base "dependencies/printing.cpp" );
+			Code memory     = scan_file( path_base "dependencies/memory.cpp" );
+			Code hashing    = scan_file( path_base "dependencies/hashing.cpp" );
+			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" );
 
 			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 );
@@ -228,10 +194,9 @@ int gen_main()
 			header.print( filesystem );
 			header.print( timing );
 
-			if ( generate_scanner )
-			{
+			if ( generate_scanner ) {
 				header.print_fmt( "\n#pragma region Parsing\n" );
-				header.print( scan_file( project_dir "dependencies/parsing.cpp" ) );
+				header.print( scan_file( path_base "dependencies/parsing.cpp" ) );
 				header.print_fmt( "#pragma endregion Parsing\n\n" );
 			}
 
@@ -239,19 +204,18 @@ int gen_main()
 			header.print_fmt( roll_own_dependencies_guard_end );
 		}
 
-		Code static_data 	   = scan_file( project_dir "components/static_data.cpp" );
-		Code ast_case_macros   = scan_file( project_dir "components/ast_case_macros.cpp" );
-		Code ast               = scan_file( project_dir "components/ast.cpp" );
-		Code code              = scan_file( project_dir "components/code_serialization.cpp" );
-		Code interface         = scan_file( project_dir "components/interface.cpp" );
-		Code upfront           = scan_file( project_dir "components/interface.upfront.cpp" );
-		Code lexer             = scan_file( project_dir "components/lexer.cpp" );
-		Code parser            = scan_file( project_dir "components/parser.cpp" );
-		Code parsing_interface = scan_file( project_dir "components/interface.parsing.cpp" );
-		Code untyped           = scan_file( project_dir "components/interface.untyped.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" );
+		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( project_dir "enums/ETokType.csv", project_dir "enums/AttributeTokens.csv" );
-		CodeNS   parser_nspace = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
+		CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
 
 		header.print_fmt( "\nGEN_NS_BEGIN\n");
 		header.print( static_data );
@@ -266,38 +230,23 @@ int gen_main()
 		header.print( interface );
 		header.print( upfront );
 		header.print_fmt( "\n#pragma region Parsing\n\n" );
-		header.print( dump_to_scratch_and_retireve(parser_nspace) );
+		header.print( format(etoktype) );
 		header.print( lexer );
 		header.print( parser );
 		header.print( parsing_interface );
 		header.print_fmt( "\n#pragma endregion Parsing\n" );
 		header.print( untyped );
-		header.print_fmt( "\n#pragma endregion Interface\n\n");
+		header.print_fmt( "\n#pragma endregion Interface\n");
 
-		if ( generate_builder )
-		{
-			header.print_fmt( "#pragma region Builder\n" );
-			header.print( scan_file( project_dir "auxillary/builder.cpp"  ) );
-			header.print_fmt( "\n#pragma endregion Builder\n\n" );
+		if ( generate_builder ) {
+			header.print( scan_file( path_base "auxillary/builder.cpp"  ) );
 		}
 
-		// Scanner header depends on implementation
-		if ( generate_scanner )
-		{
-			header.print_fmt( "\n#pragma region Scanner\n" );
-			header.print( scan_file( project_dir "auxillary/scanner.hpp" ) );
-			header.print_fmt( "#pragma endregion Scanner\n\n" );
+		if ( generate_scanner ) {
+			header.print( scan_file( path_base "auxillary/scanner.cpp" ) );
 		}
 
-#if 0
-		if ( generate_scanner )
-		{
-			header.print_fmt( "#pragma region Scanner\n\n" );
-			header.print( scan_file( project_dir "auxillary/scanner.cpp" ) );
-			header.print_fmt( "#pragma endregion Scanner\n\n" );
-		}
-#endif
-
+		header.print( fmt_newline);
 		header.print_fmt( "GEN_NS_END\n");
 
 		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
@@ -308,5 +257,4 @@ int gen_main()
 
 	gen::deinit();
 	return 0;
-#undef project_dir
 }

gen_unreal_engine/Readme.md

@@ -1,3 +1,17 @@
+## Navigation
+
+# base
+
+[Top](../Readme.md)
+
+* [docs](../docs/Readme.md)
+
 # Unreal Engine Version Generator
 
-This generates a variant of gencpp thats compatiable with use as a thirdparty module within a plugin or module of an Unreal Project or the Engine itself.
+This generates a variant of gencpp thats compatiable with use as a thirdparty module within a plugin or module of an Unreal Project or the Engine itself.
+
+If using the library's provided build scripts:
+
+```ps1
+.\build.ps1 <compiler> <debug or omit> unreal
+```

gen_unreal_engine/unreal.cpp

@@ -2,45 +2,40 @@
 #define GEN_ENFORCE_STRONG_CODE_TYPES
 #define GEN_EXPOSE_BACKEND
 #include "gen.cpp"
-
 #include "helpers/push_ignores.inline.hpp"
-#include "helpers/helper.hpp"
+
+#include <stdlib.h>
 
 GEN_NS_BEGIN
-#include "dependencies/parsing.cpp"
+#include "helpers/base_codegen.hpp"
+#include "helpers/misc.hpp"
 GEN_NS_END
 
-#include "auxillary/builder.hpp"
-#include "auxillary/builder.cpp"
-#include "auxillary/scanner.hpp"
-
-#include <cstdlib>   // for system()
-
 using namespace gen;
 
 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
 )");
@@ -50,59 +45,30 @@ global bool generate_builder = true;
 global bool generate_editor  = true;
 global bool generate_scanner = true;
 
-void format_file( char const* path )
-{
-	String resolved_path = String::make(GlobalAllocator, to_str(path));
+#define path_format_style "../scripts/.clang-format "
+#define scratch_file      "gen/scratch.hpp"
+#define path_base         "../base/"
 
-	String style_arg = String::make(GlobalAllocator, txt("-style=file:"));
-	style_arg.append("../scripts/.clang-format ");
-
-	// Need to execute clang format on the generated file to get it to match the original.
-	#define clang_format      "clang-format "
-	#define cf_format_inplace "-i "
-	#define cf_verbose        "-verbose "
-	String command = String::make( GlobalAllocator, clang_format );
-	command.append( cf_format_inplace );
-	command.append( cf_verbose );
-	command.append( style_arg );
-	command.append( resolved_path );
-		log_fmt("\tRunning clang-format on file:\n");
-		system( command );
-		log_fmt("\tclang-format finished reformatting.\n");
-	#undef cf_cmd
-	#undef cf_format_inplace
-	#undef cf_style
-	#undef cf_verbse
-}
-
-Code dump_to_scratch_and_retireve( Code code )
-{
-	Builder ecode_file_temp = Builder::open("gen/scratch.hpp");
-	ecode_file_temp.print(code);
-	ecode_file_temp.write();
-	format_file("gen/scratch.hpp");
-	Code result = scan_file( "gen/scratch.hpp" );
-	remove("gen/scratch.hpp");
-	return result;
+Code format( Code code ) {
+	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
 }
 
 int gen_main()
 {
-#define project_dir "../project/"
 	gen::init();
 
-	Code push_ignores        = scan_file( project_dir "helpers/push_ignores.inline.hpp" );
-	Code pop_ignores         = scan_file( project_dir "helpers/pop_ignores.inline.hpp" );
+	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
+	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
 
 	Code ue_forceinline = code_str(FORCEINLINE);
 	// Code
 
 	// gen_dep.hpp
 	{
-		CodeBody macros = def_body( CodeT::Global_Body );
+		CodeBody macros = def_body( CT_Global_Body );
 		{
-			FileContents content    = file_read_contents( GlobalAllocator, true, project_dir "dependencies/macros.hpp" );
-			CodeBody     ori_macros = parse_global_body( StrC { content.size, (char const*)content.data });
+			FileContents content    = file_read_contents( GlobalAllocator, true, 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();
@@ -110,10 +76,9 @@ int gen_main()
 			{
 				switch (code->Type)
 				{
-					using namespace ECode;
-					case Preprocess_Define:
+					case CT_Preprocess_Define:
 					{
-						CodeDefine define = code.cast<CodeDefine>();
+						CodeDefine define = cast(CodeDefine, code);
 						if ( define->Name.starts_with(txt("global")) )
 						{
 							macros.append(parse_global_body(txt("#define global // Global variables")));
@@ -131,17 +96,17 @@ int gen_main()
 			}
 		}
 
-		Code platform     = scan_file( project_dir "dependencies/platform.hpp" );
-		Code basic_types  = scan_file( project_dir "dependencies/basic_types.hpp" );
-		Code debug        = scan_file( project_dir "dependencies/debug.hpp" );
-		Code memory	      = scan_file( project_dir "dependencies/memory.hpp" );
-		Code string_ops   = scan_file( project_dir "dependencies/string_ops.hpp" );
-		Code printing     = scan_file( project_dir "dependencies/printing.hpp" );
-		Code containers   = scan_file( project_dir "dependencies/containers.hpp" );
-		Code hashing 	  = scan_file( project_dir "dependencies/hashing.hpp" );
-		Code strings      = scan_file( project_dir "dependencies/strings.hpp" );
-		Code filesystem   = scan_file( project_dir "dependencies/filesystem.hpp" );
-		Code timing       = scan_file( project_dir "dependencies/timing.hpp" );
+		Code platform     = scan_file( path_base "dependencies/platform.hpp" );
+		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 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" );
+		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" );
 
 		Builder
 		header = Builder::open("gen/gen.dep.hpp");
@@ -152,7 +117,7 @@ int gen_main()
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 
 		header.print( fmt_newline);
-		header.print( dump_to_scratch_and_retireve(macros) );
+		header.print( format(macros) );
 		header.print( basic_types );
 		header.print( debug );
 		header.print( memory );
@@ -172,15 +137,15 @@ int gen_main()
 
 	// gen_dep.cpp
 	{
-		Code src_start  = scan_file( project_dir "dependencies/src_start.cpp" );
-		Code debug      = scan_file( project_dir "dependencies/debug.cpp" );
-		Code string_ops = scan_file( project_dir "dependencies/string_ops.cpp" );
-		Code printing   = scan_file( project_dir "dependencies/printing.cpp" );
-		Code memory     = scan_file( project_dir "dependencies/memory.cpp" );
-		Code hashing    = scan_file( project_dir "dependencies/hashing.cpp" );
-		Code strings    = scan_file( project_dir "dependencies/strings.cpp" );
-		Code filesystem = scan_file( project_dir "dependencies/filesystem.cpp" );
-		Code timing     = scan_file( project_dir "dependencies/timing.cpp" );
+		Code src_start  = scan_file( path_base "dependencies/src_start.cpp" );
+		Code debug      = scan_file( path_base "dependencies/debug.cpp" );
+		Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
+		Code printing   = scan_file( path_base "dependencies/printing.cpp" );
+		Code memory     = scan_file( path_base "dependencies/memory.cpp" );
+		Code hashing    = scan_file( path_base "dependencies/hashing.cpp" );
+		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" );
 
 		Builder
 		src = Builder::open( "gen/gen.dep.cpp" );
@@ -208,18 +173,18 @@ int gen_main()
 
 	// gen.hpp
 	{
-		Code header_start = scan_file(             "components/header_start.hpp" );
-		Code types        = scan_file( project_dir "components/types.hpp" );
-		Code ast          = scan_file( project_dir "components/ast.hpp" );
-		Code ast_types    = scan_file( project_dir "components/ast_types.hpp" );
-		Code code_types   = scan_file( project_dir "components/code_types.hpp" );
-		Code interface    = scan_file( project_dir "components/interface.hpp" );
-		Code inlines      = scan_file( project_dir "components/inlines.hpp" );
-		Code header_end   = scan_file( project_dir "components/header_end.hpp" );
+		Code header_start = scan_file(           "components/header_start.hpp" );
+		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" );
 
-		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECodeTypes.csv" );
-		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
-		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		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 ast_inlines = gen_ast_inlines();
 
 		Builder
@@ -234,11 +199,11 @@ int gen_main()
 		header.print_fmt( "#pragma region Types\n" );
 		header.print( types );
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve(ecode) );
+		header.print( format(ecode) );
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve(eoperator) );
+		header.print( format(eoperator) );
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve(especifier) );
+		header.print( format(especifier) );
 		header.print( fmt_newline );
 		header.print_fmt( "#pragma endregion Types\n\n" );
 
@@ -253,12 +218,12 @@ int gen_main()
 		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
 		header.print( fmt_newline );
-		header.print( dump_to_scratch_and_retireve(ast_inlines) );
+		header.print( format(ast_inlines) );
 		header.print( fmt_newline );
 		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();
 	}
@@ -266,22 +231,21 @@ int gen_main()
 	// gen.cpp
 	{
 		Code        src_start          = scan_file(             "components/src_start.cpp" );
-		Code        static_data 	   = scan_file( project_dir "components/static_data.cpp" );
-		Code        ast_case_macros    = scan_file( project_dir "components/ast_case_macros.cpp" );
-		Code        ast			       = scan_file( project_dir "components/ast.cpp" );
-		Code        code_serialization = scan_file( project_dir "components/code_serialization.cpp" );
-		Code        interface	       = scan_file( project_dir "components/interface.cpp" );
-		Code        upfront 	       = scan_file( project_dir "components/interface.upfront.cpp" );
-		Code        lexer              = scan_file( project_dir "components/lexer.cpp" );
-		Code        parser             = scan_file( project_dir "components/parser.cpp" );
-		Code 	    parsing_interface  = scan_file( project_dir "components/interface.parsing.cpp" );
-		Code        untyped 	       = scan_file( project_dir "components/interface.untyped.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" );
+		Code        code_serialization = 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" );
 
 		// 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( project_dir "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-		CodeNS   nspaced_etoktype = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
+		CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", "enums/AttributeTokens.csv" );
 
 		Builder
 		src = Builder::open( "gen/gen.cpp" );
@@ -304,7 +268,7 @@ int gen_main()
 		src.print( interface );
 		src.print( upfront );
 		src.print_fmt( "\n#pragma region Parsing\n\n" );
-		src.print( dump_to_scratch_and_retireve(nspaced_etoktype) );
+		src.print( format(etoktype) );
 		src.print( lexer );
 		src.print( parser );
 		src.print( parsing_interface );
@@ -319,7 +283,7 @@ int gen_main()
 
 	// gen_builder.hpp
 	{
-		Code builder = scan_file( project_dir "auxillary/builder.hpp" );
+		Code builder = scan_file( path_base "auxillary/builder.hpp" );
 
 		Builder
 		header = Builder::open( "gen/gen.builder.hpp" );
@@ -330,7 +294,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();
@@ -338,7 +302,7 @@ int gen_main()
 
 	// gen_builder.cpp
 	{
-		Code builder = scan_file( project_dir "auxillary/builder.cpp" );
+		Code builder = scan_file( path_base "auxillary/builder.cpp" );
 
 		Builder
 		src = Builder::open( "gen/gen.builder.cpp" );
@@ -356,8 +320,8 @@ int gen_main()
 
 	// gen_scanner.hpp
 	{
-		Code parsing = scan_file( project_dir "dependencies/parsing.hpp" );
-		Code scanner = scan_file( project_dir "auxillary/scanner.hpp" );
+		Code parsing = scan_file( path_base "dependencies/parsing.hpp" );
+		Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
 
 		Builder
 		header = Builder::open( "gen/gen.scanner.hpp" );
@@ -369,7 +333,7 @@ int gen_main()
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 		header.print( parsing );
 		header.print( scanner );
-		header.print_fmt( "GEN_NS_END\n" );
+		header.print_fmt( "\nGEN_NS_END\n" );
 		header.print( fmt_newline );
 		header.print( pop_ignores );
 		header.write();
@@ -377,8 +341,8 @@ int gen_main()
 
 	// gen.scanner.cpp
 	{
-		Code parsing = scan_file( project_dir "dependencies/parsing.cpp" );
-		Code scanner = scan_file( project_dir "auxillary/scanner.cpp" );
+		Code parsing = scan_file( path_base "dependencies/parsing.cpp" );
+		Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
 
 		Builder
 		src = Builder::open( "gen/gen.scanner.cpp" );
@@ -389,7 +353,7 @@ int gen_main()
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
 		src.print( parsing );
 		// src.print( scanner );
-		src.print_fmt( "GEN_NS_END\n" );
+		src.print_fmt( "\nGEN_NS_END\n" );
 		src.print( fmt_newline );
 		src.print( pop_ignores );
 		src.write();