began to remove usage of code specific types member procs

Most likely will just reduce them to C-enums with underlying type.
Otherwise there has to be a mechanism to drop the defs down to them anyways, and eliminate the namespace wraps.

.gitignore

@@ -1,22 +1,34 @@
 .idea
 
-build/*
+**/build/*
 .vs
 
 **/*.gen.*
+**/gen/gen.hpp
+**/gen/gen.cpp
+**/gen/gen.dep.hpp
+**/gen/gen.dep.cpp
+**/gen/gen.builder.hpp
+**/gen/gen.builder.cpp
+**/gen/gen.scanner.hpp
+**/gen/gen.scanner.cpp
 
-# Build results
+gencpp.hpp
-[Dd]ebug/
+gencpp.cpp
-[Dd]ebugPublic/
+
-[Rr]elease/
+**/*.lib
-[Rr]eleases/
+**/*.pdb
-x64/
+**/*.exe
-x86/
+**/*.dll
-[Ww][Ii][Nn]32/
+
-[Aa][Rr][Mm]/
+release/**
-[Aa][Rr][Mm]64/
+
-bld/
+# Unreal
-[Bb]in/
+**/Unreal/*.h
-[Oo]bj/
+**/Unreal/*.cpp
-[Ll]og/
+! **/Unreal/validate.unreal.cpp
-[Ll]ogs/
+project/auxillary/vis_ast/dependencies/temp
+test/gen/original
+singleheader/gen/scratch.hpp
+test/gen/scratch.cpp
+gen_c_library/gen

.vscode/bookmarks.json

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

.vscode/c_cpp_properties.json

@@ -1,7 +1,7 @@
 {
     "configurations": [
         {
-            "name": "Win32",
+            "name": "Win32 msvc",
             "includePath": [
                 "${workspaceFolder}/**"
             ],
@@ -9,11 +9,36 @@
                 "_DEBUG",
                 "UNICODE",
                 "_UNICODE",
-                "GEN_TIME"
+                "GEN_TIME",
+                "GEN_IMPLEMENTATION",
+                // "GEN_DONT_USE_NAMESPACE"
+                "GEN_INTELLISENSE_DIRECTIVES",
+                "INTELLISENSE_DIRECTIVES"
+            ],
+            "windowsSdkVersion": "10.0.19041.0",
+            "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
+            "intelliSenseMode": "msvc-x64",
+            "compileCommands": "${workspaceFolder}/project/build/compile_commands.json"
+        },
+        {
+            "name": "Win32 clang",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE",
+                "GEN_TIME",
+                "GEN_IMPLEMENTATION",
+                // "GEN_DONT_USE_NAMESPACE"
+                "GEN_INTELLISENSE_DIRECTIVES",
+                "INTELLISENSE_DIRECTIVES"
             ],
             "windowsSdkVersion": "10.0.19041.0",
             "compilerPath": "C:/Users/Ed/scoop/apps/llvm/current/bin/clang++.exe",
             "intelliSenseMode": "windows-clang-x64",
+            "compileCommands": "${workspaceFolder}/project/build/compile_commands.json"
         }
     ],
     "version": 4

.vscode/launch.json

@@ -8,9 +8,9 @@
 			"type": "lldb",
 			"request": "launch",
 			"name": "Debug gentime lldb",
-			"program": "${workspaceFolder}/test/gen/build/gencpp.exe",
+			"program": "${workspaceFolder}/test/test.exe",
 			"args": [],
-			"cwd": "${workspaceFolder}/test/gen/",
+			"cwd": "${workspaceFolder}/test/",
 			"postRunCommands": [
 			]
 		},
@@ -18,9 +18,54 @@
 			"type": "cppvsdbg",
 			"request": "launch",
 			"name": "Debug gentime vsdbg",
-			"program": "${workspaceFolder}/test/gen/build/gencpp.exe",
+			"program": "${workspaceFolder}/test/build/test.exe",
 			"args": [],
-			"cwd": "${workspaceFolder}/test/gen/",
+			"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/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug singleheader vsdbg",
+			"program": "${workspaceFolder}/singleheader/build/gencpp_singleheader.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/singleheader/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug unreal vsdbg",
+			"program": "${workspaceFolder}/unreal_engine/build/unreal.exe",
+			"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"
 		}
 	]

.vscode/settings.json

@@ -18,11 +18,41 @@
 		"algorithm": "cpp",
 		"limits": "cpp",
 		"concepts": "cpp",
-		"*.rh": "cpp"
+		"*.rh": "cpp",
+		"chrono": "cpp",
+		"string": "cpp",
+		"filesystem": "cpp",
+		"format": "cpp",
+		"ratio": "cpp",
+		"xstring": "cpp",
+		"functional": "cpp",
+		"vector": "cpp",
+		"list": "cpp",
+		"xhash": "cpp",
+		"glfw3.h": "c",
+		"stdbool.h": "c",
+		"objbase.h": "c",
+		"mmreg.h": "c",
+		"mmsystem.h": "c",
+		"propidl.h": "c",
+		"android_native_app_glue.h": "c",
+		"raylib.h": "c",
+		"*.m": "cpp",
+		"atomic": "cpp",
+		"gen.h": "c",
+		"string_ops.hpp": "c"
 	},
 	"C_Cpp.intelliSenseEngineFallback": "disabled",
 	"mesonbuild.configureOnOpen": true,
-	"C_Cpp.errorSquiggles": "enabled",
+	"C_Cpp.errorSquiggles": "disabled", // This doesn't work well with how the headers are included.
 	"godot_tools.scene_file_config": "",
-	"C_Cpp.default.compilerPath": "cl.exe"
+	"C_Cpp.default.compilerPath": "cl.exe",
+	"C_Cpp.exclusionPolicy": "checkFilesAndFolders",
+	"C_Cpp.files.exclude": {
+		"**/.vscode": true,
+		"**/.vs": true,
+		"**/sanity.gen.hpp": true
+	},
+	"autoHide.autoHidePanel": false,
+	"autoHide.autoHideSideBar": false
 }

Readme.md

@@ -5,43 +5,25 @@ An attempt at simple staged metaprogramming for c/c++.
 The library API is a composition of code element constructors.  
 These build up a code AST to then serialize with a file builder.
 
-### TOC
+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.  
-* [Notes](#notes)
-* [Usage](#usage)
-* [Building](#notes)
-* [Outline](#outline)
-* [What is not provided](#what-is-not-provided)
-* [The four constructors](#there-are-four-sets-of-interfaces-for-code-ast-generation-the-library-provides)
-* [Predefined Codes](#predefined-codes)
-* [Code generation and modification](#code-generation-and-modification)
-* [On multithreading](#on-multi-threading)
-* [Extending the library](#extending-the-library)
-* [TODO](#todo)
-* [Thoughts](#thoughts)
 
 ## Notes
 
-The project has reached an *alpha* state, all the current functionality works for the test cases but it will most likely break in many other cases.
+**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.
 
-The project has no external dependencies beyond:
+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.
 
-* `stdarg.h`
+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.
-* `stddef.h`
-* `stdio.h`
-* `errno.h`
-* `unistd.h` (Linux/Mac)
-* `intrin.h` (Windows)
-* `windows.h` (Windows)
 
-Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).  
+A `natvis` and `natstepfilter` are provided in the scripts directory (its outdated, I'll update this readme when its not).
-The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
-
-A `natvis` and `natstepfilter` are provided in the scripts directory.
 
 ***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 haven't gotten headwind on it, should be easier to make than this...
+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...
 
 ## Usage
 
@@ -49,7 +31,7 @@ A metaprogram is built to generate files before the main program is built. We'll
 
 `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.
 
-In order to keep the locality of this code within the same files the following pattern may be used:
+In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't required at all):
 
 Within `program.cpp` :
 
@@ -65,6 +47,8 @@ u32 gen_main()
 }
 #endif
 
+// "Stage" agnostic code.
+
 #ifndef GEN_TIME
 #include "program.gen.cpp"
 
@@ -74,15 +58,16 @@ u32 gen_main()
 ```
 
 The design uses a constructive builder API for the code to generate.  
-The user is given `Code` objects that are used to build up the AST.
+The user is provided `Code` objects that are used to build up the AST.
 
 Example using each construction interface:
 
 ### Upfront
 
+Validation and construction through a functional interface.
 
 ```cpp
-Code t_uw           = def_type( name(uw) );
+Code t_uw           = def_type( name(usize) );
 Code t_allocator    = def_type( name(allocator) );
 Code t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
 
@@ -99,12 +84,14 @@ Code header;
 
 ### Parse
 
+Validation through ast construction.
+
 ```cpp
 Code header = parse_struct( code(
     struct ArrayHeader
     {
-        uw        Num;
+        usize        Num;
-        uw        Capacity;
+        usize        Capacity;
         allocator Allocator;
     };
 ));
@@ -113,601 +100,38 @@ Code header = parse_struct( code(
 
 ### Untyped
 
+No validation, just glorified text injection.
+
 ```cpp
-Code header = untyped_str( code(
+Code header = code_str(
     struct ArrayHeader
     {
-        uw        Num;
+        usize        Num;
-        uw        Capacity;
+        usize        Capacity;
         allocator Allocator;
     };
-));
+);
 ```
 
 `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> ))`
 
 All three constrcuton interfaces will generate the following C code:
 
 ```cpp
 struct ArrayHeader
 {
-    uw        Num;
+    usize        Num;
-    uw        Capacity;
+    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.**
+*(The library currently uses clang-format for formatting, beware its pretty slow...)*
 
 ## Building
 
-An example of building is provided in the test directory.
+See the [scripts directory](scripts/).
-
-There are two meson build files the one within test is the program's build specification.  
-The other one in the gen directory within test is the metaprogram's build specification.
-
-Both of them build the same source file: `test.cpp`. The only differences are that gen needs a different relative path to the include directories and defines the macro definition: `GEN_TIME`.
-
-This method is setup where all the metaprogram's code are the within the same files as the regular program's code.  
-
-## Outline
-
-### *WHAT IS NOT PROVIDED*
-
-* Lambdas
-* Lang provided dynamic dispatch (virtuals) : `override` and `final` specifiers complicate the specifier parsing and serialization. (Its a todo)
-* Suffix specifiers for functions (Ex: void() const ). Same reason as virtual/override/final missing for now.
-* RTTI
-* Exceptions
-* Execution statement validation              : Execution expressions are defined using the untyped API.
-* Parsing support for module specifiers and attributes. (Its a todo)
-
-Keywords kept from "Modern C++":
-
-* constexpr : Great to store compile-time constants.
-* consteval : Technically fine, need to make sure to execute in moderation.
-* constinit : Better than constexpr at doing its job, however, its only c++ 20.
-* export    : Useful if c++ modules ever come around to actually being usable.
-* import    : ^^
-* module    : ^^
-
-When it comes to expressions:
-
-**There is no support for validating expressions.**  
-**The reason:** Its difficult to parse without enough benefits.  
-Most of the time, the critical complex metaprogramming conundrums are producing the frame of abstractions around the expressions (which this library provides constructors to help validate, you can skip that process by using the untyped constructors).  
-Its not a priority to add such a level of complexity to the library when there isn't a high reward or need for it.  
-Especially when the priority is to keep this library small and easy to grasp for what it is.
-
-When it comes to templates:
-
-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 usage is non-trivial substitution.*
-
-### The Data & Interface
-
-As mentioned in [Usage](#usage), the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
-
-The AST is managed by the library and provided the user via its interface.  
-However, the user may specifiy memory configuration.
-
-Data layout of AST struct:
-
-```cpp
-union {
-    struct
-    {
-        AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
-        AST*      Specs;          // Function, Operator, Type symbol, Variable
-        union {
-            AST*  ParentType;     // Class, Struct
-            AST*  ReturnType;     // Function, Operator
-            AST*  UnderlyingType; // Enum, Typedef
-            AST*  ValueType;      // Parameter, Variable
-        };
-        AST*      Params;         // Function, Operator, Template
-        union {
-            AST*  ArrExpr;        // Type Symbol
-            AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
-            AST*  Declaration;    // Friend, Template
-            AST*  Value;          // Parameter, Variable
-        };
-    };
-    StringCached  Content;        // Attributes, Comment, Execution, Include
-    SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
-};
-union {
-    AST* Prev;
-    AST* Front; // Used by CodeBody
-    AST* Last;  // Used by CodeParam
-};
-union {
-    AST* Next;
-    AST* Back;  // Used by CodeBody
-};
-AST*              Parent;
-StringCached      Name;
-CodeT             Type;
-ModuleFlag        ModuleFlags;
-union {
-    OperatorT     Op;
-    AccessSpec    ParentAccess;
-    s32           NumEntries;
-};
-```
-
-*`CodeT` is a typedef for `ECode::Type` which 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*
-
-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
-uw ArrSpecs_Cap =
-(
-        AST_POD_Size
-        - sizeof(AST*) * 3
-        - sizeof(StringCached)
-        - sizeof(CodeT)
-        - sizeof(ModuleFlag)
-        - sizeof(s32)
-)
-/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
-```
-
-*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
-
-Data Notes:
-
-* The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `gen_string_allocator`, `get_cached_string`, `make_code`.
-* 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.
-* 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.
-* 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.
-* When benchmarking, the three most significant var to tune are:
-  * `Global_BlockSize` (found gen_dep.hpp) : Used by the GlobalAllocator for the size of each global arena.
-  * `SizePer_StringArena` (found in gen.hpp under the constants region) : Used by the string cache to store strings.
-  * `CodePool_NumBlocks` (found in gen.hpp under constants region) : Used by code pool to store ASTs.
-  * The default values can handled generating for a string up to a size of ~650 kbs (bottleneck is serialization).
-  * Increasing the values can generate files upwards of over a million lines without issue (the formatter will most likely run slower than it)
-
-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.
-
-Otherwise the library is free of any templates.
-
-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.
-* CodeAttributes
-* CodeComment
-* CodeClass
-* CodeEnum
-* CodeExec
-* CodeExtern
-* CodeInclude
-* CodeFriend
-* CodeFn
-* CodeModule
-* CodeNamespace
-* CodeOperator
-* CodeOpCast
-* CodeParam : Has support for `for-range` iterating across parameters.
-* CodeSpecifier : Has support for `for-range` iterating across specifiers.
-* CodeStruct
-* CodeTemplate
-* CodeType
-* CodeTypedef
-* CodeUnion
-* CodeUsing
-* CodeUsingNamespace
-* CodeVar
-
-Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
-Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
-Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
-
-## There are three sets of interfaces for Code AST generation the library provides
-
-* Upfront
-* Parsing
-* Untyped
-
-### Upfront Construction
-
-All component ASTs must be previously constructed, and provided on creation of the code AST.
-The construction will fail and return Code::Invalid otherwise.
-
-Interface :``
-
-* def_attributes
-  * *This is pre-appended right before the function symbol, or placed after the class or struct keyword for any flavor of attributes used.*
-  * *Its up to the user to use the desired attribute formatting: `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU).*
-* def_comment
-* def_class
-* def_enum
-* def_execution
-  * *This is equivalent to untyped_str, except that its intended for use only in execution scopes.*
-* def_extern_link
-* def_friend
-* def_function
-* def_include
-* def_module
-* def_namespace
-* def_operator
-* def_operator_cast
-* def_param
-* def_params
-* def_specifier
-* def_specifiers
-* def_struct
-* def_template
-* def_type
-* def_typedef
-* def_union
-* def_using
-* def_using_namespace
-* def_variable
-
-Bodies:
-
-* def_body
-* def_class_body
-* def_enum_body
-* def_export_body
-* def_extern_link_body
-* def_function_body
-  * *Use this for operator bodies as well*
-* def_global_body
-* def_namespace_body
-* def_struct_body
-* def_union_body
-
-Usage:
-
-```cpp
-<name> = def_<function type>( ... );
-
-Code <name>
-{
-    ...
-    <name> = def_<function 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 ));
-
-// instead of:
-def_global_body( 3, ht_entry, array_ht_entry, hashtable );
-```
-
-If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.  
-When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
-
-### Parse construction
-
-A string provided to the API is parsed for the intended language construct.
-
-Interface :
-
-* parse_class
-* parse_enum
-* parse_export_body
-* parse_extern_link
-* parse_friend
-  * Purposefully are only support forward declares with this constructor.
-* parse_function
-* parse_global_body
-* parse_namespace
-* parse_operator
-* parse_operator_cast
-* parse_struct
-* parse_template
-* parse_type
-* parse_typedef
-* parse_union
-* parse_using
-* parse_variable
-
-The lexing and parsing takes shortcuts from whats expected in the standard.
-
-* Numeric literals are not check for validity.
-* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
-  * *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 in the usual spot for class, structs, (*right after the declaration keyword*)
-  * typedefs have attributes with the type (`parse_type`)
-* As a general rule; if its not available from the upfront constructors, its not available in the parsing constructors.
-  * *Upfront constructors are not necessarily used in the parsing constructors, this is just a good metric to know what can be parsed.*
-
-Usage:
-
-```cpp
-Code <name> = parse_<function name>( string with code );
-
-Code <name> = def_<function name>( ..., parse_<function name>(
-    <string with code>
-));
-
-Code <name> = make_<function name>( ... )
-{
-    <name>->add( parse_<function name>(
-        <string with code>
-    ));
-}
-```
-
-### Untyped constructions
-
-Code ASTs are constructed using unvalidated strings.
-
-Interface :
-
-* token_fmt_va
-* token_fmt
-* untyped_str
-* 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.  
-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.
-* Untyped code can only be a child of a parent of body AST, or for values of an assignment (ex: variable assignment).
-
-These restrictions help prevent abuse of untyped code to some extent.
-
-Usage Conventions:
-
-```cpp
-Code <name> = def_variable( <type>, <name>, untyped_<function name>(
-    <string with code>
-));
-
-Code <name> = untyped_str( code(
-    <some code without "" quotes>
-));
-```
-
-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 > )
-```
-
-Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
-
-```cpp
-StrC value = txt_StrC("Something");
-
-char const* template_str = txt(
-    Code with <key> to replace with token_values
-    ...
-);
-char const* gen_code_str = token_fmt( "key", value, template_str );
-Code        <name>       = parse_<function name>( gen_code_str );
-```
-
-## Predefined Codes
-
-The following are provided predefined by the library as they are commonly used:
-
-* `access_public`
-* `access_protected`
-* `access_private`
-* `module_global_fragment`
-* `module_private_fragment`
-* `pragma_once`
-* `spec_const`
-* `spec_consteval`
-* `spec_constexpr`
-* `spec_constinit`
-* `spec_extern_linkage` (extern)
-* `spec_global` (global macro)
-* `spec_inline`
-* `spec_internal_linkage` (internal macro)
-* `spec_local_persist` (local_persist macro)
-* `spec_mutable`
-* `spec_ptr`
-* `spec_ref`
-* `spec_register`
-* `spec_rvalue`
-* `spec_static_member` (static)
-* `spec_thread_local`
-* `spec_volatile`
-* `spec_type_signed`
-* `spec_type_unsigned`
-* `spec_type_short`
-* `spec_type_long`
-* `t_auto`
-* `t_void`
-* `t_int`
-* `t_bool`
-* `t_char`
-* `t_wchar_t`
-* `t_class`
-* `t_typename`
-
-Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` is defined
-
-* `t_b32`
-* `t_s8`
-* `t_s16`
-* `t_s32`
-* `t_s64`
-* `t_u8`
-* `t_u16`
-* `t_u32`
-* `t_u64`
-* `t_sw`
-* `t_uw`
-* `t_f32`
-* `t_f64`
-
-## Extent of operator overload validation
-
-The AST and constructors will be able to validate that the arguments provided for the operator type match the expected form:
-
-* If return type must match a parameter
-* If number of parameters is correct
-* If added as a member symbol to a class or struct, that operator matches the requirements for the class (types match up)
-
-The user is responsible for making sure the code types provided are correct
-and have the desired specifiers assigned to them beforehand.
-
-## Code generation and modification
-
-There are three provided file 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
-
-* The purpose of it is to generate a file.
-* A file is specified and opened for writing using the open( file_path) ) function.
-* The code is provided via print( code ) function  will be serialized to its buffer.
-* When all serialization is finished, use the write() command to write the buffer to the file.
-
-### Editor is for editing a series of files based on a set of requests provided to it
-
-**Note: Not implemented yet**
-
-* The purpose is to overrite a specific file, it places its contents in a buffer to scan.
-* Requests are populated using the following interface:
-  * add : Add code.
-  * remove : Remove code.
-  * replace: Replace code.
-
-All three have the same parameters with exception to remove which only has SymbolInfo and Policy:
-
-* SymbolInfo:
-  * File      : The file the symbol resides in. Leave null to indicate to search all files. Leave null to indicated all-file search.
-  * Marker    : #define symbol that indicates a location or following signature is valid to manipulate. Leave null to indicate the signature should only be used.
-  * Signature : Use a Code symbol to find a valid location to manipulate, can be further filtered with the marker. Leave null to indicate the marker should only be used.
-
-* Policy : Additional policy info for completing the request (empty for now)
-* Code   : Code to inject if adding, or replace existing code with.
-
-Additionally if `GEN_FEATURE_EDITOR_REFACTOR` is defined, refactor( file_path, specification_path ) wil be made available.  
-Refactor is based of the refactor library and uses its interface.  
-It will on call add a request to the queue to run the refactor script on the file.
-
-### Scanner allows the user to generate Code ASTs by reading files
-
-**Note: Not implemented yet**
-
-* The purpose is to grab definitions to generate metadata or generate new code from these definitions.
-* Requests are populated using the add( SymbolInfo, Policy ) function. The symbol info is the same as the one used for the editor. So is the case with Policy.
-
-The file will only be read from, no writing supported.
-
-One great use case is for example: generating the single-header library for gencpp!
-
-### Additional Info (Editor and Scanner)
-
-When all requests have been populated, call process_requests().  
-It will provide an output of receipt data of the results when it completes.
-
-Files may be added to the Editor and Scanner additionally with add_files( num, files ).  
-This is intended for when you have requests that are for multiple files.
-
-Request queue in both Editor and Scanner are cleared once process_requests completes.
-
-## On multi-threading
-
-Currently unsupported. The following changes would have to be made:
-
-* Setup static data access with fences if more than one thread will generate ASTs ( or keep a different set for each thread)
-* Make sure local persistent data of functions are also thread local.
-* The builder should be done on a per-thread basis.
-* Due to the design of the editor and scanner, it will most likely be best to make each file a job to process request entries on. Receipts should have an an array to store per thread. They can be combined to the final receipts array when all files have been processed.
-
-## Extending the library
-
-This library is relatively very small, and can be extended without much hassle.
-
-The untyped codes and builder/editor/scanner can be technically be used to circumvent
-any sort of constrictions the library has with: modern c++, templates, macros, etc.
-
-Typical use case is for getting define constants an old C/C++ library with the scanner:  
-Code parse_defines() can emit a custom code AST with Macro_Constant type.
-
-Another would be getting preprocessor or template metaprogramming Codes from Unreal Engine definitions, etc.
-
-The rules for constructing the AST are largely bound the syntax rules for what can be composed with whichever version of C++ your targeting.
-
-The convention you'll see used throughout the API 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_string`, 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 constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
-
-# TODO
-
-* Support defining & parsing full definitions inside a typedef. (For C patterns)
-* Support module and attribute parsing (Marked with TODOs for now..)
-* Implement a context stack for the parsing, allows for accurate scope validation for the AST types.
-* Trailing specifiers ( postfix ) for functions (const, override, final)
-* Make a more robust test suite.
-* Generate a single-header library
-  * Componetize the library, make a metaprogram using gencpp to bootstrap itself.
-* Implement the Scanner
-* Implement the Editor
-* Should the builder be an "extension" header?
-  * Technically the library doesn't require it and the user can use their own filesystem library.
-  * It would allow me to remove the filesystem dependencies and related functions outside of gen base headers. ( At least 1k loc reduced )
-  * ADT and the CSV parser depend on it as well. The `str_fmt_file` related functions do as well but they can be ommited.
-  * Scanner and editor will also depend on it so they would need to include w/e the depency header for all three file-interacting interfaces.
-    * `gen.dep.files.hpp`
-* Convert GlobalAllocator to a slab allocator:
-
-```md
-Slab classes (for 10 mb arena)
-
-1KB   slab: 5MB  ( 5MB  / 1KB   ~ 5,000 blocks )
-4KB   slab: 10MB ( 10MB / 4KB   ~ 2,500 blocks )
-16KB  slab: 15MB ( 15MB / 16KB  ~ 960 blocks   )
-64KB  slab: 15MB ( 15MB / 64KB  ~ 240 blocks   )
-256KB slab: 20MB ( 20MB / 256KB ~ 80 blocks    )
-512KB slab: 20MB ( 20MB / 512KB ~ 40 blocks    )
-1MB   slab: 15MB ( 15MB / 1MB   ~ 15 blocks    )
-```

docs/AST_Design.md

@@ -0,0 +1,44 @@
+## 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*`, I wanted to provide a wrapper for it.
+
+The simpliest being just a type alias.
+
+```cpp
+using Code = AST*;
+```
+
+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.
+
+```cpp
+using struct AST_Typedef CodeTypedef;
+```
+
+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 redesign will occur after the following todos are addressed:
+
+* [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)
+

docs/AST_Types.md

@@ -0,0 +1,737 @@
+# 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:
+
+* Class_Body
+* Enum_Body
+* Export_Body
+* Extern_Linkage_Body
+* Function_Body
+* Global_Body
+* Namespace_Body
+* Struct_Body
+* Union_Body
+
+Fields:
+
+```cpp
+Code           Front;
+Code           Back;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+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.
+
+Serialization:
+
+Will output only the entries, the braces are handled by the parent.
+
+```cpp
+<Front>...
+<Back>
+```
+
+## Attributes
+
+Represent standard or vendor specific C/C++ attributes.
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+<Content>
+```
+
+While the parser supports the `__declspec` and `__attribute__` syntax, the upfront constructor ( def_attributes ) must have the user specify the entire attribute, including the `[[]]`, `__declspec` or `__attribute__` parts.
+
+## Comment
+
+Stores a comment.
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+<Content>
+```
+
+The parser will perserve comments found if residing with a body or in accepted inline-to-definition locations.
+Otherwise they will be skipped by the TokArray::__eat and TokArray::current( skip foramtting enabled ) functions.
+
+The upfront constructor: `def_comment` expects to recieve a comment without the `//` or `/* */` parts. It will add them during construction.
+
+## Class & Struct
+
+Fields:
+
+```cpp
+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;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+AccessSpec     ParentAccess;
+```
+
+Serialization:
+
+```cpp
+// Class_Fwd
+<ModuleFlags> <class/struct> <Name>; <InlineCmt>
+
+// Class
+<ModuleFlags> <class/struct> <Attributes> <Name> : <ParentAccess> <ParentType>, public <ParentType->Next>, ... <InlineCmt>
+{
+    <Body>
+};
+```
+
+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.
+
+## Constructor
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;  // Only supported by forward declarations
+Code           InitializerList;
+CodeParam      Params;
+Code           Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+// Constructor_Fwd
+<Specs> <Parent->Name>( <Params> ); <InlineCmt>
+
+// Constructor
+<Specs> <Parent->Name>( <Params> ) <InlineCmt>
+    : <InitializerList>
+{
+    <Body>
+}
+
+// Constructor Source Implementation
+<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
+{
+    <Body>
+}
+```
+
+## Define
+
+Represents a preprocessor define
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+#define <Name> <Content>
+```
+
+## Destructor
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeSpecifiers Specs;
+Code           Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+// Destructor_Fwd
+<Specs> ~<Parent->Name>( <Params> ) <Specs>; <InlineCmt>
+
+// Destructor
+<Specs> ~<Parent->Name>( <Params> ) <Specs>
+{
+    <Body>
+}
+
+// Destructor Source Implementation
+<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
+{
+    <Body>
+}
+```
+
+## Enum
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeAttributes Attributes;
+CodeType       UnderlyingType;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+// Enum_Fwd
+<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>
+
+// Enum
+<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>
+{
+    <Body>
+};
+```
+
+## Execution
+
+Just represents an execution body. Equivalent to an untyped body.
+Will be obsolute when function body parsing is implemented.
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+<Content>
+```
+
+## External Linkage
+
+Fields:
+
+```cpp
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+extern "<Name>"
+{
+    <Body>
+}
+```
+
+## Include
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+Code           Parent;
+parser::Token* Tok;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+#include <Content>
+```
+
+## Friend
+
+This library (until its necessary become some third-party library to do otherwise) does not support friend declarations with in-statment function definitions.
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+friend <Declaration>; <InlineCmt>
+```
+
+## Function
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeAttributes Attributes;
+CodeSpecifiers Specs;
+CodeType       ReturnType;
+CodeParam      Params;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+// Function_Fwd
+<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>; <InlineCmt>
+
+// Function
+<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>
+{
+    <Body>
+}
+```
+
+## Module
+
+Fields:
+
+```cpp
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+<ModuleFlags> module <Name>;
+```
+
+## Namespace
+
+Fields:
+
+```cpp
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+<ModuleFlags> namespace <Name>
+{
+    <Body>
+}
+```
+
+## Operator Overload
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeAttributes Attributes;
+CodeSpecifiers Specs;
+CodeType       ReturnType;
+CodeParam      Params;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+OperatorT      Op;
+```
+
+Serialization:
+
+```cpp
+// Operator_Fwd
+<ModuleFlags> <Attributes> <Specs> <ReturnType> operator <Op>( <Params> ) <Specs>; <InlineCmt>
+
+// Operator
+<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>operator <Op>( <Params> ) <Specs>
+{
+    <Body>
+}
+```
+
+## Operator Cast Overload ( User-Defined Type Conversion )
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeSpecifiers Specs;
+CodeType       ValueType;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+// Operator_Cast_Fwd
+<Specs> operator <ValueType>() <Specs>; <InlineCmt>
+
+// Operator_Cast
+<Specs> <Name>operator <ValueType>() <Specs>
+{
+    <Body>
+}
+```
+
+## Parameters (AST_Param)
+
+Fields:
+
+```cpp
+CodeType       ValueType;
+Code           Macro;
+Code           Value;
+CodeParam      Last;
+CodeParam      Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
+```
+
+Serialization:
+
+```cpp
+<Macro>, <Next> ... <Last>
+
+<Macro> <ValueType> <Name>, <Next>... <Last>
+```
+
+## Pragma
+
+Fields:
+
+```cpp
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+```
+
+Serialization:
+
+```cpp
+#pragma <Content>
+```
+
+## Preprocessor Conditional
+
+Fields:
+
+```cpp
+StringCached  Content;
+Code          Prev;
+Code          Next;
+paser::Token* Tok;
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
+```
+
+Serialization:
+
+```cpp
+#<based off Type> <Content>
+```
+
+## Specifiers
+
+Fields:
+
+```cpp
+SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
+CodeSpecifiers NextSpecs;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
+```
+
+Serialization:
+
+```cpp
+<Spec>, ...
+```
+
+## Template
+
+Fields:
+
+```cpp
+CodeParam      Params;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+<ModuleFlags>
+template< <Params> >
+<Declaration>
+```
+
+## Typename
+
+Typenames represent the type "symbol".
+
+Fields:
+
+```cpp
+CodeAttributes Attributes;
+CodeSpecifiers Specs;
+CodeReturnType ReturnType;
+CodeParam      Params;
+Code           ArrExpr;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+b32            IsParamPack;
+```
+
+Serialization:
+
+```cpp
+<Attributes> <Name> <Specs> <IsParamPack ?: ...>
+```
+
+## Typedef
+
+Behave as usual except function or macro typedefs.  
+Those (macros) don't use the underlying type field as everything was serialized under the Name field.
+
+Fields:
+
+```cpp
+CodeComment   InlineCmt;
+Code          UnderlyingType;
+Code          Prev;
+Code          Next;
+parse::Token* Tok
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
+ModuleFlag    ModuleFlags;
+b32           IsFunction;
+```
+
+Serialization:
+
+```cpp
+// Regular
+<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>
+
+// Functions
+<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
+<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
+```
+
+## Union
+
+Fields:
+
+```cpp
+CodeAttributes Attributes;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+<ModuleFlags> union <Attributes> <Name>
+{
+    <Body>
+}
+```
+
+## Using
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeAttributes Attributes;
+CodeType       UnderlyingType;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+// Regular
+<ModuleFlags> using <Attributes> <Name> = <UnderlyingType>; <InlineCmt>
+
+// Namespace
+<ModuleFlags> using namespace <Name>; <InlineCmt>
+```
+
+## Variable
+
+[Algo](./Parser_Algo.md:)
+
+Fields:
+
+```cpp
+CodeComment    InlineCmt;
+CodeAttributes Attributes;
+CodeSpecifiers Specs;
+CodeType       ValueType;
+Code           BitfieldSize;
+Code           Value;
+CodeVar        NextVar;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
+```
+
+Serialization:
+
+```cpp
+// Regular
+<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> = <Value>, NextVar ...; <InlineCmt>
+
+// Bitfield
+<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
+```

docs/Parser_Algo.md

@@ -0,0 +1,702 @@
+# 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.
+
+## Notable implementation background
+
+### 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`.
+
+Fields:
+
+```cpp
+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.
+
+Tokens are defined with the struct `gen::parser::Token`:
+
+Fields:
+
+```cpp
+char const* Text;
+sptr        Length;
+TokType     Type;
+s32         Line;
+s32         Column;
+u32         Flags;
+```
+
+Flags is a bitfield made up of TokFlags (Token Flags):
+
+* `TF_Operator` : Any operator token used in expressions
+* `TF_Assign`
+  * Using statment assignment
+  * Parameter argument default value assignment
+  * Variable declaration initialization assignment
+* `TF_Preprocess` : Related to a preprocessing directive
+* `TF_Preprocess_Cond` : A preprocess conditional
+* `TF_Attribute` : An attribute token
+* `TF_AccessSpecifier` : An accesor operation token
+* `TF_Specifier` : One of the specifier tokens
+* `TF_EndDefinition` : Can be interpreted as an end definition for a scope.
+* `TF_Formatting` : Considered a part of the formatting
+* `TF_Literal` : Anything considered a literal by C++.
+
+I plan to replace IsAssign with a general flags field and properly keep track of all operator types instead of abstracting it away to `ETokType::Operator`.
+
+Traversing the tokens is done with the following interface macros:
+
+| Macro | Description |
+| --- | --- |
+| `currtok_noskip` | Get the current token without skipping whitespace |
+| `currtok` | Get the current token, skip any whitespace tokens |
+| `prevtok` | Get the previous token (does not skip whitespace) |
+| `nexttok` | Get the next token (does not skip whitespace) |
+| `eat( Token Type )` | Check to see if the current token is of the given type, if so, advance Token's index to the next token |
+| `left` | Get the number of tokens left in the token array |
+| `check_noskip` | Check to see if the current token is of the given type, without skipping whitespace |
+| `check` | Check to see if the current token is of the given type, skip any whitespace tokens |
+
+### Parser
+
+The parser has a limited user interface, only specific types of definitions or statements are expected to be provided by the user directly when using to construct an AST dynamically (See SOA for example). It however does attempt to provide capability to parse a full C/C++ from production codebases.
+
+Each public user interface procedure has the following format:
+
+```cpp
+<code type> parse_<definition type>( StrC def )
+{
+    check_parse_args( def );
+    using namespace Parser;
+
+    TokArray toks = lex( def );
+    if ( toks.Arr == nullptr )
+        return CodeInvalid;
+
+    // Parse the tokens and return a constructed AST using internal procedures
+    ...
+}
+```
+
+The most top-level parsing procedure used for C/C++ file parsing is `parse_global_body`:
+
+It uses a helper procedure called `parse_global_nspace`.
+
+Each internal procedure will have the following format:
+
+```cpp
+internal
+<code type> parse_<definition_type>( <empty or contextual params> )
+{
+    push_scope();
+
+    ...
+
+    <code type> result = (<code type>) make_code();
+    ...
+
+    Context.pop();
+    return result;
+}
+```
+
+Below is an outline of the general alogirithim used for these internal procedures. The intention is to provide a basic briefing to aid the user in traversing the actual code definitions. These appear in the same order as they are in the `parser.cpp` file
+
+***NOTE: This is still heavily in an alpha state. A large swaph of this can change, make sure these docs are up to date before considering them 1:1 with the repo commit your considering.***
+
+## `parse_array_decl`
+
+1. Check if its an array declaration with no expression.
+    1. Consume and return empty array declaration
+2. Opening square bracket
+3. Consume expression
+4. Closing square bracket
+5. If adjacent opening bracket
+    1. Repeat array declaration parse until no brackets remain
+
+## `parse_assignment_expression`
+
+1. Eat the assignment operator
+2. Make sure there is content or at least an end statement after.
+3. Flatten the assignment expression to an untyped Code string.
+
+## `parse_attributes`
+
+1. Check for standard attribute
+2. Check for GNU attribute
+3. Check for MSVC attribute
+4. Check for a token registered as an attribute
+  a. Check and grab the arguments of a token registered of an attribute if it has any.
+5. Repeat for chained attributes. Flatten them to a single attribute AST node.
+
+## `parse_class_struct`
+
+1. Check for export module specifier
+2. class or struct keyword
+3. `parse_attributes`
+4. If identifier : `parse_identifier`
+5. Parse inherited parent or interfaces
+6. If opening curly brace : `parse_class_struct_body`
+7. If not an inplace definition
+    1. End statement
+    2. Check for inline comment
+
+## `parse_class_struct_body`
+
+1. Opening curly brace
+2. Parse the body (Possible options):
+    1. Ignore dangling end statements
+    2. Newline : ast constant
+    3. Comment : `parse_comment`
+    4. Access_Public : ast constant
+    5. Access_Protected : ast constant
+    6. Access_Private : ast constant
+    7. Decl_Class : `parse_complicated_definition`
+    8. Decl_Enum : `parse_complicated_definition`
+    9. Decl_Friend : `parse_friend`
+    10. Decl_Operator : `parse_operator_cast`
+    11. Decl_Struct : `parse_complicated_definition`
+    12. Decl_Template : `parse_template`
+    13. Decl_Typedef : `parse_typedef`
+    14. Decl_Union : `parse_complicated_definition`
+    15. Decl_Using : `parse_using`
+    16. Operator == '~'
+        1. `parse_destructor`
+    17. Preprocess_Define : `parse_define`
+    18. Preprocess_Include : `parse_include`
+    19. Preprocess_Conditional (if, ifdef, ifndef, elif, else, endif) : `parse_preprocess_cond` or else/endif ast constant
+    20. Preprocess_Macro : `parse_simple_preprocess`
+    21. Preprocess_Pragma : `parse_pragma`
+    22. Preprocess_Unsupported : `parse_simple_preprocess`
+    23. StaticAssert : `parse_static_assert`
+    24. The following compound into a resolved definition or declaration:
+        1. Attributes (Standard, GNU, MSVC) : `parse_attributes`
+        2. Specifiers (consteval, constexpr, constinit, explicit, forceinline, inline, mutable, neverinline, static, volatile, virtual)
+        3. Possible Destructor : `parse_destructor`
+        4. Possible User defined operator cast : `parse_operator_cast`
+        5. Possible Constructor : `parse_constructor`
+        6. Something that has the following: (identifier, const, unsigned, signed, short, long, bool, char, int, double)
+            1. Possible Constructor `parse_constructor`
+            2. Possible Operator, Function, or varaible : `parse_operator_function_or_variable`
+    25. Something completely unknown (will just make untyped...) : `parse_untyped`
+
+## `parse_comment`
+
+1. Just wrap the token into a cached string ( the lexer did the processing )
+
+## `parse_compilcated_definition`
+
+This is a helper function used by the following functions to help resolve a declaration or definition:
+
+* `parse_class_struct_body`
+* `parse_global_nspace`
+* `parse_union`
+
+A portion of the code in `parse_typedef` is very similar to this as both have to resolve a similar issue.
+
+1. Look ahead to the termination token (End statement)
+2. Check to see if it fits the pattern for a forward declare
+3. If the previous token was an identifier ( `token[-1]` ):
+    1. Look back one more token : `[-2]`
+    2. If the token has a closing brace its an inplace definition
+    3. If the `token[-2]` is an identifier & `token[-3]` is the declaration type, its a variable using a namespaced type.
+    4. If the `token[-2]` is an indirection, then its a variable using a namespaced/forwarded type.
+    5. If the `token[-2]` is an assign classifier, and the starting tokens were the which type with possible `class` token after, its an enum forward declaration.
+    6. If any of the above is the case, `parse_operator_function_or_variable`
+4. If the `token[2]` is a vendor fundamental type (builtin) then it is an enum forward declaration.
+5. If the previous token was a closing curly brace, its a definition : `parse_forward_or_definition`
+6. If the previous token was a closing square brace, its an array definition : `parse_operator_function_or_variable`
+
+## `parse_define`
+
+1. Define directive
+2. Get identifier
+3. Get Content (Optional)
+
+## `parse_forward_or_definition`
+
+* Parse any of the following for either a forward declaration or definition:
+    1. Decl_Class : `parse_class`
+    2. Decl_Enum : `parse_enum`
+    3. Decl_Struct : `parse_struct`
+    4. Decl_Union : `parse_union`
+
+## `parse_function_after_name`
+
+This is needed as a function defintion is not easily resolvable early on, as such this function handles resolving a function
+after its been made ceratin that the type of declaration or definition is indeed for a function signature.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, return type, & name
+
+1. `parse_parameters`
+2. parse postfix specifiers (we do not check if the specifier here is correct or not to be here... yet)
+3. If there is a body : `parse_body`
+4. Otherwise :
+     1. Statment end
+     2. Check for inline comment
+
+## `parse_function_body`
+
+Currently there is no actual parsing of the function body. Any content with the braces is shoved into an execution AST node.
+In the future statements and expressions will be parsed.
+
+1. Open curly brace
+2. Grab all tokens between the brace and the closing brace, shove them in a execution AST node.
+3. Closing curly brace
+
+## `parse_global_nspace`
+
+1. Make sure this is being called for a valid type (namespace, global body, export body, linkage body)
+2. If its not a global body, consume the opening curly brace
+3. Parse the body (Possible options):
+    1. Ignore dangling end statements
+    2. NewLine : ast constant
+    3. Comment : `parse_comment`
+    4. Decl_Cass : `parse_complicated_definition`
+    5. Decl_Enum : `parse_complicated_definition`
+    6. Decl_Extern_Linkage : `parse_extern_link`
+    7. Decl_Namespace : `parse_namespace`
+    8. Decl_Struct : `parse_complicated_definition`
+    9. Decl_Template : `parse_template`
+    10. Decl_Typedef : `parse_typedef`
+    11. Decl_Union : `parse_complicated_definition`
+    12. Decl_Using : `parse_using`
+    13. Preprocess_Define : `parse_define`
+    14. Preprocess_Include : `parse_include`
+    15. Preprocess_If, IfDef, IfNotDef, Elif : `parse_preprocess_cond`
+    16. Preprocess_Else : ast constant
+    17. Preprocess_Endif : ast constant
+    18. Preprocess_Macro : `parse_simple_preprocess`
+    19. Preprocess_Pragma : `parse_pragma`
+    20. Preprocess_Unsupported : `parse_simple_preprocess`
+    21. StaticAssert : `parse_static_assert`
+    22. Module_Export : `parse_export_body`
+    23. Module_Import : NOT_IMPLEMENTED
+    24. The following compound into a resolved definition or declaration:
+        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`
+            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
+
+## `parse_global_nspace_constructor_destructor`
+
+1. Look ahead for the start of the arguments for a possible constructor/destructor
+2. Go back past the identifier
+3. Check to see if its a destructor by checking for the `~`
+4. Continue the next token should be a `::`
+5. Determine if the next valid identifier (ignoring possible template parameters) is the same as the first identifier of the function.
+6. If it is we have either a constructor or destructor so parse using their respective functions (`parse_constructor`, `parse_destructor`).
+
+## `parse_identifier`
+
+This is going to get heavily changed down the line to have a more broken down "identifier expression" so that the qualifier, template args, etc, can be distinguished between the targeted identifier.  
+The function can parse all of them, however the AST node compresses them all into a string.
+
+1. Consume first identifier
+2. `parse_template_args`
+3. While there is a static symbol accessor ( `::` )
+    1. Consume `::`
+    2. Consume member identifier
+    3. `parse_template args` (for member identifier)
+    4. If a `~` is encounted and the scope is for a destructor's identifier, do not consume it and return with what parsed.
+
+## `parse_include`
+
+1. Consume include directive
+2. Consume the path
+
+## `parse_operator_after_ret_type`
+
+This is needed as a operator defintion is not easily resolvable early on, as such this function handles resolving a operator after its been made ceratin that the type of declaration or definition is indeed for a operator signature.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, return type
+
+1. If there is any qualifiers for the operator, parse them
+2. Consume operator keyword
+3. Determine the operator type (This will be offloaded to the lexer moreso than how it is now) & consume
+4. `parse_params`
+5. If there is no parameters this is operator is a member of pointer if its symbols is a *.
+6. Parse postfix specifiers
+7. If there is a opening curly brace, `parse function_body`
+8. Otherwise: consume end statement, check for inline comment.
+
+## `parse_operator_function_or_variable`
+
+When this function is called, attribute and specifiers may have been resolved, however what comes next can still be either an operator, function, or varaible.
+
+1. Check for preprocessor macro, if there is one : `parse_simple_preprocess`
+2. `parse_type` (Does the bulk of the work)
+3. Begin lookahead to see if we get qualifiers or we eventually find the operator declaration
+4. If we find an operator keyword : `parse_operator_after_ret_type`
+5. otherwise :
+    1. `parse_identifier`
+    2. If we se a opening parenthesis (capture start), its a function : `parse_function_after_name`
+    3. Its a variable : `parse_variable_after_name`
+
+## `parse_pragma`
+
+1. Consume pragma directive
+2. Process the token content into cached string
+
+## `parse_params`
+
+1. Consume either a `(` or `<` based on `use_template_capture` arg
+2. If the we immdiately find a closing token, consume it and finish.
+3. If we encounter a varadic argument, consume it and return a `param_varadic` ast constant
+4. `parse_type`
+5. If we have a macro, parse it (Unreal has macros as tags to parameters and or as entire arguments).
+6. So long as next token isn't a comma
+  a. If we have an identifier
+    1. Consume it
+    2. Check for assignment:
+      a. Consume assign operator
+      b. Parse the expression
+7. While we continue to encounter commas
+    a. Consume them
+    b. Repeat steps 3 to 6.2.b
+8. Consume the closing token
+
+## `parse_preprocess_cond`
+
+1. Parse conditional directive
+2. Process directive's content expression
+
+## `parse_simple_preprocess`
+
+There is still decent room for improvement in this setup. Right now the entire macro's relevant tokens are shoved into an untyped AST. It would be better to store it instead in an `AST_Macro` node instead down the line.
+
+1. Consume the macro token
+2. Check for an opening curly brace
+    1. Consume opening curly brace
+    2. Until the closing curly is encountered consume all tokens.
+    3. If the parent context is a typedef
+        1. Check for end stement
+            1. Consume it
+            2. Consume potential inline comment
+3. Otherwise do steps 3 to 3.1.2
+4. Shove it all in an untyped string
+
+## `parse_static_assert`
+
+1. Consume static assert and opening curly brace
+2. Consume all tokens until the the closing brace is reached.
+3. Consume curly brace and end statement
+4. Place all tokens within braces into a content for the assert.
+
+## `parse_template_args`
+
+This will get changed heavily once we have better support for typename expressions
+
+1. Consume opening angle bracket
+2. Consume all tokens until closing angle bracket
+3. Consme closing angle bracket
+4. Return the currtok with the ammended length.
+
+## `parse_variable_after_name`
+
+This is needed as a variable defintion is not easily resolvable early on, it takes a long evaluation period before its known that the declaration or definition is a variable. As such this function handles resolving a variable.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, value type, name
+
+1. If its an assignment, parse the assignment expression (currently to an untyped string)
+2. If its an opening curly brace, parse the expression within (currnelty to an untyped stirng).
+    1. Consume the closing curly brace
+3. If its a `:`, we're dealing with bitfield definition:
+    1. Consume the assign classifier
+    2. Consume the expression (currently to an untyped string)
+4. If a comma is encountered : `parse_variable declaration_list`
+5. Consume statement end
+6. Check for inline comment
+
+## `parse_variable_declaration_list`
+
+1. Consume the comma
+2. Parse specifiers
+3. `parse_variable_after_name`
+
+## `parse_class`
+
+1. `parse_class_struct`
+
+## `parse_constructor`
+
+This currently doesn't support postfix specifiers (planning to in the future)
+
+1. `parse_identifier`
+2. `parse_parameters`
+3. If currtok is a `:`
+    1. Consume `:`
+    2. Parse the initializer list
+    3. `parse_function_body`
+4. If currtok is an opening curly brace
+    1. `parse_function_body`
+5. Otherwise:
+    1. Consume statement end
+    2. Check for inline comment
+
+## `parse_destructor`
+
+1. Check for and consume virtual specifier
+2. Check for the `~` operator
+3. `parse_identifier`
+4. Consume opening and closing parenthesis
+5. Check for assignment operator:
+    1. Consume assignment op
+    2. Consume pure specifier `0`
+6. If not pure virtual & currtok is opening curly brace:
+    1. `parse_function_body`
+7. Otherwise:
+    1. Consume end statement
+    2. If currtok is comment : `parse_comment`
+
+## `parse_enum`
+
+1. Consume enum token
+2. Check for and consume class token
+3. `parse_attributes`
+4. If there is an identifier consume it
+5. Check for a `:`
+    1. Consume `:`
+    2. `parse_type`
+6. If there is a body parse it (Consume `{`):
+    1. Newline : ast constant
+    2. Comment : `parse_comment`
+    3. Preprocess_Define : `parse_define`
+    4. Preprocess_Conditional (if, ifdef, ifndef, elif ) : `parse_preprocess_cond`
+    5. Preprocess_Else : ast constant
+    6. Preprocess_Endif : ast constant
+    7. Preprocess_Macro : `parse_simple_preprocess`
+    8. Preprocess_Pragma : `parse_pragma`
+    9. Preprocess_Unsupported : `parse_smple_preprocess`
+    10. An actual enum entry
+        1. Consume identifier
+        2. If there is an assignment operator:
+            1. Consume operator
+            2. Consume the expression (assigned to untyped string for now)
+            3. If a macro is encountered consume it (Unreal UMETA macro support)
+        3. If there is a comma, consume it
+
+## `parse_export_body`
+
+1. `parse_global_nspace`
+
+## `parse_extern_link_body`
+
+1. `parse_global_nspace`
+
+## `parse_extern_link`
+
+1. Consume Decl_Extern_Linkage
+2. Consume the linkage identifier
+3. `parse_extern_link_body`
+
+## `parse_friend`
+
+1. Consume `friend`
+2. `parse_type`
+3. If the currok is an identifier its a function declaration or definition
+   1. `parse_function_after_name`
+4. Consume end statement so long as its not a function definion
+5. Check for inline comment, `parse_comment` if exists
+
+## `parse_function`
+
+1. Check and parse for `export`
+2. `parse_attributes`
+3. Parse specifiers
+4. `parse_type`
+5. `parse_identifier`
+6. `parse_function_after_name`
+
+## `parse_namespace`
+
+1. Consume namespace declaration
+2. Parse identifier
+3. `parse_global_namespace`
+
+## `parse_operator`
+
+1. Check for and parse export declaration
+2. `parse_attributes`
+3. Parse specifiers
+4. `parse_type`
+5. `parse_operator_after_ret_type`
+
+## `parse_operator_cast`
+
+1. Look for and parse a qualifier namespace for the cast (in-case this is defined outside the class's scope)
+2. Consume operator declaration
+3. `parse_type`
+4. Consume opening and closing parethesis
+5. Check for a const qualifiying specifier
+6. Check to see if this is a definition (`{`)
+    1. Consume `{`
+    2. Parse body to untyped string (parsing statement and expressions not supported yet)
+    3. Consume `}`
+7. Otherwise:
+    1. Consume end statement
+    2. Check for and consume comment : `parse_comment`
+
+
+## `parse_struct`
+
+1. `parse_class_struct`
+
+## `parse_template`
+
+Note: This currently doesn't support templated operator casts (going to need to add support for it)
+
+1. Check for and parse export declaration
+2. Consume template declaration
+3. `parse_params`
+4. Parse for any of the following:
+   1. Decl_Class : `parse_class`
+   2. Decl_Struct : `parse_struct`
+   3. Decl_Union : `parse_union`
+   4. Decl_Using : `parse_using`
+   5. The following compound into a resolved definition or declaration:
+       1. `parse_attributes`
+       2. Parse specifiers
+       3. Attempt to parse as constructor or destructor: `parse_global_nspace_constructor_destructor`
+       4. Otherwise: `parse_operator_function_or_variable`
+
+## `parse_type`
+
+This function's implementation is awful and not done correctly. It will most likely be overhauled in the future as I plan to segement the AST_Type into several AST varaints along with sub-types to help produce robust type expressions.  
+Hopefully I won't need to make authentic type expressions as I was hopeing to avoid that...
+
+### Current Algorithim
+
+Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
+
+1. `parse_attributes`
+2. Parse specifiers
+3. If the `parse_type` was called from a template parse, check to see if class was used instead of typname and consume as name.
+4. This is where things get ugly for each of these depend on what the next token is.
+    1. If its an in-place definition of a class, enum, struct, or union:
+    2. If its a decltype (Not supported yet but draft impl there)
+    3. If its a compound native type expression (unsigned, char, short, long, int, float, dobule, etc )
+    4. Ends up being a regular type alias of an identifier
+5. Parse specifiers (postfix)
+6. We need to now look ahead to see If we're dealing with a function typename
+7. If wer're dealing with a function typename:
+    1. Shove the specifiers, and identifier code we have so far into a return type typename's Name (untyped string)
+        1. Reset the specifiers code for the top-level typeanme
+    2. Check to see if the next token is an identifier:
+        1. `parse_identifier`
+    3. Check to see if the next token is capture start and is not the last capture ("qualifier capture"):
+        1. Consume `(`
+        2. Consume expresssion between capture
+        3. Consume `)`
+    4. `parse_params`
+    5. Parse postfix specifiers
+8. Check for varaidic argument (param pack) token:
+   1. Consume varadic argument token
+
+### WIP - Alternative Algorithim
+
+Currently wrapped up via macro: `GEN_USE_NEW_TYPENAME_PARSING`
+Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
+
+1. `parse_attributes`
+2. Parse specifiers (prefix)
+3. This is where things get ugly for each of these depend on what the next token is.
+    1. If its an in-place definition of a class, enum, struct, or union:
+    2. If its a decltype (Not supported yet but draft impl there)
+    3. If its a compound native type expression (unsigned, char, short, long, int, float, dobule, etc )
+    4. Ends up being a regular type alias of an identifier
+4. Parse specifiers (postfix)
+    1. If any specifiers are found populate specifiers code with them.
+5. We need to now look ahead to see If we're dealing with a function typename
+6. If wer're dealing with a function typename:
+    1. Shove the specifiers, and identifier code we have so far into a return type typename's Name (untyped string)
+        1. Reset the specifiers code for the top-level typename
+    2. Check to see if the next token is an identifier:
+        1. `parse_identifier`
+    3. Check to see if the next token is capture start and is not the last capture ("qualifier capture"):
+        1. Consume `(`
+        2. Parse binding specifiers
+        3. `parse_identifier`
+        4. `parse_parameters` -> params_nested
+        5. Consume `)`
+        6. Construct a nested function typename definition for the qualifier `Name`
+    4. `parse_params` - > params
+    5. Parse postfix specifiers
+7. Check for varaidic argument (param pack) token:
+   1. Consume varadic argument token
+
+### **Later: Algorithim based on typename expressions**
+
+## `parse_typedef`
+
+1. Check for export module specifier
+2. typedef keyword
+3. If its a preprocess macro: Get the macro name
+4. Else:
+   1. Check to see if its a complicated definition (in-place enum, class, struct, union)
+   2. If its a complicated definition:
+       1. Perform the look ahead similar to `parse_complicated_definition`'s implementation
+       2. Check to see if its a forward declaration : `parse_forward_declaration`
+       3. If end[-1] is an identifier:
+           1. Its either an in-place, varaible type qualified identifier, or indirection type:
+              1. `parse_foward_or_definition`
+       4. else if end[-1] is a closing curly brace
+           1. Its a definition: `parse_forward_or_definition`
+       5. else if end[-1] is a closing square brace
+           2. Its an array definition: `parse_type`
+   3. Else : `parse-type`
+   4. Check for identifier : Consume the token
+   5. `parse_array_decl`
+5. Consume end statement
+6. Check for inline comment : `parse_comment`
+
+## `parse_union`
+
+1. Check for export module specifier
+2. union keyword
+3. `parse_attributes`
+4. Check for identifier
+5. Parse the body (Possible options):
+    1. Newline
+    2. Comment
+    3. Decl_Class
+    4. Decl_Enum
+    5. Decl_Struct
+    6. Decl_Union
+    7. Preprocess_Define
+    8. Preprocess_Conditional (if, ifdef, ifndef, elif, else, endif)
+    9. Preprocess_Macro
+    10. Preprocess_Pragma
+    11. Unsupported preprocess directive
+    12. Variable
+6. If its not an inplace definiton: End Statement
+
+## `parse_using`
+
+1. Check for export module specifier
+2. using keyword
+3. Check to see if its a using namespace
+4. Get the identifier
+5. If its a regular using declaration:
+    1. `parse_attributes`
+    2. `parse_type`
+    3. `parse_array_decl`
+6. End statement
+7. Check for inline comment
+
+## `parse_variable`
+
+1. Check for export module specifier
+2. `parse_attributes`
+3. `parse specifiers`
+4. `parse_type`
+5. `parse_identifier`
+6. `parse_variable_after_name`

docs/Parsing.md

@@ -0,0 +1,81 @@
+# Parsing
+
+The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.
+
+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.
+
+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.
+
+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         );
+```
+
+To parse file buffers, use the `parse_global_body` function.
+
+***Parsing will aggregate any tokens within a function body or expression statement to an untyped Code AST.***
+
+Everything is done in one pass for both the preprocessor directives and the rest of the language.  
+The parser performs no macro expansion as the scope of gencpp feature-set is to only support the preprocessor for the goal of having rudimentary awareness of preprocessor ***conditionals***,  ***defines***, ***includes***, and ***pragmas***.  
+
+The keywords supported for the preprocessor are:
+
+* include
+* define
+* if
+* ifdef
+* elif
+* 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*.  
+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 )
+
+Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).  
+Exceptions:
+
+* function signatures are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
+  * 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`
+
+*(Exceptions are added on an on-demand basis)*
+*(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
+
+Adding your own exceptions is possible by simply modifying the parser to allow for the syntax you need.
+
+*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase some some egregious preprocessor abuse.*
+
+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.
+  * *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)
+
+Empty lines used throughout the file are preserved for formatting purposes during ast serialization.

docs/Readme.md

@@ -0,0 +1,491 @@
+## Documentation
+
+The project has no external dependencies beyond:
+
+* `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)
+
+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).
+
+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*
+
+**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.
+
+**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 usage is non-trivial substitution.*
+
+### The Data & Interface
+
+As mentioned in root readme, the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
+
+The AST is managed by the library and provided to the user via its interface.  
+However, the user may specifiy memory configuration.
+
+Data layout of AST struct (Subject to heavily change with upcoming redesign):
+
+```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)
+```
+
+*`CodeT` is a typedef for `ECode::Type` which 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*
+
+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 =
+(
+    AST_POD_Size
+    - sizeof(AST*) * 3
+    - sizeof(StringCached)
+    - sizeof(CodeT)
+    - sizeof(ModuleFlag)
+    - sizeof(u32)
+)
+/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
+```
+
+*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
+
+Data Notes:
+
+* The allocator definitions used are exposed to the user incase they want to dictate memory usage
+  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
+  * Allocators are defined with the `AllocatorInfo` structure found in `dependencies\memory.hpp`
+  * Most of the work is just defining the allocation procedure:
+
+```cpp
+    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
+```
+
+* ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
+* Both AST and Code 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.
+* 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:
+  * `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.
+  * `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.
+* CodeAttributes
+* CodeComment
+* CodeClass
+* CodeConstructor
+* CodeDefine
+* CodeDestructor
+* CodeEnum
+* CodeExec
+* CodeExtern
+* CodeInclude
+* CodeFriend
+* CodeFn
+* CodeModule
+* CodeNS
+* CodeOperator
+* CodeOpCast
+* CodeParam : Has support for `for-range` iterating across parameters.
+* CodePreprocessCond
+* CodePragma
+* CodeSpecifiers : Has support for `for-range` iterating across specifiers.
+* CodeStruct
+* CodeTemplate
+* CodeType
+* CodeTypedef
+* CodeUnion
+* CodeUsing
+* CodeVar
+
+Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
+Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
+Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
+
+## There are three sets of interfaces for Code AST generation the library provides
+
+* Upfront
+* Parsing
+* Untyped
+
+### Upfront Construction
+
+All component ASTs must be previously constructed, and provided on creation of the code AST.
+The construction will fail and return CodeInvalid otherwise.
+
+Interface :``
+
+* def_attributes
+  * *This is pre-appended right before the function symbol, or placed after the class or struct keyword for any flavor of attributes used.*
+  * *Its up to the user to use the desired attribute formatting: `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU).*
+* def_comment
+* def_class
+* def_constructor
+* def_define
+* def_destructor
+* def_enum
+* def_execution
+  * *This is equivalent to untyped_str, except that its intended for use only in execution scopes.*
+* def_extern_link
+* def_friend
+* def_function
+* def_include
+* def_module
+* def_namespace
+* def_operator
+* def_operator_cast
+* def_param
+* def_params
+* def_pragma
+* def_preprocess_cond
+* def_specifier
+* def_specifiers
+* def_struct
+* def_template
+* def_type
+* def_typedef
+* def_union
+* def_using
+* def_using_namespace
+* def_variable
+
+Bodies:
+
+* def_body
+* def_class_body
+* def_enum_body
+* def_export_body
+* def_extern_link_body
+* def_function_body
+  * *Use this for operator bodies as well*
+* def_global_body
+* def_namespace_body
+* def_struct_body
+* def_union_body
+
+Usage:
+
+```cpp
+<name> = def_<function type>( ... );
+
+Code <name>
+{
+    ...
+    <name> = def_<function 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 ));
+
+// instead of:
+def_global_body( 3, ht_entry, array_ht_entry, hashtable );
+```
+
+If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.  
+When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
+
+### Parse construction
+
+A string provided to the API is parsed for the intended language construct.
+
+Interface :
+
+* parse_class
+* parse_constructor
+* parse_destructor
+* parse_enum
+* parse_export_body
+* parse_extern_link
+* parse_friend
+  * Purposefully are only support forward declares with this constructor.
+* parse_function
+* parse_global_body
+* parse_namespace
+* parse_operator
+* parse_operator_cast
+* parse_struct
+* parse_template
+* parse_type
+* parse_typedef
+* parse_union
+* parse_using
+* parse_variable
+
+Usage:
+
+```cpp
+Code <name> = parse_<function name>( string with code );
+
+Code <name> = def_<function name>( ..., parse_<function name>(
+    <string with code>
+));
+```
+
+### Untyped constructions
+
+Code ASTs are constructed using unvalidated strings.
+
+Interface :
+
+* token_fmt_va
+* token_fmt
+* untyped_str
+* 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.  
+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.
+* Untyped code can only be a child of a parent of body AST, or for values of an assignment (ex: variable assignment).
+
+These restrictions help prevent abuse of untyped code to some extent.
+
+Usage Conventions:
+
+```cpp
+Code <name> = def_variable( <type>, <name>, untyped_<function name>(
+    <string with code>
+));
+
+Code <name> = untyped_str( code(
+    <some code without "" quotes>
+));
+```
+
+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 > )
+```
+
+Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
+
+```cpp
+StrC value = txt("Something");
+
+char const* template_str = txt(
+    Code with <key> to replace with token_values
+    ...
+);
+char const* gen_code_str = token_fmt( "key", value, template_str );
+Code        <name>       = parse_<function name>( gen_code_str );
+```
+
+## Predefined Codes
+
+The following are provided predefined by the library as they are commonly used:
+
+* `access_public`
+* `access_protected`
+* `access_private`
+* `attrib_api_export`
+* `attrib_api_import`
+* `module_global_fragment`
+* `module_private_fragment`
+* `fmt_newline`
+* `param_varaidc` (Used for varadic definitions)
+* `pragma_once`
+* `preprocess_else`
+* `preprocess_endif`
+* `spec_const`
+* `spec_consteval`
+* `spec_constexpr`
+* `spec_constinit`
+* `spec_extern_linkage` (extern)
+* `spec_final`
+* `spec_forceinline`
+* `spec_global` (global macro)
+* `spec_inline`
+* `spec_internal_linkage` (internal macro)
+* `spec_local_persist` (local_persist macro)
+* `spec_mutable`
+* `spec_neverinline`
+* `spec_override`
+* `spec_ptr`
+* `spec_pure`
+* `spec_ref`
+* `spec_register`
+* `spec_rvalue`
+* `spec_static_member` (static)
+* `spec_thread_local`
+* `spec_virtual`
+* `spec_volatile`
+* `t_empty` (Used for varaidc macros)
+* `t_auto`
+* `t_void`
+* `t_int`
+* `t_bool`
+* `t_char`
+* `t_wchar_t`
+* `t_class`
+* `t_typename`
+
+Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` is defined
+
+* `t_b32`
+* `t_s8`
+* `t_s16`
+* `t_s32`
+* `t_s64`
+* `t_u8`
+* `t_u16`
+* `t_u32`
+* `t_u64`
+* `t_sw` (ssize_t)
+* `t_uw` (size_t)
+* `t_f32`
+* `t_f64`
+
+## Extent of operator overload validation
+
+The AST and constructors will be able to validate that the arguments provided for the operator type match the expected form:
+
+* If return type must match a parameter
+* If number of parameters is correct
+* If added as a member symbol to a class or struct, that operator matches the requirements for the class (types match up)
+* There is no support for validating new & delete operations (yet)
+
+The user is responsible for making sure the code types provided are correct
+and have the desired specifiers assigned to them beforehand.
+
+## Code generation and modification
+
+There are three 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
+
+* The purpose of it is to generate a file.
+* A file is specified and opened for writing using the open( file_path) function.
+* The code is provided via print( code ) function  will be serialized to its buffer.
+* When all serialization is finished, use the write() command to write the buffer to the file.
+
+### 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.

gen_c_library/c_library.cpp

@@ -0,0 +1,398 @@
+#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#define GEN_SUPPORT_CPP_MEMBER_FEATURES 1
+#define GEN_SUPPORT_CPP_REFERENCES      1
+#include "../project/gen.cpp"
+
+#include "helpers/push_ignores.inline.hpp"
+#include "helpers/helper.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.cpp"
+GEN_NS_END
+
+#include "auxillary/builder.hpp"
+#include "auxillary/builder.cpp"
+#include "auxillary/scanner.hpp"
+
+#include <cstdlib>   // for system()
+
+#include "components/memory.fixed_arena.hpp"
+#include "components/misc.hpp"
+#include "components/containers.array.hpp"
+#include "components/containers.hashtable.hpp"
+
+using namespace gen;
+
+constexpr char const* generation_notice =
+"// This file was generated automatially by gencpp's c_library.cpp"
+"(See: https://github.com/Ed94/gencpp)\n\n";
+
+constexpr StrC roll_own_dependencies_guard_start = txt(R"(
+//! 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"(
+// GEN_ROLL_OWN_DEPENDENCIES
+#endif
+)");
+
+constexpr StrC 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"(
+#endif
+#pragma endregion GENCPP IMPLEMENTATION GUARD
+)");
+
+void format_file( char const* path )
+{
+	String resolved_path = String::make(GlobalAllocator, to_str(path));
+
+	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;
+}
+
+CodeBody parse_file( const char* path )
+{
+	FileContents file = file_read_contents( GlobalAllocator, true, path );
+	CodeBody     code = parse_global_body( { file.size, (char const*)file.data } );
+	log_fmt("\nParsed: %s\n", path);
+	return code;
+}
+
+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 c_library_header_start = scan_file( "components/header_start.hpp" );
+
+	Builder
+	header = Builder::open( "gen/gen.h" );
+	header.print_fmt( generation_notice );
+	header.print_fmt("#pragma once\n\n");
+	header.print( push_ignores );
+
+	// Headers
+	{
+		header.print( c_library_header_start );
+
+		Code platform     = scan_file( project_dir "dependencies/platform.hpp" );
+		Code macros       = scan_file( project_dir "dependencies/macros.hpp" );
+		Code basic_types  = scan_file( project_dir "dependencies/basic_types.hpp" );
+		Code debug        = scan_file( project_dir "dependencies/debug.hpp" );
+
+		header.print_fmt( roll_own_dependencies_guard_start );
+		header.print( platform );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		header.print( macros );
+		header.print( basic_types );
+		header.print( debug );
+
+		CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" );
+		CodeBody memory        = def_body(ECode::Global_Body);
+		for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case ECode::Using:
+				{
+					log_fmt("REPLACE THIS MANUALLY: %S\n", entry->Name);
+					CodeUsing   using_ver   = cast(CodeUsing, entry);
+					CodeTypedef typedef_ver = def_typedef(using_ver->Name, using_ver->UnderlyingType);
+
+					memory.append(typedef_ver);
+				}
+				break;
+				case ECode::Function_Fwd:
+				{
+					CodeFn fn = cast(CodeFn, entry);
+					if ( fn->Name.is_equal(txt("free")) )
+					{
+						fn->Name = get_cached_string(txt("gen_free_ptr"));
+					}
+					memory.append(entry);
+				}
+				break;
+				case ECode::Function:
+				{
+					CodeFn fn = cast(CodeFn, entry);
+					s32 constexpr_found = fn->Specs.remove( ESpecifier::Constexpr );
+					if (constexpr_found > -1) {
+						log_fmt("Found constexpr: %S\n", entry->to_string());
+						fn->Specs.append(ESpecifier::Inline);
+					}
+					if ( fn->Name.is_equal(txt("free")) )
+					{
+						fn->Name = get_cached_string(txt("gen_free_ptr"));
+					}
+					memory.append(entry);
+				}
+				break;
+				case ECode::Template:
+				{
+					CodeTemplate tmpl = cast(CodeTemplate, entry);
+					if ( tmpl->Declaration->Name.contains(txt("swap")))
+					{
+						CodeBody macro_swap = parse_global_body( txt(R"(
+#define swap( a, b )              \
+	do                            \
+	{                             \
+		typeof( a ) temp = ( a ); \
+		( a )            = ( b ); \
+		( b )            = temp;  \
+	} while ( 0 )
+)"
+						));
+						memory.append(macro_swap);
+					}
+				}
+				break;
+				case ECode::Class:
+				case ECode::Struct:
+				{
+					CodeBody body     = entry->Body->operator CodeBody();
+					CodeBody new_body = def_body( entry->Body->Type );
+					for ( Code body_entry = body.begin(); body_entry != body.end(); ++ body_entry ) switch
+					(body_entry->Type) {
+						case ECode::Preprocess_If:
+						{
+							ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), body_entry, body );
+						}
+						break;
+
+						default:
+							new_body.append(body_entry);
+						break;
+					}
+
+					entry->Body = rcast(AST*, new_body.ast);
+					memory.append(entry);
+				}
+				break;
+				case ECode::Preprocess_If:
+				{
+					b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
+					if (found) break;
+
+					memory.append(entry);
+				}
+				break;
+				case ECode::Preprocess_IfDef:
+				{
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
+					if (found) break;
+
+					memory.append(entry);
+				}
+				break;
+				case ECode::Preprocess_Pragma:
+				{
+					b32 found = swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory);
+					if (found) break;
+
+					memory.append(entry);
+				}
+				break;
+				default: {
+					memory.append(entry);
+				}
+				break;
+			}
+		}
+		header.print( dump_to_scratch_and_retireve(memory) );
+
+		Code string_ops = scan_file( project_dir "dependencies/string_ops.hpp" );
+		header.print( string_ops );
+
+		CodeBody printing_parsed = parse_file( project_dir "dependencies/printing.hpp" );
+		CodeBody printing        = def_body(ECode::Global_Body);
+		for ( Code entry = printing_parsed.begin(); entry != printing_parsed.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case ECode::Preprocess_IfDef:
+				{
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
+					if (found) break;
+
+					printing.append(entry);
+				}
+				break;
+				case ECode::Variable:
+				{
+					if (contains(entry->Name, txt("Msg_Invalid_Value")))
+					{
+						CodeDefine define = def_define(entry->Name, entry->Value->Content);
+						printing.append(define);
+						continue;
+					}
+					printing.append(entry);
+				}
+				break;
+				default:
+					printing.append(entry);
+				break;
+			}
+		}
+		header.print(dump_to_scratch_and_retireve(printing));
+
+		CodeBody containers = def_body(ECode::Global_Body);
+		{
+			containers.append( def_pragma(code(region Containers)));
+
+			containers.append( gen_array_base() );
+			containers.append( gen_hashtable_base() );
+
+			containers.append( def_pragma(code(endregion Containers)));
+		}
+		header.print(fmt_newline);
+		header.print(dump_to_scratch_and_retireve(containers));
+
+		Code hashing = scan_file( project_dir "dependencies/hashing.hpp" );
+		header.print( hashing );
+
+		CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
+		CodeBody strings        = def_body(ECode::Global_Body);
+		for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case ECode::Preprocess_If:
+				{
+					ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings);
+				}
+				break;
+
+				case ECode::Preprocess_IfDef:
+				{
+					ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_strings );
+				}
+				break;
+
+				case ECode::Struct_Fwd:
+				{
+					if ( entry->Name.is_equal(txt("String")) )
+					{
+						CodeTypedef c_def = parse_typedef(code( typedef char* String; ));
+						strings.append(c_def);
+						strings.append(fmt_newline);
+						++ entry;
+						continue;
+					}
+					strings.append(entry);
+				}
+				break;
+
+				case ECode::Struct:
+				{
+					CodeBody body     = entry->Body->operator CodeBody();
+					CodeBody new_body = def_body( entry->Body->Type );
+					for ( Code body_entry = body.begin(); body_entry != body.end(); ++ body_entry ) switch
+					(body_entry->Type) {
+						case ECode::Preprocess_If:
+						{
+							b32 found = ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), body_entry, body );
+							if (found) break;
+
+							new_body.append(body_entry);
+						}
+						break;
+						default:
+							new_body.append(body_entry);
+						break;
+					}
+					entry->Body = rcast(AST*, new_body.ast);
+					strings.append(entry);
+				}
+				break;
+
+				default:
+					strings.append(entry);
+				break;
+			}
+		}
+		header.print(dump_to_scratch_and_retireve(strings));
+
+		Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" );
+		Code timing = scan_file( project_dir "dependencies/timing.hpp" );
+		// header.print( filesystem );
+		// header.print( timing );
+
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.print_fmt( roll_own_dependencies_guard_end );
+
+		Code types      = scan_file( project_dir "components/types.hpp" );
+		Code ast        = scan_file( project_dir "components/ast.hpp" );
+		Code ast_types  = scan_file( project_dir "components/ast_types.hpp" );
+		Code code_types = scan_file( project_dir "components/code_types.hpp" );
+		Code interface  = scan_file( project_dir "components/interface.hpp" );
+		Code inlines 	= scan_file( project_dir "components/inlines.hpp" );
+		Code header_end = scan_file( project_dir "components/header_end.hpp" );
+
+		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+#if 0
+		header.print_fmt("#pragma region Types\n");
+		header.print( types );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( ecode ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( eoperator ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( especifier ));
+		header.print( fmt_newline );
+		header.print_fmt("#pragma endregion Types\n\n");
+	#endif
+	}
+
+	header.print( pop_ignores );
+	header.write();
+
+	// format_file( "gen/gen.h" );
+
+	gen::deinit();
+	return 0;
+#undef project_dir
+}

gen_c_library/components/containers.array.hpp

@@ -0,0 +1,295 @@
+#pragma once
+
+#include "../project/gen.hpp"
+
+using namespace gen;
+
+CodeBody gen_array_base()
+{
+	CodeTypedef td_header = parse_typedef( code( typedef struct ArrayHeader ArrayHeader; ));
+	CodeStruct  header    = parse_struct( code(
+		struct ArrayHeader
+		{
+			AllocatorInfo Allocator;
+			usize         Capacity;
+			usize         Num;
+		};
+	));
+
+	// Code grow_formula = untyped_str( txt( "#define gen_array_grow_formula( value ) ( 2 * value + 8 )\n" ));
+	Code get_header   = untyped_str( txt( "#define array_get_header( Type, self ) ( (ArrayHeader*)( self ) - 1)\n" ));
+
+	return def_global_body( args( fmt_newline, td_header, header, get_header, fmt_newline ) );
+};
+
+CodeBody gen_array( StrC type, StrC array_name )
+{
+	String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	String fn         = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
+	str_to_lower(fn.Data);
+
+#pragma push_macro( "GEN_ASSERT" )
+#undef GEN_ASSERT
+	CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
+	, stringize(
+		typedef <type>* <array_type>;
+
+		<array_type> <fn>_init           ( AllocatorInfo allocator );
+		<array_type> <fn>_init_reserve   ( AllocatorInfo allocator, usize capacity );
+		bool         <fn>_append         ( <array_type>*  self, <type> value );
+		bool         <fn>_append_items   ( <array_type>*  self, <type>* items, usize item_num );
+		bool         <fn>_append_at      ( <array_type>*  self, <type> item, usize idx );
+		bool         <fn>_append_items_at( <array_type>*  self, <type>* items, usize item_num, usize idx );
+		<type>*      <fn>_back           ( <array_type>  self );
+		void         <fn>_clear          ( <array_type>  self );
+		bool         <fn>_fill		     ( <array_type>  self, usize begin, usize end, <type> value );
+		void         <fn>_free           ( <array_type>  self );
+		bool         <fn>_grow           ( <array_type>* self, usize min_capacity );
+		usize        <fn>_num            ( <array_type>  self );
+		<type>       <fn>_pop 	         ( <array_type>  self );
+		bool         <fn>_reserve        ( <array_type>* self, usize new_capacity );
+		bool         <fn>_resize         ( <array_type>* self, usize num );
+		bool         <fn>_set_capacity   ( <array_type>* self, usize new_capacity );
+
+		<array_type> <fn>_init( AllocatorInfo allocator )
+		{
+			return <fn>_init_reserve( allocator, array_grow_formula( 0 ) );
+		}
+
+		<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
+		{
+			ArrayHeader* header = cast(ArrayHeader*, alloc( allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity ) );
+
+			if ( header == NULL )
+				return NULL;
+
+			header->Allocator = allocator;
+			header->Capacity  = capacity;
+			header->Num       = 0;
+
+			return cast( <type>*, header + 1 );
+		}
+
+		bool <fn>_append( <array_type>* self, <type> value )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( header->Num == header->Capacity )
+			{
+				if ( ! <fn>_grow( self, header->Capacity))
+					return false;
+
+				header = get_header( * self );
+			}
+
+			(* self)[ header->Num ] = value;
+			header->Num++;
+
+			return true;
+		}
+
+		bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( header->Num + item_num > header->Capacity )
+			{
+				if ( ! <fn>_grow( self, header->Capacity + item_num ))
+					return false;
+
+				header = get_header( * self );
+			}
+
+			mem_copy( (* self) + header->Num, items, sizeof(<type>) * item_num );
+			header->Num += item_num;
+
+			return true;
+		}
+
+		bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( idx >= header->Num )
+				idx = header->Num - 1;
+
+			if ( idx < 0 )
+				idx = 0;
+
+			if ( header->Capacity < header->Num + 1 )
+			{
+				if ( ! <fn>_grow( self, header->Capacity + 1 ) )
+					return false;
+
+				header = get_header( * self );
+			}
+
+			<array_type> target = (* self) + idx;
+
+			mem_move( target + 1, target, (header->Num - idx) * sizeof(<type>) );
+			header->Num++;
+
+			return true;
+		}
+
+		bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( idx >= header->Num )
+			{
+				return <fn>_append_items( self, items, item_num );
+			}
+
+			if ( item_num > header->Capacity )
+			{
+				if ( ! <fn>_grow( self, item_num + header->Capacity ) )
+					return false;
+
+				header = get_header( * self );
+			}
+
+			<type>* target = (* self) + idx + item_num;
+			<type>* src    = (* self) + idx;
+
+			mem_move( target, src, (header->Num - idx) * sizeof(<type>) );
+			mem_copy( src, items, item_num * sizeof(<type>) );
+			header->Num += item_num;
+
+			return true;
+		}
+
+		<type>* <fn>_back( <array_type> self )
+		{
+			ArrayHeader* header = get_header( self );
+
+			if ( header->Num == 0 )
+				return NULL;
+
+			return self + header->Num - 1;
+		}
+
+		void <fn>_clear( <array_type> self )
+		{
+			ArrayHeader* header = get_header( self );
+			header->Num = 0;
+		}
+
+		bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
+		{
+			ArrayHeader* header = get_header( self );
+
+			if ( begin < 0 || end >= header->Num )
+				return false;
+
+			for ( ssize idx = begin; idx < end; idx ++ )
+				self[ idx ] = value;
+
+			return true;
+		}
+
+		void <fn>_free( <array_type> self )
+		{
+			ArrayHeader* header = get_header( self );
+			free( header->Allocator, header );
+			self = NULL;
+		}
+
+		bool <fn>_grow( <array_type>* self, usize min_capacity )
+		{
+			ArrayHeader* header      = get_header( *self );
+			usize       new_capacity = array_grow_formula( header->Capacity );
+
+			if ( new_capacity < min_capacity )
+				new_capacity = min_capacity;
+
+			return <fn>_set_capacity( self, new_capacity );
+		}
+
+		usize <fn>_num( <array_type> self )
+		{
+			return get_header(self)->Num;
+		}
+
+		<type> <fn>_pop( <array_type> self )
+		{
+			ArrayHeader* header = get_header( self );
+			GEN_ASSERT( header->Num > 0 );
+
+			<type> result = self[ header->Num - 1 ];
+			header->Num--;
+			return result;
+		}
+
+		void <fn>_remove_at( <array_type> self, usize idx )
+		{
+			ArrayHeader* header = get_header( self );
+			GEN_ASSERT( idx < header->Num );
+
+			mem_move( self + idx, self + idx + 1, sizeof( <type> ) * ( header->Num - idx - 1 ) );
+			header->Num--;
+		}
+
+		bool <fn>_reserve( <array_type>* self, usize new_capacity )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( header->Capacity < new_capacity )
+				return <fn>_set_capacity( self, new_capacity );
+
+			return true;
+		}
+
+		bool <fn>_resize( <array_type>* self, usize num )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( header->Capacity < num )
+			{
+				if ( ! <fn>_grow( self, num ) )
+					return false;
+
+				header = get_header( * self );
+			}
+
+			header->Num = num;
+			return true;
+		}
+
+		bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
+		{
+			ArrayHeader* header = get_header( * self );
+
+			if ( new_capacity == header->Capacity )
+				return true;
+
+			if ( new_capacity < header->Num )
+				header->Num = new_capacity;
+
+			usize       size       = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity;
+			ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size ));
+
+			if ( new_header == NULL )
+				return false;
+
+			mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
+			free( header->Allocator, & header );
+
+			new_header->Capacity = new_capacity;
+			* self = cast( <type>*, new_header + 1 );
+			return true;
+		}
+	)));
+#pragma pop_macro( "GEN_ASSERT" )
+
+	return def_global_body( args(
+		def_pragma( to_str( str_fmt_buf( "region %S", array_type ))),
+		fmt_newline,
+		result,
+		fmt_newline,
+		def_pragma( to_str( str_fmt_buf( "endregion %S", array_type ))),
+		fmt_newline
+	));
+};
+
+// CodeBody gen_

gen_c_library/components/containers.hashtable.hpp

@@ -0,0 +1,354 @@
+#pragma once
+
+#include "../project/gen.hpp"
+#include "containers.array.hpp"
+
+using namespace gen;
+
+CodeBody gen_hashtable_base()
+{
+	return parse_global_body( code(
+		typedef struct HT_FindResult HT_FindResult;
+		struct HT_FindResult
+		{
+			ssize HashIndex;
+			ssize PrevIndex;
+			ssize EntryIndex;
+		};
+	));
+}
+
+CodeBody gen_hashtable( StrC type, StrC hashtable_name )
+{
+	String
+	fn = String::make_reserve( GlobalAllocator, hashtable_name.Len + sizeof("gen") );
+	fn.append_fmt( "%.*s", hashtable_name.Len, hashtable_name.Ptr );
+	str_to_lower(fn.Data);
+
+	String
+	tbl_type = String::make_reserve( GlobalAllocator, hashtable_name.Len + sizeof("gen") );
+	tbl_type.append_fmt( "%.*s", hashtable_name.Len, hashtable_name.Ptr );
+
+	String name_lower = String::make( GlobalAllocator, hashtable_name );
+	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 );
+
+	CodeBody hashtable_types = parse_global_body( token_fmt(
+		"type",        (StrC) type,
+		"tbl_name",    (StrC) hashtable_name,
+		"tbl_type",    (StrC) tbl_type,
+	stringize(
+		typedef struct HTE_<tbl_name> HTE_<tbl_name>;
+		struct HTE_<tbl_name>
+		{
+			u64    Key;
+			ssize  Next;
+			<type> Value;
+		};
+
+		typedef void (* <tbl_type>_MapProc)    ( <tbl_type> self, u64 key, <type> value );
+		typedef void (* <tbl_type>_MapMutProc) ( <tbl_type> self, u64 key, <type>* value );
+	)));
+
+	CodeBody entry_array = gen_array( hashtable_entry, entry_array_name );
+
+#pragma push_macro( "GEN_ASSERT" )
+#pragma push_macro( "GEN_ASSERT_NOT_NULL" )
+#undef GEN_ASSERT
+#undef GEN_ASSERT_NOT_NULL
+	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,
+	stringize(
+		typedef struct <tbl_type> <tbl_type>;
+		struct <tbl_type>
+		{
+			Array_ssize   Hashes;
+			<array_entry> Entries;
+		};
+
+		<tbl_type> <fn>_make        ( AllocatorInfo allocator );
+		<tbl_type> <fn>_make_reserve( AllocatorInfo allocator, ssize num );
+		void       <fn>_clear       ( <tbl_type> self );
+		void       <fn>_destroy     ( <tbl_type> self );
+		<type>*    <fn>_get         ( <tbl_type> self, u64 key );
+		void       <fn>_map         ( <tbl_type> self, <tbl_type>_MapProc map_proc );
+		void       <fn>_map_mut     ( <tbl_type> self, <tbl_type>_MapMutProc map_proc );
+		void       <fn>_grow        ( <tbl_type>* self );
+		void       <fn>_rehash      ( <tbl_type>* self, ssize new_num );
+		void       <fn>_rehash_fast ( <tbl_type> self );
+		void       <fn>_remove      ( <tbl_type> self, u64 key );
+		void       <fn>_remove_entry( <tbl_type> self, ssize idx );
+		void       <fn>_set         ( <tbl_type>* self, u64 key, <type> value );
+		ssize         <fn>_slot        ( <tbl_type> self, u64 key );
+
+		ssize            <fn>__add_entry( <tbl_type> self, u64 key );
+		HT_FindResult <fn>__find     ( <tbl_type> self, u64 key );
+		b32           <fn>__full     ( <tbl_type> self );
+
+		<tbl_type> <fn>_make( AllocatorInfo allocator )
+		{
+			<tbl_type>
+			result        = { NULL, NULL };
+			result.Hashes  = array_ssize_make( allocator );
+			result.Entries = <fn_array>_make( allocator );
+
+			return result;
+		}
+
+		<tbl_type> <fn>_make_reserve( AllocatorInfo allocator, ssize num )
+		{
+			<tbl_type>
+			result         = { NULL, NULL };
+			result.Hashes  = array_ssize_make_reserve( allocator, num );
+			result.Entries = <fn_array>_make_reserve( allocator, num );
+
+			return result;
+		}
+
+		void <fn>_clear( <tbl_type> self )
+		{
+			for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
+				self.Hashes[idx] = -1;
+
+			array_ssize_clear( self.Hashes );
+			<fn_array>_clear( self.Entries );
+		}
+
+		void <fn>_destroy( <tbl_type> self )
+		{
+			if ( self.Hashes && self.Entries )
+			{
+				array_ssize_free( self.Hashes );
+				<fn_array>_free( self.Entries );
+			}
+		}
+
+		<type>* <fn>_get( <tbl_type> self, u64 key )
+		{
+			ssize idx = <fn>__find( self, key ).EntryIndex;
+			if ( idx > 0 )
+				return & self.Entries[idx].Value;
+
+			return NULL;
+		}
+
+		void <fn>_map( <tbl_type> self, <tbl_type>_MapProc map_proc )
+		{
+			GEN_ASSERT_NOT_NULL( map_proc );
+
+			for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			{
+				map_proc( self, self.Entries[idx].Key, self.Entries[idx].Value );
+			}
+		}
+
+		void <fn>_map_mut( <tbl_type> self, <tbl_type>_MapMutProc map_proc )
+		{
+			GEN_ASSERT_NOT_NULL( map_proc );
+
+			for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			{
+				map_proc( self, self.Entries[idx].Key, & self.Entries[idx].Value );
+			}
+		}
+
+		void <fn>_grow( <tbl_type>* self )
+		{
+			ssize new_num = array_grow_formula( array_header( self->Entries )->Num );
+			<fn>_rehash( self, new_num );
+		}
+
+		void <fn>_rehash( <tbl_type>* self, ssize new_num )
+		{
+			ssize idx;
+			ssize last_added_index;
+
+			ArrayHeader* old_hash_header    = array_header( self->Hashes );
+			ArrayHeader* old_entries_header = array_header( self->Entries );
+
+			<tbl_type> new_tbl = <fn>_make_reserve( old_hash_header->Allocator, old_hash_header->Num );
+
+			ArrayHeader* new_hash_header = array_header( new_tbl.Hashes );
+
+			for ( idx = 0; idx < new_hash_header->Num; idx++ )
+				new_tbl.Hashes[idx] = -1;
+
+			for ( idx = 0; idx < old_entries_header->Num; idx++ )
+			{
+				<entry_type>*  entry;
+				HT_FindResult  find_result;
+
+				if ( new_hash_header->Num == 0 )
+					<fn>_grow( & new_tbl );
+
+				entry            = & self->Entries[ idx ];
+				find_result      = <fn>__find( new_tbl, entry->Key );
+				last_added_index = <fn>__add_entry( new_tbl, entry->Key );
+
+				if ( find_result.PrevIndex < 0 )
+					new_tbl.Hashes[ find_result.HashIndex ] = last_added_index;
+				else
+					new_tbl.Entries[ find_result.PrevIndex ].Next = last_added_index;
+
+				new_tbl.Entries[ last_added_index ].Next  = find_result.EntryIndex;
+				new_tbl.Entries[ last_added_index ].Value = entry->Value;
+			}
+
+			<fn>_destroy( *self );
+			* self = new_tbl;
+		}
+
+		void <fn>_rehash_fast( <tbl_type> self )
+		{
+			ssize idx;
+
+			for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+				self.Entries[ idx ].Next = -1;
+
+			for ( idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
+				self.Hashes[ idx ] = -1;
+
+			for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
+			{
+				<entry_type>*     entry;
+				HT_FindResult find_result;
+
+				entry       = & self.Entries[ idx ];
+				find_result = <fn>__find( self, entry->Key );
+
+				if ( find_result.PrevIndex < 0 )
+					self.Hashes[ find_result.HashIndex ] = idx;
+				else
+					self.Entries[ find_result.PrevIndex ].Next = idx;
+			}
+		}
+
+		void <fn>_remove( <tbl_type> self, u64 key )
+		{
+			HT_FindResult find_result = <fn>__find( self, key );
+
+			if ( find_result.EntryIndex >= 0 )
+			{
+				<fn_array>_remove_at( self.Entries, find_result.EntryIndex );
+				<fn>_rehash_fast( self );
+			}
+		}
+
+		void <fn>_remove_entry( <tbl_type> self, ssize idx )
+		{
+			<fn_array>_remove_at( self.Entries, idx );
+		}
+
+		void <fn>_set( <tbl_type>* self, u64 key, <type> value )
+		{
+			ssize            idx;
+			HT_FindResult find_result;
+
+			if ( array_header( self->Hashes )->Num == 0 )
+				<fn>_grow( self );
+
+			find_result = <fn>__find( * self, key );
+
+			if ( find_result.EntryIndex >= 0 )
+			{
+				idx = find_result.EntryIndex;
+			}
+			else
+			{
+				idx = <fn>__add_entry( * self, key );
+
+				if ( find_result.PrevIndex >= 0 )
+				{
+					self->Entries[ find_result.PrevIndex ].Next = idx;
+				}
+				else
+				{
+					self->Hashes[ find_result.HashIndex ] = idx;
+				}
+			}
+
+			self->Entries[ idx ].Value = value;
+
+			if ( <fn>__full( * self ) )
+				<fn>_grow( self );
+		}
+
+		ssize <fn>_slot( <tbl_type> self, u64 key )
+		{
+			for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; ++idx )
+				if ( self.Hashes[ idx ] == key )
+					return idx;
+
+			return -1;
+		}
+
+		ssize <fn>__add_entry( <tbl_type> self, u64 key )
+		{
+			ssize idx;
+			<entry_type> entry = { key, -1 };
+
+			idx = array_header( self.Entries )->Num;
+			<fn_array>_append( & self.Entries, entry );
+			return idx;
+		}
+
+		HT_FindResult <fn>__find( <tbl_type> self, u64 key )
+		{
+			HT_FindResult result = { -1, -1, -1 };
+
+			ArrayHeader* hash_header = array_header( self.Hashes );
+
+			if ( hash_header->Num > 0 )
+			{
+				result.HashIndex  = key % hash_header->Num;
+				result.EntryIndex = self.Hashes[ result.HashIndex ];
+
+				while ( result.EntryIndex >= 0 )
+				{
+					if ( self.Entries[ result.EntryIndex ].Key == key )
+						break;
+
+					result.PrevIndex  = result.EntryIndex;
+					result.EntryIndex = self.Entries[ result.EntryIndex ].Next;
+				}
+			}
+
+			return result;
+		}
+
+		b32 <fn>__full( <tbl_type> self )
+		{
+			ArrayHeader* hash_header    = array_header( self.Hashes );
+			ArrayHeader* entries_header = array_header( self.Entries );
+
+			return 0.75f * hash_header->Num < entries_header->Num;
+		}
+	)));
+#pragma pop_macro( "GEN_ASSERT" )
+#pragma pop_macro( "GEN_ASSERT_NOT_NULL" )
+
+	char const* cmt_str = str_fmt_buf( "Name: %.*s Type: %.*s"
+		, tbl_type.length(), tbl_type.Data
+		, type.Len, type.Ptr );
+
+	return def_global_body(args(
+		def_pragma( to_str( str_fmt_buf( "region %S", tbl_type ))),
+		fmt_newline,
+		hashtable_types,
+		fmt_newline,
+		entry_array,
+		hashtable_def,
+		fmt_newline,
+		def_pragma( to_str( str_fmt_buf( "endregion %S", tbl_type ))),
+		fmt_newline
+	));
+}

gen_c_library/components/header_start.hpp

@@ -0,0 +1,14 @@
+/*
+	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
+
+	See Readme.md for more information from the project repository.
+
+	Public Address:
+	https://github.com/Ed94/gencpp
+
+	This is a single header C-Library variant.
+	Define GEN_IMPLEMENTATION before including this file in a single compilation unit.
+*/
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : GEN_TIME not defined
+#endif

gen_c_library/components/memory.fixed_arena.hpp

@@ -0,0 +1,122 @@
+#pragma once
+#include "../project/gen.hpp"
+
+using namespace gen;
+
+CodeBody gen_fixed_arenas()
+{
+	CodeBody result = def_body(ECode::Global_Body);
+	result.append(def_pragma(txt("region FixedArena")));
+
+	char const* template_struct = stringize(
+		struct FixedArena_<Name>
+		{
+			char  memory[<Size>];
+			Arena arena;
+		};
+	);
+
+	char const* template_interface = stringize(
+		inline
+		void fixed_arena_init_<Name>(FixedArena_<Name>* result) {
+			zero_size(& result->memory[0], <Size>);
+			result->arena = arena_init_from_memory(& result->memory[0], <Size>);
+		}
+
+		inline
+		ssize fixed_arena_size_remaining_<Name>(FixedArena_<Name>* fixed_arena, ssize alignment) {
+			return size_remaining(fixed_arena->arena, alignment);
+		}
+	);
+
+	CodeStruct arena_struct_1kb   = parse_struct( token_fmt_impl( 3, "Name", txt("1KB"),   "Size", txt("kilobytes(1)"),   template_struct ));
+	CodeStruct arena_struct_4kb   = parse_struct( token_fmt_impl( 3, "Name", txt("4KB"),   "Size", txt("kilobytes(4)"),   template_struct ));
+	CodeStruct arena_struct_8kb   = parse_struct( token_fmt_impl( 3, "Name", txt("8KB"),   "Size", txt("kilobytes(8)"),   template_struct ));
+	CodeStruct arena_struct_16kb  = parse_struct( token_fmt_impl( 3, "Name", txt("16KB"),  "Size", txt("kilobytes(16)"),  template_struct ));
+	CodeStruct arena_struct_32kb  = parse_struct( token_fmt_impl( 3, "Name", txt("32KB"),  "Size", txt("kilobytes(32)"),  template_struct ));
+	CodeStruct arena_struct_64kb  = parse_struct( token_fmt_impl( 3, "Name", txt("64KB"),  "Size", txt("kilobytes(64)"),  template_struct ));
+	CodeStruct arena_struct_128kb = parse_struct( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_struct ));
+	CodeStruct arena_struct_256kb = parse_struct( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_struct ));
+	CodeStruct arena_struct_512kb = parse_struct( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_struct ));
+	CodeStruct arena_struct_1mb   = parse_struct( token_fmt_impl( 3, "Name", txt("1MB"),   "Size", txt("megabytes(1)"),   template_struct ));
+	CodeStruct arena_struct_2mb   = parse_struct( token_fmt_impl( 3, "Name", txt("2MB"),   "Size", txt("megabytes(2)"),   template_struct ));
+	CodeStruct arena_struct_4mb   = parse_struct( token_fmt_impl( 3, "Name", txt("4MB"),   "Size", txt("megabytes(4)"),   template_struct ));
+
+
+	CodeBody arena_interface_1kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"),   "Size", txt("kilobytes(1)"),    template_interface ));
+	CodeBody arena_interface_4kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4KB"),   "Size", txt("kilobytes(4)"),    template_interface ));
+	CodeBody arena_interface_8kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("8KB"),   "Size", txt("kilobytes(8)"),    template_interface ));
+	CodeBody arena_interface_16kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("16KB"),  "Size", txt("kilobytes(16)"),   template_interface ));
+	CodeBody arena_interface_32kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("32KB"),  "Size", txt("kilobytes(32)"),   template_interface ));
+	CodeBody arena_interface_64kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("64KB"),  "Size", txt("kilobytes(64)"),   template_interface ));
+	CodeBody arena_interface_128kb = parse_global_body( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_interface ));
+	CodeBody arena_interface_256kb = parse_global_body( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_interface ));
+	CodeBody arena_interface_512kb = parse_global_body( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_interface ));
+	CodeBody arena_interface_1mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1MB"),   "Size", txt("megabytes(1)"),   template_interface ));
+	CodeBody arena_interface_2mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("2MB"),   "Size", txt("megabytes(2)"),   template_interface ));
+	CodeBody arena_interface_4mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4MB"),   "Size", txt("megabytes(4)"),   template_interface ));
+
+	result.append(arena_struct_1kb);
+	result.append(arena_struct_4kb);
+	result.append(arena_struct_8kb);
+	result.append(arena_struct_16kb);
+	result.append(arena_struct_32kb);
+	result.append(arena_struct_128kb);
+	result.append(arena_struct_256kb);
+	result.append(arena_struct_512kb);
+	result.append(arena_struct_1mb);
+	result.append(arena_struct_2mb);
+	result.append(arena_struct_4mb);
+
+	result.append(arena_interface_1kb);
+	result.append(arena_interface_4kb);
+	result.append(arena_interface_8kb);
+	result.append(arena_interface_16kb);
+	result.append(arena_interface_32kb);
+	result.append(arena_interface_128kb);
+	result.append(arena_interface_256kb);
+	result.append(arena_interface_512kb);
+	result.append(arena_interface_1mb);
+	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 }) );
+	result.append(def);
+
+	result.append(parse_global_body(txt(R"(
+#define fixed_arena_init(expr) _Generic((expr), \
+    FixedArena_1KB*   : fixed_arena_init_1KB,   \
+    FixedArena_4KB*   : fixed_arena_init_4KB,   \
+    FixedArena_8KB*   : fixed_arena_init_8KB,   \
+    FixedArena_16KB*  : fixed_arena_init_16KB,  \
+    FixedArena_32KB*  : fixed_arena_init_32KB,  \
+    FixedArena_64KB*  : fixed_arena_init_64KB,  \
+    FixedArena_128KB* : fixed_arena_init_128KB, \
+    FixedArena_256KB* : fixed_arena_init_256KB, \
+    FixedArena_512KB* : fixed_arena_init_512KB, \
+    FixedArena_1MB*   : fixed_arena_init_1MB,   \
+    FixedArena_2MB*   : fixed_arena_init_2MB,   \
+    FixedArena_4MB*   : fixed_arena_init_4MB    \
+)(expr)
+
+#define fixed_arena_size_remaining(expr, alignment) _Generic((expr), \
+    FixedArena_1KB*   : fixed_arena_size_remaining_1KB,              \
+    FixedArena_4KB*   : fixed_arena_size_remaining_4KB,              \
+    FixedArena_8KB*   : fixed_arena_size_remaining_8KB,              \
+    FixedArena_16KB*  : fixed_arena_size_remaining_16KB,             \
+    FixedArena_32KB*  : fixed_arena_size_remaining_32KB,             \
+    FixedArena_64KB*  : fixed_arena_size_remaining_64KB,             \
+    FixedArena_128KB* : fixed_arena_size_remaining_128KB,            \
+    FixedArena_256KB* : fixed_arena_size_remaining_256KB,            \
+    FixedArena_512KB* : fixed_arena_size_remaining_512KB,            \
+    FixedArena_1MB*   : fixed_arena_size_remaining_1MB,              \
+    FixedArena_2MB*   : fixed_arena_size_remaining_2MB,              \
+    FixedArena_4MB*   : fixed_arena_size_remaining_4MB               \
+)(expr, alignment)
+)"
+	)));
+
+	result.append(def_pragma(txt("endregion FixedArena")));
+
+	return result;
+}

gen_c_library/components/misc.hpp

@@ -0,0 +1,72 @@
+// #pragma once
+// #include "../project/gen.hpp"
+
+// using namespace gen;
+
+using SwapContentProc = CodeBody(void);
+
+b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& body )
+{
+	b32 found = false;
+	CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
+	if ( cond->Content.contains(cond_sig) )
+	{
+		log_fmt("Preprocess cond found: %S\n", cond->Content);
+		found = true;
+
+		s32 depth = 1;
+		++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch
+		(entry_iter->Type) {
+			case ECode::Preprocess_If:
+			case ECode::Preprocess_IfDef:
+			case ECode::Preprocess_IfNotDef:
+				depth ++;
+			break;
+
+			case ECode::Preprocess_EndIf:
+			{
+				depth --;
+				if (depth == 0) {
+					continue_for = false;
+					break;
+				}
+			}
+			break;
+			default:
+				++ entry_iter;
+			break;
+		}
+	}
+
+	return found;
+}
+
+bool swap_pragma_region_implementation( StrC 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);
+	if ( possible_region->Content.contains(region_sig))
+	{
+		found = true;
+		// body.append(possible_region);
+		body.append(swap_content());
+
+		++ entry_iter; for(b32 continue_for = true; continue_for; ++entry_iter) switch
+		(entry_iter->Type) {
+			case ECode::Preprocess_Pragma:
+			{
+				CodePragma possible_end_region = cast(CodePragma, entry_iter);
+				if ( possible_end_region->Content.contains(endregion_sig) ) {
+					// body.append(possible_end_region);
+					continue_for = false;
+				}
+			}
+			break;
+		}
+		body.append(entry_iter);
+	}
+	return found;
+}

gen_c_library/gen.c

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

gen_singleheader/Readme.md

@@ -0,0 +1,4 @@
+# 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.

gen_singleheader/components/header_start.hpp

@@ -0,0 +1,14 @@
+/*
+	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
+
+	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.
+*/
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : GEN_TIME not defined
+#endif

gen_singleheader/singleheader.cpp

@@ -0,0 +1,314 @@
+#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#define GEN_SUPPORT_CPP_MEMBER_FEATURES 1
+#define GEN_SUPPORT_CPP_REFERENCES      0
+#include "gen.cpp"
+
+#include "helpers/push_ignores.inline.hpp"
+#include "helpers/helper.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.cpp"
+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"(
+#pragma region GENCPP IMPLEMENTATION GUARD
+#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
+#	define GEN_IMPLEMENTED
+)");
+
+constexpr StrC implementation_guard_end = txt(R"(
+#endif
+#pragma endregion GENCPP IMPLEMENTATION GUARD
+)");
+
+constexpr StrC 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"(
+// GEN_ROLL_OWN_DEPENDENCIES
+#endif
+)");
+
+global bool generate_gen_dep = true;
+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));
+
+	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;
+}
+
+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 single_header_start = scan_file( "components/header_start.hpp" );
+
+	Builder
+	header = Builder::open( "gen/gen.hpp" );
+	header.print_fmt( generation_notice );
+	header.print_fmt("#pragma once\n\n");
+	header.print( push_ignores );
+
+	// Headers
+	{
+		header.print( single_header_start );
+
+		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" );
+
+			header.print_fmt( roll_own_dependencies_guard_start );
+			header.print( platform );
+			header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+			header.print( macros );
+			header.print( basic_types );
+			header.print( debug );
+			header.print( memory );
+			header.print( string_ops );
+			header.print( printing );
+			header.print( containers );
+			header.print( hashing );
+			header.print( strings );
+			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" );
+			}
+
+			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" );
+
+		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+		header.print_fmt( "GEN_NS_BEGIN\n\n" );
+
+		header.print_fmt("#pragma region Types\n");
+		header.print( types );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( ecode ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( eoperator ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( especifier ));
+		header.print( fmt_newline );
+		header.print_fmt("#pragma endregion Types\n\n");
+
+		header.print_fmt("#pragma region AST\n");
+		header.print( ast );
+		header.print( code_types );
+		header.print( ast_types );
+		header.print_fmt("\n#pragma endregion AST\n");
+
+		header.print( interface );
+
+		header.print_fmt( "\n#pragma region Inlines\n" );
+		header.print( inlines );
+		header.print( dump_to_scratch_and_retireve( 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" );
+		}
+
+		header.print_fmt( "GEN_NS_END\n" );
+	}
+
+	// Implementation
+	{
+		header.print_fmt( "%s\n", (char const*) implementation_guard_start );
+
+		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" );
+
+			header.print_fmt( roll_own_dependencies_guard_start );
+			header.print_fmt( "GEN_NS_BEGIN\n\n");
+
+			header.print( impl_start );
+			header.print( debug );
+			header.print( string_ops );
+			header.print( printing );
+			header.print( memory );
+			header.print( hashing );
+			header.print( strings );
+			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.cpp" ) );
+				header.print_fmt( "#pragma endregion Parsing\n\n" );
+			}
+
+			header.print_fmt( "GEN_NS_END\n");
+			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" );
+
+		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)) );
+
+		header.print_fmt( "\nGEN_NS_BEGIN\n");
+		header.print( static_data );
+
+		header.print_fmt( "#pragma region AST\n\n" );
+		header.print( ast_case_macros );
+		header.print( ast );
+		header.print( code );
+		header.print_fmt( "#pragma endregion AST\n\n" );
+
+		header.print_fmt( "#pragma region Interface\n" );
+		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( 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");
+
+		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" );
+		}
+
+		// 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 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( "GEN_NS_END\n");
+
+		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
+	}
+
+	header.print( pop_ignores );
+	header.write();
+
+	gen::deinit();
+	return 0;
+#undef project_dir
+}

gen_unreal_engine/Readme.md

@@ -0,0 +1,3 @@
+# 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.

gen_unreal_engine/components/header_start.hpp

@@ -0,0 +1,31 @@
+/*
+	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
+
+	See Readme.md for more information from the project repository.
+
+	Public Address:
+	https://github.com/Ed94/gencpp
+
+	This is a variant intended for use with Unreal Engine 5
+*/
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : 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.hpp"
+#endif
+
+#ifndef GEN_NS_BEGIN
+#	ifdef GEN_DONT_USE_NAMESPACE
+#		define GEN_NS
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	else
+#		define GEN_NS       gen::
+#		define GEN_NS_BEGIN namespace gen {
+#		define GEN_NS_END   }
+#	endif
+#endif

gen_unreal_engine/components/src_start.cpp

@@ -0,0 +1,5 @@
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : GEN_TIME not defined
+#endif
+
+#include "gen.hpp"

gen_unreal_engine/enums/AttributeTokens.csv

@@ -0,0 +1,7 @@
+API_Export,            GEN_API_Export_Code
+API_Import,            GEN_API_Import_Code
+COREUOBJECT_API,       COREUOBJECT_API
+ENGINE_API,            ENGINE_API
+GAMEPLAYABILITIES_API, GAMEPLAYABILITIES_API
+UMG_API,               UMG_API
+UE_DEPRECATED,         UE_DEPRECATED

gen_unreal_engine/unreal.cpp

@@ -0,0 +1,397 @@
+#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#include "gen.cpp"
+
+#include "helpers/push_ignores.inline.hpp"
+#include "helpers/helper.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.cpp"
+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"(
+#pragma region GENCPP IMPLEMENTATION GUARD
+#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
+#	define GEN_IMPLEMENTED
+)");
+
+constexpr StrC implementation_guard_end = txt(R"(
+#endif
+#pragma endregion GENCPP IMPLEMENTATION GUARD
+)");
+
+constexpr StrC 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"(
+// GEN_ROLL_OWN_DEPENDENCIES
+#endif
+)");
+
+global bool generate_gen_dep = true;
+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));
+
+	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;
+}
+
+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 ue_forceinline = code_str(FORCEINLINE);
+	// Code
+
+	// gen_dep.hpp
+	{
+		CodeBody macros = def_body( CodeT::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 });
+
+			for (Code	code =  ori_macros.begin();
+						code != ori_macros.end();
+						++ code )
+			{
+				switch (code->Type)
+				{
+					using namespace ECode;
+					case Preprocess_Define:
+					{
+						CodeDefine define = code.cast<CodeDefine>();
+						if ( define->Name.starts_with(txt("global")) )
+						{
+							macros.append(parse_global_body(txt("#define global // Global variables")));
+							continue;
+						}
+
+						macros.append(define);
+					}
+					break;
+
+					default:
+						macros.append(code);
+					break;
+				}
+			}
+		}
+
+		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" );
+
+		Builder
+		header = Builder::open("gen/gen.dep.hpp");
+		header.print_fmt( generation_notice );
+		header.print( pragma_once );
+		header.print( push_ignores );
+		header.print( platform );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(macros) );
+		header.print( basic_types );
+		header.print( debug );
+		header.print( memory );
+		header.print( string_ops );
+		header.print( printing );
+		header.print( containers );
+		header.print( hashing );
+		header.print( strings );
+		header.print( filesystem );
+		header.print( timing );
+
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.print( fmt_newline );
+		header.print( pop_ignores );
+		header.write();
+	}
+
+	// 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" );
+
+		Builder
+		src = Builder::open( "gen/gen.dep.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( def_include(txt("gen.dep.hpp")));
+		src.print( fmt_newline );
+		src.print( push_ignores );
+		src.print( src_start );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		src.print( debug );
+		src.print( string_ops );
+		src.print( printing );
+		src.print( hashing );
+		src.print( memory );
+		src.print( strings );
+		src.print( filesystem );
+		src.print( timing );
+
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.print( fmt_newline );
+		src.print( pop_ignores );
+		src.write();
+	}
+
+	// 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" );
+
+		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+		Builder
+		header = Builder::open( "gen/gen.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( push_ignores );
+		header.print( fmt_newline );
+		header.print( header_start );
+		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
+
+		header.print_fmt( "#pragma region Types\n" );
+		header.print( types );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve(ecode) );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve(eoperator) );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve(especifier) );
+		header.print( fmt_newline );
+		header.print_fmt( "#pragma endregion Types\n\n" );
+
+		header.print_fmt( "#pragma region AST\n" );
+		header.print( ast );
+		header.print( code_types );
+		header.print( ast_types );
+		header.print_fmt( "\n#pragma endregion AST\n" );
+
+		header.print( interface );
+
+		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( fmt_newline );
+		header.print_fmt( "#pragma endregion Inlines\n" );
+
+		header.print( header_end );
+		header.print_fmt( "GEN_NS_END\n\n" );
+		header.print( pop_ignores );
+		header.write();
+	}
+
+	// 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" );
+
+		// 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)) );
+
+		Builder
+		src = Builder::open( "gen/gen.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( push_ignores );
+		src.print( fmt_newline );
+		src.print( src_start );
+		src.print( fmt_newline );
+		src.print_fmt( "GEN_NS_BEGIN\n");
+
+		src.print( static_data );
+
+		src.print_fmt( "\n#pragma region AST\n\n" );
+		src.print( ast_case_macros );
+		src.print( ast );
+		src.print( code_serialization );
+		src.print_fmt( "\n#pragma endregion AST\n" );
+
+		src.print_fmt( "\n#pragma region Interface\n" );
+		src.print( interface );
+		src.print( upfront );
+		src.print_fmt( "\n#pragma region Parsing\n\n" );
+		src.print( dump_to_scratch_and_retireve(nspaced_etoktype) );
+		src.print( lexer );
+		src.print( parser );
+		src.print( parsing_interface );
+		src.print( untyped );
+		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
+		src.print_fmt( "#pragma endregion Interface\n\n" );
+
+		src.print_fmt( "GEN_NS_END\n\n");
+		src.print( pop_ignores );
+		src.write();
+	}
+
+	// gen_builder.hpp
+	{
+		Code builder = scan_file( project_dir "auxillary/builder.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.builder.hpp" );
+		header.print_fmt( generation_notice );
+		header.print( push_ignores );
+		header.print( fmt_newline );
+		header.print_fmt( "#pragma once\n\n" );
+		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_newline );
+		header.print( pop_ignores );
+		header.write();
+	}
+
+	// gen_builder.cpp
+	{
+		Code builder = scan_file( project_dir "auxillary/builder.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.builder.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( push_ignores );
+		src.print( fmt_newline );
+		src.print( def_include( txt("gen.builder.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( builder );
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.print( fmt_newline );
+		src.print( pop_ignores );
+		src.write();
+	}
+
+	// gen_scanner.hpp
+	{
+		Code parsing = scan_file( project_dir "dependencies/parsing.hpp" );
+		Code scanner = scan_file( project_dir "auxillary/scanner.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.scanner.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( push_ignores );
+		header.print( fmt_newline );
+		header.print( def_include( txt("gen.hpp") ) );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+		header.print( parsing );
+		header.print( scanner );
+		header.print_fmt( "GEN_NS_END\n" );
+		header.print( fmt_newline );
+		header.print( pop_ignores );
+		header.write();
+	}
+
+	// gen.scanner.cpp
+	{
+		Code parsing = scan_file( project_dir "dependencies/parsing.cpp" );
+		Code scanner = scan_file( project_dir "auxillary/scanner.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.scanner.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( push_ignores );
+		src.print( fmt_newline );
+		src.print( def_include( txt("gen.scanner.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( parsing );
+		// src.print( scanner );
+		src.print_fmt( "GEN_NS_END\n" );
+		src.print( fmt_newline );
+		src.print( pop_ignores );
+		src.write();
+	}
+}

gencpp.10x

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

gencpp.sln

@@ -7,20 +7,37 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gencpp", "gencpp.vcxproj",
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
+		bootstrap debug|x64 = bootstrap debug|x64
-		Debug|x86 = Debug|x86
+		bootstrap debug|x86 = bootstrap debug|x86
-		Release|x64 = Release|x64
+		bootstrap release|x64 = bootstrap release|x64
-		Release|x86 = Release|x86
+		bootstrap release|x86 = bootstrap release|x86
+		singleheader debug|x64 = singleheader debug|x64
+		singleheader debug|x86 = singleheader debug|x86
+		singleheader release|x64 = singleheader release|x64
+		singleheader release|x86 = singleheader release|x86
+		test debug|x64 = test debug|x64
+		test debug|x86 = test debug|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Debug|x64.ActiveCfg = Debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.ActiveCfg = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Debug|x64.Build.0 = Debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.Build.0 = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Debug|x86.ActiveCfg = Debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.ActiveCfg = bootstrap debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Debug|x86.Build.0 = Debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.Build.0 = bootstrap debug|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Release|x64.ActiveCfg = Release|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x64.ActiveCfg = bootstrap release|x64
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Release|x64.Build.0 = Release|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.ActiveCfg = bootstrap release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Release|x86.ActiveCfg = Release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.Build.0 = bootstrap release|Win32
-		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.Release|x86.Build.0 = Release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.ActiveCfg = singleheader debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.Build.0 = singleheader debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.ActiveCfg = singleheader debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.Build.0 = singleheader debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.ActiveCfg = bootstrap debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.Build.0 = bootstrap debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.ActiveCfg = singleheader release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.Build.0 = singleheader release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.ActiveCfg = test debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.Build.0 = test debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.ActiveCfg = test debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.Build.0 = test debug|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

gencpp.vcxproj

@@ -1,20 +1,44 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
+    <ProjectConfiguration Include="bootstrap debug|Win32">
-      <Configuration>Debug</Configuration>
+      <Configuration>bootstrap debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
+    <ProjectConfiguration Include="bootstrap debug|x64">
-      <Configuration>Release</Configuration>
+      <Configuration>bootstrap debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
+    <ProjectConfiguration Include="bootstrap release|Win32">
-      <Configuration>Release</Configuration>
+      <Configuration>bootstrap release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="bootstrap release|x64">
+      <Configuration>bootstrap release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader debug|Win32">
+      <Configuration>singleheader debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader debug|x64">
+      <Configuration>singleheader debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader release|Win32">
+      <Configuration>singleheader release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader release|x64">
+      <Configuration>singleheader release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="test debug|Win32">
+      <Configuration>test debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="test debug|x64">
+      <Configuration>test debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
@@ -25,24 +49,54 @@
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="Configuration">
     <ConfigurationType>Makefile</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Makefile</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="Configuration">
     <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
@@ -50,76 +104,202 @@
   </ImportGroup>
   <ImportGroup Label="Shared">
   </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'">
     <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
     <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
     <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
     <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'">
     <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
     <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
     <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>WIN32;NDEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'">
-    <NMakeBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeBuildCommandLine>
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeCleanCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>GEN_TIME;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)thirdparty;$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(ProjectDir)test;$(SourcePath)</SourcePath>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'">
-    <NMakeBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeBuildCommandLine>
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
-    <NMakeCleanCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>GEN_TIME;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <IncludePath>$(ProjectDir)thirdparty;$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
-    <SourcePath>$(ProjectDir)project;$(ProjectDir)test;$(SourcePath)</SourcePath>
   </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug bootstrap</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug test</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine />
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug singleheader</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release singleheader</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release bootstrap</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
     <ClCompile>
       <LanguageStandard_C>stdc11</LanguageStandard_C>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
     <None Include=".editorconfig" />
+    <None Include="project\enums\AttributeTokens.csv" />
+    <None Include="project\enums\ECode.csv" />
+    <None Include="project\enums\EOperator.csv" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
     <None Include="Readme.md" />
+    <None Include="scripts\.clang-format" />
     <None Include="scripts\build.ci.ps1" />
     <None Include="scripts\build.ps1" />
     <None Include="scripts\clean.ps1" />
-    <None Include="scripts\get_sources.ps1" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="project\auxillary\builder.hpp" />
+    <ClInclude Include="project\auxillary\editor.hpp" />
+    <ClInclude Include="project\auxillary\scanner.hpp" />
+    <ClInclude Include="project\components\ast.hpp" />
+    <ClInclude Include="project\components\ast_types.hpp" />
+    <ClInclude Include="project\components\code_types.hpp" />
+    <ClInclude Include="project\components\gen\ast_inlines.hpp" />
+    <ClInclude Include="project\components\gen\ecode.hpp" />
+    <ClInclude Include="project\components\gen\eoperator.hpp" />
+    <ClInclude Include="project\components\gen\especifier.hpp" />
+    <ClInclude Include="project\components\header_end.hpp" />
+    <ClInclude Include="project\components\header_start.hpp" />
+    <ClInclude Include="project\components\inlines.hpp" />
+    <ClInclude Include="project\components\interface.hpp" />
+    <ClInclude Include="project\components\types.hpp" />
+    <ClInclude Include="project\dependencies\basic_types.hpp" />
+    <ClInclude Include="project\dependencies\containers.hpp" />
+    <ClInclude Include="project\dependencies\debug.hpp" />
+    <ClInclude Include="project\dependencies\filesystem.hpp" />
+    <ClInclude Include="project\dependencies\hashing.hpp" />
+    <ClInclude Include="project\dependencies\header_start.hpp" />
+    <ClInclude Include="project\dependencies\macros.hpp" />
+    <ClInclude Include="project\dependencies\memory.hpp" />
+    <ClInclude Include="project\dependencies\parsing.hpp" />
+    <ClInclude Include="project\dependencies\printing.hpp" />
+    <ClInclude Include="project\dependencies\strings.hpp" />
+    <ClInclude Include="project\dependencies\string_ops.hpp" />
+    <ClInclude Include="project\dependencies\timing.hpp" />
+    <ClInclude Include="project\gen.dep.hpp" />
     <ClInclude Include="project\gen.hpp" />
-    <ClInclude Include="project\gen.undef.macros.hpp" />
+    <ClInclude Include="project\helpers\helper.hpp" />
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\undef.macros.hpp" />
+    <ClInclude Include="singleheader\components\header_start.hpp" />
+    <ClInclude Include="test\CURSED_TYPEDEF.h" />
     <ClInclude Include="test\DummyInclude.hpp" />
-    <ClInclude Include="test\gen\array.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\buffer.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\hashtable.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\ring.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\sanity.Upfront.gen.hpp" />
     <ClInclude Include="test\Parsed\Buffer.Parsed.hpp" />
     <ClInclude Include="test\Parsed\HashTable.Parsed.hpp" />
     <ClInclude Include="test\Parsed\Ring.Parsed.hpp" />
+    <ClInclude Include="test\parsing.hpp" />
     <ClInclude Include="test\SOA.hpp" />
+    <ClInclude Include="test\upfront.hpp" />
     <ClInclude Include="test\Upfront\Array.Upfront.hpp" />
     <ClInclude Include="test\Upfront\Buffer.Upfront.hpp" />
     <ClInclude Include="test\Upfront\HashTable.Upfront.hpp" />
@@ -129,17 +309,66 @@
     <ClInclude Include="test\Parsed\Sanity.Parsed.hpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="project\auxillary\builder.cpp" />
+    <ClCompile Include="project\auxillary\scanner.cpp" />
+    <ClCompile Include="project\bootstrap.cpp" />
+    <ClCompile Include="project\components\ast.cpp" />
+    <ClCompile Include="project\components\ast_case_macros.cpp" />
+    <ClCompile Include="project\components\code_serialization.cpp" />
+    <ClCompile Include="project\components\gen\etoktype.cpp" />
+    <ClCompile Include="project\components\interface.cpp" />
+    <ClCompile Include="project\components\interface.parsing.cpp" />
+    <ClCompile Include="project\components\interface.untyped.cpp" />
+    <ClCompile Include="project\components\interface.upfront.cpp" />
+    <ClCompile Include="project\components\lexer.cpp" />
+    <ClCompile Include="project\components\parser.cpp" />
+    <ClCompile Include="project\components\src_start.cpp" />
+    <ClCompile Include="project\components\static_data.cpp" />
+    <ClCompile Include="project\dependencies\debug.cpp" />
+    <ClCompile Include="project\dependencies\filesystem.cpp" />
+    <ClCompile Include="project\dependencies\hashing.cpp" />
+    <ClCompile Include="project\dependencies\memory.cpp" />
+    <ClCompile Include="project\dependencies\parsing.cpp" />
+    <ClCompile Include="project\dependencies\printing.cpp" />
+    <ClCompile Include="project\dependencies\src_start.cpp" />
+    <ClCompile Include="project\dependencies\strings.cpp" />
+    <ClCompile Include="project\dependencies\string_ops.cpp" />
+    <ClCompile Include="project\dependencies\timing.cpp" />
+    <ClCompile Include="project\Example.cpp" />
     <ClCompile Include="project\gen.cpp" />
-    <ClCompile Include="singleheader\gen\gen.singleheader.cpp" />
+    <ClCompile Include="project\gen.dep.cpp" />
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckc.c" />
+    <ClCompile Include="singleheader\singleheader.cpp" />
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckcpp.cc" />
+    <ClCompile Include="test\parsed\test.parsing.cpp" />
+    <ClCompile Include="test\parsing.cpp" />
+    <ClCompile Include="test\sanity.cpp" />
+    <ClCompile Include="test\SOA.cpp" />
     <ClCompile Include="test\test.cpp" />
+    <ClCompile Include="test\test.parsing.cpp" />
+    <ClCompile Include="test\test.singleheader_ast.cpp" />
     <ClCompile Include="test\test.Upfront.cpp" />
+    <ClCompile Include="test\upfront.cpp" />
+    <ClCompile Include="test\upfront\test.upfront.cpp" />
+    <ClCompile Include="test\validate_bootstrap.cpp" />
+    <ClCompile Include="test\validate_singleheader.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />
     <Natvis Include="scripts\gencpp.natvis" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="project\enums\AttributeTokens.csv" />
+    <Content Include="project\enums\ECode.csv" />
+    <Content Include="project\enums\EOperator.csv" />
+    <Content Include="project\enums\ESpecifier.csv" />
+    <Content Include="project\enums\ETokType.csv" />
+    <Content Include="scripts\.clang-format" />
+    <Content Include="scripts\helpers\devshell.ps1" />
+    <Content Include="scripts\helpers\target_arch.psm1" />
+    <Content Include="scripts\refactor.ps1" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="singleheader\gen\" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

gencpp.vcxproj.filters

@@ -18,19 +18,124 @@
     <ClCompile Include="project\gen.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckcpp.cc">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="test\test.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="singleheader\gen\gen.singleheader.cpp">
+    <ClCompile Include="test\test.Upfront.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="test\test.Upfront.cpp">
+    <ClCompile Include="project\gen.dep.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\sanity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\SOA.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\ast_case_macros.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\src_start.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\static_data.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\bootstrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\debug.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\filesystem.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\hashing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\memory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\printing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\src_start.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\string_ops.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\strings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\timing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\builder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\scanner.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="singleheader\singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.singleheader_ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\parsed\test.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\upfront\test.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_bootstrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.untyped.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\gen\etoktype.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\Example.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\parser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\lexer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\code_serialization.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
@@ -38,27 +143,9 @@
     <ClInclude Include="project\gen.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\gen.undef.macros.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="test\DummyInclude.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="test\gen\array.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\buffer.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\hashtable.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\ring.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\sanity.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="test\Parsed\Buffer.Parsed.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -92,6 +179,117 @@
     <ClInclude Include="test\Parsed\Sanity.Parsed.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="project\gen.dep.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\ast.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\ast_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\header_end.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\inlines.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\interface.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\helper.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\undef.macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\basic_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\containers.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\debug.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\filesystem.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\hashing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\memory.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\printing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\string_ops.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\strings.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\timing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\builder.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\editor.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\scanner.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="singleheader\components\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\ast_inlines.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\ecode.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\eoperator.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\especifier.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\CURSED_TYPEDEF.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\code_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include=".editorconfig" />
@@ -99,10 +297,21 @@
     <None Include="scripts\build.ci.ps1" />
     <None Include="scripts\build.ps1" />
     <None Include="scripts\clean.ps1" />
-    <None Include="scripts\get_sources.ps1" />
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
+    <None Include="project\enums\AttributeTokens.csv" />
+    <None Include="project\enums\ECode.csv" />
+    <None Include="project\enums\EOperator.csv" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
+    <None Include="scripts\.clang-format" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />

gencpp.vcxproj.user

@@ -3,14 +3,29 @@
   <PropertyGroup>
     <ShowAllFiles>true</ShowAllFiles>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
     <LocalDebuggerAttach>false</LocalDebuggerAttach>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommand>C:\projects\gencpp\test\gen\build\gencpp.exe</LocalDebuggerCommand>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
     <LocalDebuggerAttach>false</LocalDebuggerAttach>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommand>C:\projects\gencpp\test\gen\build\gencpp.exe</LocalDebuggerCommand>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
   </PropertyGroup>
 </Project>

project/Readme.md

@@ -1,86 +1,66 @@
 # Documentation
 
-The core library is contained within `gen.hpp` and `gen.cpp`.
+The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a tailored format for the target `gen` files.
-Things related to the editor and scanner are in their own respective files. (Ex: `gen.scanner.<hpp/cpp>` )
 
+The principal (user) files are `gen.hpp` and `gen.cpp`.  
+They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
 
+Dependencies are bundled into `gen.dep.<hpp/cpp>`.  
+Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`
 
-## gen.hpp
+Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
+
+Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.
+
+The default `gen.bootstrap.cpp` located in the project folder is meant to be produce a standard segmented library, where the components of the library  
+have relatively dedicated header and source files. Dependencies included at the top of the file and each header starting with a pragma once.  
+The output will be in the `project/gen` directory (if the directory does not exist, it will create it).
+
+Use those to get a general idea of how to make your own tailored version.
 
 Feature Macros:
 
-* `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_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing. 
-* `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
+  * This is auto-generated if using the bootstrap or single-header generation
+  * *Note: The user will use the `AttributeTokens.csv` when the library is fully self-hosting.*
 * `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_USE_RECURSIVE_AST_DUPLICATION` is available but its not well tested and should not need to be used.  
+By default the base library implementation strictly uses a C-like interface. This is to allow for the generation of a C-variant of the library using [gen_c_library](../gen_c_library/). However, the library was written in C++ and supports some of its features:
-If constructing ASTs properly. There should be no modification of ASTs, and thus this would never become an issue.  
-(I will probably remove down the line...)
 
-Due to the design of `gen.hpp` to support being written alongside runtime intended code (in the same file), all the code is wrapped in a `GEN_TIME` `#ifdef` and then wrapped further in a `gen` namespace to avoid pollution of the global scope.
+* `GEN_SUPPORT_CPP_REFERENCES` : Will enable support for reference interface on some definitions
+* `GEN_SUPPORT_CPP_MEMBER_FEATURES` : Will enable support for definitions to have their interface as members.
 
-*Note: Its possible with the scanner feature to support parsing runtime files that use "generic" macros or identifiers with certain patterns.  
+*Note: A variant of the C++ library could be generated where those additonal support features are removed (see gen_c_library implementation for an idea of how)*
-This can be used to auto-queue generation of dependent definitions for the symbols used.*
 
-### Organization
+## On multi-threading
 
-Dependencies : Mostly from the c-zpl library.
+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.
 
-log_failure definition : based on whether to always use fatal on all errors
+## Extending the library
 
-Major enum definitions and their associated functions used with the AST data
+This library is relatively very small, and can be extended without much hassle.
 
-* `ECode` : Used to tag ASTs by their type
+The convention you'll see used throughout the interface of the library is as follows:
-* `EOperator` : Used to tag operator overloads with their op type
-* `ESpecifier` : Used with specifier ASTs for all specifiers the user may tag an associated
-AST with.
-* `AccessSpec` : Used with class and struct ASTs to denote the public, protected, or private fields.
-* `EnumT` : Used with def_enum to determine if constructing a regular enum or an enum class.
-* `ModuleFlag` : Used with any valid definition that can have export or import related keywords associated with it.
 
-#### Data Structures
+1. Check name or parameters to make sure they are valid for the construction requested
+2. Create a code object using `make_code`.
+3. Populate immediate fields (Name, Type, ModuleFlags, etc)
+4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected).
 
-`StringCache` : Hash table for cached strings. (`StringCached` typedef used to denote strings managed by it)
+Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.
 
-`Code` : Wrapper for `AST` with functionality for handling it appropriately.  
+`def_operator` is the most sophisticated constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
-`AST` : The node data structure for the code.  
-`Code Types` : Codes with typed ASTs. Body, Param, and Specifier have unique implementation, the rest use `Define_CodeType`  
-`AST Types` : Filtered AST definitions.  
 
-#### Gen Interface
+The library has its code segmented into component files, use it to help create a derived version without needing to have to rewrite a generated file directly or build on top of the header via composition or inheritance.
 
-First set of forwards are either backend functions used for various aspects of AST generation or configurations allocators used for different containers.
+The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.
 
-Interface forwards defined in order of: Upfront, Parsing, Untyped.
+## A note on compilation and runtime generation speed
 
-From there forwards for the File handlers are defined: Builder, Editor, Scanner.
+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).
-#### Macros
-
-General helper macros are defined along with the optional DSL macros.
-
-#### Constants
-
-Constants including optional ones are defined.
-
-#### Inlines
-
-Inlined functions related to the AST datatype that required forwards for gen interface functions are defined.
-
-## gen.cpp
-
-* Dependencies
-* Static data
-* AST Body case macros are next.
-* AST implementation
-* Gen interface begins with its `init`, `deinit`, etc.. Until `make_code_entires`
-* operator__validate defined, which will be used to verify if an operator definition is constructible.
-* Allocator interface for data arrays, code pool, code entries, string arenas, and string table.
-* Helper macros used throughout the constructor API
-* Upfront constructors, following the same order as shown in the header.
-* Parsing constructors, it defines its own lexer, and has many helper functions for parsing not exposed through the header.
-* Untyped constructors
-* Builder
-* Editor
-* Scanner

project/auxillary/builder.cpp

@@ -0,0 +1,59 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	include "builder.hpp"
+#endif
+
+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 = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+
+	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
+	return result;
+}
+
+void Builder::pad_lines( s32 num )
+{
+	append( & Buffer,  "\n" );
+}
+
+void Builder::print( Code code )
+{
+	String   str = to_string(code);
+	// const ssize len = str.length();
+	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
+	append( & Buffer, str );
+}
+
+void Builder::print_fmt( char const* fmt, ... )
+{
+	ssize   res;
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+	va_end( va );
+
+	// log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf );
+	append( & Buffer, buf, res );
+}
+
+void Builder::write()
+{
+	b32 result = file_write( & File, Buffer, length(Buffer) );
+
+	if ( result == false )
+		log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & File ) );
+
+	log_fmt( "Generated: %s\n", File.filename );
+	file_close( & File );
+	free(& Buffer);
+}

project/auxillary/builder.hpp

@@ -0,0 +1,20 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "gen.hpp"
+#endif
+
+struct Builder
+{
+	FileInfo File;
+	String   Buffer;
+
+	static Builder open( char const* path );
+
+	void pad_lines( s32 num );
+
+	void print( Code );
+	void print_fmt( char const* fmt, ... );
+
+	void write();
+};
+

project/auxillary/gen_template.hpp

@@ -0,0 +1,23 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "../gen.hpp"
+#endif
+
+/*
+	Explicitly generates a resolved definition of a cpp template definition.
+
+	TODO(Ed): Needs implementing for the C-library variant.
+	TODO(Ed): We need a non <token> syntax subst implemtnation for Strings for this to work. It must subst keywords directly based on template parameter names.
+
+	This is only meant to be used on relatively trivial templates, where the type or numeric is mostly a 'duck' type.
+	It cannot parse complex template parameters.
+
+	The varadic args should correspond 1:1 with the type of objects the generator expects from the template's parameters.alignas.
+*/
+
+CodeOperator gen_operator_template( CodeTemplate template, ... );
+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 );

project/auxillary/scanner.cpp

@@ -0,0 +1,5 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	include "scanner.hpp"
+#endif
+
+

project/auxillary/scanner.hpp

@@ -0,0 +1,160 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "gen.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
+Code scan_file( char const* path )
+{
+	FileInfo file;
+
+	FileError error = file_open_mode( & file, EFileMode_READ, path );
+	if ( error != EFileError_NONE )
+	{
+		GEN_FATAL( "scan_file: Could not open: %s", path );
+	}
+
+	ssize fsize = file_size( & file );
+	if ( fsize <= 0 )
+	{
+		GEN_FATAL("scan_file: %s is empty", path );
+	}
+
+	String str = string_make_reserve( GlobalAllocator, fsize );
+		file_read( & file, str, fsize );
+		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.
+	// Anything that comes before it will also be omitted.
+	{
+	#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" );
+
+		bool        found_directive = false;
+		char const* scanner         = str.Data;
+		s32         left            = fsize;
+		while ( left )
+		{
+			// Processing directive.
+			if ( current == '#' )
+			{
+				move_fwd();
+				while ( left && char_is_space( current ) )
+					move_fwd();
+
+				if ( ! found_directive )
+				{
+					if ( left && str_compare( scanner, directive_start.Ptr, directive_start.Len ) == matched )
+					{
+						scanner += directive_start.Len;
+						left    -= directive_start.Len;
+
+						while ( left && char_is_space( current ) )
+							move_fwd();
+
+						if ( left && str_compare( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
+						{
+							scanner += def_intellisense.Len;
+							left    -= def_intellisense.Len;
+
+							found_directive = true;
+						}
+					}
+
+					// Skip to end of line
+					while ( left && current != '\r' && current != '\n' )
+						move_fwd();
+					move_fwd();
+
+					if ( left && current == '\n' )
+						move_fwd();
+
+					continue;
+				}
+
+				if ( left && str_compare( scanner, directive_end.Ptr, directive_end.Len ) == matched )
+				{
+					scanner += directive_end.Len;
+					left    -= directive_end.Len;
+
+					// Skip to end of line
+					while ( left && current != '\r' && current != '\n' )
+						move_fwd();
+					move_fwd();
+
+					if ( left && current == '\n' )
+						move_fwd();
+
+					// sptr skip_size = fsize - left;
+					if ( (scanner + 2) >= ( str.Data + fsize ) )
+					{
+						mem_move( str, scanner, left );
+						get_header(str)->Length = left;
+						break;
+					}
+
+					mem_move( str, scanner, left );
+					get_header(str)->Length = left;
+
+					break;
+				}
+
+			}
+
+			move_fwd();
+		}
+	#undef move_fwd
+	#undef matched
+	#undef current
+	}
+
+	file_close( & file );
+	return untyped_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;
+	};
+}
+
+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;
+
+	return result;
+}
+#endif

project/bootstrap.cpp

@@ -0,0 +1,350 @@
+#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#define GEN_SUPPORT_CPP_MEMBER_FEATURES 0
+#define GEN_SUPPORT_CPP_REFERENCES      0
+#include "gen.cpp"
+
+#include "helpers/push_ignores.inline.hpp"
+#include "helpers/helper.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.cpp"
+GEN_NS_END
+
+#include "auxillary/builder.hpp"
+#include "auxillary/builder.cpp"
+#include "auxillary/scanner.hpp"
+
+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()
+
+void format_file( char const* path )
+{
+	String resolved_path = string_make(GlobalAllocator, to_str(path));
+
+	String style_arg = string_make(GlobalAllocator, txt("-style=file:"));
+	append( & style_arg, "../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 );
+	append( & command, cf_format_inplace );
+	append( & command, cf_verbose );
+	append( & command, style_arg );
+	append( & command, 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;
+}
+
+int gen_main()
+{
+	gen::init();
+
+	// PreprocessorDefines.append("GEN_NS");
+
+	Code push_ignores = scan_file( "helpers/push_ignores.inline.hpp" );
+	Code pop_ignores  = scan_file( "helpers/pop_ignores.inline.hpp" );
+
+	// gen_dep.hpp
+	{
+		Code platform     = scan_file( "dependencies/platform.hpp" );
+		Code macros 	  = scan_file( "dependencies/macros.hpp" );
+		Code basic_types  = scan_file( "dependencies/basic_types.hpp" );
+		Code debug        = scan_file( "dependencies/debug.hpp" );
+		Code memory	      = scan_file( "dependencies/memory.hpp" );
+		Code string_ops   = scan_file( "dependencies/string_ops.hpp" );
+		Code printing     = scan_file( "dependencies/printing.hpp" );
+		Code containers   = scan_file( "dependencies/containers.hpp" );
+		Code hashing 	  = scan_file( "dependencies/hashing.hpp" );
+		Code strings      = scan_file( "dependencies/strings.hpp" );
+		Code filesystem   = scan_file( "dependencies/filesystem.hpp" );
+		Code timing       = scan_file( "dependencies/timing.hpp" );
+
+		Builder
+		header = Builder::open("gen/gen.dep.hpp");
+		header.print_fmt( generation_notice );
+		header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n" );
+		header.print( platform );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		header.print( macros );
+		header.print( basic_types );
+		header.print( debug );
+		header.print( memory );
+		header.print( string_ops );
+		header.print( printing );
+		header.print( containers );
+		header.print( hashing );
+		header.print( strings );
+		header.print( filesystem );
+		header.print( timing );
+
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.write();
+	}
+
+	// gen_dep.cpp
+	{
+		Code src_start  = scan_file( "dependencies/src_start.cpp" );
+		Code debug      = scan_file( "dependencies/debug.cpp" );
+		Code string_ops = scan_file( "dependencies/string_ops.cpp" );
+		Code printing   = scan_file( "dependencies/printing.cpp" );
+		Code memory     = scan_file( "dependencies/memory.cpp" );
+		Code hashing    = scan_file( "dependencies/hashing.cpp" );
+		Code strings    = scan_file( "dependencies/strings.cpp" );
+		Code filesystem = scan_file( "dependencies/filesystem.cpp" );
+		Code timing     = scan_file( "dependencies/timing.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.dep.cpp" );
+		src.print_fmt( generation_notice );
+		src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
+		src.print( src_start );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		src.print( debug );
+		src.print( string_ops );
+		src.print( printing );
+		src.print( hashing );
+		src.print( memory );
+		src.print( strings );
+		src.print( filesystem );
+		src.print( timing );
+
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.write();
+	}
+
+	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(generation_notice) )
+	));
+
+	// gen.hpp
+	{
+		Code header_start = scan_file( "components/header_start.hpp" );
+		Code types        = scan_file( "components/types.hpp" );
+		Code ast          = scan_file( "components/ast.hpp" );
+		Code ast_types    = scan_file( "components/ast_types.hpp" );
+		Code code_types   = scan_file( "components/code_types.hpp" );
+		Code interface    = scan_file( "components/interface.hpp" );
+		Code inlines      = scan_file( "components/inlines.hpp" );
+		Code header_end   = scan_file( "components/header_end.hpp" );
+
+		CodeBody ecode       = gen_ecode     ( "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+		Builder
+		header = Builder::open( "gen/gen.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( push_ignores );
+		header.print( header_start );
+		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
+
+		header.print_fmt( "#pragma region Types\n" );
+		header.print( types );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(ecode) );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(eoperator) );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(especifier) );
+		header.print( fmt_newline);
+		header.print_fmt( "#pragma endregion Types\n\n" );
+
+		header.print_fmt( "#pragma region AST\n" );
+		header.print( ast );
+		header.print( code_types );
+		header.print( ast_types );
+		header.print_fmt( "\n#pragma endregion AST\n" );
+
+		header.print( interface );
+
+		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( fmt_newline );
+		header.print_fmt( "#pragma endregion Inlines\n" );
+
+		header.print( header_end );
+		header.print_fmt( "GEN_NS_END\n\n" );
+		header.print( pop_ignores );
+		header.write();
+
+		Builder
+		header_ecode = Builder::open( "components/gen/ecode.hpp" );
+		header_ecode.print( gen_component_header );
+		header_ecode.print( ecode );
+		header_ecode.write();
+
+		Builder
+		header_eoperator = Builder::open( "components/gen/eoperator.hpp" );
+		header_eoperator.print( gen_component_header );
+		header_eoperator.print( eoperator );
+		header_eoperator.write();
+
+		Builder
+		header_especifier = Builder::open( "components/gen/especifier.hpp" );
+		header_especifier.print( gen_component_header );
+		header_especifier.print( especifier );
+		header_especifier.write();
+
+		Builder
+		header_ast_inlines = Builder::open( "components/gen/ast_inlines.hpp" );
+		header_ast_inlines.print( gen_component_header );
+		header_ast_inlines.print( ast_inlines );
+		header_ast_inlines.write();
+	}
+
+	// gen.cpp
+	{
+		Code        src_start          = scan_file( "components/src_start.cpp" );
+		Code        static_data 	   = scan_file( "components/static_data.cpp" );
+		Code        ast_case_macros    = scan_file( "components/ast_case_macros.cpp" );
+		Code        ast			       = scan_file( "components/ast.cpp" );
+		Code        code_serialization = scan_file( "components/code_serialization.cpp" );
+		Code        interface	       = scan_file( "components/interface.cpp" );
+		Code        upfront 	       = scan_file( "components/interface.upfront.cpp" );
+		Code        lexer              = scan_file( "components/lexer.cpp" );
+		Code        parser             = scan_file( "components/parser.cpp" );
+		Code 	    parsing_interface  = scan_file( "components/interface.parsing.cpp" );
+		Code        untyped 	       = scan_file( "components/interface.untyped.cpp" );
+
+		CodeBody etoktype         = gen_etoktype( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
+		CodeNS   nspaced_etoktype = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
+
+		Builder
+		src = Builder::open( "gen/gen.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( push_ignores );
+		src.print( src_start );
+		src.print_fmt( "\nGEN_NS_BEGIN\n");
+
+		src.print( static_data );
+
+		src.print_fmt( "\n#pragma region AST\n\n" );
+		src.print( ast_case_macros );
+		src.print( ast );
+		src.print( code_serialization );
+		src.print_fmt( "\n#pragma endregion AST\n" );
+
+		src.print_fmt( "\n#pragma region Interface\n" );
+		src.print( interface );
+		src.print( upfront );
+		src.print_fmt( "\n#pragma region Parsing\n\n" );
+		src.print( dump_to_scratch_and_retireve(nspaced_etoktype) );
+		src.print( lexer );
+		src.print( parser );
+		src.print( parsing_interface );
+		src.print( untyped );
+		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
+		src.print_fmt( "#pragma endregion Interface\n\n" );
+
+		src.print_fmt( "GEN_NS_END\n\n");
+		src.print( pop_ignores );
+		src.write();
+
+		Builder
+		src_etoktype = Builder::open( "components/gen/etoktype.cpp" );
+		src_etoktype.print( gen_component_header );
+		src_etoktype.print( nspaced_etoktype );
+		src_etoktype.write();
+	}
+
+	// gen_builder.hpp
+	{
+		Code builder = scan_file( "auxillary/builder.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.builder.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		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.write();
+	}
+
+	// gen_builder.cpp
+	{
+		Code builder = scan_file( "auxillary/builder.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.builder.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( def_include( txt("gen.builder.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( builder );
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.write();
+	}
+
+	// gen_scanner.hpp
+	{
+		Code parsing = scan_file( "dependencies/parsing.hpp" );
+		Code scanner = scan_file( "auxillary/scanner.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.scanner.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( def_include( txt("gen.hpp") ) );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+		header.print( parsing );
+		header.print( scanner );
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.write();
+	}
+
+	// gen_scanner.cpp
+	{
+		Code parsing = scan_file( "dependencies/parsing.cpp" );
+		Code scanner = scan_file( "auxillary/scanner.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.scanner.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( def_include( txt("gen.scanner.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( parsing );
+		// src.print( scanner );
+		src.print_fmt( "GEN_NS_END\n" );
+		src.write();
+	}
+
+	gen::deinit();
+	return 0;
+}

project/components/ast.hpp

@@ -0,0 +1,494 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "types.hpp"
+#include "gen/ecode.hpp"
+#include "gen/eoperator.hpp"
+#include "gen/especifier.hpp"
+#endif
+
+struct AST;
+struct AST_Body;
+struct AST_Attributes;
+struct AST_Comment;
+struct AST_Constructor;
+// struct AST_BaseClass;
+struct AST_Class;
+struct AST_Define;
+struct AST_Destructor;
+struct AST_Enum;
+struct AST_Exec;
+struct AST_Extern;
+struct AST_Include;
+struct AST_Friend;
+struct AST_Fn;
+struct AST_Module;
+struct AST_NS;
+struct AST_Operator;
+struct AST_OpCast;
+struct AST_Param;
+struct AST_Pragma;
+struct AST_PreprocessCond;
+struct AST_Specifiers;
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct AST_Expr;
+struct AST_Expr_Assign;
+struct AST_Expr_Alignof;
+struct AST_Expr_Binary;
+struct AST_Expr_CStyleCast;
+struct AST_Expr_FunctionalCast;
+struct AST_Expr_CppCast;
+struct AST_Expr_ProcCall;
+struct AST_Expr_Decltype;
+struct AST_Expr_Comma;  // TODO(Ed) : This is a binary op not sure if it needs its own AST...
+struct AST_Expr_AMS;    // Access Member Symbol
+struct AST_Expr_Sizeof;
+struct AST_Expr_Subscript;
+struct AST_Expr_Ternary;
+struct AST_Expr_UnaryPrefix;
+struct AST_Expr_UnaryPostfix;
+struct AST_Expr_Element;
+
+struct AST_Stmt;
+struct AST_Stmt_Break;
+struct AST_Stmt_Case;
+struct AST_Stmt_Continue;
+struct AST_Stmt_Decl;
+struct AST_Stmt_Do;
+struct AST_Stmt_Expr;  // TODO(Ed) : Is this distinction needed? (Should it be a flag instead?)
+struct AST_Stmt_Else;
+struct AST_Stmt_If;
+struct AST_Stmt_For;
+struct AST_Stmt_Goto;
+struct AST_Stmt_Label;
+struct AST_Stmt_Switch;
+struct AST_Stmt_While;
+#endif
+
+struct AST_Struct;
+struct AST_Template;
+struct AST_Type;
+struct AST_Typedef;
+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);
+#endif
+
+Define_Code(Struct);
+Define_Code(Template);
+Define_Code(Type);
+Define_Code(Typedef);
+Define_Code(Union);
+Define_Code(Using);
+Define_Code(Var);
+#undef Define_Code
+
+namespace parser
+{
+	struct Token;
+}
+
+#if ! GEN_COMPILER_C
+template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
+#endif
+
+char const* debug_str (Code code);
+Code        duplicate (Code code);
+bool        is_equal  (Code code, Code other);
+bool        is_body   (Code code);
+bool        is_valid  (Code code);
+void        set_global(Code code);
+String      to_string (Code code);
+
+#if ! GEN_COMPILER_C
+/*
+	AST* wrapper
+	- Not constantly have to append the '*' as this is written often..
+	- Allows for implicit conversion to any of the ASTs (raw or filtered).
+*/
+struct Code
+{
+	AST* ast;
+
+#	define Using_Code( Typename )                                                     \
+	char const* debug_str()                { return GEN_NS debug_str(* this); }       \
+	Code        duplicate()                { return GEN_NS duplicate(* this); }	      \
+	bool        is_equal( Code other )     { return GEN_NS is_equal(* this, other); } \
+	bool        is_body()                  { return GEN_NS is_body(* this); }         \
+	bool        is_valid()                 { return GEN_NS is_valid(* this); }        \
+	void        set_global()               { return GEN_NS set_global(* this); }
+
+#	define Using_CodeOps( Typename )                                         \
+	Typename&   operator = ( AST* other );                                   \
+	Typename&   operator = ( Code other );                                   \
+	bool        operator ==( Code other ) { return (AST*)ast == other.ast; } \
+	bool        operator !=( Code other ) { return (AST*)ast != other.ast; } \
+	operator bool();
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+	Using_Code( Code );
+	String to_string() { return GEN_NS to_string(* this); }
+#endif
+
+	Using_CodeOps( Code );
+
+	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
+	operator CodeBody() const;
+	operator CodeAttributes() const;
+	// operator CodeBaseClass() const;
+	operator CodeComment() const;
+	operator CodeClass() const;
+	operator CodeConstructor() const;
+	operator CodeDefine() const;
+	operator CodeDestructor() const;
+	operator CodeExec() const;
+	operator CodeEnum() const;
+	operator CodeExtern() const;
+	operator CodeInclude() const;
+	operator CodeFriend() const;
+	operator CodeFn() const;
+	operator CodeModule() const;
+	operator CodeNS() const;
+	operator CodeOperator() const;
+	operator CodeOpCast() const;
+	operator CodeParam() const;
+	operator CodePragma() const;
+	operator CodePreprocessCond() const;
+	operator CodeSpecifiers() const;
+	operator CodeStruct() const;
+	operator CodeTemplate() const;
+	operator CodeType() const;
+	operator CodeTypedef() const;
+	operator CodeUnion() const;
+	operator CodeUsing() const;
+	operator CodeVar() const;
+	#undef operator
+};
+#endif
+
+#pragma region Statics
+// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
+extern Code Code_Global;
+
+// Used to identify invalid generated code.
+extern Code Code_Invalid;
+#pragma endregion Statics
+
+struct Code_POD
+{
+	AST* ast;
+};
+
+static_assert( sizeof(Code) == sizeof(Code_POD), "ERROR: Code is not POD" );
+
+// Desired width of the AST data structure.
+constexpr int const AST_POD_Size = 128;
+
+void        append       ( AST* self, AST* other );
+char const* debug_str    ( AST* self );
+AST*        duplicate    ( AST* self );
+Code*       entry        ( AST* self, u32 idx );
+bool        has_entries  ( AST* self );
+bool        is_body      ( AST* self );
+bool        is_equal     ( AST* self, AST* other );
+String      to_string    ( AST* self );
+void        to_string    ( AST* self, String* result );
+char const* type_str     ( AST* self );
+bool        validate_body( AST* self );
+
+#if GEN_CPP_SUPPORT_REFERENCES
+void        append   ( AST& self, AST& other ) { return append(& self, & other); }
+bool        is_body  ( AST& self )             { return is_body(& self); }
+bool        is_equal ( AST& self, AST& other ) { return is_equal(& self, & other); }
+char const* debug_str( AST& self )             { return debug_str( & self ); }
+String      to_string( AST& self )             { return to_string( & self ); }
+char const* type_str ( AST& self )             { return type_str( & self ); }
+#endif
+
+constexpr static
+int AST_ArrSpecs_Cap =
+(
+		AST_POD_Size
+		- sizeof(AST*) * 3
+		- sizeof(parser::Token*)
+		- sizeof(AST*)
+		- sizeof(StringCached)
+		- sizeof(CodeT)
+		- sizeof(ModuleFlag)
+		- sizeof(int)
+)
+/ sizeof(int) - 1; // -1 for 4 extra bytes
+
+/*
+	Simple AST POD with functionality to seralize into C++ syntax.
+*/
+struct AST
+{
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#	pragma region Member Functions
+	void        append     ( AST* other )  { GEN_NS append(this, other); }
+	char const* debug_str  ()              { return GEN_NS debug_str(this); }
+	AST*        duplicate  ()              { return GEN_NS duplicate(this); }
+	Code*       entry      ( u32 idx )     { return GEN_NS entry(this, idx); }
+	bool        has_entries()              { return GEN_NS has_entries(this); }
+	bool        is_equal   ( AST* other )  { return GEN_NS is_equal(this, other); }
+	bool        is_body()                  { return GEN_NS is_body(this); }
+	char const* type_str()                 { return GEN_NS type_str(this); }
+	bool        validate_body()            { return GEN_NS validate_body(this); }
+
+	String to_string()                 { return GEN_NS to_string(this); }
+	void   to_string( String& result ) { return GEN_NS to_string(this, & result); }
+
+#	pragma endregion Member Functions
+#endif
+
+	operator Code();
+	operator CodeBody();
+	operator CodeAttributes();
+	// operator CodeBaseClass();
+	operator CodeComment();
+	operator CodeConstructor();
+	operator CodeDestructor();
+	operator CodeClass();
+	operator CodeDefine();
+	operator CodeEnum();
+	operator CodeExec();
+	operator CodeExtern();
+	operator CodeInclude();
+	operator CodeFriend();
+	operator CodeFn();
+	operator CodeModule();
+	operator CodeNS();
+	operator CodeOperator();
+	operator CodeOpCast();
+	operator CodeParam();
+	operator CodePragma();
+	operator CodePreprocessCond();
+	operator CodeSpecifiers();
+	operator CodeStruct();
+	operator CodeTemplate();
+	operator CodeType();
+	operator CodeTypedef();
+	operator CodeUnion();
+	operator CodeUsing();
+	operator CodeVar();
+
+	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;           // Parameter
+				AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
+				AST*  Params;          // Constructor, Function, Operator, Template, Typename
+			};
+			union {
+				AST*  ArrExpr;          // Typename
+				AST*  Body;             // Class, Constructor, Destructor, Enum, Friend, 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*  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
+				AST*  PostNameMacro;     // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
+			};
+		};
+		StringCached  Content;          // Attributes, Comment, Execution, Include
+		struct {
+			SpecifierT ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
+			AST*       NextSpecs;              // Specifiers; If ArrSpecs is full, then NextSpecs is used.
+		};
+	};
+	union {
+		AST* Prev;
+		AST* Front;
+		AST* Last;
+	};
+	union {
+		AST* Next;
+		AST* Back;
+	};
+	parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
+	AST*              Parent;
+	StringCached      Name;
+	CodeT             Type;
+//	CodeFlag          CodeFlags;
+	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           VarConstructorInit;  // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
+		b32           EnumUnderlyingMacro; // Used by enums incase the user wants to wrap underlying type specification in a macro
+	};
+};
+
+struct AST_POD
+{
+	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;           // Parameter
+				AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
+				AST*  Params;          // Constructor, Function, Operator, Template, Typename
+			};
+			union {
+				AST*  ArrExpr;          // Typename
+				AST*  Body;             // Class, Constructr, Destructor, Enum, Friend, 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*  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
+				AST*  PostNameMacro;    // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
+			};
+		};
+		StringCached  Content;          // Attributes, Comment, Execution, Include
+		struct {
+			SpecifierT ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
+			AST*       NextSpecs;                   // Specifiers; If ArrSpecs is full, then NextSpecs is used.
+		};
+	};
+	union {
+		AST* Prev;
+		AST* Front;
+		AST* Last;
+	};
+	union {
+		AST* Next;
+		AST* Back;
+	};
+	parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
+	AST*              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	CodeFlag          CodeFlags;
+	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           VarConstructorInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
+	};
+};
+
+// Its intended for the AST to have equivalent size to its POD.
+// All extra functionality within the AST namespace should just be syntatic sugar.
+static_assert( sizeof(AST)     == sizeof(AST_POD), "ERROR: AST IS NOT POD" );
+static_assert( sizeof(AST_POD) == AST_POD_Size,    "ERROR: AST POD is not size of AST_POD_Size" );
+
+// Used when the its desired when omission is allowed in a definition.
+#define NoCode      { nullptr }
+#define InvalidCode (* Code_Invalid.ast) // Uses an implicitly overloaded cast from the AST to the desired code type.

project/components/ast_case_macros.cpp

@@ -0,0 +1,78 @@
+#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES \
+	case PlatformAttributes:                  \
+	case Class_Body:                          \
+	case Enum_Body:                           \
+	case Extern_Linkage:                      \
+	case Function_Body:                       \
+	case Function_Fwd:                        \
+	case Global_Body:                         \
+	case Namespace:                           \
+	case Namespace_Body:                      \
+	case Operator:                            \
+	case Operator_Fwd:                        \
+	case Parameters:                          \
+	case Specifiers:                          \
+	case Struct_Body:                         \
+	case Typename:
+#	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
+
+#	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES \
+	case Access_Public:                          \
+	case Access_Protected:                       \
+	case Access_Private:                         \
+	case PlatformAttributes:                     \
+	case Class_Body:                             \
+	case Enum_Body:                              \
+	case Extern_Linkage:                         \
+	case Friend:                                 \
+	case Function_Body:                          \
+	case Function_Fwd:                           \
+	case Global_Body:                            \
+	case Namespace:                              \
+	case Namespace_Body:                         \
+	case Operator:                               \
+	case Operator_Fwd:                           \
+	case Operator_Member:                        \
+	case Operator_Member_Fwd:                    \
+	case Parameters:                             \
+	case Specifiers:                             \
+	case Struct_Body:                            \
+	case Typename:
+
+#	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES \
+	case Access_Public: 				       \
+	case Access_Protected: 				       \
+	case Access_Private: 				       \
+	case PlatformAttributes:                   \
+	case Class_Body: 					       \
+	case Enum_Body: 					       \
+	case Execution: 					       \
+	case Friend: 						       \
+	case Function_Body: 				       \
+	case Namespace_Body: 				       \
+	case Operator_Member: 				       \
+	case Operator_Member_Fwd: 			       \
+	case Parameters: 					       \
+	case Specifiers: 					       \
+	case Struct_Body: 					       \
+	case 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
+
+#	define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES \
+	case Access_Public: 				          \
+	case Access_Protected: 				          \
+	case Access_Private: 				          \
+	case PlatformAttributes:                      \
+	case Class_Body: 					          \
+	case Enum_Body: 					          \
+	case Execution: 					          \
+	case Friend: 						          \
+	case Function_Body: 				          \
+	case Namespace_Body: 				          \
+	case Operator_Member: 				          \
+	case Operator_Member_Fwd: 			          \
+	case Parameters: 					          \
+	case Specifiers: 					          \
+	case Struct_Body: 					          \
+	case Typename:

project/components/gen/ecode.hpp

@@ -0,0 +1,144 @@
+#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)
+
+namespace ECode
+{
+	enum Type : u32
+	{
+		Invalid,
+		Untyped,
+		NewLine,
+		Comment,
+		Access_Private,
+		Access_Protected,
+		Access_Public,
+		PlatformAttributes,
+		Class,
+		Class_Fwd,
+		Class_Body,
+		Constructor,
+		Constructor_Fwd,
+		Destructor,
+		Destructor_Fwd,
+		Enum,
+		Enum_Fwd,
+		Enum_Body,
+		Enum_Class,
+		Enum_Class_Fwd,
+		Execution,
+		Export_Body,
+		Extern_Linkage,
+		Extern_Linkage_Body,
+		Friend,
+		Function,
+		Function_Fwd,
+		Function_Body,
+		Global_Body,
+		Module,
+		Namespace,
+		Namespace_Body,
+		Operator,
+		Operator_Fwd,
+		Operator_Member,
+		Operator_Member_Fwd,
+		Operator_Cast,
+		Operator_Cast_Fwd,
+		Parameters,
+		Preprocess_Define,
+		Preprocess_Include,
+		Preprocess_If,
+		Preprocess_IfDef,
+		Preprocess_IfNotDef,
+		Preprocess_ElIf,
+		Preprocess_Else,
+		Preprocess_EndIf,
+		Preprocess_Pragma,
+		Specifiers,
+		Struct,
+		Struct_Fwd,
+		Struct_Body,
+		Template,
+		Typedef,
+		Typename,
+		Union,
+		Union_Body,
+		Using,
+		Using_Namespace,
+		Variable,
+		NumTypes
+	};
+
+	inline StrC to_str( Type type )
+	{
+		local_persist StrC lookup[] {
+			{ sizeof( "Invalid" ),             "Invalid"             },
+			{ sizeof( "Untyped" ),             "Untyped"             },
+			{ sizeof( "NewLine" ),             "NewLine"             },
+			{ sizeof( "Comment" ),             "Comment"             },
+			{ sizeof( "Access_Private" ),      "Access_Private"      },
+			{ sizeof( "Access_Protected" ),    "Access_Protected"    },
+			{ sizeof( "Access_Public" ),       "Access_Public"       },
+			{ sizeof( "PlatformAttributes" ),  "PlatformAttributes"  },
+			{ sizeof( "Class" ),               "Class"               },
+			{ sizeof( "Class_Fwd" ),           "Class_Fwd"           },
+			{ sizeof( "Class_Body" ),          "Class_Body"          },
+			{ sizeof( "Constructor" ),         "Constructor"         },
+			{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"     },
+			{ sizeof( "Destructor" ),          "Destructor"          },
+			{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"      },
+			{ sizeof( "Enum" ),                "Enum"                },
+			{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"            },
+			{ sizeof( "Enum_Body" ),           "Enum_Body"           },
+			{ sizeof( "Enum_Class" ),          "Enum_Class"          },
+			{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"      },
+			{ sizeof( "Execution" ),           "Execution"           },
+			{ sizeof( "Export_Body" ),         "Export_Body"         },
+			{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"      },
+			{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
+			{ sizeof( "Friend" ),              "Friend"              },
+			{ sizeof( "Function" ),            "Function"            },
+			{ sizeof( "Function_Fwd" ),        "Function_Fwd"        },
+			{ sizeof( "Function_Body" ),       "Function_Body"       },
+			{ sizeof( "Global_Body" ),         "Global_Body"         },
+			{ sizeof( "Module" ),              "Module"              },
+			{ sizeof( "Namespace" ),           "Namespace"           },
+			{ sizeof( "Namespace_Body" ),      "Namespace_Body"      },
+			{ sizeof( "Operator" ),            "Operator"            },
+			{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"        },
+			{ sizeof( "Operator_Member" ),     "Operator_Member"     },
+			{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
+			{ sizeof( "Operator_Cast" ),       "Operator_Cast"       },
+			{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"   },
+			{ sizeof( "Parameters" ),          "Parameters"          },
+			{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"   },
+			{ sizeof( "Preprocess_Include" ),  "Preprocess_Include"  },
+			{ sizeof( "Preprocess_If" ),       "Preprocess_If"       },
+			{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"    },
+			{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
+			{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"     },
+			{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"     },
+			{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"    },
+			{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"   },
+			{ sizeof( "Specifiers" ),          "Specifiers"          },
+			{ sizeof( "Struct" ),              "Struct"              },
+			{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"          },
+			{ sizeof( "Struct_Body" ),         "Struct_Body"         },
+			{ sizeof( "Template" ),            "Template"            },
+			{ sizeof( "Typedef" ),             "Typedef"             },
+			{ sizeof( "Typename" ),            "Typename"            },
+			{ sizeof( "Union" ),               "Union"               },
+			{ sizeof( "Union_Body" ),          "Union_Body"          },
+			{ sizeof( "Using" ),               "Using"               },
+			{ sizeof( "Using_Namespace" ),     "Using_Namespace"     },
+			{ sizeof( "Variable" ),            "Variable"            },
+		};
+		return lookup[type];
+	}
+
+}    // namespace ECode
+
+using CodeT = ECode::Type;

project/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)
+
+namespace EOperator
+{
+	enum Type : u32
+	{
+		Invalid,
+		Assign,
+		Assign_Add,
+		Assign_Subtract,
+		Assign_Multiply,
+		Assign_Divide,
+		Assign_Modulo,
+		Assign_BAnd,
+		Assign_BOr,
+		Assign_BXOr,
+		Assign_LShift,
+		Assign_RShift,
+		Increment,
+		Decrement,
+		Unary_Plus,
+		Unary_Minus,
+		UnaryNot,
+		Add,
+		Subtract,
+		Multiply,
+		Divide,
+		Modulo,
+		BNot,
+		BAnd,
+		BOr,
+		BXOr,
+		LShift,
+		RShift,
+		LAnd,
+		LOr,
+		LEqual,
+		LNot,
+		Lesser,
+		Greater,
+		LesserEqual,
+		GreaterEqual,
+		Subscript,
+		Indirection,
+		AddressOf,
+		MemberOfPointer,
+		PtrToMemOfPtr,
+		FunctionCall,
+		Comma,
+		New,
+		NewArray,
+		Delete,
+		DeleteArray,
+		NumOps
+	};
+
+	inline StrC to_str( Type op )
+	{
+		local_persist StrC lookup[] {
+			{ sizeof( "INVALID" ),  "INVALID"  },
+			{ sizeof( "=" ),        "="        },
+			{ sizeof( "+=" ),       "+="       },
+			{ sizeof( "-=" ),       "-="       },
+			{ sizeof( "*=" ),       "*="       },
+			{ sizeof( "/=" ),       "/="       },
+			{ sizeof( "%=" ),       "%="       },
+			{ sizeof( "&=" ),       "&="       },
+			{ sizeof( "|=" ),       "|="       },
+			{ sizeof( "^=" ),       "^="       },
+			{ sizeof( "<<=" ),      "<<="      },
+			{ sizeof( ">>=" ),      ">>="      },
+			{ sizeof( "++" ),       "++"       },
+			{ sizeof( "--" ),       "--"       },
+			{ sizeof( "+" ),        "+"        },
+			{ sizeof( "-" ),        "-"        },
+			{ sizeof( "!" ),        "!"        },
+			{ sizeof( "+" ),        "+"        },
+			{ sizeof( "-" ),        "-"        },
+			{ sizeof( "*" ),        "*"        },
+			{ sizeof( "/" ),        "/"        },
+			{ sizeof( "%" ),        "%"        },
+			{ sizeof( "~" ),        "~"        },
+			{ sizeof( "&" ),        "&"        },
+			{ sizeof( "|" ),        "|"        },
+			{ sizeof( "^" ),        "^"        },
+			{ sizeof( "<<" ),       "<<"       },
+			{ sizeof( ">>" ),       ">>"       },
+			{ sizeof( "&&" ),       "&&"       },
+			{ sizeof( "||" ),       "||"       },
+			{ sizeof( "==" ),       "=="       },
+			{ sizeof( "!=" ),       "!="       },
+			{ sizeof( "<" ),        "<"        },
+			{ sizeof( ">" ),        ">"        },
+			{ sizeof( "<=" ),       "<="       },
+			{ sizeof( ">=" ),       ">="       },
+			{ sizeof( "[]" ),       "[]"       },
+			{ sizeof( "*" ),        "*"        },
+			{ sizeof( "&" ),        "&"        },
+			{ sizeof( "->" ),       "->"       },
+			{ sizeof( "->*" ),      "->*"      },
+			{ sizeof( "()" ),       "()"       },
+			{ sizeof( "," ),        ","        },
+			{ sizeof( "new" ),      "new"      },
+			{ sizeof( "new[]" ),    "new[]"    },
+			{ sizeof( "delete" ),   "delete"   },
+			{ sizeof( "delete[]" ), "delete[]" },
+		};
+		return lookup[op];
+	}
+
+}    // namespace EOperator
+
+using OperatorT = EOperator::Type;

project/components/gen/especifier.hpp

@@ -0,0 +1,98 @@
+#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)
+
+namespace ESpecifier
+{
+	enum Type : u32
+	{
+		Invalid,
+		Consteval,
+		Constexpr,
+		Constinit,
+		Explicit,
+		External_Linkage,
+		ForceInline,
+		Global,
+		Inline,
+		Internal_Linkage,
+		Local_Persist,
+		Mutable,
+		NeverInline,
+		Ptr,
+		Ref,
+		Register,
+		RValue,
+		Static,
+		Thread_Local,
+		Virtual,
+		Const,
+		Final,
+		NoExceptions,
+		Override,
+		Pure,
+		Volatile,
+		NumSpecifiers
+	};
+
+	inline bool is_trailing( Type specifier )
+	{
+		return specifier > Virtual;
+	}
+
+	inline StrC to_str( Type type )
+	{
+		local_persist StrC lookup[] {
+			{ sizeof( "INVALID" ),       "INVALID"       },
+			{ sizeof( "consteval" ),     "consteval"     },
+			{ sizeof( "constexpr" ),     "constexpr"     },
+			{ sizeof( "constinit" ),     "constinit"     },
+			{ sizeof( "explicit" ),      "explicit"      },
+			{ sizeof( "extern" ),        "extern"        },
+			{ sizeof( "forceinline" ),   "forceinline"   },
+			{ sizeof( "global" ),        "global"        },
+			{ sizeof( "inline" ),        "inline"        },
+			{ sizeof( "internal" ),      "internal"      },
+			{ sizeof( "local_persist" ), "local_persist" },
+			{ sizeof( "mutable" ),       "mutable"       },
+			{ sizeof( "neverinline" ),   "neverinline"   },
+			{ sizeof( "*" ),             "*"             },
+			{ sizeof( "&" ),             "&"             },
+			{ sizeof( "register" ),      "register"      },
+			{ sizeof( "&&" ),            "&&"            },
+			{ sizeof( "static" ),        "static"        },
+			{ sizeof( "thread_local" ),  "thread_local"  },
+			{ sizeof( "virtual" ),       "virtual"       },
+			{ sizeof( "const" ),         "const"         },
+			{ sizeof( "final" ),         "final"         },
+			{ sizeof( "noexcept" ),      "noexcept"      },
+			{ sizeof( "override" ),      "override"      },
+			{ sizeof( "= 0" ),           "= 0"           },
+			{ sizeof( "volatile" ),      "volatile"      },
+		};
+		return lookup[type];
+	}
+
+	inline Type to_type( StrC str )
+	{
+		local_persist u32 keymap[NumSpecifiers];
+		do_once_start for ( u32 index = 0; index < NumSpecifiers; index++ )
+		{
+			StrC enum_str = to_str( (Type)index );
+			keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+		}
+		do_once_end u32 hash = crc32( str.Ptr, str.Len );
+		for ( u32 index = 0; index < NumSpecifiers; index++ )
+		{
+			if ( keymap[index] == hash )
+				return (Type)index;
+		}
+		return Invalid;
+	}
+
+}    // namespace ESpecifier
+
+using SpecifierT = ESpecifier::Type;

project/components/gen/etoktype.cpp

@@ -0,0 +1,241 @@
+#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)
+
+namespace parser
+{
+	namespace ETokType
+	{
+#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Attribute_API_Import, "GEN_API_Import_Code" )
+
+		enum Type : u32
+		{
+			Invalid,
+			Access_Private,
+			Access_Protected,
+			Access_Public,
+			Access_MemberSymbol,
+			Access_StaticSymbol,
+			Ampersand,
+			Ampersand_DBL,
+			Assign_Classifer,
+			Attribute_Open,
+			Attribute_Close,
+			BraceCurly_Open,
+			BraceCurly_Close,
+			BraceSquare_Open,
+			BraceSquare_Close,
+			Capture_Start,
+			Capture_End,
+			Comment,
+			Comment_End,
+			Comment_Start,
+			Char,
+			Comma,
+			Decl_Class,
+			Decl_GNU_Attribute,
+			Decl_MSVC_Attribute,
+			Decl_Enum,
+			Decl_Extern_Linkage,
+			Decl_Friend,
+			Decl_Module,
+			Decl_Namespace,
+			Decl_Operator,
+			Decl_Struct,
+			Decl_Template,
+			Decl_Typedef,
+			Decl_Using,
+			Decl_Union,
+			Identifier,
+			Module_Import,
+			Module_Export,
+			NewLine,
+			Number,
+			Operator,
+			Preprocess_Hash,
+			Preprocess_Define,
+			Preprocess_If,
+			Preprocess_IfDef,
+			Preprocess_IfNotDef,
+			Preprocess_ElIf,
+			Preprocess_Else,
+			Preprocess_EndIf,
+			Preprocess_Include,
+			Preprocess_Pragma,
+			Preprocess_Content,
+			Preprocess_Macro,
+			Preprocess_Unsupported,
+			Spec_Alignas,
+			Spec_Const,
+			Spec_Consteval,
+			Spec_Constexpr,
+			Spec_Constinit,
+			Spec_Explicit,
+			Spec_Extern,
+			Spec_Final,
+			Spec_ForceInline,
+			Spec_Global,
+			Spec_Inline,
+			Spec_Internal_Linkage,
+			Spec_LocalPersist,
+			Spec_Mutable,
+			Spec_NeverInline,
+			Spec_Override,
+			Spec_Static,
+			Spec_ThreadLocal,
+			Spec_Volatile,
+			Spec_Virtual,
+			Star,
+			Statement_End,
+			StaticAssert,
+			String,
+			Type_Typename,
+			Type_Unsigned,
+			Type_Signed,
+			Type_Short,
+			Type_Long,
+			Type_bool,
+			Type_char,
+			Type_int,
+			Type_double,
+			Type_MS_int8,
+			Type_MS_int16,
+			Type_MS_int32,
+			Type_MS_int64,
+			Type_MS_W64,
+			Varadic_Argument,
+			__Attributes_Start,
+			Attribute_API_Export,
+			Attribute_API_Import,
+			NumTokens
+		};
+
+		inline StrC to_str( Type type )
+		{
+			local_persist StrC lookup[] {
+				{ sizeof( "__invalid__" ),         "__invalid__"         },
+				{ sizeof( "private" ),             "private"             },
+				{ sizeof( "protected" ),           "protected"           },
+				{ sizeof( "public" ),              "public"              },
+				{ sizeof( "." ),                   "."                   },
+				{ sizeof( "::" ),                  "::"                  },
+				{ sizeof( "&" ),                   "&"                   },
+				{ sizeof( "&&" ),                  "&&"                  },
+				{ sizeof( ":" ),                   ":"                   },
+				{ sizeof( "[[" ),                  "[["                  },
+				{ sizeof( "]]" ),                  "]]"                  },
+				{ sizeof( "{" ),                   "{"                   },
+				{ sizeof( "}" ),                   "}"                   },
+				{ sizeof( "[" ),                   "["                   },
+				{ sizeof( "]" ),                   "]"                   },
+				{ sizeof( "(" ),                   "("                   },
+				{ sizeof( ")" ),                   ")"                   },
+				{ sizeof( "__comment__" ),         "__comment__"         },
+				{ sizeof( "__comment_end__" ),     "__comment_end__"     },
+				{ sizeof( "__comment_start__" ),   "__comment_start__"   },
+				{ sizeof( "__character__" ),       "__character__"       },
+				{ sizeof( "," ),                   ","                   },
+				{ sizeof( "class" ),               "class"               },
+				{ sizeof( "__attribute__" ),       "__attribute__"       },
+				{ sizeof( "__declspec" ),          "__declspec"          },
+				{ sizeof( "enum" ),                "enum"                },
+				{ sizeof( "extern" ),              "extern"              },
+				{ sizeof( "friend" ),              "friend"              },
+				{ sizeof( "module" ),              "module"              },
+				{ sizeof( "namespace" ),           "namespace"           },
+				{ sizeof( "operator" ),            "operator"            },
+				{ sizeof( "struct" ),              "struct"              },
+				{ sizeof( "template" ),            "template"            },
+				{ sizeof( "typedef" ),             "typedef"             },
+				{ sizeof( "using" ),               "using"               },
+				{ sizeof( "union" ),               "union"               },
+				{ sizeof( "__identifier__" ),      "__identifier__"      },
+				{ sizeof( "import" ),              "import"              },
+				{ sizeof( "export" ),              "export"              },
+				{ sizeof( "__new_line__" ),        "__new_line__"        },
+				{ sizeof( "__number__" ),          "__number__"          },
+				{ sizeof( "__operator__" ),        "__operator__"        },
+				{ sizeof( "#" ),                   "#"                   },
+				{ sizeof( "define" ),              "define"              },
+				{ sizeof( "if" ),                  "if"                  },
+				{ sizeof( "ifdef" ),               "ifdef"               },
+				{ sizeof( "ifndef" ),              "ifndef"              },
+				{ sizeof( "elif" ),                "elif"                },
+				{ sizeof( "else" ),                "else"                },
+				{ sizeof( "endif" ),               "endif"               },
+				{ sizeof( "include" ),             "include"             },
+				{ sizeof( "pragma" ),              "pragma"              },
+				{ sizeof( "__macro_content__" ),   "__macro_content__"   },
+				{ sizeof( "__macro__" ),           "__macro__"           },
+				{ sizeof( "__unsupported__" ),     "__unsupported__"     },
+				{ sizeof( "alignas" ),             "alignas"             },
+				{ sizeof( "const" ),               "const"               },
+				{ sizeof( "consteval" ),           "consteval"           },
+				{ sizeof( "constexpr" ),           "constexpr"           },
+				{ sizeof( "constinit" ),           "constinit"           },
+				{ sizeof( "explicit" ),            "explicit"            },
+				{ sizeof( "extern" ),              "extern"              },
+				{ sizeof( "final" ),               "final"               },
+				{ sizeof( "forceinline" ),         "forceinline"         },
+				{ sizeof( "global" ),              "global"              },
+				{ sizeof( "inline" ),              "inline"              },
+				{ sizeof( "internal" ),            "internal"            },
+				{ sizeof( "local_persist" ),       "local_persist"       },
+				{ sizeof( "mutable" ),             "mutable"             },
+				{ sizeof( "neverinline" ),         "neverinline"         },
+				{ sizeof( "override" ),            "override"            },
+				{ sizeof( "static" ),              "static"              },
+				{ sizeof( "thread_local" ),        "thread_local"        },
+				{ sizeof( "volatile" ),            "volatile"            },
+				{ sizeof( "virtual" ),             "virtual"             },
+				{ sizeof( "*" ),                   "*"                   },
+				{ sizeof( ";" ),                   ";"                   },
+				{ sizeof( "static_assert" ),       "static_assert"       },
+				{ sizeof( "__string__" ),          "__string__"          },
+				{ sizeof( "typename" ),            "typename"            },
+				{ sizeof( "unsigned" ),            "unsigned"            },
+				{ sizeof( "signed" ),              "signed"              },
+				{ sizeof( "short" ),               "short"               },
+				{ sizeof( "long" ),                "long"                },
+				{ sizeof( "bool" ),                "bool"                },
+				{ sizeof( "char" ),                "char"                },
+				{ sizeof( "int" ),                 "int"                 },
+				{ sizeof( "double" ),              "double"              },
+				{ sizeof( "__int8" ),              "__int8"              },
+				{ sizeof( "__int16" ),             "__int16"             },
+				{ sizeof( "__int32" ),             "__int32"             },
+				{ sizeof( "__int64" ),             "__int64"             },
+				{ sizeof( "_W64" ),                "_W64"                },
+				{ sizeof( "..." ),                 "..."                 },
+				{ sizeof( "__attrib_start__" ),    "__attrib_start__"    },
+				{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
+				{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
+			};
+			return lookup[type];
+		}
+
+		inline Type to_type( StrC str )
+		{
+			local_persist u32 keymap[NumTokens];
+			do_once_start for ( u32 index = 0; index < NumTokens; index++ )
+			{
+				StrC enum_str = to_str( (Type)index );
+				keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+			}
+			do_once_end u32 hash = crc32( str.Ptr, str.Len );
+			for ( u32 index = 0; index < NumTokens; index++ )
+			{
+				if ( keymap[index] == hash )
+					return (Type)index;
+			}
+			return Invalid;
+		}
+
+	}    // namespace ETokType
+
+	using TokType = ETokType::Type;
+
+}    // namespace parser

project/components/header_end.hpp

@@ -0,0 +1,184 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "inlines.hpp"
+#include "gen/ast_inlines.hpp"
+#endif
+
+#pragma region Constants
+
+#ifndef GEN_GLOBAL_BUCKET_SIZE
+#	define GEN_GLOBAL_BUCKET_SIZE megabytes(8)
+#endif
+#ifndef GEN_CODEPOOL_NUM_BLOCKS
+#	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(16)
+#endif
+#ifndef GEN_SIZE_PER_STRING_ARENA
+#	define GEN_SIZE_PER_STRING_ARENA megabytes(1)
+#endif
+#ifndef GEN_MAX_COMMENT_LINE_LENGTH
+#	define GEN_MAX_COMMENT_LINE_LENGTH 1024
+#endif
+#ifndef GEN_MAX_NAME_LENGTH
+#	define GEN_MAX_NAME_LENGTH 128
+#endif
+#ifndef GEN_MAX_UNTYPED_STR_LENGTH
+#	define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
+#endif
+#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
+#	define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(4)
+#endif
+#ifndef GEN_LEX_ALLOCATOR_SIZE
+#	define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
+#endif
+#ifndef GEN_BUILDER_STR_BUFFER_RESERVE
+#	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(2)
+#endif
+
+// These constexprs are used for allocation behavior of data structures
+// or string handling while constructing or serializing.
+// Change them to suit your needs.
+
+constexpr s32 InitSize_DataArrays = 16;
+
+// NOTE: This limits the maximum size of an allocation
+// If you are generating a string larger than this, increase the size of the bucket here.
+constexpr usize  Global_BucketSize         = GEN_GLOBAL_BUCKET_SIZE;
+constexpr s32 CodePool_NumBlocks        = GEN_CODEPOOL_NUM_BLOCKS;
+constexpr s32 SizePer_StringArena       = GEN_SIZE_PER_STRING_ARENA;
+
+constexpr s32 MaxCommentLineLength      = GEN_MAX_COMMENT_LINE_LENGTH;
+constexpr s32 MaxNameLength             = GEN_MAX_NAME_LENGTH;
+constexpr s32 MaxUntypedStrLength       = GEN_MAX_UNTYPED_STR_LENGTH;
+constexpr s32 TokenFmt_TokenMap_MemSize	= GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
+constexpr s32 LexAllocator_Size         = GEN_LEX_ALLOCATOR_SIZE;
+constexpr s32 Builder_StrBufferReserve  = GEN_BUILDER_STR_BUFFER_RESERVE;
+
+extern Code access_public;
+extern Code access_protected;
+extern Code access_private;
+
+extern CodeAttributes attrib_api_export;
+extern CodeAttributes attrib_api_import;
+
+extern Code module_global_fragment;
+extern Code module_private_fragment;
+
+extern Code fmt_newline;
+
+extern CodePragma pragma_once;
+
+extern CodeParam param_varadic;
+
+extern CodePreprocessCond preprocess_else;
+extern CodePreprocessCond preprocess_endif;
+
+extern CodeSpecifiers spec_const;
+extern CodeSpecifiers spec_consteval;
+extern CodeSpecifiers spec_constexpr;
+extern CodeSpecifiers spec_constinit;
+extern CodeSpecifiers spec_extern_linkage;
+extern CodeSpecifiers spec_final;
+extern CodeSpecifiers spec_forceinline;
+extern CodeSpecifiers spec_global;
+extern CodeSpecifiers spec_inline;
+extern CodeSpecifiers spec_internal_linkage;
+extern CodeSpecifiers spec_local_persist;
+extern CodeSpecifiers spec_mutable;
+extern CodeSpecifiers spec_neverinline;
+extern CodeSpecifiers spec_noexcept;
+extern CodeSpecifiers spec_override;
+extern CodeSpecifiers spec_ptr;
+extern CodeSpecifiers spec_pure;
+extern CodeSpecifiers spec_ref;
+extern CodeSpecifiers spec_register;
+extern CodeSpecifiers spec_rvalue;
+extern CodeSpecifiers spec_static_member;
+extern CodeSpecifiers spec_thread_local;
+extern CodeSpecifiers spec_virtual;
+extern CodeSpecifiers spec_volatile;
+
+extern CodeType t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
+extern CodeType t_auto;
+extern CodeType t_void;
+extern CodeType t_int;
+extern CodeType t_bool;
+extern CodeType t_char;
+extern CodeType t_wchar_t;
+extern CodeType t_class;
+extern CodeType t_typename;
+
+#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+	// Predefined typename codes. Are set to readonly and are setup during gen::init()
+
+	extern CodeType t_b32;
+
+	extern CodeType t_s8;
+	extern CodeType t_s16;
+	extern CodeType t_s32;
+	extern CodeType t_s64;
+
+	extern CodeType t_u8;
+	extern CodeType t_u16;
+	extern CodeType t_u32;
+	extern CodeType t_u64;
+
+	extern CodeType t_ssize;
+	extern CodeType t_usize;
+
+	extern CodeType t_f32;
+	extern CodeType t_f64;
+#endif
+
+#pragma endregion Constants
+
+#pragma region Macros
+
+#ifndef token_fmt
+#	define gen_main main
+
+#	define __ NoCode
+
+	//	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__ ) }
+
+#	define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
+
+#	define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
+#	define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
+
+	// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
+#	define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
+#endif
+
+#pragma endregion Macros
+
+// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
+// Populate with strings via gen::get_cached_string.
+// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
+extern Array< StringCached > PreprocessorDefines;
+
+#ifdef GEN_EXPOSE_BACKEND
+
+	// Global allocator used for data with process lifetime.
+	extern AllocatorInfo  GlobalAllocator;
+	extern Array< Arena > Global_AllocatorBuckets;
+
+	extern Array< Pool >  CodePools;
+	extern Array< Arena > StringArenas;
+
+	extern StringTable StringCache;
+
+	extern Arena LexArena;
+
+	extern AllocatorInfo Allocator_DataArrays;
+	extern AllocatorInfo Allocator_CodePool;
+	extern AllocatorInfo Allocator_Lexer;
+	extern AllocatorInfo Allocator_StringArena;
+	extern AllocatorInfo Allocator_StringTable;
+	extern AllocatorInfo Allocator_TypeTable;
+
+#endif

project/components/header_start.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+/*
+	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
+
+	See Readme.md for more information from the project repository.
+
+	Public Address:
+	https://github.com/Ed94/gencpp
+*/
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : 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.hpp"
+#endif
+
+#ifndef GEN_NS_BEGIN
+#	ifdef GEN_DONT_USE_NAMESPACE
+#		define GEN_NS
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	else
+#		define GEN_NS       gen::
+#		define GEN_NS_BEGIN namespace gen {
+#		define GEN_NS_END   }
+#	endif
+#endif

project/components/inlines.hpp

@@ -0,0 +1,321 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "interface.hpp"
+#endif
+
+inline
+void append( AST* self, AST* other )
+{
+	GEN_ASSERT(self  != nullptr);
+	GEN_ASSERT(other != nullptr);
+
+	if ( other->Parent )
+		other = duplicate(other);
+
+	other->Parent = self;
+
+	if ( self->Front == nullptr )
+	{
+		self->Front = other;
+		self->Back  = other;
+
+		self->NumEntries++;
+		return;
+	}
+
+	AST*
+	Current       = self->Back;
+	Current->Next = other;
+	other->Prev   = Current;
+	self->Back    = other;
+	self->NumEntries++;
+}
+
+inline
+Code* entry( AST* self, u32 idx )
+{
+	GEN_ASSERT(self != nullptr);
+	AST** current = & self->Front;
+	while ( idx >= 0 && current != nullptr )
+	{
+		if ( idx == 0 )
+			return rcast( Code*, current);
+
+		current = & ( * current )->Next;
+		idx--;
+	}
+
+	return rcast( Code*, current);
+}
+
+inline
+bool has_entries(AST* self)
+{
+	GEN_ASSERT(self != nullptr);
+	return self->NumEntries > 0;
+}
+
+inline
+bool is_body(AST* self)
+{
+	GEN_ASSERT(self != nullptr);
+	switch (self->Type)
+	{
+		case ECode::Enum_Body:
+		case ECode::Class_Body:
+		case ECode::Union_Body:
+		case ECode::Export_Body:
+		case ECode::Global_Body:
+		case ECode::Struct_Body:
+		case ECode::Function_Body:
+		case ECode::Namespace_Body:
+		case ECode::Extern_Linkage_Body:
+			return true;
+	}
+	return false;
+}
+
+inline
+char const* type_str(AST* self)
+{
+	GEN_ASSERT(self != nullptr);
+	return ECode::to_str( self->Type );
+}
+
+inline
+AST::operator Code()
+{
+	return { this };
+}
+
+#pragma region Code
+
+inline
+char const* debug_str( Code code )
+{
+	if ( code.ast == nullptr )
+		return "Code::debug_str: AST is null!";
+
+	return debug_str( code.ast );
+}
+
+inline
+Code duplicate( Code code )
+{
+	if ( code.ast == nullptr )
+	{
+		log_failure("Code::duplicate: Cannot duplicate code, AST is null!");
+		return Code_Invalid;
+	}
+
+	return { duplicate(code.ast) };
+}
+
+inline
+bool is_body(Code code)
+{
+	if ( code.ast == nullptr )
+	{
+		return is_body(code.ast);
+	}
+	return false;
+}
+
+inline
+bool is_equal( Code self, Code other )
+{
+	if ( self.ast == nullptr || other.ast == nullptr )
+	{
+		// Just check if they're both null.
+		// log_failure( "Code::is_equal: Cannot compare code, AST is null!" );
+		return self.ast == nullptr && other.ast == nullptr;
+	}
+	return is_equal( self.ast, other.ast );
+}
+
+inline
+bool is_valid(Code self)
+{
+	return self.ast != nullptr && self.ast->Type != CodeT::Invalid;
+}
+
+inline
+void set_global(Code self)
+{
+	if ( self.ast == nullptr )
+	{
+		log_failure("Code::set_global: Cannot set code as global, AST is null!");
+		return;
+	}
+
+	self->Parent = Code_Global.ast;
+}
+
+inline
+Code& Code::operator ++()
+{
+	if ( ast )
+		ast = ast->Next;
+
+	return *this;
+}
+
+#pragma endregion Code
+
+inline
+void append( CodeBody self, Code other )
+{
+	GEN_ASSERT(other.ast != nullptr);
+
+	if (is_body(other)) {
+		append( self, cast(CodeBody, other) );
+		return;
+	}
+
+	append( rcast(AST*, self.ast), other.ast );
+}
+
+inline
+void append( CodeBody self, CodeBody body )
+{
+	for ( Code entry : body ) {
+		append( self, entry );
+	}
+}
+
+inline
+void add_interface( CodeClass self, CodeType type )
+{
+	GEN_ASSERT(self.ast !=nullptr);
+	CodeType possible_slot = self->ParentType;
+	if ( possible_slot.ast )
+	{
+		// Were adding an interface to parent type, so we need to make sure the parent type is public.
+		self->ParentAccess = AccessSpec_Public;
+		// If your planning on adding a proper parent,
+		// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
+	}
+
+	while ( possible_slot.ast != nullptr )
+	{
+		possible_slot.ast = (AST_Type*) possible_slot->Next.ast;
+	}
+
+	possible_slot.ast = type.ast;
+}
+
+inline
+void CodeParam::append( CodeParam other )
+{
+	AST* self  = (AST*) ast;
+	AST* entry = (AST*) other.ast;
+
+	if ( entry->Parent )
+		entry = GEN_NS duplicate( entry );
+
+	entry->Parent = self;
+
+	if ( self->Last == nullptr )
+	{
+		self->Last = entry;
+		self->Next = entry;
+		self->NumEntries++;
+		return;
+	}
+
+	self->Last->Next = entry;
+	self->Last       = entry;
+	self->NumEntries++;
+}
+
+inline
+CodeParam CodeParam::get( s32 idx )
+{
+	CodeParam param = *this;
+	do
+	{
+		if ( ! ++ param )
+			return { nullptr };
+
+		param = { (AST_Param*) param.raw()->Next };
+	}
+	while ( --idx );
+
+	return param;
+}
+
+inline
+bool CodeParam::has_entries()
+{
+	return ast->NumEntries > 0;
+}
+
+inline
+CodeParam& CodeParam::operator ++()
+{
+	ast = ast->Next.ast;
+	return * this;
+}
+
+inline
+void CodeStruct::add_interface( CodeType type )
+{
+	CodeType possible_slot = ast->ParentType;
+	if ( possible_slot.ast )
+	{
+		// Were adding an interface to parent type, so we need to make sure the parent type is public.
+		ast->ParentAccess = AccessSpec_Public;
+		// If your planning on adding a proper parent,
+		// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
+	}
+
+	while ( possible_slot.ast != nullptr )
+	{
+		possible_slot.ast = (AST_Type*) possible_slot->Next.ast;
+	}
+
+	possible_slot.ast = type.ast;
+}
+
+inline
+CodeBody def_body( CodeT type )
+{
+	switch ( type )
+	{
+		using namespace ECode;
+		case Class_Body:
+		case Enum_Body:
+		case Export_Body:
+		case Extern_Linkage:
+		case Function_Body:
+		case Global_Body:
+		case Namespace_Body:
+		case Struct_Body:
+		case Union_Body:
+			break;
+
+		default:
+			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
+			return (CodeBody)Code_Invalid;
+	}
+
+	Code
+	result       = make_code();
+	result->Type = type;
+	return (CodeBody)result;
+}
+
+inline
+StrC token_fmt_impl( ssize num, ... )
+{
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+	mem_set( buf, 0, GEN_PRINTF_MAXLEN );
+
+	va_list va;
+	va_start(va, num );
+	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
+	va_end(va);
+
+	return { result, buf };
+}

project/components/interface.cpp

@@ -0,0 +1,468 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "code_serialization.cpp"
+#endif
+
+namespace parser {
+internal void init();
+internal void deinit();
+}
+
+internal
+void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
+{
+	Arena* last = back(& Global_AllocatorBuckets);
+
+	switch ( type )
+	{
+		case EAllocation_ALLOC:
+		{
+			if ( ( last->TotalUsed + size ) > last->TotalSize )
+			{
+				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
+
+				if ( bucket.PhysicalStart == nullptr )
+					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
+
+				if ( ! append( & Global_AllocatorBuckets, bucket ) )
+					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+
+				last = back(& Global_AllocatorBuckets);
+			}
+
+			return alloc_align( allocator_info(last), size, alignment );
+		}
+		case EAllocation_FREE:
+		{
+			// Doesn't recycle.
+		}
+		break;
+		case EAllocation_FREE_ALL:
+		{
+			// Memory::cleanup instead.
+		}
+		break;
+		case EAllocation_RESIZE:
+		{
+			if ( last->TotalUsed + size > last->TotalSize )
+			{
+				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
+
+				if ( bucket.PhysicalStart == nullptr )
+					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
+
+				if ( ! append( & Global_AllocatorBuckets, bucket ) )
+					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
+
+				last = back(& Global_AllocatorBuckets);
+			}
+
+			void* result = alloc_align( last->Backing, size, alignment );
+
+			if ( result != nullptr && old_memory != nullptr )
+			{
+				mem_copy( result, old_memory, old_size );
+			}
+
+			return result;
+		}
+	}
+
+	return nullptr;
+}
+
+internal
+void define_constants()
+{
+	Code_Global                         = make_code();
+	scast(String, Code_Global->Name)    = get_cached_string( txt("Global Code") );
+	scast(String, Code_Global->Content) = Code_Global->Name;
+
+	Code_Invalid = make_code();
+	set_global(Code_Invalid);
+
+	t_empty       = (CodeType) make_code();
+	t_empty->Type = ECode::Typename;
+	t_empty->Name = get_cached_string( txt("") );
+	set_global(t_empty);
+
+	access_private       = make_code();
+	access_private->Type = ECode::Access_Private;
+	access_private->Name = get_cached_string( txt("private:\n") );
+	set_global(access_private);
+
+	access_protected       = make_code();
+	access_protected->Type = ECode::Access_Protected;
+	access_protected->Name = get_cached_string( txt("protected:\n") );
+	set_global(access_protected);
+
+	access_public       = make_code();
+	access_public->Type = ECode::Access_Public;
+	access_public->Name = get_cached_string( txt("public:\n") );
+	set_global(access_public);
+
+	attrib_api_export = def_attributes( code(GEN_API_Export_Code));
+	set_global(attrib_api_export);
+
+	attrib_api_import = def_attributes( code(GEN_API_Import_Code));
+	set_global(attrib_api_import);
+
+	module_global_fragment          = make_code();
+	module_global_fragment->Type    = ECode::Untyped;
+	module_global_fragment->Name    = get_cached_string( txt("module;") );
+	module_global_fragment->Content = module_global_fragment->Name;
+	set_global(module_global_fragment);
+
+	module_private_fragment          = make_code();
+	module_private_fragment->Type    = ECode::Untyped;
+	module_private_fragment->Name    = get_cached_string( txt("module : private;") );
+	module_private_fragment->Content = module_private_fragment->Name;
+	set_global(module_private_fragment);
+
+	fmt_newline = make_code();
+	fmt_newline->Type = ECode::NewLine;
+	set_global(fmt_newline);
+
+	pragma_once          = (CodePragma) make_code();
+	pragma_once->Type    = ECode::Preprocess_Pragma;
+	pragma_once->Name    = get_cached_string( txt("once") );
+	pragma_once->Content = pragma_once->Name;
+	set_global(pragma_once);
+
+	param_varadic            = (CodeType) make_code();
+	param_varadic->Type      = ECode::Parameters;
+	param_varadic->Name      = get_cached_string( txt("...") );
+	param_varadic->ValueType = t_empty;
+	set_global(param_varadic);
+
+	preprocess_else = (CodePreprocessCond) make_code();
+	preprocess_else->Type = ECode::Preprocess_Else;
+	set_global(preprocess_else);
+
+	preprocess_endif = (CodePreprocessCond) make_code();
+	preprocess_endif->Type = ECode::Preprocess_EndIf;
+	set_global(preprocess_endif);
+
+#	define def_constant_code_type( Type_ )   \
+		t_##Type_ = def_type( name(Type_) ); \
+		t_##Type_.set_global();
+
+	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 );
+
+#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+	t_b32 = def_type( name(b32) );
+
+	def_constant_code_type( s8 );
+	def_constant_code_type( s16 );
+	def_constant_code_type( s32 );
+	def_constant_code_type( s64 );
+
+	def_constant_code_type( u8 );
+	def_constant_code_type( u16 );
+	def_constant_code_type( u32 );
+	def_constant_code_type( u64 );
+
+	def_constant_code_type( ssize );
+	def_constant_code_type( usize );
+
+	def_constant_code_type( f32 );
+	def_constant_code_type( f64 );
+#endif
+#	undef def_constant_code_type
+
+
+#	define def_constant_spec( Type_, ... )                                  \
+		spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
+		spec_##Type_.set_global();
+
+#	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,            ESpecifier::Const );
+	def_constant_spec( consteval,        ESpecifier::Consteval );
+	def_constant_spec( constexpr,        ESpecifier::Constexpr );
+	def_constant_spec( constinit,        ESpecifier::Constinit );
+	def_constant_spec( extern_linkage,   ESpecifier::External_Linkage );
+	def_constant_spec( final, 		     ESpecifier::Final );
+	def_constant_spec( forceinline,      ESpecifier::ForceInline );
+	def_constant_spec( global,           ESpecifier::Global );
+	def_constant_spec( inline,           ESpecifier::Inline );
+	def_constant_spec( internal_linkage, ESpecifier::Internal_Linkage );
+	def_constant_spec( local_persist,    ESpecifier::Local_Persist );
+	def_constant_spec( mutable,          ESpecifier::Mutable );
+	def_constant_spec( neverinline,      ESpecifier::NeverInline );
+	def_constant_spec( noexcept,         ESpecifier::NoExceptions );
+	def_constant_spec( override,         ESpecifier::Override );
+	def_constant_spec( ptr,              ESpecifier::Ptr );
+	def_constant_spec( pure,             ESpecifier::Pure )
+	def_constant_spec( ref,              ESpecifier::Ref );
+	def_constant_spec( register,         ESpecifier::Register );
+	def_constant_spec( rvalue,           ESpecifier::RValue );
+	def_constant_spec( static_member,    ESpecifier::Static );
+	def_constant_spec( thread_local,     ESpecifier::Thread_Local );
+	def_constant_spec( virtual, 		 ESpecifier::Virtual );
+	def_constant_spec( volatile, 	     ESpecifier::Volatile)
+
+	spec_local_persist = def_specifiers( 1, ESpecifier::Local_Persist );
+	spec_local_persist.set_global();
+
+#	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")
+
+#	pragma pop_macro("enum_underlying")
+
+#	undef def_constant_spec
+}
+
+void init()
+{
+	// Setup global allocator
+	{
+		GlobalAllocator = AllocatorInfo { & Global_Allocator_Proc, nullptr };
+
+		Global_AllocatorBuckets = array_init_reserve<Arena>( heap(), 128 );
+
+		if ( Global_AllocatorBuckets == nullptr )
+			GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
+
+		Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
+
+		if ( bucket.PhysicalStart == nullptr )
+			GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
+
+		append( & Global_AllocatorBuckets, bucket );
+	}
+
+	// Setup the arrays
+	{
+		CodePools = array_init_reserve<Pool>( Allocator_DataArrays, InitSize_DataArrays );
+
+		if ( CodePools == nullptr )
+			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
+
+		StringArenas = array_init_reserve<Arena>( Allocator_DataArrays, InitSize_DataArrays );
+
+		if ( StringArenas == nullptr )
+			GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
+	}
+
+	// Setup the code pool and code entries arena.
+	{
+		Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+
+		if ( code_pool.PhysicalStart == nullptr )
+			GEN_FATAL( "gen::init: Failed to initialize the code pool" );
+
+		append( & CodePools, code_pool );
+
+		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
+
+		Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+
+		if ( string_arena.PhysicalStart == nullptr )
+			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
+
+		append( & StringArenas, string_arena );
+	}
+
+	// Setup the hash tables
+	{
+		StringCache = hashtable_init<StringCached>(Allocator_StringTable);
+
+		if ( StringCache.Entries == nullptr )
+			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
+	}
+
+	// Preprocessor Defines
+	PreprocessorDefines = array_init_reserve<StringCached>( GlobalAllocator, kilobytes(1) );
+
+	define_constants();
+	parser::init();
+}
+
+void deinit()
+{
+	usize index = 0;
+	usize left  = num(CodePools);
+	do
+	{
+		Pool* code_pool = & CodePools[index];
+		free(code_pool);
+		index++;
+	}
+	while ( left--, left );
+
+	index = 0;
+	left  = num(StringArenas);
+	do
+	{
+		Arena* string_arena = & StringArenas[index];
+		free(string_arena);
+		index++;
+	}
+	while ( left--, left );
+
+	destroy(& StringCache);
+
+	free( & CodePools);
+	free( & StringArenas);
+
+	free(& LexArena);
+
+	free(& PreprocessorDefines);
+
+	index = 0;
+	left  = num(Global_AllocatorBuckets);
+	do
+	{
+		Arena* bucket = & Global_AllocatorBuckets[ index ];
+		free(bucket);
+		index++;
+	}
+	while ( left--, left );
+
+	free(Global_AllocatorBuckets);
+	parser::deinit();
+}
+
+void reset()
+{
+	s32 index = 0;
+	s32 left  = num(CodePools);
+	do
+	{
+		Pool* code_pool = & CodePools[index];
+		clear(* code_pool);
+		index++;
+	}
+	while ( left--, left );
+
+	index = 0;
+	left  = num(StringArenas);
+	do
+	{
+		Arena* string_arena = & StringArenas[index];
+		string_arena->TotalUsed = 0;;
+		index++;
+	}
+	while ( left--, left );
+
+	clear(StringCache);
+
+	define_constants();
+}
+
+AllocatorInfo get_string_allocator( s32 str_length )
+{
+	Arena* last = back(& StringArenas);
+
+	usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
+
+	if ( last->TotalUsed + ssize(size_req) > last->TotalSize )
+	{
+		Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+
+		if ( ! append( & StringArenas, new_arena ) )
+			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
+
+		last = back(& StringArenas);
+	}
+
+	return allocator_info(last);
+}
+
+// Will either make or retrive a code string.
+StringCached get_cached_string( StrC str )
+{
+	s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len;
+	u64 key         = crc32( str.Ptr, hash_length );
+	{
+		StringCached* result = get(StringCache, key );
+
+		if ( result )
+			return * result;
+	}
+
+	String result = string_make( get_string_allocator( str.Len ), str );
+	set<StringCached>(& StringCache, key, result );
+
+	return result;
+}
+
+// Used internally to retireve a Code object form the CodePool.
+Code make_code()
+{
+	Pool* allocator = back( & CodePools);
+	if ( allocator->FreeList == nullptr )
+	{
+		Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+
+		if ( code_pool.PhysicalStart == nullptr )
+			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
+
+		if ( ! append( & CodePools, code_pool ) )
+			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
+
+		allocator = back( & CodePools);
+	}
+
+	Code result { rcast( AST*, alloc( allocator_info(allocator), sizeof(AST) )) };
+	mem_set( result.ast, 0, sizeof(AST) );
+	// result->Type = ECode::Invalid;
+
+	// result->Content     = { nullptr };
+	// result->Prev        = { nullptr };
+	// result->Next        = { nullptr };
+	// result->Token		= nullptr;
+	// result->Parent      = { nullptr };
+	// result->Name        = { nullptr };
+	// result->Type        = ECode::Invalid;
+	// result->ModuleFlags = ModuleFlag::Invalid;
+	// result->NumEntries  = 0;
+
+	return result;
+}
+
+void set_allocator_data_arrays( AllocatorInfo allocator )
+{
+	Allocator_DataArrays = allocator;
+}
+
+void set_allocator_code_pool( AllocatorInfo allocator )
+{
+	Allocator_CodePool = allocator;
+}
+
+void set_allocator_lexer( AllocatorInfo allocator )
+{
+	Allocator_Lexer = allocator;
+}
+
+void set_allocator_string_arena( AllocatorInfo allocator )
+{
+	Allocator_StringArena = allocator;
+}
+
+void set_allocator_string_table( AllocatorInfo allocator )
+{
+	Allocator_StringArena = allocator;
+}

project/components/interface.hpp

@@ -0,0 +1,217 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "ast_types.hpp"
+#endif
+
+#pragma region Gen Interface
+
+// Initialize the library.
+// This currently just initializes the CodePool.
+void init();
+
+// Currently manually free's the arenas, code for checking for leaks.
+// However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
+void deinit();
+
+// Clears the allocations, but doesn't return to the heap, the calls init() again.
+// Ease of use.
+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 );
+
+/*
+	This provides a fresh Code AST.
+	The gen interface use this as their method from getting a new AST object from the CodePool.
+	Use this if you want to make your own API for formatting the supported Code Types.
+*/
+Code make_code();
+
+// Set these before calling gen's init() procedure.
+
+void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
+void set_allocator_code_pool   ( AllocatorInfo pool_allocator );
+void set_allocator_lexer       ( AllocatorInfo lex_allocator );
+void set_allocator_string_arena( AllocatorInfo string_allocator );
+void set_allocator_string_table( AllocatorInfo string_allocator );
+void set_allocator_type_table  ( AllocatorInfo type_reg_allocator );
+
+#pragma region Upfront
+
+CodeAttributes def_attributes( StrC content );
+CodeComment    def_comment   ( StrC content );
+
+CodeClass def_class( StrC name
+	, Code           body         = NoCode
+	, CodeType       parent       = NoCode, AccessSpec access = AccessSpec_Default
+	, CodeAttributes attributes   = NoCode
+	, ModuleFlag     mflags       = ModuleFlag_None
+	, CodeType*      interfaces   = nullptr, s32 num_interfaces = 0 );
+
+CodeConstructor def_constructor( CodeParam params = NoCode, Code initializer_list = NoCode, Code body = NoCode );
+
+CodeDefine def_define( StrC name, StrC content );
+
+CodeDestructor def_destructor( Code body = NoCode, CodeSpecifiers specifiers = NoCode );
+
+CodeEnum def_enum( StrC name
+	, Code         body      = NoCode,           CodeType       type       = NoCode
+	, EnumT        specifier = EnumDecl_Regular, CodeAttributes attributes = NoCode
+	, ModuleFlag   mflags    = ModuleFlag_None );
+
+CodeExec   def_execution  ( StrC content );
+CodeExtern def_extern_link( StrC name, Code body );
+CodeFriend def_friend     ( Code symbol );
+
+CodeFn def_function( StrC name
+	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag mflags     = ModuleFlag_None );
+
+CodeInclude   def_include  ( StrC content, bool foreign = false );
+CodeModule    def_module   ( StrC name,            ModuleFlag mflags = ModuleFlag_None );
+CodeNS        def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag_None );
+
+CodeOperator def_operator( OperatorT op, StrC nspace
+	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag_None );
+
+CodeOpCast def_operator_cast( CodeType type, Code body = NoCode, CodeSpecifiers specs = NoCode );
+
+CodeParam  def_param ( CodeType type, StrC name, Code value = NoCode );
+CodePragma def_pragma( StrC directive );
+
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
+
+CodeSpecifiers def_specifier( SpecifierT specifier );
+
+CodeStruct def_struct( StrC name
+	, Code           body       = NoCode
+	, CodeType       parent     = NoCode, AccessSpec access = AccessSpec_Default
+	, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag_None
+	, CodeType*      interfaces = nullptr, s32 num_interfaces = 0 );
+
+CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag_None );
+
+CodeType    def_type   ( StrC name, Code arrayexpr = NoCode, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode );
+CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag_None );
+
+CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag_None );
+
+CodeUsing def_using( StrC name, CodeType type = NoCode
+	, CodeAttributes attributess = NoCode
+	, ModuleFlag     mflags      = ModuleFlag_None );
+
+CodeUsing def_using_namespace( StrC name );
+
+CodeVar def_variable( CodeType type, StrC name, Code value = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag_None );
+
+// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
+CodeBody def_body( CodeT type );
+
+// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
+/// or provide as an array of Code objects.
+
+CodeBody       def_class_body      ( s32 num, ... );
+CodeBody       def_class_body      ( s32 num, Code* codes );
+CodeBody       def_enum_body       ( s32 num, ... );
+CodeBody       def_enum_body       ( s32 num, Code* codes );
+CodeBody       def_export_body     ( s32 num, ... );
+CodeBody       def_export_body     ( s32 num, Code* codes);
+CodeBody       def_extern_link_body( s32 num, ... );
+CodeBody       def_extern_link_body( s32 num, Code* codes );
+CodeBody       def_function_body   ( s32 num, ... );
+CodeBody       def_function_body   ( s32 num, Code* codes );
+CodeBody       def_global_body     ( s32 num, ... );
+CodeBody       def_global_body     ( s32 num, Code* codes );
+CodeBody       def_namespace_body  ( s32 num, ... );
+CodeBody       def_namespace_body  ( s32 num, Code* codes );
+CodeParam      def_params          ( s32 num, ... );
+CodeParam      def_params          ( s32 num, CodeParam* params );
+CodeSpecifiers def_specifiers      ( s32 num, ... );
+CodeSpecifiers def_specifiers      ( s32 num, SpecifierT* specs );
+CodeBody       def_struct_body     ( s32 num, ... );
+CodeBody       def_struct_body     ( s32 num, Code* codes );
+CodeBody       def_union_body      ( s32 num, ... );
+CodeBody       def_union_body      ( s32 num, Code* codes );
+
+#pragma endregion Upfront
+
+#pragma region Parsing
+
+// TODO(Ed) : Implmeent the new parser API design.
+
+#if 0
+namespace parser {
+	struct StackNode
+	{
+		StackNode* Prev;
+
+		Token Start;
+		Token Name;       // The name of the AST node (if parsed)
+		StrC  FailedProc; // The name of the procedure that failed
+	};
+	// Stack nodes are allocated the error's allocator
+
+	struct Error
+	{
+		String     message;
+		StackNode* context_stack;
+	};
+}
+
+struct ParseInfo
+{
+	Arena FileMem;
+	Arena TokMem;
+	Arena CodeMem;
+
+	FileContents         FileContent;
+	Array<parser::Token> Tokens;
+	Array<parser::Error> Errors;
+	// Errors are allocated to a dedicated general arena.
+};
+
+CodeBody parse_file( StrC 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    );
+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         );
+
+#pragma endregion Parsing
+
+#pragma region Untyped text
+
+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, ... );
+
+Code untyped_str      ( StrC content);
+Code untyped_fmt      ( char const* fmt, ... );
+Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
+
+#pragma endregion Untyped text
+
+#pragma endregion Gen Interface

project/components/interface.parsing.cpp

@@ -0,0 +1,329 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "gen/etoktype.cpp"
+#include "interface.upfront.cpp"
+#include "lexer.cpp"
+#include "parser.cpp"
+#endif
+
+// Publically Exposed Interface
+
+CodeClass parse_class( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	push_scope();
+	CodeClass result = (CodeClass) parse_class_struct( TokType::Decl_Class );
+	Context.pop();
+	return result;
+}
+
+CodeConstructor parse_constructor( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	// TODO(Ed): Constructors can have prefix attributes
+
+	CodeSpecifiers specifiers;
+	SpecifierT     specs_found[ 16 ] { ESpecifier::NumSpecifiers };
+	s32            NumSpecifiers = 0;
+
+	while ( left && currtok.is_specifier() )
+	{
+		SpecifierT spec = ESpecifier::to_type( currtok );
+
+		b32 ignore_spec = false;
+
+		switch ( spec )
+		{
+			case ESpecifier::Constexpr :
+			case ESpecifier::Explicit:
+			case ESpecifier::Inline :
+			case ESpecifier::ForceInline :
+			case ESpecifier::NeverInline :
+				break;
+
+			case ESpecifier::Const :
+				ignore_spec = true;
+				break;
+
+			default :
+				log_failure( "Invalid specifier %s for variable\n%s", ESpecifier::to_str( spec ), Context.to_string() );
+				Context.pop();
+				return InvalidCode;
+		}
+
+		// Every specifier after would be considered part of the type type signature
+		if (ignore_spec)
+			break;
+
+		specs_found[ NumSpecifiers ] = spec;
+		NumSpecifiers++;
+		eat( currtok.Type );
+	}
+
+	if ( NumSpecifiers )
+	{
+		specifiers = def_specifiers( NumSpecifiers, specs_found );
+		// <specifiers> ...
+	}
+
+	Context.Tokens         = toks;
+	CodeConstructor result = parse_constructor( specifiers );
+	return result;
+}
+
+CodeDestructor parse_destructor( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	// TODO(Ed): Destructors can have prefix attributes
+	// TODO(Ed): Destructors can have virtual
+
+	Context.Tokens        = toks;
+	CodeDestructor result = parse_destructor();
+	return result;
+}
+
+CodeEnum parse_enum( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+	{
+		Context.pop();
+		return InvalidCode;
+	}
+
+	Context.Tokens = toks;
+	return parse_enum();
+}
+
+CodeBody parse_export_body( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_export_body();
+}
+
+CodeExtern parse_extern_link( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_extern_link();
+}
+
+CodeFriend parse_friend( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_friend();
+}
+
+CodeFn parse_function( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return (CodeFn) parse_function();
+}
+
+CodeBody parse_global_body( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	push_scope();
+	CodeBody result = parse_global_nspace( ECode::Global_Body );
+	Context.pop();
+	return result;
+}
+
+CodeNS parse_namespace( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_namespace();
+}
+
+CodeOperator parse_operator( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return (CodeOperator) parse_operator();
+}
+
+CodeOpCast parse_operator_cast( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_operator_cast();
+}
+
+CodeStruct parse_struct( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	push_scope();
+	CodeStruct result = (CodeStruct) parse_class_struct( TokType::Decl_Struct );
+	Context.pop();
+	return result;
+}
+
+CodeTemplate parse_template( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_template();
+}
+
+CodeType parse_type( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_type();
+}
+
+CodeTypedef parse_typedef( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_typedef();
+}
+
+CodeUnion parse_union( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_union();
+}
+
+CodeUsing parse_using( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_using();
+}
+
+CodeVar parse_variable( StrC def )
+{
+	check_parse_args( def );
+	using namespace parser;
+
+	TokArray toks = lex( def );
+	if ( toks.Arr == nullptr )
+		return InvalidCode;
+
+	Context.Tokens = toks;
+	return parse_variable();
+}
+
+// Undef helper macros
+#	undef check_parse_args
+#	undef currtok
+#	undef prevtok
+#   undef nexttok
+#	undef eat
+#	undef left
+#	undef check
+#	undef push_scope

project/components/interface.untyped.cpp

@@ -0,0 +1,187 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "interface.parsing.cpp"
+#endif
+
+ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
+{
+	char const* buf_begin = buf;
+	ssize       remaining = buf_size;
+
+	local_persist
+	Arena tok_map_arena;
+
+	HashTable<StrC> tok_map;
+	{
+		local_persist
+		char tok_map_mem[ TokenFmt_TokenMap_MemSize ];
+
+		tok_map_arena = arena_init_from_memory( tok_map_mem, sizeof(tok_map_mem) );
+		tok_map       = hashtable_init<StrC>( 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 );
+
+			u32 key = crc32( token, str_len(token) );
+			set(& tok_map, key, value );
+		}
+	}
+
+	char const* fmt     = va_arg( va, char const* );
+	char        current = *fmt;
+
+	while ( current )
+	{
+		ssize len = 0;
+
+		while ( current && current != '<' && remaining )
+		{
+			* buf = * fmt;
+			buf++;
+			fmt++;
+			remaining--;
+
+			current = * fmt;
+		}
+
+		if ( current == '<' )
+		{
+			char const* scanner = fmt + 1;
+
+			s32 tok_len = 0;
+
+			while ( *scanner != '>' )
+			{
+				tok_len++;
+				scanner++;
+			}
+
+			char const* token = fmt + 1;
+
+			u32       key   = crc32( token, tok_len );
+			StrC*     value = get(tok_map, key );
+
+			if ( value )
+			{
+				ssize          left = value->Len;
+				char const* str  = value->Ptr;
+
+				while ( left-- )
+				{
+					* buf = * str;
+					buf++;
+					str++;
+					remaining--;
+				}
+
+				scanner++;
+				fmt     = scanner;
+				current = * fmt;
+				continue;
+			}
+
+			* buf = * fmt;
+			buf++;
+			fmt++;
+			remaining--;
+
+			current = * fmt;
+		}
+	}
+
+	clear(tok_map);
+	free(& tok_map_arena);
+
+	ssize result = buf_size - remaining;
+
+	return result;
+}
+
+Code untyped_str( StrC content )
+{
+	if ( content.Len == 0 )
+	{
+		log_failure( "untyped_str: empty string" );
+		return InvalidCode;
+	}
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( content );
+	result->Type    = ECode::Untyped;
+	result->Content = result->Name;
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_str: could not cache string" );
+		return InvalidCode;
+	}
+
+	return result;
+}
+
+Code untyped_fmt( char const* fmt, ...)
+{
+	if ( fmt == nullptr )
+	{
+		log_failure( "untyped_fmt: null format string" );
+		return InvalidCode;
+	}
+
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, fmt);
+	ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	va_end(va);
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( { str_len(fmt, MaxNameLength), fmt } );
+	result->Type    = ECode::Untyped;
+	result->Content = get_cached_string( { length, buf } );
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return InvalidCode;
+	}
+
+	return result;
+}
+
+Code untyped_token_fmt( s32 num_tokens, ... )
+{
+	if ( num_tokens == 0 )
+	{
+		log_failure( "untyped_token_fmt: zero tokens" );
+		return InvalidCode;
+	}
+
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, num_tokens);
+	ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
+	va_end(va);
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( { length, buf } );
+	result->Type    = ECode::Untyped;
+	result->Content = result->Name;
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return InvalidCode;
+	}
+
+	return result;
+}

project/components/src_start.cpp

@@ -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.hpp"
+
+//! 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.cpp"
+#endif

project/components/static_data.cpp

@@ -0,0 +1,107 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "gen.hpp"
+#endif
+
+#pragma region StaticData
+
+// TODO : Convert global allocation strategy to use a slab allocation strategy.
+global AllocatorInfo  GlobalAllocator;
+global Array<Arena>   Global_AllocatorBuckets;
+
+// TODO(Ed) : Make the code pool a dynamic arena
+global Array< Pool >  CodePools         = { nullptr };
+global Array< Arena > StringArenas      = { nullptr };
+
+global StringTable StringCache;
+
+global Arena LexArena;
+
+global AllocatorInfo Allocator_DataArrays  = heap();
+global AllocatorInfo Allocator_CodePool    = heap();
+global AllocatorInfo Allocator_Lexer       = heap();
+global AllocatorInfo Allocator_StringArena = heap();
+global AllocatorInfo Allocator_StringTable = heap();
+global AllocatorInfo Allocator_TypeTable   = heap();
+
+#pragma endregion StaticData
+
+#pragma region Constants
+
+global Code access_public;
+global Code access_protected;
+global Code access_private;
+
+global CodeAttributes attrib_api_export;
+global CodeAttributes attrib_api_import;
+
+global Code module_global_fragment;
+global Code module_private_fragment;
+
+global Code fmt_newline;
+
+global CodeParam param_varadic;
+
+global CodePragma pragma_once;
+
+global CodePreprocessCond preprocess_else;
+global CodePreprocessCond preprocess_endif;
+
+global CodeSpecifiers spec_const;
+global CodeSpecifiers spec_consteval;
+global CodeSpecifiers spec_constexpr;
+global CodeSpecifiers spec_constinit;
+global CodeSpecifiers spec_extern_linkage;
+global CodeSpecifiers spec_final;
+global CodeSpecifiers spec_forceinline;
+global CodeSpecifiers spec_global;
+global CodeSpecifiers spec_inline;
+global CodeSpecifiers spec_internal_linkage;
+global CodeSpecifiers spec_local_persist;
+global CodeSpecifiers spec_mutable;
+global CodeSpecifiers spec_noexcept;
+global CodeSpecifiers spec_neverinline;
+global CodeSpecifiers spec_override;
+global CodeSpecifiers spec_ptr;
+global CodeSpecifiers spec_pure;
+global CodeSpecifiers spec_ref;
+global CodeSpecifiers spec_register;
+global CodeSpecifiers spec_rvalue;
+global CodeSpecifiers spec_static_member;
+global CodeSpecifiers spec_thread_local;
+global CodeSpecifiers spec_virtual;
+global CodeSpecifiers spec_volatile;
+
+global CodeType t_empty;
+global CodeType t_auto;
+global CodeType t_void;
+global CodeType t_int;
+global CodeType t_bool;
+global CodeType t_char;
+global CodeType t_wchar_t;
+global CodeType t_class;
+global CodeType t_typename;
+
+global Array< StringCached > PreprocessorDefines;
+
+#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+global CodeType t_b32;
+
+global CodeType t_s8;
+global CodeType t_s16;
+global CodeType t_s32;
+global CodeType t_s64;
+
+global CodeType t_u8;
+global CodeType t_u16;
+global CodeType t_u32;
+global CodeType t_u64;
+
+global CodeType t_ssize;
+global CodeType t_usize;
+
+global CodeType t_f32;
+global CodeType t_f64;
+#endif
+
+#pragma endregion Constants

project/components/types.hpp

@@ -0,0 +1,113 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "header_start.hpp"
+#endif
+
+using LogFailType = ssize(*)(char const*, ...);
+
+// By default this library will either crash or exit if an error is detected while generating codes.
+// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
+#ifdef GEN_DONT_USE_FATAL
+	#define log_failure log_fmt
+#else
+	#define log_failure GEN_FATAL
+#endif
+
+enum AccessSpec enum_underlying(u32)
+{
+	AccessSpec_Default,
+	AccessSpec_Private,
+	AccessSpec_Protected,
+	AccessSpec_Public,
+
+	AccessSpec_Num_AccessSpec,
+	AccessSpec_Invalid,
+
+	AccessSpec_SizeDef = GEN_U32_MAX,
+};
+static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
+
+inline
+char const* to_str( AccessSpec type )
+{
+	local_persist
+	char const* lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
+		"",
+		"private",
+		"protected",
+		"public",
+	};
+
+	if ( type > AccessSpec_Public )
+		return "Invalid";
+
+	return lookup[ (u32)type ];
+}
+
+enum CodeFlag enum_underlying(u32)
+{
+	CodeFlag_None          = 0,
+	CodeFlag_FunctionType  = bit(0),
+	CodeFlag_ParamPack     = bit(1),
+	CodeFlag_Module_Export = bit(2),
+	CodeFlag_Module_Import = bit(3),
+
+	CodeFlag_SizeDef = GEN_U32_MAX,
+};
+static_assert( size_of(CodeFlag) == size_of(u32), "CodeFlag not u32 size" );
+
+// Used to indicate if enum definitoin is an enum class or regular enum.
+enum EnumDecl enum_underlying(u8)
+{
+	EnumDecl_Regular,
+	EnumDecl_Class,
+
+	EnumT_SizeDef = GEN_U8_MAX,
+};
+typedef u8 EnumT;
+
+enum ModuleFlag enum_underlying(u32)
+{
+	ModuleFlag_None    = 0,
+	ModuleFlag_Export  = bit(0),
+	ModuleFlag_Import  = bit(1),
+
+	Num_ModuleFlags,
+	ModuleFlag_Invalid,
+
+	ModuleFlag_SizeDef = GEN_U32_MAX,
+};
+static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
+
+inline
+StrC to_str( ModuleFlag flag )
+{
+	local_persist
+	StrC lookup[ (u32)ModuleFlag::Num_ModuleFlags ] = {
+		{ sizeof("__none__"), "__none__" },
+		{ sizeof("export"), "export" },
+		{ sizeof("import"), "import" },
+	};
+
+	if ( flag > ModuleFlag_Import )
+		return { sizeof("invalid"), "invalid" };
+
+	return lookup[ (u32)flag ];
+}
+
+inline
+ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
+{
+	return (ModuleFlag)( (u32)A | (u32)B );
+}
+
+enum EPreprocessCond enum_underlying(u32)
+{
+	PreprocessCond_If,
+	PreprocessCond_IfDef,
+	PreprocessCond_IfNotDef,
+	PreprocessCond_ElIf,
+
+	EPreprocessCond_SizeDef = GEN_U32_MAX,
+};
+static_assert( size_of(EPreprocessCond) == size_of(u32), "EPreprocessCond not u32 size" );

project/dependencies/basic_types.hpp

@@ -0,0 +1,143 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "platform.hpp"
+#	include "macros.hpp"
+#endif
+
+#pragma region Basic Types
+
+#define GEN_U8_MIN 0u
+#define GEN_U8_MAX 0xffu
+#define GEN_I8_MIN ( -0x7f - 1 )
+#define GEN_I8_MAX 0x7f
+
+#define GEN_U16_MIN 0u
+#define GEN_U16_MAX 0xffffu
+#define GEN_I16_MIN ( -0x7fff - 1 )
+#define GEN_I16_MAX 0x7fff
+
+#define GEN_U32_MIN 0u
+#define GEN_U32_MAX 0xffffffffu
+#define GEN_I32_MIN ( -0x7fffffff - 1 )
+#define GEN_I32_MAX 0x7fffffff
+
+#define GEN_U64_MIN 0ull
+#define GEN_U64_MAX 0xffffffffffffffffull
+#define GEN_I64_MIN ( -0x7fffffffffffffffll - 1 )
+#define GEN_I64_MAX 0x7fffffffffffffffll
+
+#if defined( GEN_ARCH_32_BIT )
+#	define GEN_USIZE_MIN GEN_U32_MIN
+#	define GEN_USIZE_MAX GEN_U32_MAX
+#	define GEN_ISIZE_MIN GEN_S32_MIN
+#	define GEN_ISIZE_MAX GEN_S32_MAX
+#elif defined( GEN_ARCH_64_BIT )
+#	define GEN_USIZE_MIN GEN_U64_MIN
+#	define GEN_USIZE_MAX GEN_U64_MAX
+#	define GEN_ISIZE_MIN GEN_I64_MIN
+#	define GEN_ISIZE_MAX GEN_I64_MAX
+#else
+#	error Unknown architecture size. This library only supports 32 bit and 64 bit architectures.
+#endif
+
+#define GEN_F32_MIN 1.17549435e-38f
+#define GEN_F32_MAX 3.40282347e+38f
+#define GEN_F64_MIN 2.2250738585072014e-308
+#define GEN_F64_MAX 1.7976931348623157e+308
+
+#if defined( GEN_COMPILER_MSVC )
+#	if _MSC_VER < 1300
+typedef unsigned char  u8;
+typedef signed   char  s8;
+typedef unsigned short u16;
+typedef signed   short s16;
+typedef unsigned int   u32;
+typedef signed   int   s32;
+#    else
+typedef unsigned __int8  u8;
+typedef signed   __int8  s8;
+typedef unsigned __int16 u16;
+typedef signed   __int16 s16;
+typedef unsigned __int32 u32;
+typedef signed   __int32 s32;
+#    endif
+typedef unsigned __int64 u64;
+typedef signed   __int64 s64;
+#else
+#	include <stdint.h>
+
+typedef uint8_t  u8;
+typedef int8_t   s8;
+typedef uint16_t u16;
+typedef int16_t  s16;
+typedef uint32_t u32;
+typedef int32_t  s32;
+typedef uint64_t u64;
+typedef int64_t  s64;
+#endif
+
+static_assert( sizeof( u8 )  == sizeof( s8 ),  "sizeof(u8) != sizeof(s8)" );
+static_assert( sizeof( u16 ) == sizeof( s16 ), "sizeof(u16) != sizeof(s16)" );
+static_assert( sizeof( u32 ) == sizeof( s32 ), "sizeof(u32) != sizeof(s32)" );
+static_assert( sizeof( u64 ) == sizeof( s64 ), "sizeof(u64) != sizeof(s64)" );
+
+static_assert( sizeof( u8 )  == 1, "sizeof(u8) != 1" );
+static_assert( sizeof( u16 ) == 2, "sizeof(u16) != 2" );
+static_assert( sizeof( u32 ) == 4, "sizeof(u32) != 4" );
+static_assert( sizeof( u64 ) == 8, "sizeof(u64) != 8" );
+
+typedef size_t    usize;
+typedef ptrdiff_t ssize;
+
+static_assert( sizeof( usize ) == sizeof( ssize ), "sizeof(usize) != sizeof(ssize)" );
+
+// NOTE: (u)zpl_intptr is only here for semantic reasons really as this library will only support 32/64 bit OSes.
+#if defined( _WIN64 )
+typedef signed __int64   sptr;
+typedef unsigned __int64 uptr;
+#elif defined( _WIN32 )
+// NOTE; To mark types changing their size, e.g. zpl_intptr
+#	ifndef _W64
+#		if ! defined( __midl ) && ( defined( _X86_ ) || defined( _M_IX86 ) ) && _MSC_VER >= 1300
+#			define _W64 __w64
+#		else
+#			define _W64
+#		endif
+#	endif
+typedef _W64 signed int   sptr;
+typedef _W64 unsigned int uptr;
+#else
+typedef uintptr_t uptr;
+typedef intptr_t  sptr;
+#endif
+
+static_assert( sizeof( uptr ) == sizeof( sptr ), "sizeof(uptr) != sizeof(sptr)" );
+
+typedef float  f32;
+typedef double f64;
+
+static_assert( sizeof( f32 ) == 4, "sizeof(f32) != 4" );
+static_assert( sizeof( f64 ) == 8, "sizeof(f64) != 8" );
+
+typedef s8  b8;
+typedef s16 b16;
+typedef s32 b32;
+
+typedef void*       mem_ptr;
+typedef void const* mem_ptr_const ;
+
+#if ! GEN_COMPILER_C
+template<typename Type> uptr to_uptr( Type* ptr ) { return (uptr)ptr; }
+template<typename Type> sptr to_sptr( Type* ptr ) { return (sptr)ptr; }
+
+template<typename Type> mem_ptr       to_mem_ptr      ( Type ptr ) { return (mem_ptr)      ptr; }
+template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem_ptr_const)ptr; }
+#else
+#define to_utpr( ptr ) ((uptr)(ptr))
+#define to_stpr( ptr ) ((sptr)(ptr))
+
+#define to_mem_ptr( ptr)       ((mem_ptr)ptr)
+#define to_mem_ptr_const( ptr) ((mem_ptr)ptr)
+#endif
+
+#pragma endregion Basic Types

project/dependencies/containers.hpp

@@ -0,0 +1,695 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "printing.hpp"
+#endif
+
+#pragma region Containers
+
+template<class TType>             struct RemoveConst                    { typedef TType Type;       };
+template<class TType>             struct RemoveConst<const TType>       { typedef TType Type;       };
+template<class TType>             struct RemoveConst<const TType[]>     { typedef TType Type[];     };
+template<class TType, usize Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
+
+template<class TType>
+using TRemoveConst = typename RemoveConst<TType>::Type;
+
+#pragma region Array
+#define Array(Type) Array<Type>
+
+// #define array_init(Type, ...)         array_init        <Type>(__VA_ARGS__)
+// #define array_init_reserve(Type, ...) array_init_reserve<Type>(__VA_ARGS__)
+
+struct ArrayHeader;
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+	template<class Type> struct Array;
+#else
+	template<class Type> using Array = Type*;
+#endif
+
+usize array_grow_formula(ssize value);
+
+template<class Type> Array(Type)  array_init        (AllocatorInfo allocator);
+template<class Type> Array(Type)  array_init_reserve(AllocatorInfo allocator, ssize capacity);
+template<class Type> bool         append            (Array(Type)* array, Array(Type) other);
+template<class Type> bool         append            (Array(Type)* array, Type value);
+template<class Type> bool         append            (Array(Type)* array, Type* items, usize item_num);
+template<class Type> bool         append_at         (Array(Type)* array, Type item, usize idx);
+template<class Type> bool         append_at         (Array(Type)* array, Type* items, usize item_num, usize idx);
+template<class Type> Type*        back              (Array(Type)  array);
+template<class Type> void         clear             (Array(Type)  array);
+template<class Type> bool         fill              (Array(Type)  array, usize begin, usize end, Type value);
+template<class Type> void         free              (Array(Type)* array);
+template<class Type> bool         grow              (Array(Type)* array, usize min_capacity);
+template<class Type> usize        num               (Array(Type)  array);
+template<class Type> void         pop               (Array(Type)  array);
+template<class Type> void         remove_at         (Array(Type)  array, usize idx);
+template<class Type> bool         reserve           (Array(Type)* array, usize new_capacity);
+template<class Type> bool         resize            (Array(Type)* array, usize num);
+template<class Type> bool         set_capacity      (Array(Type)* array, usize new_capacity);
+template<class Type> ArrayHeader* get_header        (Array(Type)  array);
+
+struct ArrayHeader {
+	AllocatorInfo Allocator;
+	usize         Capacity;
+	usize         Num;
+};
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+template<class Type>
+struct Array
+{
+	Type* Data;
+
+#pragma region Member Mapping
+	forceinline static Array  init(AllocatorInfo allocator)                         { return GEN_NS array_init<Type>(allocator); }
+	forceinline static Array  init_reserve(AllocatorInfo allocator, ssize capacity) { return GEN_NS array_init_reserve<Type>(allocator, capacity); }
+	forceinline static usize  grow_formula(ssize value)                             { return GEN_NS array_grow_formula<Type>(value); }
+
+	forceinline bool         append(Array other)                               { return GEN_NS append<Type>(this, other); }
+	forceinline bool         append(Type value)                                { return GEN_NS append<Type>(this, value); }
+	forceinline bool         append(Type* items, usize item_num)               { return GEN_NS append<Type>(this, items, item_num); }
+	forceinline bool         append_at(Type item, usize idx)                   { return GEN_NS append_at<Type>(this, item, idx); }
+	forceinline bool         append_at(Type* items, usize item_num, usize idx) { return GEN_NS append_at<Type>(this, items, item_num, idx); }
+	forceinline Type*        back()                                            { return GEN_NS back<Type>(* this); }
+	forceinline void         clear()                                           { GEN_NS clear<Type>(* this); }
+	forceinline bool         fill(usize begin, usize end, Type value)          { return GEN_NS fill<Type>(* this, begin, end, value); }
+	forceinline void         free()                                            { GEN_NS free<Type>(this); }
+	forceinline ArrayHeader* get_header()                                      { return GEN_NS get_header<Type>(* this); }
+	forceinline bool         grow(usize min_capacity)                          { return GEN_NS grow<Type>(this, min_capacity); }
+	forceinline usize        num()                                             { return GEN_NS num<Type>(*this); }
+	forceinline void         pop()                                             { GEN_NS pop<Type>(* this); }
+	forceinline void         remove_at(usize idx)                              { GEN_NS remove_at<Type>(* this, idx); }
+	forceinline bool         reserve(usize new_capacity)                       { return GEN_NS reserve<Type>(this, new_capacity); }
+	forceinline bool         resize(usize num)                                 { return GEN_NS resize<Type>(this, num); }
+	forceinline bool         set_capacity(usize new_capacity)                  { return GEN_NS set_capacity<Type>(this, new_capacity); }
+#pragma endregion Member Mapping
+
+	forceinline operator Type*()             { return Data; }
+	forceinline operator Type const*() const { return Data; }
+	forceinline Type* begin()                { return Data; }
+	forceinline Type* end()                  { return Data + get_header()->Num; }
+
+	forceinline Type&       operator[](ssize index)       { return Data[index]; }
+	forceinline Type const& operator[](ssize index) const { return Data[index]; }
+};
+#endif
+
+#if GEN_SUPPORT_CPP_REFERENCES
+template<class Type> bool         append(Array<Type>& array, Array<Type> other)                         { return GEN_NS append( & array, other ); }
+template<class Type> bool         append(Array<Type>& array, Type value)                                { return GEN_NS append( & array, value ); }
+template<class Type> bool         append(Array<Type>& array, Type* items, usize item_num)               { return GEN_NS append( & array, items, item_num ); }
+template<class Type> bool         append_at(Array<Type>& array, Type item, usize idx)                   { return GEN_NS append_at( & array, item, idx ); }
+template<class Type> bool         append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return GEN_NS append_at( & array, items, item_num, idx ); }
+template<class Type> void         free(Array<Type>& array)                                              { return GEN_NS free( & array ); }
+template<class Type> bool         grow(Array<Type>& array, usize min_capacity)                          { return GEN_NS grow( & array, min_capacity); }
+template<class Type> bool         reserve(Array<Type>& array, usize new_capacity)                       { return GEN_NS reserve( & array, new_capacity); }
+template<class Type> bool         resize(Array<Type>& array, usize num)                                 { return GEN_NS resize( & array, num); }
+template<class Type> bool         set_capacity(Array<Type>& array, usize new_capacity)                  { return GEN_NS 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 + get_header(array)->Num; }
+template<class Type> forceinline Type* next(Array<Type>& array, Type* entry) { return entry + 1; }
+#else
+template<class Type> forceinline Type* begin(Array<Type> array)             { return array;      }
+template<class Type> forceinline Type* end(Array<Type> array)               { return array + get_header(array)->Num; }
+template<class Type> forceinline Type* next(Array<Type> array, Type* entry) { return entry + 1; }
+#endif
+
+template<class Type> inline
+Array<Type> array_init(AllocatorInfo allocator) {
+	return array_init_reserve<Type>(allocator, array_grow_formula(0));
+}
+
+template<class Type> inline
+Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity)
+{
+	ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(Type) * capacity));
+
+	if (header == nullptr)
+ 		return {nullptr};
+
+	header->Allocator = allocator;
+	header->Capacity  = capacity;
+	header->Num       = 0;
+
+	return {rcast(Type*, header + 1)};
+}
+
+usize array_grow_formula(ssize value) {
+	return 2 * value + 8;
+}
+
+template<class Type> inline
+bool append(Array<Type>* array, Array<Type> other) {
+	return append(array, other, num(other));
+}
+
+template<class Type> inline
+bool append(Array<Type>* array, Type value)
+{
+	ArrayHeader* header = get_header(* array);
+
+	if (header->Num == header->Capacity)
+	{
+		if (!grow(array, header->Capacity))
+			return false;
+		header = get_header(* array);
+	}
+
+	(*array)[ header->Num] = value;
+	header->Num++;
+
+	return true;
+}
+
+template<class Type> inline
+bool append(Array<Type>* array, Type* items, usize item_num)
+{
+	ArrayHeader* header = get_header(array);
+
+	if (header->Num + item_num > header->Capacity)
+	{
+		if (!grow(array, header->Capacity + item_num))
+			return false;
+		header = get_header(array);
+	}
+
+	mem_copy(array.Data + header->Num, items, item_num * sizeof(Type));
+	header->Num += item_num;
+
+	return true;
+}
+
+template<class Type> inline
+bool append_at(Array<Type>* array, Type item, usize idx)
+{
+	ArrayHeader* header = get_header(* array);
+
+	ssize slot = idx;
+	if (slot >= header->Num)
+	 	slot = header->Num - 1;
+
+	if (slot < 0)
+ 		slot = 0;
+
+	if (header->Capacity < header->Num + 1)
+	{
+		if ( ! grow(array, header->Capacity + 1))
+			return false;
+
+		header = get_header(* array);
+	}
+
+	Type* target = &(*array)[slot];
+
+	mem_move(target + 1, target, (header->Num - slot) * sizeof(Type));
+	header->Num++;
+
+	header = get_header(* array);
+
+	return true;
+}
+
+template<class Type> inline
+bool append_at(Array<Type>* array, Type* items, usize item_num, usize idx)
+{
+	ArrayHeader* header = get_header(array);
+
+	if (idx >= header->Num)
+	{
+		return append(array, items, item_num);
+ 	}
+
+	if (item_num > header->Capacity)
+	{
+		if (! grow(array, header->Capacity + item_num))
+			return false;
+
+		header = get_header(array);
+	}
+
+	Type* target = array.Data + idx + item_num;
+	Type* src    = array.Data + idx;
+
+	mem_move(target, src, (header->Num - idx) * sizeof(Type));
+	mem_copy(src, items, item_num * sizeof(Type));
+	header->Num += item_num;
+
+	return true;
+}
+
+template<class Type> inline
+Type* back(Array<Type>* array)
+{
+	GEN_ASSERT(array != nullptr);
+
+	ArrayHeader* header = get_header(* array);
+	if (header->Num <= 0)
+		return nullptr;
+
+	return & (*array)[header->Num - 1];
+}
+
+template<class Type> inline
+void clear(Array<Type> array) {
+	ArrayHeader* header = get_header(array);
+	header->Num = 0;
+}
+
+template<class Type> inline
+bool fill(Array<Type> array, usize begin, usize end, Type value)
+{
+	ArrayHeader* header = get_header(array);
+
+	if (begin < 0 || end > header->Num)
+	return false;
+
+	for (ssize idx = ssize(begin); idx < ssize(end); idx++)
+	{
+		array[idx] = value;
+	}
+
+	return true;
+}
+
+template<class Type> inline
+void free(Array<Type>* array) {
+	GEN_ASSERT(array != nullptr);
+	ArrayHeader* header = get_header(* array);
+	GEN_NS free(header->Allocator, header);
+	Type** Data = (Type**)array;
+	*Data = nullptr;
+}
+
+template<class Type> forceinline
+ArrayHeader* get_header(Array<Type> array) {
+    Type* Data = array;
+
+	using NonConstType = TRemoveConst<Type>;
+    return rcast(ArrayHeader*, const_cast<NonConstType*>(Data)) - 1;
+}
+template<class Type> inline
+bool grow(Array<Type>* array, usize min_capacity)
+{
+	ArrayHeader* header       = get_header(* array);
+	usize        new_capacity = array_grow_formula(header->Capacity);
+
+	if (new_capacity < min_capacity)
+	new_capacity = min_capacity;
+
+	return set_capacity(array, new_capacity);
+}
+
+template<class Type> inline
+usize num(Array<Type> array) {
+	return get_header(array)->Num;
+}
+
+template<class Type> inline
+void pop(Array<Type> array) {
+	ArrayHeader* header = get_header(array);
+	GEN_ASSERT(header->Num > 0);
+	header->Num--;
+}
+
+template<class Type> inline
+void remove_at(Array<Type> array, usize idx)
+{
+	ArrayHeader* header = get_header(array);
+	GEN_ASSERT(idx < header->Num);
+
+	mem_move(array + idx, array + idx + 1, sizeof(Type) * (header->Num - idx - 1));
+	header->Num--;
+}
+
+template<class Type> inline
+bool reserve(Array<Type>* array, usize new_capacity)
+{
+	ArrayHeader* header = get_header(array);
+
+	if (header->Capacity < new_capacity)
+ 		return set_capacity(array, new_capacity);
+
+	return true;
+}
+
+template<class Type> inline
+bool resize(Array<Type>* array, usize num)
+{
+	ArrayHeader* header = get_header(* array);
+
+	if (header->Capacity < num) {
+		if (! grow( array, num))
+			return false;
+		header = get_header(* array);
+	}
+
+	header->Num = num;
+ 	return true;
+}
+
+template<class Type> inline
+bool set_capacity(Array<Type>* array, usize new_capacity)
+{
+	ArrayHeader* header = get_header(* array);
+
+	if (new_capacity == header->Capacity)
+	return true;
+
+	if (new_capacity < header->Num)
+	{
+		header->Num = new_capacity;
+		return true;
+	}
+
+	ssize        size       = sizeof(ArrayHeader) + sizeof(Type) * new_capacity;
+	ArrayHeader* new_header = rcast(ArrayHeader*, alloc(header->Allocator, size));
+
+	if (new_header == nullptr)
+		return false;
+
+	mem_move(new_header, header, sizeof(ArrayHeader) + sizeof(Type) * header->Num);
+
+	new_header->Capacity = new_capacity;
+
+	GEN_NS free(header->Allocator, header);
+
+	Type** Data = (Type**)array;
+	* Data = rcast(Type*, new_header + 1);
+	return true;
+}
+
+#pragma endregion Array
+
+// TODO(Ed) : This thing needs ALOT of work.
+
+#pragma region HashTable
+template<class Type> struct HashTable;
+
+struct HashTableFindResult {
+	ssize HashIndex;
+	ssize PrevIndex;
+	ssize EntryIndex;
+};
+
+template<class Type>
+struct HashTableEntry {
+	u64   Key;
+	ssize Next;
+	Type  Value;
+};
+
+#define HashTableEntry(Type) HashTableEntry<Type>
+
+template<class Type> HashTable<Type>       hashtable_init(AllocatorInfo allocator);
+template<class Type> HashTable<Type>       hashtable_init_reserve(AllocatorInfo allocator, usize num);
+template<class Type> void                  clear        (HashTable<Type>  table);
+template<class Type> void                  destroy      (HashTable<Type>* table);
+template<class Type> Type*                 get          (HashTable<Type>  table, u64 key);
+template<class Type> void                  grow         (HashTable<Type>* table);
+template<class Type> void                  rehash       (HashTable<Type>* table, ssize new_num);
+template<class Type> void                  rehash_fast  (HashTable<Type>  table);
+template<class Type> void                  remove       (HashTable<Type>  table, u64 key);
+template<class Type> void                  remove_entry (HashTable<Type>  table, ssize idx);
+template<class Type> void                  set          (HashTable<Type>* table, u64 key, Type value);
+template<class Type> ssize                 slot         (HashTable<Type>  table, u64 key);
+template<class Type> ssize                 add_entry    (HashTable<Type>* table, u64 key);
+template<class Type> HashTableFindResult   find         (HashTable<Type>  table, u64 key);
+template<class Type> bool                  full         (HashTable<Type>  table);
+template<class Type> void                  map          (HashTable<Type>  table, void (*map_proc)(u64 key, Type value));
+template<class Type> void                  map_mut      (HashTable<Type>  table, void (*map_proc)(u64 key, Type* value));
+
+static constexpr f32 HashTable_CriticalLoadScale = 0.7f;
+
+template<typename Type>
+struct HashTable
+{
+	Array<ssize>                Hashes;
+	Array<HashTableEntry<Type>> Entries;
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#pragma region Member Mapping
+	forceinline static HashTable init(AllocatorInfo allocator)                    { return GEN_NS hashtable_init<Type>(allocator); }
+	forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return GEN_NS hashtable_init_reserve<Type>(allocator, num); }
+
+	forceinline void  clear()                           { GEN_NS clear<Type>(*this); }
+	forceinline void  destroy()                         { GEN_NS destroy<Type>(*this); }
+	forceinline Type* get(u64 key)                      { return GEN_NS get<Type>(*this, key); }
+	forceinline void  grow()                            { GEN_NS grow<Type>(*this); }
+	forceinline void  rehash(ssize new_num)             { GEN_NS rehash<Type>(*this, new_num); }
+	forceinline void  rehash_fast()                     { GEN_NS rehash_fast<Type>(*this); }
+	forceinline void  remove(u64 key)                   { GEN_NS remove<Type>(*this, key); }
+	forceinline void  remove_entry(ssize idx)           { GEN_NS remove_entry<Type>(*this, idx); }
+	forceinline void  set(u64 key, Type value)          { GEN_NS set<Type>(*this, key, value); }
+	forceinline ssize slot(u64 key)                     { return GEN_NS slot<Type>(*this, key); }
+	forceinline void  map(void (*proc)(u64, Type))      { GEN_NS map<Type>(*this, proc); }
+	forceinline void  map_mut(void (*proc)(u64, Type*)) { GEN_NS map_mut<Type>(*this, proc); }
+#pragma endregion Member Mapping
+#endif
+};
+
+#if GEN_SUPPORT_CPP_REFERENCES
+template<class Type> void  destroy  (HashTable<Type>& table)                      { destroy(& table); }
+template<class Type> void  grow     (HashTable<Type>& table)                      { grow(& table); }
+template<class Type> void  rehash   (HashTable<Type>& table, ssize new_num)       { rehash(& table, new_num); }
+template<class Type> void  set      (HashTable<Type>& table, u64 key, Type value) { set(& table, key, value); }
+template<class Type> ssize add_entry(HashTable<Type>& table, u64 key)             { add_entry(& table, key); }
+#endif
+
+template<typename Type> inline
+HashTable<Type> hashtable_init(AllocatorInfo allocator) {
+	HashTable<Type> result = hashtable_init_reserve<Type>(allocator, 8);
+	return result;
+}
+
+template<typename Type> inline
+HashTable<Type> hashtable_init_reserve(AllocatorInfo allocator, usize num)
+{
+	HashTable<Type> result = { { nullptr }, { nullptr } };
+
+	result.Hashes = array_init_reserve<ssize>(allocator, num);
+	get_header(result.Hashes)->Num = num;
+	resize(& result.Hashes, num);
+	fill<ssize>(result.Hashes, 0, num, -1);
+
+	result.Entries = array_init_reserve<HashTableEntry<Type>>(allocator, num);
+	return result;
+}
+
+template<typename Type> inline
+void clear(HashTable<Type> table) {
+	clear(table.Entries);
+	fill<ssize>(table.Hashes, 0, num(table.Hashes), -1);
+}
+
+template<typename Type> inline
+void destroy(HashTable<Type>* table) {
+	if (table->Hashes && get_header(table->Hashes)->Capacity) {
+		free(& table->Hashes);
+		free(& table->Entries);
+	}
+}
+
+template<typename Type> inline
+Type* get(HashTable<Type> table, u64 key) {
+	ssize idx = find(table, key).EntryIndex;
+	if (idx >= 0)
+		return & table.Entries[idx].Value;
+
+	return nullptr;
+}
+
+template<typename Type> inline
+void map(HashTable<Type> table, void (*map_proc)(u64 key, Type value)) {
+	GEN_ASSERT_NOT_NULL(map_proc);
+
+	for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
+		map_proc(table.Entries[idx].Key, table.Entries[idx].Value);
+	}
+}
+
+template<typename Type> inline
+void map_mut(HashTable<Type> table, void (*map_proc)(u64 key, Type* value)) {
+	GEN_ASSERT_NOT_NULL(map_proc);
+
+	for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
+		map_proc(table.Entries[idx].Key, & table.Entries[idx].Value);
+	}
+}
+
+template<typename Type> inline
+void grow(HashTable<Type>* table) {
+	ssize new_num = array_grow_formula(num(table->Entries));
+	rehash(table, new_num);
+}
+
+template<typename Type> inline
+void rehash(HashTable<Type>* table, ssize new_num)
+{
+	ssize last_added_index;
+	HashTable<Type> new_ht = hashtable_init_reserve<Type>(get_header(table->Hashes)->Allocator, new_num);
+
+	for (ssize idx = 0; idx < ssize(num(table->Entries)); ++idx)
+	{
+		HashTableFindResult find_result;
+		HashTableEntry<Type>& entry = table->Entries[idx];
+
+		find_result = find(new_ht, entry.Key);
+		last_added_index = add_entry(& new_ht, entry.Key);
+
+		if (find_result.PrevIndex < 0)
+			new_ht.Hashes[find_result.HashIndex] = last_added_index;
+		else
+			new_ht.Entries[find_result.PrevIndex].Next = last_added_index;
+
+		new_ht.Entries[last_added_index].Next = find_result.EntryIndex;
+		new_ht.Entries[last_added_index].Value = entry.Value;
+	}
+
+	destroy(table);
+	* table = new_ht;
+}
+
+template<typename Type> inline
+void rehash_fast(HashTable<Type> table)
+{
+	ssize idx;
+
+	for (idx = 0; idx < ssize(num(table.Entries)); idx++)
+		table.Entries[idx].Next = -1;
+
+	for (idx = 0; idx < ssize(num(table.Hashes)); idx++)
+		table.Hashes[idx] = -1;
+
+	for (idx = 0; idx < ssize(num(table.Entries)); idx++)
+	{
+		HashTableEntry<Type>* entry;
+		HashTableFindResult find_result;
+
+		entry = &table.Entries[idx];
+		find_result = find(table, entry->Key);
+
+		if (find_result.PrevIndex < 0)
+			table.Hashes[find_result.HashIndex] = idx;
+		else
+			table.Entries[find_result.PrevIndex].Next = idx;
+	}
+}
+
+template<typename Type> inline
+void remove(HashTable<Type> table, u64 key) {
+	HashTableFindResult find_result = find(table, key);
+
+	if (find_result.EntryIndex >= 0) {
+		remove_at(table.Entries, find_result.EntryIndex);
+		rehash_fast(table);
+	}
+}
+
+template<typename Type> inline
+void remove_entry(HashTable<Type> table, ssize idx) {
+	remove_at(table.Entries, idx);
+}
+
+template<typename Type> inline
+void set(HashTable<Type>* table, u64 key, Type value)
+{
+	ssize idx;
+	HashTableFindResult find_result;
+
+	if (full(* table))
+		grow(table);
+
+	find_result = find(* table, key);
+	if (find_result.EntryIndex >= 0) {
+		idx = find_result.EntryIndex;
+	}
+	else
+	{
+		idx = add_entry(table, key);
+
+		if (find_result.PrevIndex >= 0) {
+			table->Entries[find_result.PrevIndex].Next = idx;
+		}
+		else {
+			table->Hashes[find_result.HashIndex] = idx;
+		}
+	}
+
+	table->Entries[idx].Value = value;
+
+	if (full(* table))
+		grow(table);
+}
+
+template<typename Type> inline
+ssize slot(HashTable<Type> table, u64 key) {
+	for (ssize idx = 0; idx < ssize(num(table.Hashes)); ++idx)
+		if (table.Hashes[idx] == key)
+			return idx;
+
+	return -1;
+}
+
+template<typename Type> inline
+ssize add_entry(HashTable<Type>* table, u64 key) {
+	ssize idx;
+	HashTableEntry<Type> entry = { key, -1 };
+
+	idx = num(table->Entries);
+	append( & table->Entries, entry);
+	return idx;
+}
+
+template<typename Type> inline
+HashTableFindResult find(HashTable<Type> table, u64 key)
+{
+	HashTableFindResult result = { -1, -1, -1 };
+
+	if (num(table.Hashes) > 0)
+	{
+		result.HashIndex = key % num(table.Hashes);
+		result.EntryIndex = table.Hashes[result.HashIndex];
+
+		while (result.EntryIndex >= 0)
+		{
+			if (table.Entries[result.EntryIndex].Key == key)
+				break;
+
+			result.PrevIndex = result.EntryIndex;
+			result.EntryIndex = table.Entries[result.EntryIndex].Next;
+		}
+	}
+
+	return result;
+}
+
+template<typename Type> inline
+bool full(HashTable<Type> table) {
+	usize critical_load = usize(HashTable_CriticalLoadScale * f32(num(table.Hashes)));
+	b32 result = num(table.Entries) > critical_load;
+	return result;
+}
+
+#define hashtable_init(Type, allocator)               hashtable_init<Type>(allocator)
+#define hashtable_init_reserve(Type, allocator, num)  hashtable_init_reserve<Type>(allocator, num)
+#define hashtable_clear(Type, table)                  clear<Type>(table)
+#define hashtable_destroy(Type, table)                destroy<Type>(table)
+#define hashtable_get(Type, table, key)               get<Type>(table, key)
+#define hashtable_grow(Type, table)                   grow<Type>(table)
+#define hashtable_rehash(Type, table, new_num)        rehash<Type>(table, new_num)
+#define hashtable_rehash_fast(Type, table)            rehash_fast<Type>(table)
+#define hashtable_remove(Type, table, key)            remove<Type>(table, key)
+#define hashtable_remove_entry(Type, table, idx)      remove_entry<Type>(table, idx)
+#define hashtable_set(Type, table, key, value)        set<Type>(table, key, value)
+#define hashtable_slot(Type, table, key)              slot<Type>(table, key)
+#define hashtable_add_entry(Type, table, key)         add_entry<Type>(table, key)
+#define hashtable_find(Type, table, key)              find<Type>(table, key)
+#define hashtable_full(Type, table)                   full<Type>(table)
+#define hashtable_map(Type, table, map_proc)          map<Type>(table, map_proc)
+#define hashtable_map_mut(Type, table, map_proc)      map_mut<Type>(table, map_proc)
+
+#pragma endregion HashTable
+
+#pragma endregion Containers

project/dependencies/debug.cpp

@@ -0,0 +1,48 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "debug.hpp"
+#	include "basic_types.hpp"
+#   include "src_start.cpp"
+#endif
+
+#pragma region Debug
+
+void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... )
+{
+	_printf_err( "%s:(%d): Assert Failure: ", file, line );
+
+	if ( condition )
+		_printf_err( "`%s` \n", condition );
+
+	if ( msg )
+	{
+		va_list va;
+		va_start( va, msg );
+		_printf_err_va( msg, va );
+		va_end( va );
+	}
+
+	_printf_err( "%s", "\n" );
+}
+
+s32 assert_crash( char const* condition )
+{
+	GEN_PANIC( condition );
+	return 0;
+}
+
+#if defined( GEN_SYSTEM_WINDOWS )
+	void process_exit( u32 code )
+	{
+		ExitProcess( code );
+	}
+#else
+#	include <stdlib.h>
+
+	void process_exit( u32 code )
+	{
+		exit( code );
+	}
+#endif
+
+#pragma endregion Debug

project/dependencies/debug.hpp

@@ -0,0 +1,63 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "basic_types.hpp"
+#endif
+
+#pragma region Debug
+
+#if defined( _MSC_VER )
+#	if _MSC_VER < 1300
+#		define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
+#	else
+#		define GEN_DEBUG_TRAP() __debugbreak()
+#	endif
+#elif defined( GEN_COMPILER_TINYC )
+#	define GEN_DEBUG_TRAP() process_exit( 1 )
+#else
+#	define GEN_DEBUG_TRAP() __builtin_trap()
+#endif
+
+#define GEN_ASSERT( cond ) GEN_ASSERT_MSG( cond, NULL )
+
+#define GEN_ASSERT_MSG( cond, msg, ... )                                                     \
+	do                                                                                       \
+	{                                                                                        \
+		if ( ! ( cond ) )                                                                    \
+		{                                                                                    \
+			assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ );   \
+			GEN_DEBUG_TRAP();                                                                \
+		}                                                                                    \
+	} while ( 0 )
+
+#define GEN_ASSERT_NOT_NULL( ptr ) GEN_ASSERT_MSG( ( ptr ) != NULL, #ptr " must not be NULL" )
+
+// NOTE: Things that shouldn't happen with a message!
+#define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
+
+#if Build_Debug
+	#define GEN_FATAL( ... )                               \
+	do                                                     \
+	{                                                      \
+		local_persist thread_local                         \
+		char buf[GEN_PRINTF_MAXLEN] = { 0 };               \
+		                                                   \
+		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__);      \
+		GEN_PANIC(buf);                                    \
+	}                                                      \
+	while (0)
+#else
+
+#	define GEN_FATAL( ... )                  \
+	do                                       \
+	{                                        \
+		str_fmt_out_err( __VA_ARGS__ );      \
+		process_exit(1);                     \
+	}                                        \
+	while (0)
+#endif
+
+void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
+s32  assert_crash( char const* condition );
+void process_exit( u32 code );
+
+#pragma endregion Debug

project/dependencies/filesystem.cpp

@@ -0,0 +1,658 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "strings.cpp"
+#endif
+
+#pragma region File Handling
+
+#if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
+
+internal
+wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
+{
+	wchar_t* w_text = NULL;
+	ssize       len = 0, w_len = 0, w_len1 = 0;
+	if ( text == NULL )
+	{
+		if ( w_len_ )
+			*w_len_ = w_len;
+		return NULL;
+	}
+	len = str_len( text );
+	if ( len == 0 )
+	{
+		if ( w_len_ )
+			*w_len_ = w_len;
+		return NULL;
+	}
+	w_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), NULL, 0 );
+	if ( w_len == 0 )
+	{
+		if ( w_len_ )
+			*w_len_ = w_len;
+		return NULL;
+	}
+	w_text = alloc_array( a, wchar_t, w_len + 1 );
+	w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), w_text, scast( int, w_len) );
+	if ( w_len1 == 0 )
+	{
+		free( a, w_text );
+		if ( w_len_ )
+			*w_len_ = 0;
+		return NULL;
+	}
+	w_text[ w_len ] = 0;
+	if ( w_len_ )
+		*w_len_ = w_len;
+	return w_text;
+}
+
+internal
+GEN_FILE_SEEK_PROC( _win32_file_seek )
+{
+	LARGE_INTEGER li_offset;
+	li_offset.QuadPart = offset;
+	if ( ! SetFilePointerEx( fd.p, li_offset, &li_offset, whence ) )
+	{
+		return false;
+	}
+
+	if ( new_offset )
+		*new_offset = li_offset.QuadPart;
+	return true;
+}
+
+internal
+GEN_FILE_READ_AT_PROC( _win32_file_read )
+{
+	// unused( stop_at_newline );
+	b32 result = false;
+	_win32_file_seek( fd, offset, ESeekWhence_BEGIN, NULL );
+	DWORD size_ = scast( DWORD, ( size > GEN_I32_MAX ? GEN_I32_MAX : size ));
+	DWORD bytes_read_;
+	if ( ReadFile( fd.p, buffer, size_, &bytes_read_, NULL ) )
+	{
+		if ( bytes_read )
+			*bytes_read = bytes_read_;
+		result = true;
+	}
+
+	return result;
+}
+
+internal
+GEN_FILE_WRITE_AT_PROC( _win32_file_write )
+{
+	DWORD size_ = scast( DWORD, ( size > GEN_I32_MAX ? GEN_I32_MAX : size ));
+	DWORD bytes_written_;
+	_win32_file_seek( fd, offset, ESeekWhence_BEGIN, NULL );
+	if ( WriteFile( fd.p, buffer, size_, &bytes_written_, NULL ) )
+	{
+		if ( bytes_written )
+			*bytes_written = bytes_written_;
+		return true;
+	}
+	return false;
+}
+
+internal
+GEN_FILE_CLOSE_PROC( _win32_file_close )
+{
+	CloseHandle( fd.p );
+}
+
+FileOperations const default_file_operations = { _win32_file_read, _win32_file_write, _win32_file_seek, _win32_file_close };
+
+neverinline
+GEN_FILE_OPEN_PROC( _win32_file_open )
+{
+	DWORD    desired_access;
+	DWORD    creation_disposition;
+	void*    handle;
+	wchar_t* w_text;
+
+	switch ( mode & GEN_FILE_MODES )
+	{
+		case EFileMode_READ :
+			desired_access       = GENERIC_READ;
+			creation_disposition = OPEN_EXISTING;
+			break;
+		case EFileMode_WRITE :
+			desired_access       = GENERIC_WRITE;
+			creation_disposition = CREATE_ALWAYS;
+			break;
+		case EFileMode_APPEND :
+			desired_access       = GENERIC_WRITE;
+			creation_disposition = OPEN_ALWAYS;
+			break;
+		case EFileMode_READ | EFileMode_RW :
+			desired_access       = GENERIC_READ | GENERIC_WRITE;
+			creation_disposition = OPEN_EXISTING;
+			break;
+		case EFileMode_WRITE | EFileMode_RW :
+			desired_access       = GENERIC_READ | GENERIC_WRITE;
+			creation_disposition = CREATE_ALWAYS;
+			break;
+		case EFileMode_APPEND | EFileMode_RW :
+			desired_access       = GENERIC_READ | GENERIC_WRITE;
+			creation_disposition = OPEN_ALWAYS;
+			break;
+		default :
+			GEN_PANIC( "Invalid file mode" );
+			return EFileError_INVALID;
+	}
+
+	w_text = _alloc_utf8_to_ucs2( heap(), filename, NULL );
+	handle = CreateFileW( w_text, desired_access, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL );
+
+	free( heap(), w_text );
+
+	if ( handle == INVALID_HANDLE_VALUE )
+	{
+		DWORD err = GetLastError();
+		switch ( err )
+		{
+			case ERROR_FILE_NOT_FOUND :
+				return EFileError_NOT_EXISTS;
+			case ERROR_FILE_EXISTS :
+				return EFileError_EXISTS;
+			case ERROR_ALREADY_EXISTS :
+				return EFileError_EXISTS;
+			case ERROR_ACCESS_DENIED :
+				return EFileError_PERMISSION;
+		}
+		return EFileError_INVALID;
+	}
+
+	if ( mode & EFileMode_APPEND )
+	{
+		LARGE_INTEGER offset = { { 0 } };
+		if ( ! SetFilePointerEx( handle, offset, NULL, ESeekWhence_END ) )
+		{
+			CloseHandle( handle );
+			return EFileError_INVALID;
+		}
+	}
+
+	fd->p = handle;
+	*ops  = default_file_operations;
+	return EFileError_NONE;
+}
+
+#else    // POSIX
+#	include <fcntl.h>
+
+internal
+GEN_FILE_SEEK_PROC( _posix_file_seek )
+{
+#	if defined( GEN_SYSTEM_OSX )
+	s64 res = lseek( fd.i, offset, whence );
+#	else    // TODO(ZaKlaus): @fixme lseek64
+	s64 res = lseek( fd.i, offset, whence );
+#	endif
+	if ( res < 0 )
+		return false;
+	if ( new_offset )
+		*new_offset = res;
+	return true;
+}
+
+internal
+GEN_FILE_READ_AT_PROC( _posix_file_read )
+{
+	unused( stop_at_newline );
+	ssize res = pread( fd.i, buffer, size, offset );
+	if ( res < 0 )
+		return false;
+	if ( bytes_read )
+		*bytes_read = res;
+	return true;
+}
+
+internal
+GEN_FILE_WRITE_AT_PROC( _posix_file_write )
+{
+	ssize  res;
+	s64 curr_offset = 0;
+	_posix_file_seek( fd, 0, ESeekWhence_CURRENT, &curr_offset );
+	if ( curr_offset == offset )
+	{
+		// NOTE: Writing to stdout et al. doesn't like pwrite for numerous reasons
+		res = write( scast( int, fd.i), buffer, size );
+	}
+	else
+	{
+		res = pwrite( scast( int, fd.i), buffer, size, offset );
+	}
+	if ( res < 0 )
+		return false;
+	if ( bytes_written )
+		*bytes_written = res;
+	return true;
+}
+
+internal
+GEN_FILE_CLOSE_PROC( _posix_file_close )
+{
+	close( fd.i );
+}
+
+FileOperations const default_file_operations = { _posix_file_read, _posix_file_write, _posix_file_seek, _posix_file_close };
+
+neverinline
+GEN_FILE_OPEN_PROC( _posix_file_open )
+{
+	s32 os_mode;
+	switch ( mode & GEN_FILE_MODES )
+	{
+		case EFileMode_READ :
+			os_mode = O_RDONLY;
+			break;
+		case EFileMode_WRITE :
+			os_mode = O_WRONLY | O_CREAT | O_TRUNC;
+			break;
+		case EFileMode_APPEND :
+			os_mode = O_WRONLY | O_APPEND | O_CREAT;
+			break;
+		case EFileMode_READ | EFileMode_RW :
+			os_mode = O_RDWR;
+			break;
+		case EFileMode_WRITE | EFileMode_RW :
+			os_mode = O_RDWR | O_CREAT | O_TRUNC;
+			break;
+		case EFileMode_APPEND | EFileMode_RW :
+			os_mode = O_RDWR | O_APPEND | O_CREAT;
+			break;
+		default :
+			GEN_PANIC( "Invalid file mode" );
+			return EFileError_INVALID;
+	}
+
+	fd->i = open( filename, os_mode, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
+	if ( fd->i < 0 )
+	{
+		// TODO : More file errors
+		return EFileError_INVALID;
+	}
+
+	*ops = default_file_operations;
+	return EFileError_NONE;
+}
+
+// POSIX
+#endif
+
+internal void _dirinfo_free_entry( DirEntry* entry );
+
+// TODO : Is this a bad idea?
+global b32      _std_file_set                     = false;
+global FileInfo _std_files[ EFileStandard_COUNT ] = {
+{
+	{ nullptr, nullptr, nullptr, nullptr },
+	{ nullptr },
+	0,
+	nullptr,
+	0,
+	nullptr
+} };
+
+#if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
+
+FileInfo* file_get_standard( FileStandardType std )
+{
+	if ( ! _std_file_set )
+	{
+#	define GEN__SET_STD_FILE( type, v ) \
+		_std_files[ type ].fd.p = v;    \
+		_std_files[ type ].ops  = default_file_operations
+		GEN__SET_STD_FILE( EFileStandard_INPUT, GetStdHandle( STD_INPUT_HANDLE ) );
+		GEN__SET_STD_FILE( EFileStandard_OUTPUT, GetStdHandle( STD_OUTPUT_HANDLE ) );
+		GEN__SET_STD_FILE( EFileStandard_ERROR, GetStdHandle( STD_ERROR_HANDLE ) );
+#	undef GEN__SET_STD_FILE
+		_std_file_set = true;
+	}
+	return &_std_files[ std ];
+}
+
+#else    // POSIX
+
+FileInfo* file_get_standard( FileStandardType std )
+{
+	if ( ! _std_file_set )
+	{
+#	define GEN__SET_STD_FILE( type, v ) \
+		_std_files[ type ].fd.i = v;     \
+		_std_files[ type ].ops  = default_file_operations
+		GEN__SET_STD_FILE( EFileStandard_INPUT, 0 );
+		GEN__SET_STD_FILE( EFileStandard_OUTPUT, 1 );
+		GEN__SET_STD_FILE( EFileStandard_ERROR, 2 );
+#	undef GEN__SET_STD_FILE
+		_std_file_set = true;
+	}
+	return &_std_files[ std ];
+}
+
+#endif
+
+FileError file_close( FileInfo* f )
+{
+	if ( ! f )
+		return EFileError_INVALID;
+
+	if ( f->filename )
+		free( heap(), ccast( char*, f->filename ));
+
+#if defined( GEN_SYSTEM_WINDOWS )
+	if ( f->fd.p == INVALID_HANDLE_VALUE )
+		return EFileError_INVALID;
+#else
+	if ( f->fd.i < 0 )
+		return EFileError_INVALID;
+#endif
+
+	if ( f->is_temp )
+	{
+		f->ops.close( f->fd );
+		return EFileError_NONE;
+	}
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+	f->ops.close( f->fd );
+
+#if 0
+	if ( f->Dir )
+	{
+		_dirinfo_free_entry( f->Dir );
+		mfree( f->Dir );
+		f->Dir = NULL;
+	}
+#endif
+
+	return EFileError_NONE;
+}
+
+FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename )
+{
+	FileError err = EFileError_NONE;
+	ssize        len = str_len( filename );
+
+	f->ops             = ops;
+	f->fd              = fd;
+	f->dir             = nullptr;
+	f->last_write_time = 0;
+	f->filename        = alloc_array( heap(), char, len + 1 );
+	mem_copy( ccast( char*, f->filename), ccast( char*, filename), len + 1 );
+
+	return err;
+}
+
+FileError file_open( FileInfo* f, char const* filename )
+{
+	return file_open_mode( f, EFileMode_READ, filename );
+}
+
+FileError file_open_mode( FileInfo* f, FileMode mode, char const* filename )
+{
+	FileInfo file_ =
+	{
+		{ nullptr, nullptr, nullptr, nullptr },
+		{ nullptr },
+		0,
+		nullptr,
+		0,
+		nullptr
+		};
+
+	*f = file_;
+	FileError err;
+
+#if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
+	err = _win32_file_open( &f->fd, &f->ops, mode, filename );
+#else
+	err = _posix_file_open( &f->fd, &f->ops, mode, filename );
+#endif
+
+	if ( err == EFileError_NONE )
+		return file_new( f, f->fd, f->ops, filename );
+
+	return err;
+}
+
+s64 file_size( FileInfo* f )
+{
+	s64 size        = 0;
+	s64 prev_offset = file_tell( f );
+
+	file_seek_to_end( f );
+	size = file_tell( f );
+
+	file_seek( f, prev_offset );
+
+	return size;
+}
+
+FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const* filepath )
+{
+	FileContents result;
+	FileInfo     file  ;
+
+	result.allocator = a;
+
+	if ( file_open( &file, filepath ) == EFileError_NONE )
+	{
+		ssize fsize = scast( ssize , file_size( &file ));
+		if ( fsize > 0 )
+		{
+			result.data = alloc( a, zero_terminate ? fsize + 1 : fsize );
+			result.size = fsize;
+			file_read_at( &file, result.data, result.size, 0 );
+			if ( zero_terminate )
+			{
+				u8* str      = rcast( u8*, result.data);
+				str[ fsize ] = '\0';
+			}
+		}
+		file_close( &file );
+	}
+
+	return result;
+}
+
+struct _memory_fd
+{
+	u8            magic;
+	u8*           buf;    //< zpl_array OR plain buffer if we can't write
+	ssize         cursor;
+	AllocatorInfo allocator;
+
+	FileStreamFlags flags;
+	ssize           cap;
+};
+
+#define GEN__FILE_STREAM_FD_MAGIC 37
+
+FileDescriptor _file_stream_fd_make( _memory_fd* d );
+_memory_fd*    _file_stream_from_fd( FileDescriptor fd );
+
+inline
+FileDescriptor _file_stream_fd_make( _memory_fd* d )
+{
+	FileDescriptor fd = { 0 };
+	fd.p              = ( void* )d;
+	return fd;
+}
+
+inline
+_memory_fd* _file_stream_from_fd( FileDescriptor fd )
+{
+	_memory_fd* d = ( _memory_fd* )fd.p;
+	GEN_ASSERT( d->magic == GEN__FILE_STREAM_FD_MAGIC );
+	return d;
+}
+
+b8 file_stream_new( FileInfo* file, AllocatorInfo allocator )
+{
+	GEN_ASSERT_NOT_NULL( file );
+
+	_memory_fd* d = ( _memory_fd* )alloc( allocator, size_of( _memory_fd ) );
+
+	if ( ! d )
+		return false;
+
+	zero_item( file );
+	d->magic     = GEN__FILE_STREAM_FD_MAGIC;
+	d->allocator = allocator;
+	d->flags     = EFileStream_CLONE_WRITABLE;
+	d->cap       = 0;
+	d->buf       = array_init<u8>( allocator );
+
+	if ( ! d->buf )
+		return false;
+
+	file->ops             = memory_file_operations;
+	file->fd              = _file_stream_fd_make( d );
+	file->dir             = NULL;
+	file->last_write_time = 0;
+	file->filename        = NULL;
+	file->is_temp         = true;
+	return true;
+}
+
+b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize size, FileStreamFlags flags )
+{
+	GEN_ASSERT_NOT_NULL( file );
+	_memory_fd* d = ( _memory_fd* )alloc( allocator, size_of( _memory_fd ) );
+	if ( ! d )
+		return false;
+	zero_item( file );
+	d->magic     = GEN__FILE_STREAM_FD_MAGIC;
+	d->allocator = allocator;
+	d->flags     = flags;
+	if ( d->flags & EFileStream_CLONE_WRITABLE )
+	{
+		Array<u8> arr = array_init_reserve<u8>( allocator, size );
+		d->buf = arr;
+
+		if ( ! d->buf )
+			return false;
+
+		mem_copy( d->buf, buffer, size );
+		d->cap = size;
+
+		get_header(arr)->Num = size;
+	}
+	else
+	{
+		d->buf = buffer;
+		d->cap = size;
+	}
+	file->ops             = memory_file_operations;
+	file->fd              = _file_stream_fd_make( d );
+	file->dir             = NULL;
+	file->last_write_time = 0;
+	file->filename        = NULL;
+	file->is_temp         = true;
+	return true;
+}
+
+u8* file_stream_buf( FileInfo* file, ssize* size )
+{
+	GEN_ASSERT_NOT_NULL( file );
+	_memory_fd* d = _file_stream_from_fd( file->fd );
+	if ( size )
+		*size = d->cap;
+	return d->buf;
+}
+
+internal
+GEN_FILE_SEEK_PROC( _memory_file_seek )
+{
+	_memory_fd* d      = _file_stream_from_fd( fd );
+	ssize          buflen = d->cap;
+
+	if ( whence == ESeekWhence_BEGIN )
+		d->cursor = 0;
+	else if ( whence == ESeekWhence_END )
+		d->cursor = buflen;
+
+	d->cursor = max( 0, clamp( d->cursor + offset, 0, buflen ) );
+	if ( new_offset )
+		*new_offset = d->cursor;
+	return true;
+}
+
+internal
+GEN_FILE_READ_AT_PROC( _memory_file_read )
+{
+	// unused( stop_at_newline );
+	_memory_fd* d = _file_stream_from_fd( fd );
+	mem_copy( buffer, d->buf + offset, size );
+	if ( bytes_read )
+		*bytes_read = size;
+	return true;
+}
+
+internal
+GEN_FILE_WRITE_AT_PROC( _memory_file_write )
+{
+	_memory_fd* d = _file_stream_from_fd( fd );
+
+	if ( ! ( d->flags & ( EFileStream_CLONE_WRITABLE | EFileStream_WRITABLE ) ) )
+		return false;
+
+	ssize buflen   = d->cap;
+	ssize extralen = max( 0, size - ( buflen - offset ) );
+	ssize rwlen    = size - extralen;
+	ssize new_cap  = buflen + extralen;
+
+	if ( d->flags & EFileStream_CLONE_WRITABLE )
+	{
+		Array<u8> arr = { d->buf };
+
+		if ( get_header(arr)->Capacity < usize(new_cap) )
+		{
+			if ( ! grow( & arr, ( s64 )( new_cap ) ) )
+				return false;
+			d->buf = arr;
+		}
+	}
+
+	mem_copy( d->buf + offset, buffer, rwlen );
+
+	if ( ( d->flags & EFileStream_CLONE_WRITABLE ) && extralen > 0 )
+	{
+		Array<u8> arr = { d->buf };
+
+		mem_copy( d->buf + offset + rwlen, pointer_add_const( buffer, rwlen ), extralen );
+		d->cap = new_cap;
+		get_header(arr)->Capacity = new_cap;
+	}
+	else
+	{
+		extralen = 0;
+	}
+
+	if ( bytes_written )
+		*bytes_written = ( rwlen + extralen );
+	return true;
+}
+
+internal
+GEN_FILE_CLOSE_PROC( _memory_file_close )
+{
+	_memory_fd*   d         = _file_stream_from_fd( fd );
+	AllocatorInfo allocator = d->allocator;
+
+	if ( d->flags & EFileStream_CLONE_WRITABLE )
+	{
+		Array<u8> arr = { d->buf };
+		free(& arr);
+	}
+
+	free( allocator, d );
+}
+
+FileOperations const memory_file_operations = { _memory_file_read, _memory_file_write, _memory_file_seek, _memory_file_close };
+
+#pragma endregion File Handling

project/dependencies/filesystem.hpp

@@ -0,0 +1,384 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "strings.hpp"
+#endif
+
+#pragma region File Handling
+
+typedef u32 FileMode;
+
+enum FileModeFlag
+{
+	EFileMode_READ   = bit( 0 ),
+	EFileMode_WRITE  = bit( 1 ),
+	EFileMode_APPEND = bit( 2 ),
+	EFileMode_RW     = bit( 3 ),
+	GEN_FILE_MODES   = EFileMode_READ | EFileMode_WRITE | EFileMode_APPEND | EFileMode_RW,
+};
+
+// NOTE: Only used internally and for the file operations
+enum SeekWhenceType
+{
+	ESeekWhence_BEGIN   = 0,
+	ESeekWhence_CURRENT = 1,
+	ESeekWhence_END     = 2,
+};
+
+enum FileError
+{
+	EFileError_NONE,
+	EFileError_INVALID,
+	EFileError_INVALID_FILENAME,
+	EFileError_EXISTS,
+	EFileError_NOT_EXISTS,
+	EFileError_PERMISSION,
+	EFileError_TRUNCATION_FAILURE,
+	EFileError_NOT_EMPTY,
+	EFileError_NAME_TOO_LONG,
+	EFileError_UNKNOWN,
+};
+
+union FileDescriptor
+{
+	void* p;
+	sptr  i;
+	uptr  u;
+};
+
+typedef struct FileOperations FileOperations;
+
+#define GEN_FILE_OPEN_PROC( name )     FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
+#define GEN_FILE_READ_AT_PROC( name )  b32 name( FileDescriptor fd, void* buffer, ssize size, s64 offset, ssize* bytes_read, b32 stop_at_newline )
+#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
+#define GEN_FILE_SEEK_PROC( name )     b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset )
+#define GEN_FILE_CLOSE_PROC( name )    void name( FileDescriptor fd )
+
+typedef GEN_FILE_OPEN_PROC( file_open_proc );
+typedef GEN_FILE_READ_AT_PROC( FileReadProc );
+typedef GEN_FILE_WRITE_AT_PROC( FileWriteProc );
+typedef GEN_FILE_SEEK_PROC( FileSeekProc );
+typedef GEN_FILE_CLOSE_PROC( FileCloseProc );
+
+struct FileOperations
+{
+	FileReadProc*  read_at;
+	FileWriteProc* write_at;
+	FileSeekProc*  seek;
+	FileCloseProc* close;
+};
+
+extern FileOperations const default_file_operations;
+
+typedef u64 FileTime;
+
+enum DirType
+{
+	GEN_DIR_TYPE_FILE,
+	GEN_DIR_TYPE_FOLDER,
+	GEN_DIR_TYPE_UNKNOWN,
+};
+
+struct DirInfo;
+
+struct DirEntry
+{
+	char const*     filename;
+	struct DirInfo* dir_info;
+	u8              type;
+};
+
+struct DirInfo
+{
+	char const* fullpath;
+	DirEntry*   entries;    // zpl_array
+
+	// Internals
+	char** filenames;    // zpl_array
+	String buf;
+};
+
+struct FileInfo
+{
+	FileOperations ops;
+	FileDescriptor fd;
+	b32            is_temp;
+
+	char const* filename;
+	FileTime    last_write_time;
+	DirEntry*   dir;
+};
+
+enum FileStandardType
+{
+	EFileStandard_INPUT,
+	EFileStandard_OUTPUT,
+	EFileStandard_ERROR,
+
+	EFileStandard_COUNT,
+};
+
+/**
+	* Get standard file I/O.
+	* @param  std Check zpl_file_standard_type
+	* @return     File handle to standard I/O
+	*/
+FileInfo* file_get_standard( FileStandardType std );
+
+/**
+	* Closes the file
+	* @param  file
+	*/
+FileError file_close( FileInfo* file );
+
+/**
+	* Returns the currently opened file's name
+	* @param  file
+	*/
+inline
+	char const* file_name( FileInfo* file )
+{
+	return file->filename ? file->filename : "";
+}
+
+/**
+	* Opens a file
+	* @param  file
+	* @param  filename
+	*/
+FileError file_open( FileInfo* file, char const* filename );
+
+/**
+	* Opens a file using a specified mode
+	* @param  file
+	* @param  mode     Access mode to use
+	* @param  filename
+	*/
+FileError file_open_mode( FileInfo* file, FileMode mode, char const* filename );
+
+/**
+	* Reads from a file
+	* @param  file
+	* @param  buffer Buffer to read to
+	* @param  size   Size to read
+	*/
+b32 file_read( FileInfo* file, void* buffer, ssize size );
+
+/**
+	* Reads file at a specific offset
+	* @param  file
+	* @param  buffer     Buffer to read to
+	* @param  size       Size to read
+	* @param  offset     Offset to read from
+	* @param  bytes_read How much data we've actually read
+	*/
+b32 file_read_at( FileInfo* file, void* buffer, ssize size, s64 offset );
+
+/**
+	* Reads file safely
+	* @param  file
+	* @param  buffer     Buffer to read to
+	* @param  size       Size to read
+	* @param  offset     Offset to read from
+	* @param  bytes_read How much data we've actually read
+	*/
+b32 file_read_at_check( FileInfo* file, void* buffer, ssize size, s64 offset, ssize* bytes_read );
+
+struct FileContents
+{
+	AllocatorInfo allocator;
+	void*         data;
+	ssize            size;
+};
+
+constexpr b32 zero_terminate    = true;
+constexpr b32 no_zero_terminate = false;
+
+/**
+	* Reads the whole file contents
+	* @param  a              Allocator to use
+	* @param  zero_terminate End the read data with null terminator
+	* @param  filepath       Path to the file
+	* @return                File contents data
+	*/
+FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const* filepath );
+
+/**
+	* Returns a size of the file
+	* @param  file
+	* @return      File size
+	*/
+s64 file_size( FileInfo* file );
+
+/**
+	* Seeks the file cursor from the beginning of file to a specific position
+	* @param  file
+	* @param  offset Offset to seek to
+	*/
+s64 file_seek( FileInfo* file, s64 offset );
+
+/**
+	* Seeks the file cursor to the end of the file
+	* @param  file
+	*/
+s64 file_seek_to_end( FileInfo* file );
+
+/**
+	* Returns the length from the beginning of the file we've read so far
+	* @param  file
+	* @return      Our current position in file
+	*/
+s64 file_tell( FileInfo* file );
+
+/**
+	* Writes to a file
+	* @param  file
+	* @param  buffer Buffer to read from
+	* @param  size   Size to read
+	*/
+b32 file_write( FileInfo* file, void const* buffer, ssize size );
+
+/**
+	* Writes to file at a specific offset
+	* @param  file
+	* @param  buffer        Buffer to read from
+	* @param  size          Size to write
+	* @param  offset        Offset to write to
+	* @param  bytes_written How much data we've actually written
+	*/
+b32 file_write_at( FileInfo* file, void const* buffer, ssize size, s64 offset );
+
+/**
+	* Writes to file safely
+	* @param  file
+	* @param  buffer        Buffer to read from
+	* @param  size          Size to write
+	* @param  offset        Offset to write to
+	* @param  bytes_written How much data we've actually written
+	*/
+b32 file_write_at_check( FileInfo* file, void const* buffer, ssize size, s64 offset, ssize* bytes_written );
+
+enum FileStreamFlags : u32
+{
+	/* Allows us to write to the buffer directly. Beware: you can not append a new data! */
+	EFileStream_WRITABLE = bit( 0 ),
+
+	/* Clones the input buffer so you can write (zpl_file_write*) data into it. */
+	/* Since we work with a clone, the buffer size can dynamically grow as well. */
+	EFileStream_CLONE_WRITABLE = bit( 1 ),
+};
+
+/**
+	* Opens a new memory stream
+	* @param file
+	* @param allocator
+	*/
+b8 file_stream_new( FileInfo* file, AllocatorInfo allocator );
+
+/**
+	* Opens a memory stream over an existing buffer
+	* @param  file
+	* @param  allocator
+	* @param  buffer   Memory to create stream from
+	* @param  size     Buffer's size
+	* @param  flags
+	*/
+b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize size, FileStreamFlags flags );
+
+/**
+	* Retrieves the stream's underlying buffer and buffer size.
+	* @param file memory stream
+	* @param size (Optional) buffer size
+	*/
+u8* file_stream_buf( FileInfo* file, ssize* size );
+
+extern FileOperations const memory_file_operations;
+
+inline
+s64 file_seek( FileInfo* f, s64 offset )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, offset, ESeekWhence_BEGIN, &new_offset );
+
+	return new_offset;
+}
+
+inline
+s64 file_seek_to_end( FileInfo* f )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, 0, ESeekWhence_END, &new_offset );
+
+	return new_offset;
+}
+
+inline
+s64 file_tell( FileInfo* f )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, 0, ESeekWhence_CURRENT, &new_offset );
+
+	return new_offset;
+}
+
+inline
+b32 file_read( FileInfo* f, void* buffer, ssize size )
+{
+	s64 cur_offset = file_tell( f );
+	b32 result     = file_read_at( f, buffer, size, file_tell( f ) );
+	file_seek( f, cur_offset + size );
+	return result;
+}
+
+inline
+b32 file_read_at( FileInfo* f, void* buffer, ssize size, s64 offset )
+{
+	return file_read_at_check( f, buffer, size, offset, NULL );
+}
+
+inline
+b32 file_read_at_check( FileInfo* f, void* buffer, ssize size, s64 offset, ssize* bytes_read )
+{
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+	return f->ops.read_at( f->fd, buffer, size, offset, bytes_read, false );
+}
+
+inline
+b32 file_write( FileInfo* f, void const* buffer, ssize size )
+{
+	s64 cur_offset = file_tell( f );
+	b32 result     = file_write_at( f, buffer, size, file_tell( f ) );
+
+	file_seek( f, cur_offset + size );
+
+	return result;
+}
+
+inline
+b32 file_write_at( FileInfo* f, void const* buffer, ssize size, s64 offset )
+{
+	return file_write_at_check( f, buffer, size, offset, NULL );
+}
+
+inline
+b32 file_write_at_check( FileInfo* f, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
+{
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	return f->ops.write_at( f->fd, buffer, size, offset, bytes_written );
+}
+
+#pragma endregion File Handling

project/dependencies/hashing.cpp

@@ -0,0 +1,90 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "memory.cpp"
+#endif
+
+#pragma region Hashing
+
+global u32 const _crc32_table[ 256 ] = {
+	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd,
+	0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+	0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+	0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+	0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce,
+	0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+	0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+	0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0,
+	0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703,
+	0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+	0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+	0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5,
+	0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
+};
+
+u32 crc32( void const* data, ssize len )
+{
+	ssize        remaining;
+	u32       result = ~( scast( u32, 0) );
+	u8 const* c      = rcast( u8 const*, data);
+	for ( remaining = len; remaining--; c++ )
+		result = ( result >> 8 ) ^ ( _crc32_table[ ( result ^ *c ) & 0xff ] );
+	return ~result;
+}
+
+global u64 const _crc64_table[ 256 ] = {
+	0x0000000000000000ull, 0x7ad870c830358979ull, 0xf5b0e190606b12f2ull, 0x8f689158505e9b8bull, 0xc038e5739841b68full, 0xbae095bba8743ff6ull, 0x358804e3f82aa47dull,
+	0x4f50742bc81f2d04ull, 0xab28ecb46814fe75ull, 0xd1f09c7c5821770cull, 0x5e980d24087fec87ull, 0x24407dec384a65feull, 0x6b1009c7f05548faull, 0x11c8790fc060c183ull,
+	0x9ea0e857903e5a08ull, 0xe478989fa00bd371ull, 0x7d08ff3b88be6f81ull, 0x07d08ff3b88be6f8ull, 0x88b81eabe8d57d73ull, 0xf2606e63d8e0f40aull, 0xbd301a4810ffd90eull,
+	0xc7e86a8020ca5077ull, 0x4880fbd87094cbfcull, 0x32588b1040a14285ull, 0xd620138fe0aa91f4ull, 0xacf86347d09f188dull, 0x2390f21f80c18306ull, 0x594882d7b0f40a7full,
+	0x1618f6fc78eb277bull, 0x6cc0863448deae02ull, 0xe3a8176c18803589ull, 0x997067a428b5bcf0ull, 0xfa11fe77117cdf02ull, 0x80c98ebf2149567bull, 0x0fa11fe77117cdf0ull,
+	0x75796f2f41224489ull, 0x3a291b04893d698dull, 0x40f16bccb908e0f4ull, 0xcf99fa94e9567b7full, 0xb5418a5cd963f206ull, 0x513912c379682177ull, 0x2be1620b495da80eull,
+	0xa489f35319033385ull, 0xde51839b2936bafcull, 0x9101f7b0e12997f8ull, 0xebd98778d11c1e81ull, 0x64b116208142850aull, 0x1e6966e8b1770c73ull, 0x8719014c99c2b083ull,
+	0xfdc17184a9f739faull, 0x72a9e0dcf9a9a271ull, 0x08719014c99c2b08ull, 0x4721e43f0183060cull, 0x3df994f731b68f75ull, 0xb29105af61e814feull, 0xc849756751dd9d87ull,
+	0x2c31edf8f1d64ef6ull, 0x56e99d30c1e3c78full, 0xd9810c6891bd5c04ull, 0xa3597ca0a188d57dull, 0xec09088b6997f879ull, 0x96d1784359a27100ull, 0x19b9e91b09fcea8bull,
+	0x636199d339c963f2ull, 0xdf7adabd7a6e2d6full, 0xa5a2aa754a5ba416ull, 0x2aca3b2d1a053f9dull, 0x50124be52a30b6e4ull, 0x1f423fcee22f9be0ull, 0x659a4f06d21a1299ull,
+	0xeaf2de5e82448912ull, 0x902aae96b271006bull, 0x74523609127ad31aull, 0x0e8a46c1224f5a63ull, 0x81e2d7997211c1e8ull, 0xfb3aa75142244891ull, 0xb46ad37a8a3b6595ull,
+	0xceb2a3b2ba0eececull, 0x41da32eaea507767ull, 0x3b024222da65fe1eull, 0xa2722586f2d042eeull, 0xd8aa554ec2e5cb97ull, 0x57c2c41692bb501cull, 0x2d1ab4dea28ed965ull,
+	0x624ac0f56a91f461ull, 0x1892b03d5aa47d18ull, 0x97fa21650afae693ull, 0xed2251ad3acf6feaull, 0x095ac9329ac4bc9bull, 0x7382b9faaaf135e2ull, 0xfcea28a2faafae69ull,
+	0x8632586aca9a2710ull, 0xc9622c4102850a14ull, 0xb3ba5c8932b0836dull, 0x3cd2cdd162ee18e6ull, 0x460abd1952db919full, 0x256b24ca6b12f26dull, 0x5fb354025b277b14ull,
+	0xd0dbc55a0b79e09full, 0xaa03b5923b4c69e6ull, 0xe553c1b9f35344e2ull, 0x9f8bb171c366cd9bull, 0x10e3202993385610ull, 0x6a3b50e1a30ddf69ull, 0x8e43c87e03060c18ull,
+	0xf49bb8b633338561ull, 0x7bf329ee636d1eeaull, 0x012b592653589793ull, 0x4e7b2d0d9b47ba97ull, 0x34a35dc5ab7233eeull, 0xbbcbcc9dfb2ca865ull, 0xc113bc55cb19211cull,
+	0x5863dbf1e3ac9decull, 0x22bbab39d3991495ull, 0xadd33a6183c78f1eull, 0xd70b4aa9b3f20667ull, 0x985b3e827bed2b63ull, 0xe2834e4a4bd8a21aull, 0x6debdf121b863991ull,
+	0x1733afda2bb3b0e8ull, 0xf34b37458bb86399ull, 0x8993478dbb8deae0ull, 0x06fbd6d5ebd3716bull, 0x7c23a61ddbe6f812ull, 0x3373d23613f9d516ull, 0x49aba2fe23cc5c6full,
+	0xc6c333a67392c7e4ull, 0xbc1b436e43a74e9dull, 0x95ac9329ac4bc9b5ull, 0xef74e3e19c7e40ccull, 0x601c72b9cc20db47ull, 0x1ac40271fc15523eull, 0x5594765a340a7f3aull,
+	0x2f4c0692043ff643ull, 0xa02497ca54616dc8ull, 0xdafce7026454e4b1ull, 0x3e847f9dc45f37c0ull, 0x445c0f55f46abeb9ull, 0xcb349e0da4342532ull, 0xb1eceec59401ac4bull,
+	0xfebc9aee5c1e814full, 0x8464ea266c2b0836ull, 0x0b0c7b7e3c7593bdull, 0x71d40bb60c401ac4ull, 0xe8a46c1224f5a634ull, 0x927c1cda14c02f4dull, 0x1d148d82449eb4c6ull,
+	0x67ccfd4a74ab3dbfull, 0x289c8961bcb410bbull, 0x5244f9a98c8199c2ull, 0xdd2c68f1dcdf0249ull, 0xa7f41839ecea8b30ull, 0x438c80a64ce15841ull, 0x3954f06e7cd4d138ull,
+	0xb63c61362c8a4ab3ull, 0xcce411fe1cbfc3caull, 0x83b465d5d4a0eeceull, 0xf96c151de49567b7ull, 0x76048445b4cbfc3cull, 0x0cdcf48d84fe7545ull, 0x6fbd6d5ebd3716b7ull,
+	0x15651d968d029fceull, 0x9a0d8ccedd5c0445ull, 0xe0d5fc06ed698d3cull, 0xaf85882d2576a038ull, 0xd55df8e515432941ull, 0x5a3569bd451db2caull, 0x20ed197575283bb3ull,
+	0xc49581ead523e8c2ull, 0xbe4df122e51661bbull, 0x3125607ab548fa30ull, 0x4bfd10b2857d7349ull, 0x04ad64994d625e4dull, 0x7e7514517d57d734ull, 0xf11d85092d094cbfull,
+	0x8bc5f5c11d3cc5c6ull, 0x12b5926535897936ull, 0x686de2ad05bcf04full, 0xe70573f555e26bc4ull, 0x9ddd033d65d7e2bdull, 0xd28d7716adc8cfb9ull, 0xa85507de9dfd46c0ull,
+	0x273d9686cda3dd4bull, 0x5de5e64efd965432ull, 0xb99d7ed15d9d8743ull, 0xc3450e196da80e3aull, 0x4c2d9f413df695b1ull, 0x36f5ef890dc31cc8ull, 0x79a59ba2c5dc31ccull,
+	0x037deb6af5e9b8b5ull, 0x8c157a32a5b7233eull, 0xf6cd0afa9582aa47ull, 0x4ad64994d625e4daull, 0x300e395ce6106da3ull, 0xbf66a804b64ef628ull, 0xc5bed8cc867b7f51ull,
+	0x8aeeace74e645255ull, 0xf036dc2f7e51db2cull, 0x7f5e4d772e0f40a7ull, 0x05863dbf1e3ac9deull, 0xe1fea520be311aafull, 0x9b26d5e88e0493d6ull, 0x144e44b0de5a085dull,
+	0x6e963478ee6f8124ull, 0x21c640532670ac20ull, 0x5b1e309b16452559ull, 0xd476a1c3461bbed2ull, 0xaeaed10b762e37abull, 0x37deb6af5e9b8b5bull, 0x4d06c6676eae0222ull,
+	0xc26e573f3ef099a9ull, 0xb8b627f70ec510d0ull, 0xf7e653dcc6da3dd4ull, 0x8d3e2314f6efb4adull, 0x0256b24ca6b12f26ull, 0x788ec2849684a65full, 0x9cf65a1b368f752eull,
+	0xe62e2ad306bafc57ull, 0x6946bb8b56e467dcull, 0x139ecb4366d1eea5ull, 0x5ccebf68aecec3a1ull, 0x2616cfa09efb4ad8ull, 0xa97e5ef8cea5d153ull, 0xd3a62e30fe90582aull,
+	0xb0c7b7e3c7593bd8ull, 0xca1fc72bf76cb2a1ull, 0x45775673a732292aull, 0x3faf26bb9707a053ull, 0x70ff52905f188d57ull, 0x0a2722586f2d042eull, 0x854fb3003f739fa5ull,
+	0xff97c3c80f4616dcull, 0x1bef5b57af4dc5adull, 0x61372b9f9f784cd4ull, 0xee5fbac7cf26d75full, 0x9487ca0fff135e26ull, 0xdbd7be24370c7322ull, 0xa10fceec0739fa5bull,
+	0x2e675fb4576761d0ull, 0x54bf2f7c6752e8a9ull, 0xcdcf48d84fe75459ull, 0xb71738107fd2dd20ull, 0x387fa9482f8c46abull, 0x42a7d9801fb9cfd2ull, 0x0df7adabd7a6e2d6ull,
+	0x772fdd63e7936bafull, 0xf8474c3bb7cdf024ull, 0x829f3cf387f8795dull, 0x66e7a46c27f3aa2cull, 0x1c3fd4a417c62355ull, 0x935745fc4798b8deull, 0xe98f353477ad31a7ull,
+	0xa6df411fbfb21ca3ull, 0xdc0731d78f8795daull, 0x536fa08fdfd90e51ull, 0x29b7d047efec8728ull,
+};
+
+u64 crc64( void const* data, ssize len )
+{
+	ssize        remaining;
+	u64       result = ( scast( u64, 0) );
+	u8 const* c      = rcast( u8 const*, data);
+	for ( remaining = len; remaining--; c++ )
+		result = ( result >> 8 ) ^ ( _crc64_table[ ( result ^ *c ) & 0xff ] );
+	return result;
+}
+
+#pragma endregion Hashing

project/dependencies/hashing.hpp

@@ -0,0 +1,11 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "containers.hpp"
+#endif
+
+#pragma region Hashing
+
+u32 crc32( void const* data, ssize len );
+u64 crc64( void const* data, ssize len );
+
+#pragma endregion Hashing

project/dependencies/macros.hpp

@@ -0,0 +1,237 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#   pragma once
+#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 api_c
+#define api_c extern "C"
+#endif
+
+#ifndef bit
+#define bit( Value )                             ( 1 << Value )
+#define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
+#endif
+
+
+#if ! GEN_C_COMPILER
+#	ifndef cast
+#	define cast( type, value ) (tmpl_cast<type>( value ))
+#	endif
+#	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 cast
+#	define cast( type, value )  ( (type)(value) )
+#	endif
+#	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
+#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 !defined(GEN_SUPPORT_CPP_REFERENCES) && (GEN_COMPILER_C || __STDC_VERSION__ < 202311L)
+#	undef    GEN_SUPPORT_CPP_REFERENCES
+#	define   GEN_SUPPORT_CPP_REFERENCES 0
+#endif
+
+#if !defined(GEN_SUPPORT_CPP_MEMBER_FEATURES) && (GEN_COMPILER_C || __STDC_VERSION__ < 202311L)
+#	undef    GEN_SUPPORT_CPP_MEMBER_FEATURES
+#	define   GEN_SUPPORT_CPP_MEMBER_FEATURES 0
+#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
+
+// This is intended to only really be used internally or with the C-library variant
+// C++ users can just use the for-range directly.
+#if GEN_COMPILER_C
+#	define foreach(Type, entry_id, iterable) for ( Type entry_id = begin(iterable); entry_id != end(iterable); entry_id = next(iterable, entry_id) )
+#else
+#	define foreach(Type, entry_id, iterable) for ( Type entry_id : iterable )
+#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
+#endif
+
+#pragma endregion Macros

project/dependencies/memory.cpp

@@ -0,0 +1,520 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "printing.cpp"
+#endif
+
+#pragma region Memory
+
+void* mem_copy( void* dest, void const* source, ssize n )
+{
+	if ( dest == NULL )
+	{
+		return NULL;
+	}
+
+	return memcpy( dest, source, n );
+}
+
+void const* mem_find( void const* data, u8 c, ssize n )
+{
+	u8 const* s = rcast( u8 const*, data);
+	while ( ( rcast( uptr, s) & ( sizeof( usize ) - 1 ) ) && n && *s != c )
+	{
+		s++;
+		n--;
+	}
+	if ( n && *s != c )
+	{
+		ssize const* w;
+		ssize        k = GEN__ONES * c;
+		w           = rcast( ssize const*, s);
+		while ( n >= size_of( ssize ) && ! GEN__HAS_ZERO( *w ^ k ) )
+		{
+			w++;
+			n -= size_of( ssize );
+		}
+		s = rcast( u8 const*, w);
+		while ( n && *s != c )
+		{
+			s++;
+			n--;
+		}
+	}
+
+	return n ? rcast( void const*, s ) : NULL;
+}
+
+#define GEN_HEAP_STATS_MAGIC 0xDEADC0DE
+
+struct _heap_stats
+{
+	u32 magic;
+	ssize  used_memory;
+	ssize  alloc_count;
+};
+
+global _heap_stats _heap_stats_info;
+
+void heap_stats_init( void )
+{
+	zero_item( &_heap_stats_info );
+	_heap_stats_info.magic = GEN_HEAP_STATS_MAGIC;
+}
+
+ssize heap_stats_used_memory( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	return _heap_stats_info.used_memory;
+}
+
+ssize heap_stats_alloc_count( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	return _heap_stats_info.alloc_count;
+}
+
+void heap_stats_check( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	GEN_ASSERT( _heap_stats_info.used_memory == 0 );
+	GEN_ASSERT( _heap_stats_info.alloc_count == 0 );
+}
+
+struct _heap_alloc_info
+{
+	ssize    size;
+	void* physical_start;
+};
+
+void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
+{
+	void* ptr = NULL;
+	// unused( allocator_data );
+	// unused( old_size );
+	if ( ! alignment )
+		alignment = GEN_DEFAULT_MEMORY_ALIGNMENT;
+
+#ifdef GEN_HEAP_ANALYSIS
+	ssize alloc_info_size      = size_of( _heap_alloc_info );
+	ssize alloc_info_remainder = ( alloc_info_size % alignment );
+	ssize track_size           = max( alloc_info_size, alignment ) + alloc_info_remainder;
+	switch ( type )
+	{
+		case EAllocation_FREE :
+			{
+				if ( ! old_memory )
+					break;
+				_heap_alloc_info* alloc_info  = rcast( _heap_alloc_info*, old_memory) - 1;
+				_heap_stats_info.used_memory -= alloc_info->size;
+				_heap_stats_info.alloc_count--;
+				old_memory = alloc_info->physical_start;
+			}
+			break;
+		case EAllocation_ALLOC :
+			{
+				size += track_size;
+			}
+			break;
+		default :
+			break;
+	}
+#endif
+
+	switch ( type )
+	{
+#if defined( GEN_COMPILER_MSVC ) || ( defined( GEN_COMPILER_GCC ) && defined( GEN_SYSTEM_WINDOWS ) ) || ( defined( GEN_COMPILER_TINYC ) && defined( GEN_SYSTEM_WINDOWS ) )
+		case EAllocation_ALLOC :
+			ptr = _aligned_malloc( size, alignment );
+			if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				zero_size( ptr, size );
+			break;
+		case EAllocation_FREE :
+			_aligned_free( old_memory );
+			break;
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+
+#elif defined( GEN_SYSTEM_LINUX ) && ! defined( GEN_CPU_ARM ) && ! defined( GEN_COMPILER_TINYC )
+		case EAllocation_ALLOC :
+			{
+				ptr = aligned_alloc( alignment, ( size + alignment - 1 ) & ~( alignment - 1 ) );
+
+				if ( flags & GEN_ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				{
+					zero_size( ptr, size );
+				}
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				free( old_memory );
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+#else
+		case EAllocation_ALLOC :
+			{
+				posix_memalign( &ptr, alignment, size );
+
+				if ( flags & GEN_ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				{
+					zero_size( ptr, size );
+				}
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				free( old_memory );
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+#endif
+
+		case EAllocation_FREE_ALL :
+			break;
+	}
+
+#ifdef GEN_HEAP_ANALYSIS
+	if ( type == EAllocation_ALLOC )
+	{
+		_heap_alloc_info* alloc_info = rcast( _heap_alloc_info*, rcast( char*, ptr) + alloc_info_remainder );
+		zero_item( alloc_info );
+		alloc_info->size              = size - track_size;
+		alloc_info->physical_start    = ptr;
+		ptr                           = rcast( void*, alloc_info + 1 );
+		_heap_stats_info.used_memory += alloc_info->size;
+		_heap_stats_info.alloc_count++;
+	}
+#endif
+
+	return ptr;
+}
+
+#pragma region VirtualMemory
+VirtualMemory vm_from_memory( void* data, ssize size )
+{
+	VirtualMemory vm;
+	vm.data = data;
+	vm.size = size;
+	return vm;
+}
+
+#if defined( GEN_SYSTEM_WINDOWS )
+VirtualMemory vm_alloc( void* addr, ssize size )
+{
+	VirtualMemory vm;
+	GEN_ASSERT( size > 0 );
+	vm.data = VirtualAlloc( addr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE );
+	vm.size = size;
+	return vm;
+}
+
+b32 vm_free( VirtualMemory vm )
+{
+	MEMORY_BASIC_INFORMATION info;
+	while ( vm.size > 0 )
+	{
+		if ( VirtualQuery( vm.data, &info, size_of( info ) ) == 0 )
+			return false;
+		if ( info.BaseAddress != vm.data || info.AllocationBase != vm.data || info.State != MEM_COMMIT || info.RegionSize > scast( usize, vm.size) )
+		{
+			return false;
+		}
+		if ( VirtualFree( vm.data, 0, MEM_RELEASE ) == 0 )
+			return false;
+		vm.data  = pointer_add( vm.data, info.RegionSize );
+		vm.size -= info.RegionSize;
+	}
+	return true;
+}
+
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
+{
+	VirtualMemory new_vm = { 0 };
+	void*             ptr;
+	GEN_ASSERT( vm.size >= lead_size + size );
+
+	ptr = pointer_add( vm.data, lead_size );
+
+	vm_free( vm );
+	new_vm = vm_alloc( ptr, size );
+	if ( new_vm.data == ptr )
+		return new_vm;
+	if ( new_vm.data )
+		vm_free( new_vm );
+	return new_vm;
+}
+
+b32 vm_purge( VirtualMemory vm )
+{
+	VirtualAlloc( vm.data, vm.size, MEM_RESET, PAGE_READWRITE );
+	// NOTE: Can this really fail?
+	return true;
+}
+
+ssize virtual_memory_page_size( ssize* alignment_out )
+{
+	SYSTEM_INFO info;
+	GetSystemInfo( &info );
+	if ( alignment_out )
+		*alignment_out = info.dwAllocationGranularity;
+	return info.dwPageSize;
+}
+
+#else
+#	include <sys/mman.h>
+
+#	ifndef MAP_ANONYMOUS
+#		define MAP_ANONYMOUS MAP_ANON
+#	endif
+VirtualMemory vm_alloc( void* addr, ssize size )
+{
+	VirtualMemory vm;
+	GEN_ASSERT( size > 0 );
+	vm.data = mmap( addr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
+	vm.size = size;
+	return vm;
+}
+
+b32 vm_free( VirtualMemory vm )
+{
+	munmap( vm.data, vm.size );
+	return true;
+}
+
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
+{
+	void*  ptr;
+	ssize trail_size;
+	GEN_ASSERT( vm.size >= lead_size + size );
+
+	ptr        = pointer_add( vm.data, lead_size );
+	trail_size = vm.size - lead_size - size;
+
+	if ( lead_size != 0 )
+		vm_free( vm_from_memory(( vm.data, lead_size ) );
+	if ( trail_size != 0 )
+		vm_free( vm_from_memory( ptr, trail_size ) );
+	return vm_from_memory( ptr, size );
+}
+
+b32 vm_purge( VirtualMemory vm )
+{
+	int err = madvise( vm.data, vm.size, MADV_DONTNEED );
+	return err != 0;
+}
+
+ssize virtual_memory_page_size( ssize* alignment_out )
+{
+	// TODO: Is this always true?
+	ssize result = scast( ssize, sysconf( _SC_PAGE_SIZE ));
+	if ( alignment_out )
+		*alignment_out = result;
+	return result;
+}
+#endif
+
+#pragma endregion VirtualMemory
+
+void* arena_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
+{
+	Arena* arena = rcast(Arena*, allocator_data);
+	void*      ptr   = NULL;
+
+	// unused( old_size );
+
+	switch ( type )
+	{
+		case EAllocation_ALLOC :
+			{
+				void* end        = pointer_add( arena->PhysicalStart, arena->TotalUsed );
+				ssize    total_size = align_forward_i64( size, alignment );
+
+				// NOTE: Out of memory
+				if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize )
+				{
+					// zpl__printf_err("%s", "Arena out of memory\n");
+					GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
+					return nullptr;
+				}
+
+				ptr              = align_forward( end, alignment );
+				arena->TotalUsed += total_size;
+
+				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+					zero_size( ptr, size );
+			}
+			break;
+
+		case EAllocation_FREE :
+			// NOTE: Free all at once
+			// Use Temp_Arena_Memory if you want to free a block
+			break;
+
+		case EAllocation_FREE_ALL :
+			arena->TotalUsed = 0;
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				// TODO : Check if ptr is on top of stack and just extend
+				AllocatorInfo a = arena->Backing;
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+	}
+	return ptr;
+}
+
+void* pool_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
+{
+	Pool* pool = rcast( Pool*, allocator_data);
+	void* ptr  = NULL;
+
+	// unused( old_size );
+
+	switch ( type )
+	{
+		case EAllocation_ALLOC :
+			{
+				uptr next_free;
+
+				GEN_ASSERT( size == pool->BlockSize );
+				GEN_ASSERT( alignment == pool->BlockAlign );
+				GEN_ASSERT( pool->FreeList != NULL );
+
+				next_free        = * rcast( uptr*, pool->FreeList);
+				ptr              = pool->FreeList;
+				pool->FreeList   = rcast( void*, next_free);
+				pool->TotalSize += pool->BlockSize;
+
+				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+					zero_size( ptr, size );
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				uptr* next;
+				if ( old_memory == NULL )
+					return NULL;
+
+				next             = rcast( uptr*, old_memory);
+				*next            = rcast( uptr, pool->FreeList);
+				pool->FreeList   = old_memory;
+				pool->TotalSize -= pool->BlockSize;
+			}
+			break;
+
+		case EAllocation_FREE_ALL :
+			{
+				ssize    actual_block_size, block_index;
+				void* curr;
+				uptr* end;
+
+				actual_block_size = pool->BlockSize + pool->BlockAlign;
+				pool->TotalSize   = 0;
+
+				// NOTE: Init intrusive freelist
+				curr = pool->PhysicalStart;
+				for ( block_index = 0; block_index < pool->NumBlocks - 1; block_index++ )
+				{
+					uptr* next = rcast( uptr*, curr);
+					* next     = rcast( uptr, curr) + actual_block_size;
+					curr       = pointer_add( curr, actual_block_size );
+				}
+
+				end            = rcast( uptr*, curr);
+				* end          = scast( uptr, NULL);
+				pool->FreeList = pool->PhysicalStart;
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			// NOTE: Cannot resize
+			GEN_PANIC( "You cannot resize something allocated by with a pool." );
+			break;
+	}
+
+	return ptr;
+}
+
+Pool pool_init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align )
+{
+	Pool pool = {};
+
+	ssize    actual_block_size, pool_size, block_index;
+	void *data, *curr;
+	uptr* end;
+
+	zero_item( &pool );
+
+	pool.Backing     = backing;
+	pool.BlockSize   = block_size;
+	pool.BlockAlign  = block_align;
+	pool.NumBlocks   = num_blocks;
+
+	actual_block_size = block_size + block_align;
+	pool_size         = num_blocks * actual_block_size;
+
+	data = alloc_align( backing, pool_size, block_align );
+
+	// NOTE: Init intrusive freelist
+	curr = data;
+	for ( block_index = 0; block_index < num_blocks - 1; block_index++ )
+	{
+		uptr* next = ( uptr* ) curr;
+		*next      = ( uptr  ) curr + actual_block_size;
+		curr       = pointer_add( curr, actual_block_size );
+	}
+
+	end  =  ( uptr* ) curr;
+	*end =  ( uptr )  NULL;
+
+	pool.PhysicalStart = data;
+	pool.FreeList      = data;
+
+	return pool;
+}
+
+void clear(Pool& pool)
+{
+	ssize actual_block_size, block_index;
+	void* curr;
+	uptr* end;
+
+	actual_block_size = pool.BlockSize + pool.BlockAlign;
+
+	curr = pool.PhysicalStart;
+	for ( block_index = 0; block_index < pool.NumBlocks - 1; block_index++ )
+	{
+		uptr* next = ( uptr* ) curr;
+		*next      = ( uptr  ) curr + actual_block_size;
+		curr       = pointer_add( curr, actual_block_size );
+	}
+
+	end  =  ( uptr* ) curr;
+	*end =  ( uptr )  NULL;
+
+	pool.FreeList = pool.PhysicalStart;
+}
+
+#pragma endregion Memory

project/dependencies/memory.hpp

@@ -0,0 +1,675 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "debug.hpp"
+#endif
+
+#pragma region Memory
+
+#define kilobytes( x ) (          ( x ) * ( s64 )( 1024 ) )
+#define megabytes( x ) ( kilobytes( x ) * ( s64 )( 1024 ) )
+#define gigabytes( x ) ( megabytes( x ) * ( s64 )( 1024 ) )
+#define terabytes( x ) ( gigabytes( x ) * ( s64 )( 1024 ) )
+
+#define GEN__ONES          ( scast( GEN_NS usize, - 1) / GEN_U8_MAX )
+#define GEN__HIGHS         ( GEN__ONES * ( GEN_U8_MAX / 2 + 1 ) )
+#define GEN__HAS_ZERO( x ) ( ( ( x ) - GEN__ONES ) & ~( x ) & GEN__HIGHS )
+
+template< class Type >
+void swap( Type& a, Type& b )
+{
+	Type tmp = a;
+	a = b;
+	b = tmp;
+}
+
+//! Checks if value is power of 2.
+b32 is_power_of_two( ssize x );
+
+//! Aligns address to specified alignment.
+void* align_forward( void* ptr, ssize alignment );
+
+//! Aligns value to a specified alignment.
+s64 align_forward_i64( s64 value, ssize alignment );
+
+//! Moves pointer forward by bytes.
+void* pointer_add( void* ptr, ssize bytes );
+
+//! Moves pointer forward by bytes.
+void const* pointer_add_const( void const* ptr, ssize bytes );
+
+//! Calculates difference between two addresses.
+ssize pointer_diff( void const* begin, void const* end );
+
+//! Copy non-overlapping memory from source to destination.
+void* mem_copy( void* dest, void const* source, ssize size );
+
+//! Search for a constant value within the size limit at memory location.
+void const* mem_find( void const* data, u8 byte_value, ssize size );
+
+//! Copy memory from source to destination.
+void* mem_move( void* dest, void const* source, ssize size );
+
+//! Set constant value at memory location with specified size.
+void* mem_set( void* data, u8 byte_value, ssize size );
+
+//! @param ptr Memory location to clear up.
+//! @param size The size to clear up with.
+void zero_size( void* ptr, ssize size );
+
+//! Clears up an item.
+#define zero_item( t ) zero_size( ( t ), size_of( *( t ) ) )    // NOTE: Pass pointer of struct
+
+//! Clears up an array.
+#define zero_array( a, count ) zero_size( ( a ), size_of( *( a ) ) * count )
+
+enum AllocType_Def //enum_underlying(u8)
+{
+	EAllocation_ALLOC,
+	EAllocation_FREE,
+	EAllocation_FREE_ALL,
+	EAllocation_RESIZE,
+};
+typedef enum AllocType_Def AllocType;
+
+typedef void*(AllocatorProc)( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
+
+struct AllocatorInfo_Def
+{
+	AllocatorProc* Proc;
+	void*          Data;
+};
+typedef struct AllocatorInfo_Def AllocatorInfo;
+
+enum AllocFlag
+{
+	ALLOCATOR_FLAG_CLEAR_TO_ZERO = bit( 0 ),
+};
+
+#ifndef GEN_DEFAULT_MEMORY_ALIGNMENT
+#	define GEN_DEFAULT_MEMORY_ALIGNMENT ( 2 * size_of( void* ) )
+#endif
+
+#ifndef GEN_DEFAULT_ALLOCATOR_FLAGS
+#	define GEN_DEFAULT_ALLOCATOR_FLAGS ( ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+#endif
+
+//! Allocate memory with default alignment.
+void* alloc( AllocatorInfo a, ssize size );
+
+//! Allocate memory with specified alignment.
+void* alloc_align( AllocatorInfo a, ssize size, ssize alignment );
+
+//! Free allocated memory.
+void free( AllocatorInfo a, void* ptr );
+
+//! Free all memory allocated by an allocator.
+void free_all( AllocatorInfo a );
+
+//! Resize an allocated memory.
+void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size );
+
+//! Resize an allocated memory with specified alignment.
+void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
+
+//! Allocate memory for an item.
+#define alloc_item( allocator_, Type ) ( Type* )alloc( allocator_, size_of( Type ) )
+
+//! Allocate memory for an array of items.
+#define alloc_array( allocator_, Type, count ) ( Type* )alloc( allocator_, size_of( Type ) * ( count ) )
+
+/* heap memory analysis tools */
+/* define GEN_HEAP_ANALYSIS to enable this feature */
+/* call zpl_heap_stats_init at the beginning of the entry point */
+/* you can call zpl_heap_stats_check near the end of the execution to validate any possible leaks */
+void  heap_stats_init( void );
+ssize heap_stats_used_memory( void );
+ssize heap_stats_alloc_count( void );
+void  heap_stats_check( void );
+
+//! Allocate/Resize memory using default options.
+
+//! Use this if you don't need a "fancy" resize allocation
+void* default_resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
+
+void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
+
+//! The heap allocator backed by operating system's memory manager.
+constexpr AllocatorInfo heap( void ) { AllocatorInfo allocator = { heap_allocator_proc, nullptr }; return allocator; }
+
+//! Helper to allocate memory using heap allocator.
+#define malloc( sz ) alloc( heap(), sz )
+
+//! Helper to free memory allocated by heap allocator.
+#define mfree( ptr ) free( heap(), ptr )
+
+struct VirtualMemory
+{
+	void*  data;
+	ssize size;
+};
+
+//! Initialize virtual memory from existing data.
+VirtualMemory vm_from_memory( void* data, ssize size );
+
+//! Allocate virtual memory at address with size.
+
+//! @param addr The starting address of the region to reserve. If NULL, it lets operating system to decide where to allocate it.
+//! @param size The size to serve.
+VirtualMemory vm_alloc( void* addr, ssize size );
+
+//! Release the virtual memory.
+b32 vm_free( VirtualMemory vm );
+
+//! Trim virtual memory.
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size );
+
+//! Purge virtual memory.
+b32 gen_vm_purge( VirtualMemory vm );
+
+//! Retrieve VM's page size and alignment.
+ssize gen_virtual_memory_page_size( ssize* alignment_out );
+
+#pragma region Arena
+struct Arena;
+
+AllocatorInfo allocator_info( Arena* arena );
+
+// Remove static keyword and rename allocator_proc
+void* arena_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags);
+
+// Add these declarations after the Arena struct
+Arena arena_init_from_allocator(AllocatorInfo backing, ssize size);
+Arena arena_init_from_memory   ( void* start, ssize size );
+
+Arena init_sub      (Arena* parent, ssize size);
+ssize alignment_of  (Arena* arena, ssize alignment);
+void  free          (Arena* arena);
+ssize size_remaining(Arena* arena, ssize alignment);
+
+// This id is defined by Unreal for asserts
+#pragma push_macro("check")
+#undef check
+void   check(Arena* arena);
+#pragma pop_macro("check")
+
+struct Arena
+{
+	AllocatorInfo Backing;
+	void*         PhysicalStart;
+	ssize         TotalSize;
+	ssize         TotalUsed;
+	ssize         TempCount;
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#pragma region Member Mapping
+	forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); }
+
+	forceinline static void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { return GEN_NS arena_allocator_proc( allocator_data, type, size, alignment, old_memory, old_size, flags ); }
+	forceinline static Arena init_from_memory( void* start, ssize size )                                                                                      { return GEN_NS arena_init_from_memory( start, size ); }
+	forceinline static Arena init_from_allocator( AllocatorInfo backing, ssize size )                                                                         { return GEN_NS arena_init_from_allocator( backing, size ); }
+	forceinline static Arena init_sub( Arena& parent, ssize size )                                                                                            { return GEN_NS arena_init_from_allocator( parent.Backing, size ); }
+	forceinline        ssize alignment_of( ssize alignment )                                                                                                  { return GEN_NS alignment_of(this, alignment); }
+	forceinline        void  free()                                                                                                                           { return GEN_NS free(this);  }
+	forceinline        ssize size_remaining( ssize alignment )                                                                                                { return GEN_NS size_remaining(this, alignment); }
+
+// This id is defined by Unreal for asserts
+#pragma push_macro("check")
+#undef check
+	forceinline void check() { GEN_NS check(this); }
+#pragma pop_macro("check")
+
+#pragma endregion Member Mapping
+#endif
+};
+
+#if GEN_SUPPORT_CPP_REFERENCES
+forceinline AllocatorInfo allocator_info(Arena& arena )                 { return allocator_info(& arena); }
+forceinline Arena         init_sub      (Arena& parent, ssize size)     { return init_sub( & parent, size); }
+forceinline ssize         alignment_of  (Arena& arena, ssize alignment) { return alignment_of( & arena, alignment); }
+forceinline void          free          (Arena& arena)                  { return free(& arena); }
+forceinline ssize         size_remaining(Arena& arena, ssize alignment) { return size_remaining(& arena, alignment); }
+
+// This id is defined by Unreal for asserts
+#pragma push_macro("check")
+#undef check
+forceinline void check(Arena& arena) { return check(& arena); };
+#pragma pop_macro("check")
+#endif
+
+
+inline
+AllocatorInfo allocator_info( Arena* arena ) {
+	GEN_ASSERT(arena != nullptr);
+	return { arena_allocator_proc, arena };
+}
+
+inline
+Arena arena_init_from_memory( void* start, ssize size )
+{
+	Arena arena = {
+		{ nullptr, nullptr },
+		start,
+		size,
+		0,
+		0
+	};
+	return arena;
+}
+
+inline
+Arena arena_init_from_allocator(AllocatorInfo backing, ssize size) {
+	Arena result = {
+		backing,
+		alloc(backing, size),
+		size,
+		0,
+		0
+	};
+	return result;
+}
+
+inline
+Arena init_sub(Arena* parent, ssize size) {
+	GEN_ASSERT(parent != nullptr);
+	return arena_init_from_allocator(parent->Backing, size);
+}
+
+inline
+ssize alignment_of(Arena* arena, ssize alignment)
+{
+	GEN_ASSERT(arena != nullptr);
+	ssize alignment_offset, result_pointer, mask;
+	GEN_ASSERT(is_power_of_two(alignment));
+
+	alignment_offset = 0;
+	result_pointer  = (ssize)arena->PhysicalStart + arena->TotalUsed;
+	mask            = alignment - 1;
+
+	if (result_pointer & mask)
+	alignment_offset = alignment - (result_pointer & mask);
+
+	return alignment_offset;
+}
+
+#pragma push_macro("check")
+#undef check
+inline
+void check(Arena* arena)
+{
+    GEN_ASSERT(arena != nullptr );
+    GEN_ASSERT(arena->TempCount == 0);
+}
+#pragma pop_macro("check")
+
+inline
+void free(Arena* arena)
+{
+	GEN_ASSERT(arena != nullptr);
+	if (arena->Backing.Proc)
+	{
+		GEN_NS free(arena->Backing, arena->PhysicalStart);
+		arena->PhysicalStart = nullptr;
+	}
+}
+
+inline
+ssize size_remaining(Arena* arena, ssize alignment)
+{
+	GEN_ASSERT(arena != nullptr);
+	ssize result = arena->TotalSize - (arena->TotalUsed + alignment_of(arena, alignment));
+	return result;
+}
+#pragma endregion Arena
+
+#pragma region FixedArena
+template<s32 Size>
+struct FixedArena;
+
+template<s32 Size> FixedArena<Size> fixed_arena_init();
+template<s32 Size> AllocatorInfo    allocator_info(FixedArena<Size>* fixed_arena );
+template<s32 Size> ssize            size_remaining(FixedArena<Size>* fixed_arena, ssize alignment);
+
+#if GEN_SUPPORT_CPP_REFERENCES
+template<s32 Size> AllocatorInfo    allocator_info( FixedArena<Size>& fixed_arena )                { return allocator_info(& fixed_arena); }
+template<s32 Size> ssize            size_remaining(FixedArena<Size>& fixed_arena, ssize alignment) { return size_remaining( & fixed_arena, alignment); }
+#endif
+
+// Just a wrapper around using an arena with memory associated with its scope instead of from an allocator.
+// Used for static segment or stack allocations.
+template< s32 Size >
+struct FixedArena
+{
+	char  memory[Size];
+	Arena arena;
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#pragma region Member Mapping
+	forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); }
+
+	forceinline static FixedArena init()                          { FixedArena result; GEN_NS fixed_arena_init<Size>(result); return result; }
+	forceinline ssize             size_remaining(ssize alignment) { GEN_NS size_remaining(this, alignment); }
+#pragma endregion Member Mapping
+#endif
+};
+
+template<s32 Size> inline
+AllocatorInfo allocator_info( FixedArena<Size>* fixed_arena ) {
+	GEN_ASSERT(fixed_arena);
+	return { arena_allocator_proc, & fixed_arena->arena };
+}
+
+template<s32 Size> inline
+void fixed_arena_init(FixedArena<Size>* result) {
+    zero_size(& result->memory[0], Size);
+    result->arena = arena_init_from_memory(& result->memory[0], Size);
+}
+
+template<s32 Size> inline
+ssize size_remaining(FixedArena<Size>* fixed_arena, ssize alignment) {
+    return size_remaining(fixed_arena->arena, alignment);
+}
+
+using Arena_1KB   = FixedArena< kilobytes( 1 ) >;
+using Arena_4KB   = FixedArena< kilobytes( 4 ) >;
+using Arena_8KB   = FixedArena< kilobytes( 8 ) >;
+using Arena_16KB  = FixedArena< kilobytes( 16 ) >;
+using Arena_32KB  = FixedArena< kilobytes( 32 ) >;
+using Arena_64KB  = FixedArena< kilobytes( 64 ) >;
+using Arena_128KB = FixedArena< kilobytes( 128 ) >;
+using Arena_256KB = FixedArena< kilobytes( 256 ) >;
+using Arena_512KB = FixedArena< kilobytes( 512 ) >;
+using Arena_1MB   = FixedArena< megabytes( 1 ) >;
+using Arena_2MB   = FixedArena< megabytes( 2 ) >;
+using Arena_4MB   = FixedArena< megabytes( 4 ) >;
+#pragma endregion FixedArena
+
+#pragma region Pool
+struct Pool;
+
+void* pool_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags);
+
+Pool          pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size);
+Pool          pool_init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align);
+AllocatorInfo allocator_info(Pool* pool);
+void          clear(Pool* pool);
+void          free(Pool* pool);
+
+#if GEN_SUPPORT_CPP_REFERENCES
+AllocatorInfo allocator_info(Pool& pool);
+void          clear(Pool& pool);
+void          free(Pool& pool);
+#endif
+
+struct Pool
+{
+	AllocatorInfo Backing;
+	void*         PhysicalStart;
+	void*         FreeList;
+	ssize         BlockSize;
+	ssize         BlockAlign;
+	ssize         TotalSize;
+	ssize         NumBlocks;
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#pragma region Member Mapping
+    forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); }
+
+    forceinline static void* allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags) { return GEN_NS pool_allocator_proc(allocator_data, type, size, alignment, old_memory, old_size, flags); }
+    forceinline static Pool  init(AllocatorInfo backing, ssize num_blocks, ssize block_size)                                                                { return GEN_NS pool_init(backing, num_blocks, block_size); }
+    forceinline static Pool  init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align)                                       { return GEN_NS pool_init_align(backing, num_blocks, block_size, block_align); }
+    forceinline        void  clear() { GEN_NS clear( this); }
+    forceinline        void  free()  { GEN_NS free( this); }
+#pragma endregion
+#endif
+};
+
+inline
+AllocatorInfo allocator_info(Pool* pool) {
+   return { pool_allocator_proc, pool };
+}
+
+inline
+Pool pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size) {
+   return pool_init_align(backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT);
+}
+
+inline
+void free(Pool* pool) {
+   if(pool->Backing.Proc) {
+       GEN_NS free(pool->Backing, pool->PhysicalStart);
+   }
+}
+#pragma endregion Pool
+
+inline
+b32 is_power_of_two( ssize x ) {
+	if ( x <= 0 )
+		return false;
+	return ! ( x & ( x - 1 ) );
+}
+
+inline
+mem_ptr align_forward( void* ptr, ssize alignment )
+{
+	GEN_ASSERT( is_power_of_two( alignment ) );
+	uptr p       = to_uptr(ptr);
+	uptr forward = (p + ( alignment - 1 ) ) & ~( alignment - 1 );
+
+	return to_mem_ptr(forward);
+}
+
+inline s64 align_forward_i64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; }
+
+inline void*       pointer_add      ( void*       ptr, ssize bytes ) { return rcast(void*,       rcast( u8*,        ptr) + bytes ); }
+inline void const* pointer_add_const( void const* ptr, ssize bytes ) { return rcast(void const*, rcast( u8 const*,  ptr) + bytes ); }
+
+inline sptr pointer_diff( mem_ptr_const begin, mem_ptr_const end ) {
+	return scast( ssize, rcast( u8 const*, end) - rcast(u8 const*, begin) );
+}
+
+inline
+void* mem_move( void* destination, void const* source, ssize byte_count )
+{
+	if ( destination == NULL )
+	{
+		return NULL;
+	}
+
+	u8*       dest_ptr = rcast( u8*, destination);
+	u8 const* src_ptr  = rcast( u8 const*, source);
+
+	if ( dest_ptr == src_ptr )
+		return dest_ptr;
+
+	if ( src_ptr + byte_count <= dest_ptr || dest_ptr + byte_count <= src_ptr )    // NOTE: Non-overlapping
+		return mem_copy( dest_ptr, src_ptr, byte_count );
+
+	if ( dest_ptr < src_ptr )
+	{
+		if ( to_uptr(src_ptr) % size_of( ssize ) == to_uptr(dest_ptr) % size_of( ssize ) )
+		{
+			while ( pcast( uptr, dest_ptr) % size_of( ssize ) )
+			{
+				if ( ! byte_count-- )
+					return destination;
+
+				*dest_ptr++ = *src_ptr++;
+			}
+			while ( byte_count >= size_of( ssize ) )
+			{
+				* rcast(ssize*, dest_ptr)  = * rcast(ssize const*, src_ptr);
+				byte_count -= size_of( ssize );
+				dest_ptr   += size_of( ssize );
+				src_ptr    += size_of( ssize );
+			}
+		}
+		for ( ; byte_count; byte_count-- )
+			*dest_ptr++ = *src_ptr++;
+	}
+	else
+	{
+		if ( ( to_uptr(src_ptr) % size_of( ssize ) ) == ( to_uptr(dest_ptr) % size_of( ssize ) ) )
+		{
+			while ( to_uptr( dest_ptr + byte_count ) % size_of( ssize ) )
+			{
+				if ( ! byte_count-- )
+					return destination;
+
+				dest_ptr[ byte_count ] = src_ptr[ byte_count ];
+			}
+			while ( byte_count >= size_of( ssize ) )
+			{
+				byte_count                              -= size_of( ssize );
+				* rcast(ssize*, dest_ptr + byte_count )  = * rcast( ssize const*, src_ptr + byte_count );
+			}
+		}
+		while ( byte_count )
+			byte_count--, dest_ptr[ byte_count ] = src_ptr[ byte_count ];
+	}
+
+	return destination;
+}
+
+inline
+void* mem_set( void* destination, u8 fill_byte, ssize byte_count )
+{
+	if ( destination == NULL )
+	{
+		return NULL;
+	}
+
+	ssize align_offset;
+	u8*   dest_ptr  = rcast( u8*, destination);
+	u32   fill_word = ( ( u32 )-1 ) / 255 * fill_byte;
+
+	if ( byte_count == 0 )
+		return destination;
+
+	dest_ptr[ 0 ] = dest_ptr[ byte_count - 1 ] = fill_byte;
+	if ( byte_count < 3 )
+		return destination;
+
+	dest_ptr[ 1 ] = dest_ptr[ byte_count - 2 ] = fill_byte;
+	dest_ptr[ 2 ] = dest_ptr[ byte_count - 3 ] = fill_byte;
+	if ( byte_count < 7 )
+		return destination;
+
+	dest_ptr[ 3 ] = dest_ptr[ byte_count - 4 ] = fill_byte;
+	if ( byte_count < 9 )
+		return destination;
+
+	align_offset  = -to_sptr( dest_ptr ) & 3;
+	dest_ptr     += align_offset;
+	byte_count   -= align_offset;
+	byte_count   &= -4;
+
+	* rcast( u32*, ( dest_ptr + 0              ) ) = fill_word;
+	* rcast( u32*, ( dest_ptr + byte_count - 4 ) ) = fill_word;
+	if ( byte_count < 9 )
+		return destination;
+
+	* rcast( u32*, dest_ptr + 4 )               = fill_word;
+	* rcast( u32*, dest_ptr + 8 )               = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 12 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 8 )  = fill_word;
+	if ( byte_count < 25 )
+		return destination;
+
+	* rcast( u32*, dest_ptr + 12 )              = fill_word;
+	* rcast( u32*, dest_ptr + 16 )              = fill_word;
+	* rcast( u32*, dest_ptr + 20 )              = fill_word;
+	* rcast( u32*, dest_ptr + 24 )              = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 28 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 24 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 20 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 16 ) = fill_word;
+
+	align_offset  = 24 + to_uptr( dest_ptr ) & 4;
+	dest_ptr     += align_offset;
+	byte_count   -= align_offset;
+
+	{
+		u64 fill_doubleword = ( scast( u64, fill_word) << 32 ) | fill_word;
+		while ( byte_count > 31 )
+		{
+			* rcast( u64*, dest_ptr + 0 )  = fill_doubleword;
+			* rcast( u64*, dest_ptr + 8 )  = fill_doubleword;
+			* rcast( u64*, dest_ptr + 16 ) = fill_doubleword;
+			* rcast( u64*, dest_ptr + 24 ) = fill_doubleword;
+
+			byte_count -= 32;
+			dest_ptr += 32;
+		}
+	}
+
+	return destination;
+}
+
+inline
+void* alloc_align( AllocatorInfo a, ssize size, ssize alignment ) {
+	return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* alloc( AllocatorInfo a, ssize size ) {
+	return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+inline
+void free( AllocatorInfo a, void* ptr ) {
+	if ( ptr != nullptr )
+		a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void free_all( AllocatorInfo a ) {
+	a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size ) {
+	return resize_align( a, ptr, old_size, new_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+inline
+void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment ) {
+	return a.Proc( a.Data, EAllocation_RESIZE, new_size, alignment, ptr, old_size, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, ssize new_size, ssize alignment )
+{
+	if ( ! old_memory )
+		return alloc_align( a, new_size, alignment );
+
+	if ( new_size == 0 )
+	{
+		free( a, old_memory );
+		return nullptr;
+	}
+
+	if ( new_size < old_size )
+		new_size = old_size;
+
+	if ( old_size == new_size )
+	{
+		return old_memory;
+	}
+	else
+	{
+		void*  new_memory = alloc_align( a, new_size, alignment );
+		if ( ! new_memory )
+			return nullptr;
+
+		mem_move( new_memory, old_memory, min( new_size, old_size ) );
+		free( a, old_memory );
+		return new_memory;
+	}
+}
+
+inline
+void zero_size( void* ptr, ssize size ) {
+	mem_set( ptr, 0, size );
+}
+
+#pragma endregion Memory

project/dependencies/parsing.hpp

@@ -0,0 +1,432 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#endif
+
+#pragma region ADT
+
+enum ADT_Type : u32
+{
+	EADT_TYPE_UNINITIALISED, /* node was not initialised, this is a programming error! */
+	EADT_TYPE_ARRAY,
+	EADT_TYPE_OBJECT,
+	EADT_TYPE_STRING,
+	EADT_TYPE_MULTISTRING,
+	EADT_TYPE_INTEGER,
+	EADT_TYPE_REAL,
+};
+
+enum ADT_Props : u32
+{
+	EADT_PROPS_NONE,
+	EADT_PROPS_NAN,
+	EADT_PROPS_NAN_NEG,
+	EADT_PROPS_INFINITY,
+	EADT_PROPS_INFINITY_NEG,
+	EADT_PROPS_FALSE,
+	EADT_PROPS_TRUE,
+	EADT_PROPS_NULL,
+	EADT_PROPS_IS_EXP,
+	EADT_PROPS_IS_HEX,
+
+	// Used internally so that people can fill in real numbers they plan to write.
+	EADT_PROPS_IS_PARSED_REAL,
+};
+
+enum ADT_NamingStyle : u32
+{
+	EADT_NAME_STYLE_DOUBLE_QUOTE,
+	EADT_NAME_STYLE_SINGLE_QUOTE,
+	EADT_NAME_STYLE_NO_QUOTES,
+};
+
+enum ADT_AssignStyle : u32
+{
+	EADT_ASSIGN_STYLE_COLON,
+	EADT_ASSIGN_STYLE_EQUALS,
+	EADT_ASSIGN_STYLE_LINE,
+};
+
+enum ADT_DelimStyle : u32
+{
+	EADT_DELIM_STYLE_COMMA,
+	EADT_DELIM_STYLE_LINE,
+	EADT_DELIM_STYLE_NEWLINE,
+};
+
+enum ADT_Error : u32
+{
+	EADT_ERROR_NONE,
+	EADT_ERROR_INTERNAL,
+	EADT_ERROR_ALREADY_CONVERTED,
+	EADT_ERROR_INVALID_TYPE,
+	EADT_ERROR_OUT_OF_MEMORY,
+};
+
+struct ADT_Node
+{
+	char const*      name;
+	struct ADT_Node* parent;
+
+	/* properties */
+	ADT_Type type  : 4;
+	u8 props : 4;
+#ifndef GEN_PARSER_DISABLE_ANALYSIS
+	u8 cfg_mode          : 1;
+	u8 name_style        : 2;
+	u8 assign_style      : 2;
+	u8 delim_style       : 2;
+	u8 delim_line_width  : 4;
+	u8 assign_line_width : 4;
+#endif
+
+	/* adt data */
+	union
+	{
+		char const*     string;
+		Array(ADT_Node) nodes;    ///< zpl_array
+
+		struct
+		{
+			union
+			{
+				f64 real;
+				s64 integer;
+			};
+
+#ifndef GEN_PARSER_DISABLE_ANALYSIS
+			/* number analysis */
+			s32 base;
+			s32 base2;
+			u8  base2_offset : 4;
+			s8  exp          : 4;
+			u8  neg_zero     : 1;
+			u8  lead_digit   : 1;
+#endif
+		};
+	};
+};
+
+/* ADT NODE LIMITS
+	* delimiter and assignment segment width is limited to 128 whitespace symbols each.
+	* real number limits decimal position to 128 places.
+	* real number exponent is limited to 64 digits.
+	*/
+
+/**
+	* @brief Initialise an ADT object or array
+	*
+	* @param node
+	* @param backing Memory allocator used for descendants
+	* @param name Node's name
+	* @param is_array
+	* @return error code
+	*/
+u8 adt_make_branch( ADT_Node* node, AllocatorInfo backing, char const* name, b32 is_array );
+
+/**
+	* @brief Destroy an ADT branch and its descendants
+	*
+	* @param node
+	* @return error code
+	*/
+u8 adt_destroy_branch( ADT_Node* node );
+
+/**
+	* @brief Initialise an ADT leaf
+	*
+	* @param node
+	* @param name Node's name
+	* @param type Node's type (use zpl_adt_make_branch for container nodes)
+	* @return error code
+	*/
+u8 adt_make_leaf( ADT_Node* node, char const* name, ADT_Type type );
+
+
+/**
+	* @brief Fetch a node using provided URI string.
+	*
+	* This method uses a basic syntax to fetch a node from the ADT. The following features are available
+	* to retrieve the data:
+	*
+	* - "a/b/c" navigates through objects "a" and "b" to get to "c"
+	* - "arr/[foo=123]/bar" iterates over "arr" to find any object with param "foo" that matches the value "123", then gets its field called "bar"
+	* - "arr/3" retrieves the 4th element in "arr"
+	* - "arr/[apple]" retrieves the first element of value "apple" in "arr"
+	*
+	* @param node ADT node
+	* @param uri Locator string as described above
+	* @return zpl_adt_node*
+	*
+	* @see code/apps/examples/json_get.c
+	*/
+ADT_Node* adt_query( ADT_Node* node, char const* uri );
+
+/**
+	* @brief Find a field node within an object by the given name.
+	*
+	* @param node
+	* @param name
+	* @param deep_search Perform search recursively
+	* @return zpl_adt_node * node
+	*/
+ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search );
+
+/**
+	* @brief Allocate an unitialised node within a container at a specified index.
+	*
+	* @param parent
+	* @param index
+	* @return zpl_adt_node * node
+	*/
+ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index );
+
+/**
+	* @brief Allocate an unitialised node within a container.
+	*
+	* @param parent
+	* @return zpl_adt_node * node
+	*/
+ADT_Node* adt_alloc( ADT_Node* parent );
+
+/**
+	* @brief Move an existing node to a new container at a specified index.
+	*
+	* @param node
+	* @param new_parent
+	* @param index
+	* @return zpl_adt_node * node
+	*/
+ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index );
+
+/**
+	* @brief Move an existing node to a new container.
+	*
+	* @param node
+	* @param new_parent
+	* @return zpl_adt_node * node
+	*/
+ADT_Node* adt_move_node( ADT_Node* node, ADT_Node* new_parent );
+
+/**
+	* @brief Swap two nodes.
+	*
+	* @param node
+	* @param other_node
+	* @return
+	*/
+void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node );
+
+/**
+	* @brief Remove node from container.
+	*
+	* @param node
+	* @return
+	*/
+void adt_remove_node( ADT_Node* node );
+
+/**
+	* @brief Initialise a node as an object
+	*
+	* @param obj
+	* @param name
+	* @param backing
+	* @return
+	*/
+b8 adt_set_obj( ADT_Node* obj, char const* name, AllocatorInfo backing );
+
+/**
+	* @brief Initialise a node as an array
+	*
+	* @param obj
+	* @param name
+	* @param backing
+	* @return
+	*/
+b8 adt_set_arr( ADT_Node* obj, char const* name, AllocatorInfo backing );
+
+/**
+	* @brief Initialise a node as a string
+	*
+	* @param obj
+	* @param name
+	* @param value
+	* @return
+	*/
+b8 adt_set_str( ADT_Node* obj, char const* name, char const* value );
+
+/**
+	* @brief Initialise a node as a float
+	*
+	* @param obj
+	* @param name
+	* @param value
+	* @return
+	*/
+b8 adt_set_flt( ADT_Node* obj, char const* name, f64 value );
+
+/**
+	* @brief Initialise a node as a signed integer
+	*
+	* @param obj
+	* @param name
+	* @param value
+	* @return
+	*/
+b8 adt_set_int( ADT_Node* obj, char const* name, s64 value );
+
+/**
+	* @brief Append a new node to a container as an object
+	*
+	* @param parent
+	* @param name
+	* @return*
+	*/
+ADT_Node* adt_append_obj( ADT_Node* parent, char const* name );
+
+/**
+	* @brief Append a new node to a container as an array
+	*
+	* @param parent
+	* @param name
+	* @return*
+	*/
+ADT_Node* adt_append_arr( ADT_Node* parent, char const* name );
+
+/**
+	* @brief Append a new node to a container as a string
+	*
+	* @param parent
+	* @param name
+	* @param value
+	* @return*
+	*/
+ADT_Node* adt_append_str( ADT_Node* parent, char const* name, char const* value );
+
+/**
+	* @brief Append a new node to a container as a float
+	*
+	* @param parent
+	* @param name
+	* @param value
+	* @return*
+	*/
+ADT_Node* adt_append_flt( ADT_Node* parent, char const* name, f64 value );
+
+/**
+	* @brief Append a new node to a container as a signed integer
+	*
+	* @param parent
+	* @param name
+	* @param value
+	* @return*
+	*/
+ADT_Node* adt_append_int( ADT_Node* parent, char const* name, s64 value );
+
+/* parser helpers */
+
+/**
+	* @brief Parses a text and stores the result into an unitialised node.
+	*
+	* @param node
+	* @param base
+	* @return*
+	*/
+char* adt_parse_number( ADT_Node* node, char* base );
+
+/**
+	* @brief Parses a text and stores the result into an unitialised node.
+	* This function expects the entire input to be a number.
+	*
+	* @param node
+	* @param base
+	* @return*
+	*/
+char* adt_parse_number_strict( ADT_Node* node, char* base_str );
+
+/**
+	* @brief Parses and converts an existing string node into a number.
+	*
+	* @param node
+	* @return
+	*/
+ADT_Error adt_str_to_number( ADT_Node* node );
+
+/**
+	* @brief Parses and converts an existing string node into a number.
+	* This function expects the entire input to be a number.
+	*
+	* @param node
+	* @return
+	*/
+ADT_Error adt_str_to_number_strict( ADT_Node* node );
+
+/**
+	* @brief Prints a number into a file stream.
+	*
+	* The provided file handle can also be a memory mapped stream.
+	*
+	* @see zpl_file_stream_new
+	* @param file
+	* @param node
+	* @return
+	*/
+ADT_Error adt_print_number( FileInfo* file, ADT_Node* node );
+
+/**
+	* @brief Prints a string into a file stream.
+	*
+	* The provided file handle can also be a memory mapped stream.
+	*
+	* @see zpl_file_stream_new
+	* @param file
+	* @param node
+	* @param escaped_chars
+	* @param escape_symbol
+	* @return
+	*/
+ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_chars, char const* escape_symbol );
+
+#pragma endregion ADT
+
+#pragma region CSV
+
+enum CSV_Error : u32
+{
+	ECSV_Error__NONE,
+	ECSV_Error__INTERNAL,
+	ECSV_Error__UNEXPECTED_END_OF_INPUT,
+	ECSV_Error__MISMATCHED_ROWS,
+};
+
+typedef ADT_Node CSV_Object;
+
+u8   csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header );
+u8   csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim );
+void csv_free( CSV_Object* obj );
+
+void   csv_write( FileInfo* file, CSV_Object* obj );
+String 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 );
+
+/* inline */
+
+inline
+u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
+{
+	return csv_parse_delimiter( root, text, allocator, has_header, ',' );
+}
+
+inline
+void csv_write( FileInfo* file, CSV_Object* obj )
+{
+	csv_write_delimiter( file, obj, ',' );
+}
+
+inline
+String csv_write_string( AllocatorInfo a, CSV_Object* obj )
+{
+	return csv_write_string_delimiter( a, obj, ',' );
+}
+
+#pragma endregion CSV

project/dependencies/platform.hpp

@@ -0,0 +1,154 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#endif
+
+#pragma region Platform Detection
+
+/* Platform architecture */
+
+#if defined( _WIN64 ) || defined( __x86_64__ ) || defined( _M_X64 ) || defined( __64BIT__ ) || defined( __powerpc64__ ) || defined( __ppc64__ ) || defined( __aarch64__ )
+#	ifndef GEN_ARCH_64_BIT
+#		define GEN_ARCH_64_BIT 1
+#	endif
+#else
+#	ifndef GEN_ARCH_32_BItxt_StrCaT
+#		define GEN_ARCH_32_BIT 1
+#	endif
+#endif
+
+/* Platform OS */
+
+#if defined( _WIN32 ) || defined( _WIN64 )
+#	ifndef GEN_SYSTEM_WINDOWS
+#		define GEN_SYSTEM_WINDOWS 1
+#	endif
+#elif defined( __APPLE__ ) && defined( __MACH__ )
+#	ifndef GEN_SYSTEM_OSX
+#		define GEN_SYSTEM_OSX 1
+#	endif
+#	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
+#	endif
+#	if defined( ANDROID ) || defined( __ANDROID__ )
+#		ifndef GEN_SYSTEM_ANDROID
+#			define GEN_SYSTEM_ANDROID 1
+#		endif
+#		ifndef GEN_SYSTEM_LINUX
+#			define GEN_SYSTEM_LINUX 1
+#		endif
+#	elif defined( __linux__ )
+#		ifndef GEN_SYSTEM_LINUX
+#			define GEN_SYSTEM_LINUX 1
+#		endif
+#	elif defined( __FreeBSD__ ) || defined( __FreeBSD_kernel__ )
+#		ifndef GEN_SYSTEM_FREEBSD
+#			define GEN_SYSTEM_FREEBSD 1
+#		endif
+#	elif defined( __OpenBSD__ )
+#		ifndef GEN_SYSTEM_OPENBSD
+#			define GEN_SYSTEM_OPENBSD 1
+#		endif
+#	elif defined( __EMSCRIPTEN__ )
+#		ifndef GEN_SYSTEM_EMSCRIPTEN
+#			define GEN_SYSTEM_EMSCRIPTEN 1
+#		endif
+#	elif defined( __CYGWIN__ )
+#		ifndef GEN_SYSTEM_CYGWIN
+#			define GEN_SYSTEM_CYGWIN 1
+#		endif
+#	else
+#		error This UNIX operating system is not supported
+#	endif
+#else
+#	error This operating system is not supported
+#endif
+
+/* Platform compiler */
+
+#if defined( _MSC_VER )
+#	define GEN_COMPILER_CLANG 0
+#	define GEN_COMPILER_MSVC  1
+#	define GEN_COMPILER_GCC   0
+#elif defined( __GNUC__ )
+#	define GEN_COMPILER_CLANG 0
+#	define GEN_COMPILER_MSVC  0
+#	define GEN_COMPILER_GCC   1
+#elif defined( __clang__ )
+#	define GEN_COMPILER_CLANG 1
+#	define GEN_COMPILER_MSVC  0
+#	define GEN_COMPILER_GCC   1
+#else
+#	error Unknown compiler
+#endif
+
+#if defined( __has_attribute )
+#	define GEN_HAS_ATTRIBUTE( attribute ) __has_attribute( attribute )
+#else
+#	define GEN_HAS_ATTRIBUTE( attribute ) ( 0 )
+#endif
+
+#if defined(GEN_GCC_VERSION_CHECK)
+#  undef GEN_GCC_VERSION_CHECK
+#endif
+#if defined(GEN_GCC_VERSION)
+#  define GEN_GCC_VERSION_CHECK(major,minor,patch) (GEN_GCC_VERSION >= GEN_VERSION_ENCODE(major, minor, patch))
+#else
+#  define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#ifndef GEN_COMPILER_C
+#	if defined(__STDC_VERSION__)
+#		define GEN_COMPILER_C 1
+#	else
+#		define GEN_COMPILER_C 0
+#	endif
+#endif
+
+#pragma endregion Platform Detection
+
+#pragma region Mandatory Includes
+
+#	include <stdarg.h>
+#	include <stddef.h>
+
+#	if defined( GEN_SYSTEM_WINDOWS )
+#		include <intrin.h>
+#	endif
+
+#if GEN_COMPILER_C
+#include <assert.h>
+#endif
+
+#pragma endregion Mandatory Includes
+
+#if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
+#	if GEN_COMPILER_C
+#		define GEN_NS_ENUM_BEGIN
+#		define GEN_NS_ENUM_END
+#		define GEN_NS
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	else
+#		define GEN_NS_ENUM_BEGIN namespace gen_internal_enums {
+#		define GEN_NS_ENUM_END   }
+#		define GEN_NS       ::
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	endif
+#else
+#	define GEN_NS_ENUM_BEGIN namespace gen_internal_enums {
+#	define GEN_NS_ENUM_END   }
+#	define GEN_NS       gen::
+#	define GEN_NS_BEGIN namespace gen {
+#	define GEN_NS_END   }
+#endif

project/dependencies/printing.cpp

@@ -0,0 +1,591 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "filesystem.hpp"
+#	include "strings.hpp"
+#	include "string_ops.cpp"
+#endif
+
+#pragma region Printing
+
+enum
+{
+	GEN_FMT_MINUS = bit( 0 ),
+	GEN_FMT_PLUS  = bit( 1 ),
+	GEN_FMT_ALT   = bit( 2 ),
+	GEN_FMT_SPACE = bit( 3 ),
+	GEN_FMT_ZERO  = bit( 4 ),
+
+	GEN_FMT_CHAR   = bit( 5 ),
+	GEN_FMT_SHORT  = bit( 6 ),
+	GEN_FMT_INT    = bit( 7 ),
+	GEN_FMT_LONG   = bit( 8 ),
+	GEN_FMT_LLONG  = bit( 9 ),
+	GEN_FMT_SIZE   = bit( 10 ),
+	GEN_FMT_INTPTR = bit( 11 ),
+
+	GEN_FMT_UNSIGNED = bit( 12 ),
+	GEN_FMT_LOWER    = bit( 13 ),
+	GEN_FMT_UPPER    = bit( 14 ),
+	GEN_FMT_WIDTH    = bit( 15 ),
+
+	GEN_FMT_DONE = bit( 30 ),
+
+	GEN_FMT_INTS = GEN_FMT_CHAR | GEN_FMT_SHORT | GEN_FMT_INT | GEN_FMT_LONG | GEN_FMT_LLONG | GEN_FMT_SIZE | GEN_FMT_INTPTR
+};
+
+struct _format_info
+{
+	s32 base;
+	s32 flags;
+	s32 width;
+	s32 precision;
+};
+
+internal ssize _print_string( char* text, ssize max_len, _format_info* info, char const* str )
+{
+	ssize    res = 0, len = 0;
+	ssize    remaining = max_len;
+	char* begin     = text;
+
+	if ( str == NULL && max_len >= 6 )
+	{
+		res += str_copy_nulpad( text, "(null)", 6 );
+		return res;
+	}
+
+	if ( info && info->precision >= 0 )
+		// Made the design decision for this library that precision is the length of the string.
+		len = info->precision;
+	else
+		len = str_len( str );
+
+	if ( info && ( info->width == 0 && info->flags & GEN_FMT_WIDTH ) )
+	{
+		return res;
+	}
+
+	if ( info && ( info->width == 0 || info->flags & GEN_FMT_MINUS ) )
+	{
+		if ( info->precision > 0 )
+			len = info->precision < len ? info->precision : len;
+		if ( res + len > max_len )
+			return res;
+		res  += str_copy_nulpad( text, str, len );
+		text += res;
+
+		if ( info->width > res )
+		{
+			ssize padding = info->width - len;
+
+			char pad = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
+			while ( padding-- > 0 && remaining-- > 0 )
+				*text++ = pad, res++;
+		}
+	}
+	else
+	{
+		if ( info && ( info->width > res ) )
+		{
+			ssize   padding = info->width - len;
+			char pad     = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
+			while ( padding-- > 0 && remaining-- > 0 )
+				*text++ = pad, res++;
+		}
+
+		if ( res + len > max_len )
+			return res;
+		res += str_copy_nulpad( text, str, len );
+	}
+
+	if ( info )
+	{
+		if ( info->flags & GEN_FMT_UPPER )
+			str_to_upper( begin );
+		else if ( info->flags & GEN_FMT_LOWER )
+			str_to_lower( begin );
+	}
+
+	return res;
+}
+
+internal ssize _print_char( char* text, ssize max_len, _format_info* info, char arg )
+{
+	char str[ 2 ] = "";
+	str[ 0 ]      = arg;
+	return _print_string( text, max_len, info, str );
+}
+
+internal ssize _print_repeated_char( char* text, ssize max_len, _format_info* info, char arg )
+{
+	ssize  res = 0;
+	s32 rem = ( info ) ? ( info->width > 0 ) ? info->width : 1 : 1;
+	res     = rem;
+	while ( rem-- > 0 )
+		*text++ = arg;
+
+	return res;
+}
+
+internal ssize _print_i64( char* text, ssize max_len, _format_info* info, s64 value )
+{
+	char num[ 130 ];
+	i64_to_str( value, num, info ? info->base : 10 );
+	return _print_string( text, max_len, info, num );
+}
+
+internal ssize _print_u64( char* text, ssize max_len, _format_info* info, u64 value )
+{
+	char num[ 130 ];
+	u64_to_str( value, num, info ? info->base : 10 );
+	return _print_string( text, max_len, info, num );
+}
+
+internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is_hexadecimal, f64 arg )
+{
+	// TODO: Handle exponent notation
+	ssize    width, len, remaining = max_len;
+	char* text_begin = text;
+
+	if ( arg )
+	{
+		u64 value;
+		if ( arg < 0 )
+		{
+			if ( remaining > 1 )
+				*text = '-', remaining--;
+			text++;
+			arg = -arg;
+		}
+		else if ( info->flags & GEN_FMT_MINUS )
+		{
+			if ( remaining > 1 )
+				*text = '+', remaining--;
+			text++;
+		}
+
+		value  = scast( u64, arg);
+		len    = _print_u64( text, remaining, NULL, value );
+		text  += len;
+
+		if ( len >= remaining )
+			remaining = min( remaining, 1 );
+		else
+			remaining -= len;
+		arg -= value;
+
+		if ( info->precision < 0 )
+			info->precision = 6;
+
+		if ( ( info->flags & GEN_FMT_ALT ) || info->precision > 0 )
+		{
+			s64 mult = 10;
+			if ( remaining > 1 )
+				*text = '.', remaining--;
+			text++;
+			while ( info->precision-- > 0 )
+			{
+				value  = scast( u64, arg * mult );
+				len    = _print_u64( text, remaining, NULL, value );
+				text  += len;
+				if ( len >= remaining )
+					remaining = min( remaining, 1 );
+				else
+					remaining -= len;
+				arg  -= scast( f64, value / mult);
+				mult *= 10;
+			}
+		}
+	}
+	else
+	{
+		if ( remaining > 1 )
+			*text = '0', remaining--;
+		text++;
+		if ( info->flags & GEN_FMT_ALT )
+		{
+			if ( remaining > 1 )
+				*text = '.', remaining--;
+			text++;
+		}
+	}
+
+	width = info->width - ( text - text_begin );
+	if ( width > 0 )
+	{
+		char  fill = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
+		char* end  = text + remaining - 1;
+		len        = ( text - text_begin );
+
+		for ( len = ( text - text_begin ); len--; )
+		{
+			if ( ( text_begin + len + width ) < end )
+				*( text_begin + len + width ) = *( text_begin + len );
+		}
+
+		len   = width;
+		text += len;
+		if ( len >= remaining )
+			remaining = min( remaining, 1 );
+		else
+			remaining -= len;
+
+		while ( len-- )
+		{
+			if ( text_begin + len < end )
+				text_begin[ len ] = fill;
+		}
+	}
+
+	return ( text - text_begin );
+}
+
+neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
+{
+	char const* text_begin = text;
+	ssize          remaining  = max_len, res;
+
+	while ( *fmt )
+	{
+		_format_info info = { 0 };
+		ssize           len  = 0;
+		info.precision    = -1;
+
+		while ( *fmt && *fmt != '%' && remaining )
+			*text++ = *fmt++;
+
+		if ( *fmt == '%' )
+		{
+			do
+			{
+				switch ( *++fmt )
+				{
+					case '-' :
+						{
+							info.flags |= GEN_FMT_MINUS;
+							break;
+						}
+					case '+' :
+						{
+							info.flags |= GEN_FMT_PLUS;
+							break;
+						}
+					case '#' :
+						{
+							info.flags |= GEN_FMT_ALT;
+							break;
+						}
+					case ' ' :
+						{
+							info.flags |= GEN_FMT_SPACE;
+							break;
+						}
+					case '0' :
+						{
+							info.flags |= ( GEN_FMT_ZERO | GEN_FMT_WIDTH );
+							break;
+						}
+					default :
+						{
+							info.flags |= GEN_FMT_DONE;
+							break;
+						}
+				}
+			} while ( ! ( info.flags & GEN_FMT_DONE ) );
+		}
+
+		// NOTE: Optional Width
+		if ( *fmt == '*' )
+		{
+			int width = va_arg( va, int );
+			if ( width < 0 )
+			{
+				info.flags |= GEN_FMT_MINUS;
+				info.width  = -width;
+			}
+			else
+			{
+				info.width = width;
+			}
+			info.flags |= GEN_FMT_WIDTH;
+			fmt++;
+		}
+		else
+		{
+			info.width = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
+			if ( info.width != 0 )
+			{
+				info.flags |= GEN_FMT_WIDTH;
+			}
+		}
+
+		// NOTE: Optional Precision
+		if ( *fmt == '.' )
+		{
+			fmt++;
+			if ( *fmt == '*' )
+			{
+				info.precision = va_arg( va, int );
+				fmt++;
+			}
+			else
+			{
+				info.precision = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
+			}
+			info.flags &= ~GEN_FMT_ZERO;
+		}
+
+		switch ( *fmt++ )
+		{
+			case 'h' :
+				if ( *fmt == 'h' )
+				{    // hh => char
+					info.flags |= GEN_FMT_CHAR;
+					fmt++;
+				}
+				else
+				{    // h => short
+					info.flags |= GEN_FMT_SHORT;
+				}
+				break;
+
+			case 'l' :
+				if ( *fmt == 'l' )
+				{    // ll => long long
+					info.flags |= GEN_FMT_LLONG;
+					fmt++;
+				}
+				else
+				{    // l => long
+					info.flags |= GEN_FMT_LONG;
+				}
+				break;
+
+				break;
+
+			case 'z' :    // NOTE: zpl_usize
+				info.flags |= GEN_FMT_UNSIGNED;
+				// fallthrough
+			case 't' :    // NOTE: zpl_isize
+				info.flags |= GEN_FMT_SIZE;
+				break;
+
+			default :
+				fmt--;
+				break;
+		}
+
+		switch ( *fmt )
+		{
+			case 'u' :
+				info.flags |= GEN_FMT_UNSIGNED;
+				// fallthrough
+			case 'd' :
+			case 'i' :
+				info.base = 10;
+				break;
+
+			case 'o' :
+				info.base = 8;
+				break;
+
+			case 'x' :
+				info.base   = 16;
+				info.flags |= ( GEN_FMT_UNSIGNED | GEN_FMT_LOWER );
+				break;
+
+			case 'X' :
+				info.base   = 16;
+				info.flags |= ( GEN_FMT_UNSIGNED | GEN_FMT_UPPER );
+				break;
+
+			case 'f' :
+			case 'F' :
+			case 'g' :
+			case 'G' :
+				len = _print_f64( text, remaining, &info, 0, va_arg( va, f64 ) );
+				break;
+
+			case 'a' :
+			case 'A' :
+				len = _print_f64( text, remaining, &info, 1, va_arg( va, f64 ) );
+				break;
+
+			case 'c' :
+				len = _print_char( text, remaining, &info, scast( char, va_arg( va, int ) ));
+				break;
+
+			case 's' :
+				len = _print_string( text, remaining, &info, va_arg( va, char* ) );
+				break;
+
+			case 'S':
+			{
+				String gen_str = String { va_arg( va, char*) };
+
+				info.precision = length(gen_str);
+				len            = _print_string( text, remaining, &info, gen_str );
+			}
+			break;
+
+			case 'r' :
+				len = _print_repeated_char( text, remaining, &info, va_arg( va, int ) );
+				break;
+
+			case 'p' :
+				info.base   = 16;
+				info.flags |= ( GEN_FMT_LOWER | GEN_FMT_UNSIGNED | GEN_FMT_ALT | GEN_FMT_INTPTR );
+				break;
+
+			case '%' :
+				len = _print_char( text, remaining, &info, '%' );
+				break;
+
+			default :
+				fmt--;
+				break;
+		}
+
+		fmt++;
+
+		if ( info.base != 0 )
+		{
+			if ( info.flags & GEN_FMT_UNSIGNED )
+			{
+				u64 value = 0;
+				switch ( info.flags & GEN_FMT_INTS )
+				{
+					case GEN_FMT_CHAR :
+						value = scast( u64, scast( u8, va_arg( va, int )));
+						break;
+					case GEN_FMT_SHORT :
+						value = scast( u64, scast( u16, va_arg( va, int )));
+						break;
+					case GEN_FMT_LONG:
+						value = scast( u64, va_arg( va, unsigned long ));
+						break;
+					case GEN_FMT_LLONG :
+						value = scast( u64, va_arg( va, unsigned long long ));
+						break;
+					case GEN_FMT_SIZE :
+						value = scast( u64, va_arg( va, usize ));
+						break;
+					case GEN_FMT_INTPTR :
+						value = scast( u64, va_arg( va, uptr ));
+						break;
+					default :
+						value = scast( u64, va_arg( va, unsigned int ));
+						break;
+				}
+
+				len = _print_u64( text, remaining, &info, value );
+			}
+			else
+			{
+				s64 value = 0;
+				switch ( info.flags & GEN_FMT_INTS )
+				{
+					case GEN_FMT_CHAR :
+						value = scast( s64, scast( s8, va_arg( va, int )));
+						break;
+					case GEN_FMT_SHORT :
+						value = scast( s64, scast( s16, va_arg( va, int )));
+						break;
+					case GEN_FMT_LONG :
+						value = scast( s64, va_arg( va, long ));
+						break;
+					case GEN_FMT_LLONG :
+						value = scast( s64, va_arg( va, long long ));
+						break;
+					case GEN_FMT_SIZE :
+						value = scast( s64, va_arg( va, usize ));
+						break;
+					case GEN_FMT_INTPTR :
+						value = scast( s64, va_arg( va, uptr ));
+						break;
+					default :
+						value = scast( s64, va_arg( va, int ));
+						break;
+				}
+
+				len = _print_i64( text, remaining, &info, value );
+			}
+		}
+
+		text += len;
+		if ( len >= remaining )
+			remaining = min( remaining, 1 );
+		else
+			remaining -= len;
+	}
+
+	*text++ = '\0';
+	res     = ( text - text_begin );
+	return ( res >= max_len || res < 0 ) ? -1 : res;
+}
+
+char* 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 );
+	return buffer;
+}
+
+char* str_fmt_buf( char const* fmt, ... )
+{
+	va_list va;
+	char*   str;
+	va_start( va, fmt );
+	str = str_fmt_buf_va( fmt, va );
+	va_end( va );
+	return str;
+}
+
+ssize str_fmt_file_va( struct 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 );
+	b32                             res = file_write( f, buf, len - 1 );    // NOTE: prevent extra whitespace
+	return res ? len : -1;
+}
+
+ssize str_fmt_file( struct FileInfo* f, char const* fmt, ... )
+{
+	ssize      res;
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_file_va( f, fmt, va );
+	va_end( va );
+	return res;
+}
+
+ssize 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 );
+	va_end( va );
+	return res;
+}
+
+ssize str_fmt_out_va( char const* fmt, va_list va )
+{
+	return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
+}
+
+ssize str_fmt_out_err_va( char const* fmt, va_list va )
+{
+	return str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va );
+}
+
+ssize str_fmt_out_err( char const* fmt, ... )
+{
+	ssize      res;
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_out_err_va( fmt, va );
+	va_end( va );
+	return res;
+}
+
+#pragma endregion Printing

project/dependencies/printing.hpp

@@ -0,0 +1,41 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "string_ops.hpp"
+#endif
+
+#pragma region Printing
+
+struct FileInfo;
+
+#ifndef GEN_PRINTF_MAXLEN
+#	define GEN_PRINTF_MAXLEN kilobytes(128)
+#endif
+
+// NOTE: A locally persisting buffer is used internally
+char*  str_fmt_buf       ( char const* fmt, ... );
+char*  str_fmt_buf_va    ( char const* fmt, va_list va );
+ssize  str_fmt           ( char* str, ssize n, char const* fmt, ... );
+ssize  str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
+ssize  str_fmt_out_va    ( char const* fmt, va_list va );
+ssize  str_fmt_out_err   ( char const* fmt, ... );
+ssize  str_fmt_out_err_va( char const* fmt, va_list va );
+ssize  str_fmt_file      ( FileInfo* f, char const* fmt, ... );
+ssize  str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+
+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 = str_fmt_out_va(fmt, va);
+	va_end(va);
+
+	return res;
+}
+
+#pragma endregion Printing

project/dependencies/src_start.cpp

@@ -0,0 +1,84 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	include "header_start.hpp"
+#endif
+
+#pragma region Macros and Includes
+
+#	include <stdio.h>
+// NOTE: Ensure we use standard methods for these calls if we use GEN_PICO
+#	if ! defined( GEN_PICO_CUSTOM_ROUTINES )
+#		if ! defined( GEN_MODULE_CORE )
+#			define _strlen                   strlen
+#			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 )
+#		endif
+#	endif
+#
+#	include <errno.h>
+#
+#	if defined( GEN_SYSTEM_UNIX ) || defined( GEN_SYSTEM_MACOS )
+#		include <unistd.h>
+#	elif defined( GEN_SYSTEM_WINDOWS )
+#		if ! defined( GEN_NO_WINDOWS_H )
+#			ifndef WIN32_LEAN_AND_MEAN
+#				ifndef NOMINMAX
+#					define NOMINMAX
+#				endif
+#
+#				define WIN32_LEAN_AND_MEAN
+#				define WIN32_MEAN_AND_LEAN
+#				define VC_EXTRALEAN
+#			endif
+#			include <windows.h>
+#			undef NOMINMAX
+#			undef WIN32_LEAN_AND_MEAN
+#			undef WIN32_MEAN_AND_LEAN
+#			undef VC_EXTRALEAN
+#		endif
+#	endif
+
+#include <sys/stat.h>
+
+#ifdef GEN_SYSTEM_MACOS
+#	include <copyfile.h>
+#endif
+
+#ifdef GEN_SYSTEM_CYGWIN
+#	include <windows.h>
+#endif
+
+#if defined( GEN_SYSTEM_WINDOWS ) && ! defined( GEN_COMPILER_GCC )
+#	include <io.h>
+#endif
+
+#if defined( GEN_SYSTEM_LINUX )
+#	include <sys/types.h>
+#endif
+
+#ifdef GEN_BENCHMARK
+// Timing includes
+#if defined( GEN_SYSTEM_MACOS ) || GEN_SYSTEM_UNIX
+#	include <time.h>
+#	include <sys/time.h>
+#endif
+
+#if defined( GEN_SYSTEM_MACOS )
+#	include <mach/mach.h>
+#	include <mach/mach_time.h>
+#	include <mach/clock.h>
+#endif
+
+#if defined( GEN_SYSTEM_EMSCRIPTEN )
+#	include <emscripten.h>
+#endif
+
+#if defined( GEN_SYSTEM_WINDOWS )
+#	include <timezoneapi.h>
+#endif
+#endif
+
+#pragma endregion Macros and Includes

project/dependencies/string_ops.cpp

@@ -0,0 +1,215 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "string_ops.hpp"
+#	include "debug.cpp"
+#endif
+
+#pragma region String Ops
+
+internal
+ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
+{
+	const char* text_begin = text;
+	s64         result     = 0;
+	b32         negative   = false;
+
+	if ( *text == '-' )
+	{
+		negative = true;
+		text++;
+	}
+
+	if ( base == 16 && str_compare( text, "0x", 2 ) == 0 )
+		text += 2;
+
+	for ( ;; )
+	{
+		s64 v;
+		if ( char_is_digit( *text ) )
+			v = *text - '0';
+		else if ( base == 16 && char_is_hex_digit( *text ) )
+			v = hex_digit_to_int( *text );
+		else
+			break;
+
+		result *= base;
+		result += v;
+		text++;
+	}
+
+	if ( value )
+	{
+		if ( negative )
+			result = -result;
+		*value = result;
+	}
+
+	return ( text - text_begin );
+}
+
+// TODO : Are these good enough for characters?
+global const char _num_to_char_table[] =
+	"0123456789"
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	"abcdefghijklmnopqrstuvwxyz"
+	"@$";
+
+s64 str_to_i64( const char* str, char** end_ptr, s32 base )
+{
+	ssize  len;
+	s64 value;
+
+	if ( ! base )
+	{
+		if ( ( str_len( str ) > 2 ) && ( str_compare( str, "0x", 2 ) == 0 ) )
+			base = 16;
+		else
+			base = 10;
+	}
+
+	len = _scan_zpl_i64( str, base, &value );
+	if ( end_ptr )
+		*end_ptr = ( char* )str + len;
+	return value;
+}
+
+void i64_to_str( s64 value, char* string, s32 base )
+{
+	char* buf      = string;
+	b32   negative = false;
+	u64   v;
+
+	if ( value < 0 )
+	{
+		negative = true;
+		value    = -value;
+	}
+
+	v = scast( u64, value);
+	if ( v != 0 )
+	{
+		while ( v > 0 )
+		{
+			*buf++  = _num_to_char_table[ v % base ];
+			v      /= base;
+		}
+	}
+	else
+	{
+		*buf++ = '0';
+	}
+	if ( negative )
+		*buf++ = '-';
+	*buf = '\0';
+	str_reverse( string );
+}
+
+void u64_to_str( u64 value, char* string, s32 base )
+{
+	char* buf = string;
+
+	if ( value )
+	{
+		while ( value > 0 )
+		{
+			*buf++  = _num_to_char_table[ value % base ];
+			value  /= base;
+		}
+	}
+	else
+	{
+		*buf++ = '0';
+	}
+	*buf = '\0';
+
+	str_reverse( string );
+}
+
+f64 str_to_f64( const char* str, char** end_ptr )
+{
+	f64 result, value, sign, scale;
+	s32 frac;
+
+	while ( char_is_space( *str ) )
+	{
+		str++;
+	}
+
+	sign = 1.0;
+	if ( *str == '-' )
+	{
+		sign = -1.0;
+		str++;
+	}
+	else if ( *str == '+' )
+	{
+		str++;
+	}
+
+	for ( value = 0.0; char_is_digit( *str ); str++ )
+	{
+		value = value * 10.0 + ( *str - '0' );
+	}
+
+	if ( *str == '.' )
+	{
+		f64 pow10 = 10.0;
+		str++;
+		while ( char_is_digit( *str ) )
+		{
+			value += ( *str - '0' ) / pow10;
+			pow10 *= 10.0;
+			str++;
+		}
+	}
+
+	frac  = 0;
+	scale = 1.0;
+	if ( ( *str == 'e' ) || ( *str == 'E' ) )
+	{
+		u32 exp;
+
+		str++;
+		if ( *str == '-' )
+		{
+			frac = 1;
+			str++;
+		}
+		else if ( *str == '+' )
+		{
+			str++;
+		}
+
+		for ( exp = 0; char_is_digit( *str ); str++ )
+		{
+			exp = exp * 10 + ( *str - '0' );
+		}
+		if ( exp > 308 )
+			exp = 308;
+
+		while ( exp >= 50 )
+		{
+			scale *= 1e50;
+			exp   -= 50;
+		}
+		while ( exp >= 8 )
+		{
+			scale *= 1e8;
+			exp   -= 8;
+		}
+		while ( exp > 0 )
+		{
+			scale *= 10.0;
+			exp   -= 1;
+		}
+	}
+
+	result = sign * ( frac ? ( value / scale ) : ( value * scale ) );
+
+	if ( end_ptr )
+		* end_ptr = rcast( char*, ccast(char*, str) );
+
+	return result;
+}
+
+#pragma endregion String Ops

project/dependencies/string_ops.hpp

@@ -0,0 +1,287 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "memory.hpp"
+#endif
+
+#pragma region String Ops
+
+const char* char_first_occurence( const char* str, char c );
+
+b32   char_is_alpha( char c );
+b32   char_is_alphanumeric( char c );
+b32   char_is_digit( char c );
+b32   char_is_hex_digit( char c );
+b32   char_is_space( char c );
+char  char_to_lower( char c );
+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( 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( 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 );
+
+// NOTE: ASCII only
+void str_to_lower( char* str );
+void str_to_upper( char* str );
+
+s64  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 );
+
+inline
+const char* char_first_occurence( const char* s, char c )
+{
+	char ch = c;
+	for ( ; *s != ch; s++ )
+	{
+		if ( *s == '\0' )
+			return NULL;
+	}
+	return s;
+}
+
+inline
+b32 char_is_alpha( char c )
+{
+	if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
+		return true;
+	return false;
+}
+
+inline
+b32 char_is_alphanumeric( char c )
+{
+	return char_is_alpha( c ) || char_is_digit( c );
+}
+
+inline
+b32 char_is_digit( char c )
+{
+	if ( c >= '0' && c <= '9' )
+		return true;
+	return false;
+}
+
+inline
+b32 char_is_hex_digit( char c )
+{
+	if ( char_is_digit( c ) || ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) )
+		return true;
+	return false;
+}
+
+inline
+b32 char_is_space( char c )
+{
+	if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
+		return true;
+	return false;
+}
+
+inline
+char char_to_lower( char c )
+{
+	if ( c >= 'A' && c <= 'Z' )
+		return 'a' + ( c - 'A' );
+	return c;
+}
+
+inline char char_to_upper( char c )
+{
+	if ( c >= 'a' && c <= 'z' )
+		return 'A' + ( c - 'a' );
+	return c;
+}
+
+inline
+s32 digit_to_int( char c )
+{
+	return char_is_digit( c ) ? c - '0' : c - 'W';
+}
+
+inline
+s32 hex_digit_to_int( char c )
+{
+	if ( char_is_digit( c ) )
+		return digit_to_int( c );
+	else if ( is_between( c, 'a', 'f' ) )
+		return c - 'a' + 10;
+	else if ( is_between( c, 'A', 'F' ) )
+		return c - 'A' + 10;
+	return -1;
+}
+
+inline
+s32 str_compare( const char* s1, const char* s2 )
+{
+	while ( *s1 && ( *s1 == *s2 ) )
+	{
+		s1++, s2++;
+	}
+	return *( u8* )s1 - *( u8* )s2;
+}
+
+inline
+s32 str_compare( const char* s1, const char* s2, ssize len )
+{
+	for ( ; len > 0; s1++, s2++, len-- )
+	{
+		if ( *s1 != *s2 )
+			return ( ( s1 < s2 ) ? -1 : +1 );
+		else if ( *s1 == '\0' )
+			return 0;
+	}
+	return 0;
+}
+
+inline
+char* str_copy( char* dest, const char* source, ssize len )
+{
+	GEN_ASSERT_NOT_NULL( dest );
+	if ( source )
+	{
+		char* str = dest;
+		while ( len > 0 && *source )
+		{
+			*str++ = *source++;
+			len--;
+		}
+		while ( len > 0 )
+		{
+			*str++ = '\0';
+			len--;
+		}
+	}
+	return dest;
+}
+
+inline
+ssize str_copy_nulpad( char* dest, const char* source, ssize len )
+{
+	ssize result = 0;
+	GEN_ASSERT_NOT_NULL( dest );
+	if ( source )
+	{
+		const char* source_start = source;
+		char*       str          = dest;
+		while ( len > 0 && *source )
+		{
+			*str++ = *source++;
+			len--;
+		}
+		while ( len > 0 )
+		{
+			*str++ = '\0';
+			len--;
+		}
+
+		result = source - source_start;
+	}
+	return result;
+}
+
+inline
+ssize str_len( const char* str )
+{
+	if ( str == NULL )
+	{
+		return 0;
+	}
+	const char* p = str;
+	while ( *str )
+		str++;
+	return str - p;
+}
+
+inline
+ssize str_len( const char* str, ssize max_len )
+{
+	const char* end = rcast(const char*, mem_find( str, 0, max_len ));
+	if ( end )
+		return end - str;
+	return max_len;
+}
+
+inline
+char* str_reverse( char* str )
+{
+	ssize    len  = str_len( str );
+	char* a    = str + 0;
+	char* b    = str + len - 1;
+	len       /= 2;
+	while ( len-- )
+	{
+		swap( *a, *b );
+		a++, b--;
+	}
+	return str;
+}
+
+inline
+char const* str_skip( char const* str, char c )
+{
+	while ( *str && *str != c )
+	{
+		++str;
+	}
+	return str;
+}
+
+inline
+char const* str_skip_any( char const* str, char const* char_list )
+{
+	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(void const*, str), str_len( str ) ));
+	ssize       char_list_count = str_len( char_list );
+	for ( ssize i = 0; i < char_list_count; i++ )
+	{
+		char const* p = 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 )
+{
+	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
+	{
+		++str;
+	}
+	return str;
+}
+
+inline
+void str_to_lower( char* str )
+{
+	if ( ! str )
+		return;
+	while ( *str )
+	{
+		*str = char_to_lower( *str );
+		str++;
+	}
+}
+
+inline
+void str_to_upper( char* str )
+{
+	if ( ! str )
+		return;
+	while ( *str )
+	{
+		*str = char_to_upper( *str );
+		str++;
+	}
+}
+
+#pragma endregion String Ops

project/dependencies/strings.cpp

@@ -0,0 +1,54 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "hashing.cpp"
+#endif
+
+#pragma region String
+String string_make_length( AllocatorInfo allocator, char const* str, ssize length )
+{
+	constexpr ssize header_size = sizeof( StringHeader );
+
+	s32   alloc_size = header_size + length + 1;
+	void* allocation = alloc( allocator, alloc_size );
+
+	if ( allocation == nullptr )
+		return { nullptr };
+
+	StringHeader&
+	header = * rcast(StringHeader*, allocation);
+	header = { allocator, length, length };
+
+	String  result = { rcast( char*, allocation) + header_size };
+
+	if ( length && str )
+		mem_copy( result, str, length );
+	else
+		mem_set( result, 0, alloc_size - header_size );
+
+	result[ length ] = '\0';
+
+	return result;
+}
+
+String string_make_reserve( AllocatorInfo allocator, ssize capacity )
+{
+	constexpr ssize header_size = sizeof( StringHeader );
+
+	s32   alloc_size = header_size + capacity + 1;
+	void* allocation = alloc( allocator, alloc_size );
+
+	if ( allocation == nullptr )
+		return { nullptr };
+
+	mem_set( allocation, 0, alloc_size );
+
+	StringHeader*
+	header            = rcast(StringHeader*, allocation);
+	header->Allocator = allocator;
+	header->Capacity  = capacity;
+	header->Length    = 0;
+
+	String result = { rcast(char*, allocation) + header_size };
+	return result;
+}
+#pragma endregion String

project/dependencies/strings.hpp

@@ -0,0 +1,600 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "hashing.hpp"
+#endif
+
+#pragma region Strings
+
+// Constant string with length.
+struct StrC
+{
+	ssize       Len;
+	char const* Ptr;
+
+#if ! GEN_COMPILER_C
+	operator char const* ()               const { return Ptr; }
+	char const& operator[]( ssize index ) const { return Ptr[index]; }
+#endif
+};
+
+#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
+#define txt( text )         StrC { sizeof( text ) - 1, ( text ) }
+
+inline
+StrC to_str( char const* str ) {
+	return { str_len( str ), str };
+}
+
+// Dynamic String
+// This is directly based off the ZPL string api.
+// They used a header pattern
+// I kept it for simplicty of porting but its not necessary to keep it that way.
+#pragma region String
+struct StringHeader;
+struct String;
+
+usize string_grow_formula(usize value);
+
+String        string_make         (AllocatorInfo allocator, char const*  str);
+String        string_make         (AllocatorInfo allocator, StrC         str);
+String        string_make_reserve (AllocatorInfo allocator, ssize        capacity);
+String        string_make_length  (AllocatorInfo allocator, char const*  str,   ssize length);
+String        string_fmt          (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
+String        string_fmt_buf      (AllocatorInfo allocator, char const*  fmt, ...);
+String        string_join         (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
+bool          are_equal           (String const lhs, String const rhs);
+bool          are_equal           (String const lhs, StrC rhs);
+bool          make_space_for      (String*      str, char const*  to_append, ssize add_len);
+bool          append              (String*      str, char         c);
+bool          append              (String*      str, char const*  str_to_append);
+bool          append              (String*      str, char const*  str_to_append, ssize length);
+bool          append              (String*      str, StrC         str_to_append);
+bool          append              (String*      str, String const other);
+bool          append_fmt          (String*      str, char const*  fmt, ...);
+ssize         avail_space         (String const str);
+char*         back                (String       str);
+bool          contains            (String const str, StrC         substring);
+bool          contains            (String const str, String const substring);
+ssize         capacity            (String const str);
+void          clear               (String       str);
+String        duplicate           (String const str, AllocatorInfo allocator);
+void          free                (String*      str);
+StringHeader* get_header          (String       str);
+ssize         length              (String const str);
+b32           starts_with         (String const str, StrC   substring);
+b32           starts_with         (String const str, String substring);
+void          skip_line           (String       str);
+void          strip_space         (String       str);
+void          trim                (String       str, char const* cut_set);
+void          trim_space          (String       str);
+String        visualize_whitespace(String const str);
+
+struct StringHeader {
+	AllocatorInfo Allocator;
+	ssize         Capacity;
+	ssize         Length;
+};
+
+#if ! GEN_COMPILER_C
+struct String
+{
+	char* Data;
+
+	forceinline operator bool()              { return Data != nullptr; }
+	forceinline operator char*()             { return Data; }
+	forceinline operator char const*() const { return Data; }
+	forceinline operator StrC() const        { return { GEN_NS length(* this), Data }; }
+
+	String const& operator=(String const& other) const {
+		if (this == &other)
+			return *this;
+
+		String* this_ = ccast(String*, 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 char* begin() const { return Data; }
+	forceinline char* end() const   { return Data + GEN_NS length(* this); }
+
+#if GEN_SUPPORT_CPP_MEMBER_FEATURES
+#pragma region Member Mapping
+	forceinline static String make(AllocatorInfo allocator, char const* str)                { return GEN_NS string_make(allocator, str); }
+	forceinline static String make(AllocatorInfo allocator, StrC str)                       { return GEN_NS string_make(allocator, str); }
+	forceinline static String make_reserve(AllocatorInfo allocator, ssize cap)              { return GEN_NS string_make_reserve(allocator, cap); }
+	forceinline static String make_length(AllocatorInfo a, char const* s, ssize l)          { return GEN_NS string_make_length(a, s, l); }
+	forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return GEN_NS string_join(a, p, n, g); }
+	forceinline static usize  grow_formula(usize value)                                     { return GEN_NS string_grow_formula(value); }
+
+	static
+	String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+		va_list va;
+		va_start(va, fmt);
+		str_fmt_va(buf, buf_size, fmt, va);
+		va_end(va);
+		return GEN_NS string_make(allocator, buf);
+	}
+
+	static
+	String fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
+		local_persist thread_local
+		char buf[GEN_PRINTF_MAXLEN] = { 0 };
+		va_list va;
+		va_start(va, fmt);
+		str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+		va_end(va);
+		return GEN_NS string_make(allocator, buf);
+	}
+
+	forceinline bool          make_space_for(char const* str, ssize add_len) { return GEN_NS make_space_for(this, str, add_len); }
+	forceinline bool          append(char c)                                 { return GEN_NS append(this, c); }
+	forceinline bool          append(char const* str)                        { return GEN_NS append(this, str); }
+	forceinline bool          append(char const* str, ssize length)          { return GEN_NS append(this, str, length); }
+	forceinline bool          append(StrC str)                               { return GEN_NS append(this, str); }
+	forceinline bool          append(const String other)                     { return GEN_NS append(this, other); }
+	forceinline ssize         avail_space() const                            { return GEN_NS avail_space(* this); }
+	forceinline char*         back()                                         { return GEN_NS back(* this); }
+	forceinline bool          contains(StrC substring) const                 { return GEN_NS contains(* this, substring); }
+	forceinline bool          contains(String const& substring) const        { return GEN_NS contains(* this, substring); }
+	forceinline ssize         capacity() const                               { return GEN_NS capacity(* this); }
+	forceinline void          clear()                                        { GEN_NS clear(* this); }
+	forceinline String        duplicate(AllocatorInfo allocator) const       { return GEN_NS duplicate(* this, allocator); }
+	forceinline void          free()                                         { GEN_NS free(this); }
+	forceinline bool          is_equal(String const& other) const            { return GEN_NS are_equal(* this, other); }
+	forceinline bool          is_equal(StrC other) const                     { return GEN_NS are_equal(* this, other); }
+	forceinline ssize         length() const                                 { return GEN_NS length(* this); }
+	forceinline b32           starts_with(StrC substring) const              { return GEN_NS starts_with(* this, substring); }
+	forceinline b32           starts_with(String substring) const            { return GEN_NS starts_with(* this, substring); }
+	forceinline void          skip_line()                                    { GEN_NS skip_line(* this); }
+	forceinline void          strip_space()                                  { GEN_NS strip_space(* this); }
+	forceinline void          trim(char const* cut_set)                      { GEN_NS trim(* this, cut_set); }
+	forceinline void          trim_space()                                   { GEN_NS trim_space(* this); }
+	forceinline String        visualize_whitespace() const                   { return GEN_NS visualize_whitespace(* this); }
+	forceinline StringHeader& get_header()                                   { return * GEN_NS 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 = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+		va_end(va);
+
+		return GEN_NS append(this, buf, res);
+	}
+#pragma endregion Member Mapping
+#endif
+};
+#endif
+
+#if GEN_SUPPORT_CPP_REFERENCES
+bool          make_space_for(String& str, char const* to_append, ssize add_len);
+bool          append(String& str, char c);
+bool          append(String& str, char const* str_to_append);
+bool          append(String& str, char const* str_to_append, ssize length);
+bool          append(String& str, StrC str_to_append);
+bool          append(String& str, const String other);
+bool          append_fmt(String& str, char const* fmt, ...);
+char&         back(String& str);
+void          clear(String& str);
+void          free(String& str);
+#endif
+
+inline char* begin(String& str) { return str; }
+inline char* end(String& str)   { return scast(char*, str) + length(str); }
+inline char* next(String& str)  { return scast(char*, str) + 1; }
+
+inline
+usize string_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;
+}
+
+inline
+String string_make(AllocatorInfo allocator, char const* str) {
+	ssize length = str ? str_len(str) : 0;
+	return string_make_length(allocator, str, length);
+}
+
+inline
+String string_make(AllocatorInfo allocator, StrC str) {
+	return string_make_length(allocator, str.Ptr, str.Len);
+}
+
+inline
+String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
+	va_list va;
+	va_start(va, fmt);
+	str_fmt_va(buf, buf_size, fmt, va);
+	va_end(va);
+
+	return string_make(allocator, buf);
+}
+
+inline
+String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
+{
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, fmt);
+	str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	va_end(va);
+
+	return string_make(allocator, buf);
+}
+
+inline
+String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
+{
+	String result = string_make(allocator, "");
+
+	for (ssize idx = 0; idx < num_parts; ++idx)
+	{
+		append(& result, parts[idx]);
+
+		if (idx < num_parts - 1)
+			append(& result, glue);
+	}
+
+	return result;
+}
+
+inline
+bool append(String* str, char c) {
+	GEN_ASSERT(str != nullptr);
+	return append(str, &c, 1);
+}
+
+inline
+bool append(String* str, char const* str_to_append) {
+	GEN_ASSERT(str != nullptr);
+	return append(str, str_to_append, str_len(str_to_append));
+}
+
+inline
+bool append(String* str, char const* str_to_append, ssize append_length)
+{
+	GEN_ASSERT(str != nullptr);
+	if (sptr(str_to_append) > 0)
+	{
+		ssize curr_len = length(* str);
+
+		if ( ! make_space_for(str, str_to_append, append_length))
+			return false;
+
+		StringHeader* header = get_header(* str);
+
+		char* Data = * str;
+		mem_copy( Data + curr_len, str_to_append, append_length);
+
+		Data[curr_len + append_length] = '\0';
+
+		header->Length = curr_len + append_length;
+	}
+	return str_to_append != nullptr;
+}
+
+inline
+bool append(String* str, StrC str_to_append) {
+	GEN_ASSERT(str != nullptr);
+	return append(str, str_to_append.Ptr, str_to_append.Len);
+}
+
+inline
+bool append(String* str, const String other) {
+	GEN_ASSERT(str != nullptr);
+	return append(str, other, length(other));
+}
+
+bool append_fmt(String* str, char const* fmt, ...) {
+	GEN_ASSERT(str != nullptr);
+	ssize res;
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, fmt);
+	res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
+	va_end(va);
+
+	return append(str, buf, res);
+}
+
+inline
+bool are_equal(String const lhs, String const rhs)
+{
+	if (length(lhs) != length(rhs))
+		return false;
+
+	for (ssize idx = 0; idx < length(lhs); ++idx)
+		if (lhs[idx] != rhs[idx])
+			return false;
+
+	return true;
+}
+
+inline
+bool are_equal(String const lhs, StrC rhs)
+{
+	if (length(lhs) != (rhs.Len))
+		return false;
+
+	for (ssize idx = 0; idx < length(lhs); ++idx)
+		if (lhs[idx] != rhs.Ptr[idx])
+			return false;
+
+	return true;
+}
+
+inline
+ssize avail_space(String const str) {
+	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+	return header->Capacity - header->Length;
+}
+
+inline
+char* back(String* str) {
+	return & (*str)[length(* str) - 1];
+}
+
+inline
+bool contains(String const str, StrC substring)
+{
+	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+
+	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 (str_compare(str + idx, substring.Ptr, sub_len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+inline
+bool contains(String const str, String const substring)
+{
+	StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+
+	if (length(substring) > header->Length)
+		return false;
+
+	ssize main_len = header->Length;
+	ssize sub_len  = length(substring);
+
+	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
+	{
+		if (str_compare(str + idx, substring, sub_len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+inline
+ssize capacity(String const str) {
+   StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+   return header->Capacity;
+}
+
+inline
+void clear(String str) {
+   get_header(str)->Length = 0;
+}
+
+inline
+String duplicate(String const str, AllocatorInfo allocator) {
+   return string_make_length(allocator, str, length(str));
+}
+
+inline
+void free(String* str) {
+	GEN_ASSERT(str != nullptr);
+	if (! (* str))
+		return;
+
+	StringHeader* header = get_header(* str);
+	GEN_NS free(header->Allocator, header);
+}
+
+inline
+StringHeader* get_header(String str) {
+   return (StringHeader*)(scast(char*, str) - sizeof(StringHeader));
+}
+
+inline
+ssize length(String const str)
+{
+   StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
+   return header.Length;
+}
+
+inline
+bool make_space_for(String* str, char const* to_append, ssize add_len)
+{
+	ssize available = avail_space(* str);
+
+	if (available >= add_len) {
+		return true;
+	}
+	else
+	{
+		ssize new_len, old_size, new_size;
+		void* ptr;
+		void* new_ptr;
+
+		AllocatorInfo allocator = get_header(* str)->Allocator;
+		StringHeader* header    = nullptr;
+
+		new_len  = string_grow_formula(length(* str) + add_len);
+		ptr      = get_header(* str);
+		old_size = size_of(StringHeader) + length(* str) + 1;
+		new_size = size_of(StringHeader) + new_len + 1;
+
+		new_ptr = resize(allocator, ptr, old_size, new_size);
+
+		if (new_ptr == nullptr)
+			return false;
+
+		header = rcast(StringHeader*, new_ptr);
+		header->Allocator = allocator;
+		header->Capacity  = new_len;
+
+		char** Data = rcast(char**, str);
+		* Data = rcast(char*, header + 1);
+
+		return true;
+	}
+}
+
+inline
+b32 starts_with(String const str, StrC substring) {
+	if (substring.Len > length(str))
+	return false;
+
+	b32 result = str_compare(str.Data, substring.Ptr, substring.Len) == 0;
+	return result;
+}
+
+inline
+b32 starts_with(String const str, String substring) {
+	if (length(substring) > length(str))
+		return false;
+
+	b32 result = str_compare(str.Data, substring.Data, length(substring) - 1) == 0;
+	return result;
+}
+
+inline
+void skip_line(String str)
+{
+#define current (*scanner)
+	char* scanner = str.Data;
+	while (current != '\r' && current != '\n') {
+ 		++scanner;
+	}
+
+	s32 new_length = scanner - str.Data;
+
+	if (current == '\r') {
+		new_length += 1;
+	}
+
+	mem_move(str.Data, scanner, new_length);
+
+	StringHeader* header = get_header(str);
+	header->Length = new_length;
+#undef current
+}
+
+inline
+void strip_space(String 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
+   get_header(str)->Length = write_pos - str.Data;
+}
+
+inline
+void trim(String str, char const* cut_set)
+{
+   ssize len = 0;
+
+   char* start_pos = str.Data;
+   char* end_pos = str.Data + 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.Data != start_pos)
+   	mem_move(str.Data, start_pos, len);
+
+   str.Data[len] = '\0';
+
+   get_header(str)->Length = len;
+}
+
+inline
+void trim_space(String str) {
+   trim(str, " \t\r\n\v\f");
+}
+
+inline
+String visualize_whitespace(String const str)
+{
+	StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader));
+	String        result = string_make_reserve(header->Allocator, length(str) * 2); // Assume worst case for space requirements.
+
+	for (auto c : str) switch (c)
+	{
+		case ' ':
+			append(& result, txt("·"));
+		break;
+		case '\t':
+			append(& result, txt("→"));
+		break;
+		case '\n':
+			append(& result, txt("↵"));
+		break;
+		case '\r':
+			append(& result, txt("⏎"));
+		break;
+		case '\v':
+			append(& result, txt("⇕"));
+		break;
+		case '\f':
+			append(& result, txt("⌂"));
+		break;
+		default:
+			append(& result, c);
+		break;
+	}
+
+	return result;
+}
+#pragma endregion String
+
+struct String_POD {
+	char* Data;
+};
+static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
+
+// Implements basic string interning. Data structure is based off the ZPL Hashtable.
+typedef HashTable<String const>   StringTable;
+
+// Represents strings cached with the string table.
+// Should never be modified, if changed string is desired, cache_string( str ) another.
+typedef String const   StringCached;
+
+#pragma endregion Strings

project/dependencies/timing.cpp

@@ -0,0 +1,167 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "filesystem.cpp"
+#endif
+
+#pragma region Timing
+
+#ifdef GEN_BENCHMARK
+	#if defined( GEN_COMPILER_MSVC ) && ! defined( __clang__ )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		return __rdtsc();
+	}
+	#elif defined( __i386__ )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		u64 x;
+		__asm__ volatile( ".byte 0x0f, 0x31" : "=A"( x ) );
+		return x;
+	}
+	#elif defined( __x86_64__ )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		u32 hi, lo;
+		__asm__ __volatile__( "rdtsc" : "=a"( lo ), "=d"( hi ) );
+		return scast( u64, lo ) | ( scast( u64, hi ) << 32 );
+	}
+	#elif defined( __powerpc__ )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		u64 result = 0;
+		u32 upper, lower, tmp;
+		__asm__ volatile(
+			"0:                   \n"
+			"\tmftbu   %0         \n"
+			"\tmftb    %1         \n"
+			"\tmftbu   %2         \n"
+			"\tcmpw    %2,%0      \n"
+			"\tbne     0b         \n"
+			: "=r"( upper ), "=r"( lower ), "=r"( tmp )
+		);
+		result = upper;
+		result = result << 32;
+		result = result | lower;
+
+		return result;
+	}
+	#elif defined( GEN_SYSTEM_EMSCRIPTEN )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		return ( u64 )( emscripten_get_now() * 1e+6 );
+	}
+	#elif defined( GEN_CPU_ARM ) && ! defined( GEN_COMPILER_TINYC )
+	u64 read_cpu_time_stamp_counter( void )
+	{
+	#	if defined( __aarch64__ )
+		int64_t r = 0;
+		asm volatile( "mrs %0, cntvct_el0" : "=r"( r ) );
+	#	elif ( __ARM_ARCH >= 6 )
+		uint32_t r = 0;
+		uint32_t pmccntr;
+		uint32_t pmuseren;
+		uint32_t pmcntenset;
+
+		// Read the user mode perf monitor counter access permissions.
+		asm volatile( "mrc p15, 0, %0, c9, c14, 0" : "=r"( pmuseren ) );
+		if ( pmuseren & 1 )
+		{    // Allows reading perfmon counters for user mode code.
+			asm volatile( "mrc p15, 0, %0, c9, c12, 1" : "=r"( pmcntenset ) );
+			if ( pmcntenset & 0x80000000ul )
+			{    // Is it counting?
+				asm volatile( "mrc p15, 0, %0, c9, c13, 0" : "=r"( pmccntr ) );
+				// The counter is set up to count every 64th cycle
+				return ( ( int64_t )pmccntr ) * 64;    // Should optimize to << 6
+			}
+		}
+	#	else
+	#		error "No suitable method for read_cpu_time_stamp_counter for this cpu type"
+	#	endif
+
+		return r;
+	}
+	#else
+	u64 read_cpu_time_stamp_counter( void )
+	{
+		GEN_PANIC( "read_cpu_time_stamp_counter is not supported on this particular setup" );
+		return -0;
+	}
+	#endif
+
+	#if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
+
+	u64 time_rel_ms( void )
+	{
+		local_persist LARGE_INTEGER win32_perf_count_freq = {};
+		u64                         result;
+		LARGE_INTEGER               counter;
+		local_persist LARGE_INTEGER win32_perf_counter = {};
+		if ( ! win32_perf_count_freq.QuadPart )
+		{
+			QueryPerformanceFrequency( &win32_perf_count_freq );
+			GEN_ASSERT( win32_perf_count_freq.QuadPart != 0 );
+			QueryPerformanceCounter( &win32_perf_counter );
+		}
+
+		QueryPerformanceCounter( &counter );
+
+		result = ( counter.QuadPart - win32_perf_counter.QuadPart ) * 1000 / ( win32_perf_count_freq.QuadPart );
+		return result;
+	}
+
+	#else
+
+	#	if defined( GEN_SYSTEM_LINUX ) || defined( GEN_SYSTEM_FREEBSD ) || defined( GEN_SYSTEM_OPENBSD ) || defined( GEN_SYSTEM_EMSCRIPTEN )
+	u64 _unix_gettime( void )
+	{
+		struct timespec t;
+		u64             result;
+
+		clock_gettime( 1 /*CLOCK_MONOTONIC*/, &t );
+		result = 1000 * t.tv_sec + 1.0e-6 * t.tv_nsec;
+		return result;
+	}
+	#	endif
+
+	u64 time_rel_ms( void )
+	{
+	#	if defined( GEN_SYSTEM_OSX )
+		u64 result;
+
+		local_persist u64 timebase  = 0;
+		local_persist u64 timestart = 0;
+
+		if ( ! timestart )
+		{
+			mach_timebase_info_data_t tb = { 0 };
+			mach_timebase_info( &tb );
+			timebase   = tb.numer;
+			timebase  /= tb.denom;
+			timestart  = mach_absolute_time();
+		}
+
+		// NOTE: mach_absolute_time() returns things in nanoseconds
+		result = 1.0e-6 * ( mach_absolute_time() - timestart ) * timebase;
+		return result;
+	#	else
+		local_persist u64 unix_timestart = 0.0;
+
+		if ( ! unix_timestart )
+		{
+			unix_timestart = _unix_gettime();
+		}
+
+		u64 now = _unix_gettime();
+
+		return ( now - unix_timestart );
+	#	endif
+	}
+	#endif
+
+	f64 time_rel( void )
+	{
+		return ( f64 )( time_rel_ms() * 1e-3 );
+	}
+#endif
+
+#pragma endregion Timing

project/dependencies/timing.hpp

@@ -0,0 +1,19 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "filesystem.hpp"
+#endif
+
+#pragma region Timing
+
+#ifdef GEN_BENCHMARK
+//! Return CPU timestamp.
+u64 read_cpu_time_stamp_counter( void );
+
+//! Return relative time (in seconds) since the application start.
+f64 time_rel( void );
+
+//! Return relative time since the application start.
+u64 time_rel_ms( void );
+#endif
+
+#pragma endregion Timing

project/enums/AttributeTokens.csv

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

project/enums/ECode.csv

@@ -0,0 +1,60 @@
+Invalid
+Untyped
+NewLine
+Comment
+Access_Private
+Access_Protected
+Access_Public
+PlatformAttributes
+Class
+Class_Fwd
+Class_Body
+Constructor
+Constructor_Fwd
+Destructor
+Destructor_Fwd
+Enum
+Enum_Fwd
+Enum_Body
+Enum_Class
+Enum_Class_Fwd
+Execution
+Export_Body
+Extern_Linkage
+Extern_Linkage_Body
+Friend
+Function
+Function_Fwd
+Function_Body
+Global_Body
+Module
+Namespace
+Namespace_Body
+Operator
+Operator_Fwd
+Operator_Member
+Operator_Member_Fwd
+Operator_Cast
+Operator_Cast_Fwd
+Parameters
+Preprocess_Define
+Preprocess_Include
+Preprocess_If
+Preprocess_IfDef
+Preprocess_IfNotDef
+Preprocess_ElIf
+Preprocess_Else
+Preprocess_EndIf
+Preprocess_Pragma
+Specifiers
+Struct
+Struct_Fwd
+Struct_Body
+Template
+Typedef
+Typename
+Union
+Union_Body
+Using
+Using_Namespace
+Variable

project/enums/ECode_ExecutionSupport.csv

@@ -0,0 +1,144 @@
+Invalid
+Untyped
+NewLine
+Comment
+Access_Private
+Access_Protected
+Access_Public
+PlatformAttributes
+Class
+Class_Fwd
+Class_Body
+Constructor
+Constructor_Fwd
+Destructor
+Destructor_Fwd
+Enum
+Enum_Fwd
+Enum_Body
+Enum_Class
+Enum_Class_Fwd
+Execution
+
+Expression
+
+Expr_Identifier
+Expr_NumericLiteral
+Expr_StringLiteral
+
+Expr_Alignof
+Expr_ProcCall
+
+Expr_Assign_Add
+Expr_Assign_Subtract
+Expr_Assign_Multiply
+Expr_Assign_Divide
+Expr_Assign_Modulo
+Expr_Assign_Bitwise_And
+Expr_Assign_Bitwise_Or
+Expr_Assign_Bitwise_XOr
+Expr_Assign_LeftShift
+Expr_Assign_RightShift
+
+Expr_CStyleCast
+Expr_FunctionalCast
+Expr_ConstCast
+Expr_DynamicCast
+Expr_ReinterpretCast
+Expr_StaticCast
+
+Expr_Unary_Add
+Expr_Unary_Minus
+Expr_Unary_Not
+Expr_Unary_Increment
+Expr_Unary_Decrement
+Expr_Indirection
+Expr_AddressOf,
+
+Expr_UnaryPost_Increment
+Expr_UnaryPost_Decrement
+Expr_Subscript
+
+Expr_Binary_Add
+Expr_Binary_Subtract
+Expr_Binary_Multiply
+Expr_Binary_Divide
+Expr_Binary_Modulo
+Expr_Binary_Bitwise_And
+Expr_Binary_Bitwise_Or
+Expr_Binary_Bitwise_XOr
+Expr_Binary_Bitwise_LeftShift
+Expr_Binary_Bitwise_RightShift
+Expr_Binary_Logical_Not
+Expr_Binary_Logical_And
+Expr_Binary_Logical_Or
+Expr_Binary_Equal
+Expr_Binary_NotEqual
+Expr_Binary_Lesser
+Expr_Binary_Greater
+Expr_Binary_LesserEqual
+Expr_Binary_GreaterEqual
+Expr_MemberOfObject,
+Expr_MemberOfPointer,
+Expr_PointerToMemberOfObject,
+Expr_PointerToMemberOfPointer,
+Expr_Comma,
+Expr_Tenary,
+
+Export_Body
+Extern_Linkage
+Extern_Linkage_Body
+Friend
+Function
+Function_Fwd
+Function_Body
+Global_Body
+
+Module
+Namespace
+Namespace_Body
+Operator
+Operator_Fwd
+Operator_Member
+Operator_Member_Fwd
+Operator_Cast
+Operator_Cast_Fwd
+Parameters
+Preprocess_Define
+Preprocess_Include
+Preprocess_If
+Preprocess_IfDef
+Preprocess_IfNotDef
+Preprocess_ElIf
+Preprocess_Else
+Preprocess_EndIf
+Preprocess_Pragma
+Specifiers
+
+Statement
+Stmt_Break
+Stmt_Case
+Stmt_Continue
+Stmt_Declaration
+Stmt_Do
+Stmt_Expr
+Stmt_Else
+Stmt_If
+Stmt_For
+Stmt_Goto
+Stmt_Label
+Stmt_Switch
+Stmt_Switch
+Stmt_While
+
+Struct
+Struct_Fwd
+Struct_Body
+Template
+Typedef
+Typename
+Union
+Union_Body
+Using
+Using_Namespace
+Variable

project/enums/EOperator.csv

@@ -0,0 +1,47 @@
+Invalid,         INVALID
+Assign,          "="
+Assign_Add,      "+="
+Assign_Subtract, "-="
+Assign_Multiply, "*="
+Assign_Divide,   "/="
+Assign_Modulo,   "%="
+Assign_BAnd,     "&="
+Assign_BOr,      "|="
+Assign_BXOr,     "^="
+Assign_LShift,   "<<="
+Assign_RShift,   ">>="
+Increment,       "++"
+Decrement,       "--"
+Unary_Plus,      "+"
+Unary_Minus,     "-"
+UnaryNot,        "!"
+Add,             "+"
+Subtract,        "-"
+Multiply,        "*"
+Divide,          "/"
+Modulo,          "%"
+BNot,            "~"
+BAnd,            "&"
+BOr,             "|"
+BXOr,            "^"
+LShift,          "<<"
+RShift,          ">>"
+LAnd,            "&&"
+LOr,             "||"
+LEqual,          "=="
+LNot,            "!="
+Lesser,          "<"
+Greater,         ">"
+LesserEqual,     "<="
+GreaterEqual,    ">="
+Subscript,       "[]"
+Indirection,     "*"
+AddressOf,       "&"
+MemberOfPointer, "->"
+PtrToMemOfPtr,   "->*"
+FunctionCall,    "()"
+Comma,           ","
+New,             "new"
+NewArray,        "new[]"
+Delete,          "delete"
+DeleteArray,     "delete[]"

project/enums/ESpecifier.csv

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

project/enums/ETokType.csv

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

project/enums/ETokType_New.csv

@@ -0,0 +1,183 @@
+Invalid,                "__invalid__"
+Access_Private,         "private"
+Access_Protected,       "protected"
+Access_Public,          "public"
+Access_MemberSymbol,    "."
+Access_StaticSymbol,    "::"
+Ampersand,              "&"
+Ampersand_DBL,          "&&"
+Assign_Classifer,       ":"
+Attribute_Open,         "[["
+Attribute_Close,        "]]"
+BraceCurly_Open,        "{"
+BraceCurly_Close,       "}"
+BraceSquare_Open,       "["
+BraceSquare_Close,      "]"
+Capture_Start,          "("
+Capture_End,            ")"
+Comment,                "__comment__"
+Comment_End,            "__comment_end__"
+Comment_Start,          "__comment_start__"
+Char,                   "__character__"
+Comma,                  ","
+
+Decl_Class,             "class"
+Decl_Default            "default"
+Decl_GNU_Attribute,     "__attribute__"
+Decl_MSVC_Attribute,    "__declspec"
+Decl_Enum,              "enum"
+Decl_Extern_Linkage,    "extern"
+Decl_Friend,            "friend"
+Decl_Module,            "module"
+Decl_Namespace,         "namespace"
+Decl_Operator,          "operator"
+Decl_Struct,            "struct"
+Decl_Template,          "template"
+
+Decl_Type,              "decltype"
+
+Decl_Typedef,           "typedef"
+Decl_Using,             "using"
+Decl_Union,             "union"
+
+Expr_AlignOf,           "alignof"
+
+
+Identifier,             "__identifier__"
+
+Module_Import,          "import"
+Module_Export,          "export"
+
+NewLine,                "__new_line__"
+
+Number,                 "__number__"
+
+Operator,               "__operator__"
+
+Op_Assign,                    "="
+Op_Assign_Add,                "+="
+Op_Assign_Subtract,           "-="
+Op_Assign_Multiply,           "*="
+Op_Assign_Divide,             "/="
+Op_Assign_Modulo,             "%="
+Op_Assign_Bitwise_And,        "&="
+Op_Assign_Bitwise_Or,         "|="
+Op_Assign_Bitwise_XOr,        "^="
+Op_Assign_Bitwise_LeftShift,  "<<="
+Op_Assign_Bitwise_RightShift, ">>="
+
+Op_Increment, "++"
+Op_Decrement, "--"
+
+Op_Add,                 "+"
+Op_Subtract,            "-"
+Op_Multiply,            "*"
+Op_Divide,              "/"
+Op_Modulo,              "%"
+
+Op_Bitwise_And,         "&"
+Op_Bitwise_Or,          "|"
+Op_Bitwise_XOr,         "^"
+Op_Bitwise_LeftShitf,   "<<"
+Op_Bitwise_RightShift,  ">>"
+
+Op_UnaryAdd,            "+"
+Op_UnaryMinus,          "-"
+Op_UnaryNot,            "~"
+
+Op_Logical_Not,         "!"
+Op_Logical_And,         "&&"
+Op_Logical_Or,          "||"
+
+Op_Equal,               "=="
+Op_NotEqual,            "!="
+Op_Lesser,              "<"
+Op_Greater,             ">"
+Op_LesserEqual,         "<="
+Op_GreaterEqual",       ">=
+
+Op_Subscript,                "[]"
+Op_Indirection,              "*"
+Op_AddressOf,                "&"
+Op_MemberOfObject,           "."
+Op_MemberOfPointer",         "->"
+Op_PointerToMemberOfObject,  ".*"
+Op_PointerToMemberOfPointer, "->*"
+
+Op_Comma,                    ","
+Op_Ternary,                  "?"
+
+Preprocess_Hash,        "#"
+Preprocess_Define,      "define"
+Preprocess_If,          "if"
+Preprocess_IfDef,       "ifdef"
+Preprocess_IfNotDef,    "ifndef"
+Preprocess_ElIf,        "elif"
+Preprocess_Else,        "else"
+Preprocess_EndIf,       "endif"
+Preprocess_Include,     "include"
+Preprocess_Pragma,      "pragma"
+Preprocess_Content,	    "__macro_content__"
+Preprocess_Macro,       "__macro__"
+Preprocess_Generic,     "_Generic"
+Preprocess_Unsupported, "__unsupported__"
+
+Spec_Alignof,           "alignof"
+Spec_Const,             "const"
+Spec_Consteval,         "consteval"
+Spec_Constexpr,         "constexpr"
+Spec_Constinit,         "constinit"
+Spec_Explicit,          "explicit"
+Spec_Extern,            "extern"
+Spec_Final,             "final"
+Spec_ForceInline,	    "forceinline"
+Spec_Global,            "global"
+Spec_Inline,            "inline"
+Spec_Internal_Linkage,  "internal"
+Spec_LocalPersist,      "local_persist"
+Spec_Mutable,           "mutable"
+Spec_NeverInline,       "neverinline"
+Spec_Override,          "override"
+Spec_Static,            "static"
+Spec_ThreadLocal,       "thread_local"
+Spec_Volatile,          "volatile"
+Spec_Virtual,           "virtual"
+
+Star,                   "*"
+
+Stmt_Break,             "break"
+Stmt_Case,              "case"
+Stmt_Continue,          "continue"
+Stmt_Default,           "default"
+Stmt_Do,                "do"
+Stmt_Else,              "else"
+Stmt_End,               ";"
+Stmt_If,                "if"
+Stmt_For,               "for"
+Stmt_Goto,              "goto"
+Stmt_Return,            "return"
+Stmt_Switch,            "switch"
+Stmt_While,             "while"
+
+StaticAssert,           "static_assert"
+String,                 "__string__"
+
+Type_Auto,              "auto"
+Type_Unsigned,          "unsigned"
+Type_Signed,            "signed"
+Type_Short,             "short"
+Type_Long,              "long"
+Type_bool,              "bool"
+Type_char,              "char"
+Type_int,               "int"
+Type_float,             "float"
+Type_double,            "double"
+Type_MS_int8,           "__int8"
+Type_MS_int16,          "__int16"
+Type_MS_int32,          "__int32"
+Type_MS_int64,          "__int64"
+Type_MS_W64,            "_W64"
+
+Varadic_Argument,       "..."
+
+__Attributes_Start,     "__attrib_start__"

project/gen.editor.hpp

@@ -1,73 +0,0 @@
-#pragma once
-
-#include "gen.scanner.hpp"
-
-namespace gen {
-
-struct Policy
-{
-	// Nothing for now.
-};
-
-enum class SymbolType : u32
-{
-	Code,
-	Line,
-	Marker
-};
-
-struct Editor
-{
-	enum RequestType : u32
-	{
-		Add,
-		Replace,
-		Remove
-	};
-
-	struct SymbolData
-	{
-		Policy      Policy;
-		SymbolInfo  Info;
-	};
-
-	struct RequestEntry
-	{
-		union {
-			SymbolData Symbol;
-			String     Specification;
-		};
-		RequestType    Type;
-	};
-
-	struct Receipt
-	{
-		StringCached File;
-		Code         Found;
-		Code         Written;
-		bool         Result;
-	};
-
-	static AllocatorInfo Allocator;
-
-	static void set_allocator( AllocatorInfo  allocator );
-
-	Array<FileInfo>     Files;
-	String              Buffer;
-	Array<RequestEntry> Requests;
-
-	void add_files( s32 num, char const** files );
-
-	void add    ( SymbolInfo definition,  Policy policy, Code to_inject );
-	void remove ( SymbolInfo definition,  Policy policy );
-	void replace( SymbolInfo definition,  Policy policy, Code to_replace);
-
-#	ifdef GEN_FEATURE_EDITOR_REFACTOR
-	void refactor( char const* file_path, char const* specification_path );
-#	endif
-
-	bool process_requests( Array<Receipt> out_receipts );
-};
-
-// namespace gen
-};

project/gen.scanner.hpp

@@ -1,44 +0,0 @@
-#pragma once
-#include "gen.hpp"
-
-namespace gen {
-
-struct SymbolInfo
-{
-	StringCached File;
-	char const*  Marker;
-	Code         Signature;
-};
-
-
-struct Scanner
-{
-	struct RequestEntry
-	{
-		SymbolInfo Info;
-	};
-
-	struct Receipt
-	{
-		StringCached File;
-		Code         Defintion;
-		bool         Result;
-	};
-
-	AllocatorInfo MemAlloc;
-
-	static void set_allocator( AllocatorInfo allocator );
-
-	Array<FileInfo>     Files;
-	String              Buffer;
-	Array<RequestEntry> Requests;
-
-	void add_files( s32 num, char const** files );
-
-	void add( SymbolInfo signature, Policy policy );
-
-	bool process_requests( Array<Receipt> out_receipts );
-};
-
-// namespace gen
-}

project/helpers/helper.hpp

@@ -0,0 +1,568 @@
+#pragma once
+
+#include "gen.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.hpp"
+GEN_NS_END
+
+using namespace gen;
+
+CodeBody gen_ecode( char const* path )
+{
+	char  scratch_mem[kilobytes(1)];
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( allocator_info( & scratch), zero_terminate, path );
+
+	CSV_Object csv_nodes;
+	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
+
+	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
+
+	String enum_entries   = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
+
+	for ( ADT_Node& node : enum_strs )
+	{
+		char const* code = node.string;
+
+		append_fmt( & enum_entries, "%s,\n", code );
+		append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
+	}
+
+	CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", (StrC)enum_entries, "enum Type : u32 { <entries> NumTypes };"));
+
+#pragma push_macro("local_persist")
+#undef local_persist
+	CodeFn to_str = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+#pragma pop_macro("local_persist")
+
+	CodeNS    nspace = def_namespace( name(ECode), def_namespace_body( args( enum_code, to_str ) ) );
+	CodeUsing code_t = def_using( name(CodeT), def_type( name(ECode::Type) ) );
+
+	return def_global_body( args( nspace, code_t, fmt_newline ) );
+}
+
+CodeBody gen_eoperator( char const* path )
+{
+	char scratch_mem[kilobytes(4)];
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( allocator_info(& scratch), zero_terminate, path );
+
+	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 < num(enum_strs); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = str_strs [idx].string;
+
+		append_fmt( & enum_entries, "%s,\n", enum_str );
+		append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			NumOps
+		};
+	)));
+
+#pragma push_macro("local_persist")
+#undef local_persist
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		inline
+		StrC to_str( Type op )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ op ];
+		}
+	)));
+#pragma pop_macro("local_persist")
+
+	CodeNS nspace = def_namespace( name(EOperator), def_namespace_body( args( enum_code, to_str ) ) );
+
+	CodeUsing operator_t = def_using( name(OperatorT), def_type( name(EOperator::Type) ) );
+
+	return def_global_body( args( nspace, operator_t, fmt_newline ) );
+}
+
+CodeBody gen_especifier( char const* path )
+{
+	char scratch_mem[kilobytes(4)];
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( allocator_info(& scratch), zero_terminate, path );
+
+	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 < num(enum_strs); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = str_strs [idx].string;
+
+		append_fmt( & enum_entries, "%s,\n", enum_str );
+		append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			NumSpecifiers
+		};
+	)));
+
+	CodeFn is_trailing = parse_function(token_fmt("specifier", (StrC)to_str_entries, stringize(
+		inline
+		bool is_trailing( Type specifier )
+		{
+			return specifier > Virtual;
+		}
+	)));
+
+#pragma push_macro("local_persist")
+#pragma push_macro("do_once_start")
+#pragma push_macro("do_once_end")
+#pragma push_macro("forceinline")
+#pragma push_macro("neverinline")
+#undef local_persist
+#undef do_once_start
+#undef do_once_end
+#undef forceinline
+#undef neverinline
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		inline
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+
+	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
+		Type to_type( StrC str )
+		{
+			local_persist
+			u32 keymap[ NumSpecifiers ];
+			do_once_start
+				for ( u32 index = 0; index < NumSpecifiers; index++ )
+				{
+					StrC enum_str = to_str( (Type)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);
+				}
+			do_once_end
+
+			u32 hash = crc32( str.Ptr, str.Len );
+
+			for ( u32 index = 0; index < NumSpecifiers; index++ )
+			{
+				if ( keymap[index] == hash )
+					return (Type)index;
+			}
+
+			return Invalid;
+		}
+	)));
+#pragma pop_macro("local_persist")
+#pragma pop_macro("do_once_start")
+#pragma pop_macro("do_once_end")
+#pragma pop_macro("forceinline")
+#pragma pop_macro("neverinline")
+
+	CodeNS nspace = def_namespace( name(ESpecifier), def_namespace_body( args( enum_code, is_trailing, to_str, to_type ) ) );
+
+	CodeUsing specifier_t = def_using( name(SpecifierT), def_type( name(ESpecifier::Type) ) );
+
+	return def_global_body( args( nspace, specifier_t, fmt_newline ) );
+}
+
+CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
+{
+	char  scratch_mem[kilobytes(16)];
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	AllocatorInfo scratch_info = allocator_info(& scratch);
+
+	FileContents enum_content = file_read_contents( scratch_info, zero_terminate, etok_path );
+
+	CSV_Object csv_enum_nodes;
+	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), GlobalAllocator, false );
+
+	FileContents attrib_content = file_read_contents( scratch_info, zero_terminate, attr_path );
+
+	CSV_Object csv_attr_nodes;
+	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), GlobalAllocator, 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;
+
+	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) );
+
+	for (usize idx = 0; idx < num(enum_strs); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = enum_str_strs [idx].string;
+
+		append_fmt( & enum_entries, "%s,\n", enum_str );
+		append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	for ( usize idx = 0; idx < num(attribute_strs); idx++ )
+	{
+		char const* attribute_str = attribute_strs[idx].string;
+		char const* entry_to_str  = attribute_str_strs [idx].string;
+
+		append_fmt( & attribute_entries, "Attribute_%s,\n", attribute_str );
+		append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		append_fmt( & attribute_define_entries, "Entry( Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
+
+		if ( idx < num(attribute_strs) - 1 )
+			append( & attribute_define_entries, " \\\n");
+		else
+			append( & attribute_define_entries, "\n");
+	}
+
+#pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
+#undef GEN_DEFINE_ATTRIBUTE_TOKENS
+	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), attribute_define_entries  );
+#pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
+
+	// We cannot parse this enum, it has Attribute names as enums
+	CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, "attribute_toks", (StrC)attribute_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			<attribute_toks>
+			NumTokens
+		};
+	)));
+
+#pragma push_macro("local_persist")
+#pragma push_macro("do_once_start")
+#pragma push_macro("do_once_end")
+#undef local_persist
+#undef do_once_start
+#undef do_once_end
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, "attribute_toks", (StrC)to_str_attributes, stringize(
+		inline
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+				<attribute_toks>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+
+	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
+		Type to_type( StrC str )
+		{
+			local_persist
+			u32 keymap[ NumTokens ];
+			do_once_start
+				for ( u32 index = 0; index < NumTokens; index++ )
+				{
+					StrC enum_str = to_str( (Type)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);
+				}
+			do_once_end
+
+			u32 hash = crc32( str.Ptr, str.Len );
+
+			for ( u32 index = 0; index < NumTokens; index++ )
+			{
+				if ( keymap[index] == hash )
+					return (Type)index;
+			}
+
+			return Invalid;
+		}
+	)));
+#pragma pop_macro("local_persist")
+#pragma pop_macro("do_once_start")
+#pragma pop_macro("do_once_end")
+
+	CodeNS    nspace     = def_namespace( name(ETokType), def_namespace_body( args( attribute_entires_def, enum_code, to_str, to_type ) ) );
+	CodeUsing td_toktype = def_using( name(TokType), def_type( name(ETokType::Type) ) );
+
+	return def_global_body( args( nspace, td_toktype ) );
+}
+
+CodeBody gen_ast_inlines()
+{
+#pragma push_macro("GEN_NS")
+#pragma push_macro("rcast")
+#pragma push_macro("log_failure")
+#pragma push_macro("CodeInvalid")
+#undef GEN_NS
+#undef rcast
+#undef log_failure
+#undef CodeInvalid
+	char const* code_impl_tmpl = stringize(
+		\n
+		inline
+		<typename>& <typename>::operator =( Code other )
+		{
+			if ( other.ast && other->Parent )
+			{
+				ast = rcast( decltype(ast), GEN_NS duplicate(other.ast) );
+				rcast( AST*, ast)->Parent = nullptr;
+			}
+
+			ast = rcast( decltype(ast), other.ast );
+			return *this;
+		}
+		inline
+		<typename>::operator bool()
+		{
+			return ast != nullptr;
+		}
+	);
+
+	char const* codetype_impl_tmpl = stringize(
+		inline
+		AST* Code<typename>::raw()
+		{
+			return rcast( AST*, ast );
+		}
+		inline
+		Code<typename>::operator Code()
+		{
+			return *rcast( Code*, this );
+		}
+		inline
+		AST_<typename>* Code<typename>::operator->()
+		{
+			if ( ast == nullptr )
+			{
+				log_failure( "Attempt to dereference a nullptr!" );
+				return nullptr;
+			}
+			return ast;
+		}
+		\n
+	);
+#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(CodeType),           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 ));
+
+	append(impl_code_attr,     parse_global_body( token_fmt( "typename", StrC name(Attributes),     codetype_impl_tmpl )));
+	append(impl_code_cmt,      parse_global_body( token_fmt( "typename", StrC name(Comment),        codetype_impl_tmpl )));
+	append(impl_code_constr,   parse_global_body( token_fmt( "typename", StrC name(Constructor),    codetype_impl_tmpl )));
+	append(impl_code_define,   parse_global_body( token_fmt( "typename", StrC name(Define),         codetype_impl_tmpl )));
+	append(impl_code_destruct, parse_global_body( token_fmt( "typename", StrC name(Destructor),     codetype_impl_tmpl )));
+	append(impl_code_enum,     parse_global_body( token_fmt( "typename", StrC name(Enum),           codetype_impl_tmpl )));
+	append(impl_code_exec,     parse_global_body( token_fmt( "typename", StrC name(Exec),           codetype_impl_tmpl )));
+	append(impl_code_extern,   parse_global_body( token_fmt( "typename", StrC name(Extern),         codetype_impl_tmpl )));
+	append(impl_code_include,  parse_global_body( token_fmt( "typename", StrC name(Include),        codetype_impl_tmpl )));
+	append(impl_code_friend,   parse_global_body( token_fmt( "typename", StrC name(Friend),         codetype_impl_tmpl )));
+	append(impl_code_fn,       parse_global_body( token_fmt( "typename", StrC name(Fn),             codetype_impl_tmpl )));
+	append(impl_code_module,   parse_global_body( token_fmt( "typename", StrC name(Module),         codetype_impl_tmpl )));
+	append(impl_code_ns,       parse_global_body( token_fmt( "typename", StrC name(NS),             codetype_impl_tmpl )));
+	append(impl_code_op,       parse_global_body( token_fmt( "typename", StrC name(Operator),       codetype_impl_tmpl )));
+	append(impl_code_opcast,   parse_global_body( token_fmt( "typename", StrC name(OpCast),         codetype_impl_tmpl )));
+	append(impl_code_pragma,   parse_global_body( token_fmt( "typename", StrC name(Pragma),         codetype_impl_tmpl )));
+	append(impl_code_precond,  parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), codetype_impl_tmpl )));
+	append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", StrC name(Template),       codetype_impl_tmpl )));
+	append(impl_code_type,     parse_global_body( token_fmt( "typename", StrC name(Type),           codetype_impl_tmpl )));
+	append(impl_code_typedef,  parse_global_body( token_fmt( "typename", StrC name(Typedef),        codetype_impl_tmpl )));
+	append(impl_code_union,    parse_global_body( token_fmt( "typename", StrC name(Union),          codetype_impl_tmpl )));
+	append(impl_code_using,    parse_global_body( token_fmt( "typename", StrC name(Using),          codetype_impl_tmpl )));
+	append(impl_code_var,      parse_global_body( token_fmt( "typename", StrC name(Var),            codetype_impl_tmpl )));
+
+	char const* cast_tmpl = stringize(
+		inline	AST::operator Code<typename>()
+		{
+			return { rcast( AST_<typename>*, this ) };
+		}
+		inline Code::operator Code<typename>() const
+		{
+			return { (AST_<typename>*) ast };
+		}
+	);
+
+	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(Type),           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 result = def_global_body( args(
+		def_pragma( txt("region generated code inline implementation")),
+		fmt_newline,
+		impl_code,
+		impl_code_body,
+		impl_code_attr,
+		impl_code_cmt,
+		impl_code_constr,
+		impl_code_class,
+		impl_code_define,
+		impl_code_destruct,
+		impl_code_enum,
+		impl_code_exec,
+		impl_code_extern,
+		impl_code_friend,
+		impl_code_fn,
+		impl_code_include,
+		impl_code_module,
+		impl_code_ns,
+		impl_code_op,
+		impl_code_opcast,
+		impl_code_param,
+		impl_code_pragma,
+		impl_code_precond,
+		impl_code_specs,
+		impl_code_struct,
+		impl_code_tmpl,
+		impl_code_type,
+		impl_code_typedef,
+		impl_code_union,
+		impl_code_using,
+		impl_code_var,
+		fmt_newline,
+		def_pragma( txt("endregion generated code inline implementation")),
+		fmt_newline,
+		def_pragma( txt("region generated AST/Code cast implementation")),
+		fmt_newline,
+		impl_cast_body,
+		impl_cast_attribute,
+		impl_cast_cmt,
+		impl_cast_constr,
+		impl_cast_class,
+		impl_cast_define,
+		impl_cast_destruct,
+		impl_cast_enum,
+		impl_cast_exec,
+		impl_cast_extern,
+		impl_cast_friend,
+		impl_cast_fn,
+		impl_cast_include,
+		impl_cast_module,
+		impl_cast_ns,
+		impl_cast_op,
+		impl_cast_opcast,
+		impl_cast_param,
+		impl_cast_pragma,
+		impl_cast_precond,
+		impl_cast_specs,
+		impl_cast_struct,
+		impl_cast_tmpl,
+		impl_cast_type,
+		impl_cast_typedef,
+		impl_cast_union,
+		impl_cast_using,
+		impl_cast_var,
+		fmt_newline,
+		def_pragma( txt("endregion generated AST/Code cast implementation")),
+		fmt_newline
+	));
+
+	return result;
+#pragma pop_macro("rcast")
+#pragma pop_macro("log_failure")
+}

project/helpers/member_proc_support.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "gen.hpp"
+
+GEN_NS_BEGIN
+#include "dependencies/parsing.hpp"
+GEN_NS_END
+
+using namespace gen;
+