bug fix

Now the lexer and parser need to be elimination...

.gitignore

@@ -16,25 +16,19 @@
 gencpp.hpp
 gencpp.cpp
 
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-vc140.pdb
+**/*.lib
+**/*.pdb
+**/*.exe
+**/*.dll
 
+release/**
 
 # Unreal
 **/Unreal/*.h
 **/Unreal/*.cpp
 ! **/Unreal/validate.unreal.cpp
+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

@@ -12,7 +12,8 @@
                 "GEN_TIME",
                 "GEN_IMPLEMENTATION",
                 // "GEN_DONT_USE_NAMESPACE"
-                "GEN_INTELLISENSE_DIRECTIVES"
+                "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",
@@ -31,7 +32,8 @@
                 "GEN_TIME",
                 "GEN_IMPLEMENTATION",
                 // "GEN_DONT_USE_NAMESPACE"
-                "GEN_INTELLISENSE_DIRECTIVES"
+                "GEN_INTELLISENSE_DIRECTIVES",
+                "INTELLISENSE_DIRECTIVES"
             ],
             "windowsSdkVersion": "10.0.19041.0",
             "compilerPath": "C:/Users/Ed/scoop/apps/llvm/current/bin/clang++.exe",

.vscode/launch.json

@@ -40,6 +40,33 @@
 			"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

@@ -28,7 +28,19 @@
 		"functional": "cpp",
 		"vector": "cpp",
 		"list": "cpp",
-		"xhash": "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,
@@ -40,5 +52,7 @@
 		"**/.vscode": true,
 		"**/.vs": true,
 		"**/sanity.gen.hpp": true
-	}
+	},
+	"autoHide.autoHidePanel": false,
+	"autoHide.autoHideSideBar": false
 }

Readme.md

@@ -10,6 +10,10 @@ Its not meant to be a black box metaprogramming utility, it should be easy to in
 
 ## Notes
 
+**On Partial Hiatus: Life has got me tackling other issues..**  
+I will be passively updating the library with bug fixes and minor improvements as I use it for my personal projects.  
+There won't be any major reworks or features to this thing for a while.
+
 This project is still in development (very much an alpha state), so expect bugs and missing features.  
 See [issues](https://github.com/Ed94/gencpp/issues) for a list of known bugs or todos.
 
@@ -63,7 +67,7 @@ Example using each construction interface:
 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 ) ));
 
@@ -86,8 +90,8 @@ Validation through ast construction.
 Code header = parse_struct( code(
     struct ArrayHeader
     {
-        uw        Num;
-        uw        Capacity;
+        usize        Num;
+        usize        Capacity;
         allocator Allocator;
     };
 ));
@@ -102,8 +106,8 @@ No validation, just glorified text injection.
 Code header = code_str(
     struct ArrayHeader
     {
-        uw        Num;
-        uw        Capacity;
+        usize        Num;
+        usize        Capacity;
         allocator Allocator;
     };
 );
@@ -119,8 +123,8 @@ All three constrcuton interfaces will generate the following C code:
 ```cpp
 struct ArrayHeader
 {
-    uw        Num;
-    uw        Capacity;
+    usize        Num;
+    usize        Capacity;
     allocator Allocator;
 };
 ```

docs/AST_Design.md

@@ -1,11 +1,3 @@
-# Forward
-
-Was never satisfied with how I did the wrap of the management of the AST.  
-For C++, the current design may be as good as it gets for the limitations of the langauge.
-
-I'll at least try in this issue to brainstorm something simpiler without losing ergonomics.  
-This will also be a good place to document the current design.
-
 ## Current Design
 
 `AST` is the actual managed node object for the library.  
@@ -22,10 +14,8 @@ The simpliest being just a type alias.
 using Code = AST*;
 ```
 
-This is what the genc library would have to use due to its constraints of a langauge.
-Anything else and it would either be an unergonomic mess of struct wrapping with a mess of macros & procedures to interface with it.
-
-Further, to provide intuitive filters on the AST, there are AST types (covered in [AST_Types.md](AST_Types.md)).
+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.
@@ -35,3 +25,20 @@ 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

@@ -19,12 +19,13 @@ These are containers representing a scope body of a definition that can be of th
 Fields:
 
 ```cpp
-Code         Front;
-Code         Back;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-s32          NumEntries;
+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.
@@ -48,12 +49,13 @@ Represent standard or vendor specific C/C++ attributes.
 Fields:
 
 ```cpp
-StringCached  Content;
-Code          Prev;
-Code          Next;
-Code          Parent;
-StringCached  Name;
-CodeT         Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -71,12 +73,13 @@ Stores a comment.
 Fields:
 
 ```cpp
-StringCached  Content;
-Code          Prev;
-Code          Next;
-Code          Parent;
-StringCached  Name;
-CodeT         Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -101,6 +104,7 @@ 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;
@@ -128,14 +132,16 @@ You'll notice that only one parent type is supported only with parent access. Th
 Fields:
 
 ```cpp
-CodeComment InlineCmt;  // Only supported by forward declarations
-Code        InitializerList;
-CodeParam   Params;
-Code        Body;
-Code        Prev;
-Code        Next;
-Code        Parent;
-CodeT       Type;
+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:
@@ -150,6 +156,12 @@ Serialization:
 {
     <Body>
 }
+
+// Constructor Source Implementation
+<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
+{
+    <Body>
+}
 ```
 
 ## Define
@@ -159,12 +171,13 @@ Represents a preprocessor define
 Fields:
 
 ```cpp
-StringCached  Content;
-Code          Prev;
-Code          Next;
-Code          Parent;
-StringCached  Name;
-CodeT         Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -183,7 +196,9 @@ CodeSpecifiers Specs;
 Code           Body;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
+StringCached   Name;
 CodeT          Type;
 ```
 
@@ -198,6 +213,12 @@ Serialization:
 {
     <Body>
 }
+
+// Destructor Source Implementation
+<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
+{
+    <Body>
+}
 ```
 
 ## Enum
@@ -211,6 +232,7 @@ CodeType       UnderlyingType;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -238,12 +260,13 @@ Will be obsolute when function body parsing is implemented.
 Fields:
 
 ```cpp
-StringCached Content;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -257,12 +280,13 @@ Serialization:
 Fields:
 
 ```cpp
-CodeBody     Body;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -279,12 +303,13 @@ extern "<Name>"
 Fields:
 
 ```cpp
-StringCached Content;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+Code           Parent;
+parser::Token* Tok;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -300,13 +325,14 @@ This library (until its necessary become some third-party library to do otherwis
 Fields:
 
 ```cpp
-CodeComment  InlineCmt;
-Code         Declaration;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+CodeComment    InlineCmt;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -327,8 +353,9 @@ CodeType       ReturnType;
 CodeParam      Params;
 CodeBody       Body;
 Code           Prev;
-Code           Parent;
 Code           Next;
+parser::Token* Tok;
+Code           Parent;
 StringCached   Name;
 CodeT          Type;
 ModuleFlag     ModuleFlags;
@@ -352,12 +379,13 @@ Serialization:
 Fields:
 
 ```cpp
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-ModuleFlag   ModuleFlags;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -371,13 +399,14 @@ Serialization:
 Fields:
 
 ```cpp
-CodeBody     Body;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-ModuleFlag   ModuleFlags;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -402,6 +431,7 @@ CodeParam      Params;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -433,6 +463,7 @@ CodeType       ValueType;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -451,25 +482,29 @@ Serialization:
 }
 ```
 
-## Parameters
+## Parameters (AST_Param)
 
 Fields:
 
 ```cpp
-CodeType     ValueType;
-Code         Value;
-CodeParam    Last;
-CodeParam    Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-s32          NumEntries;
+CodeType       ValueType;
+Code           Macro;
+Code           Value;
+CodeParam      Last;
+CodeParam      Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
 ```
 
 Serialization:
 
 ```cpp
-<ValueType> <Name>, <Next>... <Last>
+<Macro>, <Next> ... <Last>
+
+<Macro> <ValueType> <Name>, <Next>... <Last>
 ```
 
 ## Pragma
@@ -477,12 +512,13 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached Content;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -496,12 +532,13 @@ Serialization:
 Fields:
 
 ```cpp
-StringCached Content;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
+StringCached  Content;
+Code          Prev;
+Code          Next;
+paser::Token* Tok;
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
 ```
 
 Serialization:
@@ -515,13 +552,15 @@ Serialization:
 Fields:
 
 ```cpp
-SpecifierT        ArrSpecs[ AST::ArrSpecs_Cap ];
-Code              Prev;
-Code              Next;
-Code              Parent;
-StringCached      Name;
-CodeT             Type;
-s32               NumEntries;
+SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
+CodeSpecifiers NextSpecs;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
 ```
 
 Serialization:
@@ -535,14 +574,15 @@ Serialization:
 Fields:
 
 ```cpp
-CodeParam    Params;
-Code         Declaration;
-Code         Prev;
-Code         Next;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-ModuleFlag   ModuleFlags;
+CodeParam      Params;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -567,6 +607,7 @@ CodeParam      Params;
 Code           ArrExpr;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -582,20 +623,21 @@ Serialization:
 ## Typedef
 
 Behave as usual except function or macro typedefs.  
-Those don't use the underlying type field as everything was serialized under the Name field.
+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;
-Code         Parent;
-StringCached Name;
-CodeT        Type;
-ModuleFlag   ModuleFlags;
-b32          IsFunction;
+CodeComment   InlineCmt;
+Code          UnderlyingType;
+Code          Prev;
+Code          Next;
+parse::Token* Tok
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
+ModuleFlag    ModuleFlags;
+b32           IsFunction;
 ```
 
 Serialization:
@@ -605,7 +647,8 @@ Serialization:
 <ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>
 
 // Functions
-<ModuleFlags> typedef <Name>; <InlineCmt>
+<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
+<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
 ```
 
 ## Union
@@ -617,6 +660,7 @@ CodeAttributes Attributes;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -642,6 +686,7 @@ CodeAttributes Attributes;
 CodeType       UnderlyingType;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -660,6 +705,8 @@ Serialization:
 
 ## Variable
 
+[Algo](./Parser_Algo.md:)
+
 Fields:
 
 ```cpp
@@ -669,8 +716,10 @@ CodeSpecifiers Specs;
 CodeType       ValueType;
 Code           BitfieldSize;
 Code           Value;
+CodeVar        NextVar;
 Code           Prev;
 Code           Next;
+parser::Token* Tok;
 Code           Parent;
 StringCached   Name;
 CodeT          Type;
@@ -681,8 +730,8 @@ Serialization:
 
 ```cpp
 // Regular
-<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> = <Value>; <InlineCmt>
+<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> = <Value>, NextVar ...; <InlineCmt>
 
 // Bitfield
-<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>; <InlineCmt>
+<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
 ```

docs/Parser_Algo.md

@@ -1,40 +1,51 @@
 # Parser's Algorithim
 
-gencpp uses a hand-written recursive descent parser. Both the lexer and parser handle a full C/C++ file in a single pass.
+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`.
+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`:
+Tokens are defined with the struct `gen::parser::Token`:
 
 Fields:
+
 ```cpp
 char const* Text;
 sptr        Length;
 TokType     Type;
 s32         Line;
 s32         Column;
-bool 	    IsAssign;
+u32         Flags;
 ```
 
-`IsAssign` is a flag that is set when the token is an assignment operator. Which is used for various purposes:
+Flags is a bitfield made up of TokFlags (Token Flags):
 
-* Using statment assignment
-* Parameter argument default value assignment
-* Variable declaration initialization assignment
+* `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`.
 
@@ -53,12 +64,12 @@ Traversing the tokens is done with the following interface macros:
 
 ### 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. 
+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
-CodeStruct parse_<definition type>( StrC def )
+<code type> parse_<definition type>( StrC def )
 {
     check_parse_args( def );
     using namespace Parser;
@@ -76,14 +87,616 @@ The most top-level parsing procedure used for C/C++ file parsing is `parse_globa
 
 It uses a helper procedure called `parse_global_nspace`.
 
-Each internal procedure will be 
+Each internal procedure will have the following format:
 
-## parse_global_nspace
+```cpp
+internal
+<code type> parse_<definition_type>( <empty or contextual params> )
+{
+    push_scope();
 
-1. Make sure the type provided to the helper function is a `Namespace_Body`, `Global_Body`, `Export_Body`, `Extern_Linkage_body`.
-2. If its not a `Global_Body` eat the opening brace for the scope.
-3. 
+    ...
+
+    <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_type
+## `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

@@ -2,7 +2,7 @@
 
 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 5500 loc. I hope to keep it under 10k loc worst case.
+This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~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.
 
@@ -73,7 +73,7 @@ The lexing and parsing takes shortcuts from whats expected in the standard.
 * 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
+  * 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)

docs/Readme.md

@@ -25,6 +25,8 @@ This library was written in a subset of C++ where the following are not used at
 * 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:
@@ -65,7 +67,7 @@ As mentioned in root readme, the user is provided Code objects by calling the co
 The AST is managed by the library and provided to the user via its interface.  
 However, the user may specifiy memory configuration.
 
-Data layout of AST struct:
+Data layout of AST struct (Subject to heavily change with upcoming redesign):
 
 ```cpp
 union {
@@ -82,6 +84,7 @@ union {
             AST*  ValueType;       // Parameter, Variable
         };
         union {
+            AST*  Macro;           // Parameters
             AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
             AST*  Params;          // Constructor, Function, Operator, Template, Typename
         };
@@ -98,7 +101,7 @@ union {
     };
     StringCached  Content;          // Attributes, Comment, Execution, Include
     struct {
-        SpecifierT ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
+        SpecifierT ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
         AST*       NextSpecs;                   // Specifiers
     };
 };
@@ -135,7 +138,7 @@ The width dictates how much the static array can hold before it must give way to
 
 ```cpp
 constexpr static
-uw ArrSpecs_Cap =
+usize ArrSpecs_Cap =
 (
     AST_POD_Size
     - sizeof(AST*) * 3
@@ -157,7 +160,7 @@ Data Notes:
   * Most of the work is just defining the allocation procedure:
 
 ```cpp
-    void* ( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+    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.
@@ -461,6 +464,7 @@ The AST and constructors will be able to validate that the arguments provided fo
 * 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.

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(CT_Global_Body);
+		for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case CT_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 CT_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 CT_Function:
+				{
+					CodeFn fn = cast(CodeFn, entry);
+					s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
+					if (constexpr_found > -1) {
+						log_fmt("Found constexpr: %S\n", entry.to_string());
+						fn->Specs.append(Spec_Inline);
+					}
+					if ( fn->Name.is_equal(txt("free")) )
+					{
+						fn->Name = get_cached_string(txt("gen_free_ptr"));
+					}
+					memory.append(entry);
+				}
+				break;
+				case CT_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 CT_Class:
+				case CT_Struct:
+				{
+					CodeBody body     = cast(CodeBody, entry->Body);
+					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 CT_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 = new_body;
+					memory.append(entry);
+				}
+				break;
+				case CT_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 CT_Preprocess_IfDef:
+				{
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
+					if (found) break;
+
+					memory.append(entry);
+				}
+				break;
+				case CT_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(CT_Global_Body);
+		for ( Code entry = printing_parsed.begin(); entry != printing_parsed.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case CT_Preprocess_IfDef:
+				{
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
+					if (found) break;
+
+					printing.append(entry);
+				}
+				break;
+				case CT_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(CT_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(CT_Global_Body);
+		for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case CT_Preprocess_If:
+				{
+					ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings);
+				}
+				break;
+
+				case CT_Preprocess_IfDef:
+				{
+					ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_strings );
+				}
+				break;
+
+				case CT_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 CT_Struct:
+				{
+					CodeBody body     = cast(CodeBody, entry->Body);
+					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 CT_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 = new_body;
+					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(CT_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 CT_Preprocess_If:
+			case CT_Preprocess_IfDef:
+			case CT_Preprocess_IfNotDef:
+				depth ++;
+			break;
+
+			case CT_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 CT_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

@@ -1,4 +1,4 @@
 # Singleheader
 
-Creates a single header file version of the library using `gen.singleheader.cpp`.
+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

@@ -12,12 +12,3 @@
 #if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
 #	error Gen.hpp : GEN_TIME not defined
 #endif
-
-#ifdef GEN_DONT_USE_NAMESPACE
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
-#else
-#	define GEN_NS_BEGIN namespace gen {
-#	define GEN_NS_END   }
-#endif
-

gen_singleheader/singleheader.cpp

@@ -1,6 +1,8 @@
 #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"
@@ -14,6 +16,8 @@ GEN_NS_END
 #include "auxillary/builder.cpp"
 #include "auxillary/scanner.hpp"
 
+#include <cstdlib>   // for system()
+
 using namespace gen;
 
 constexpr char const* generation_notice =
@@ -35,7 +39,6 @@ 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"(
@@ -48,6 +51,42 @@ 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/"
@@ -69,7 +108,7 @@ int gen_main()
 
 		if ( generate_gen_dep )
 		{
-			Code header_start = scan_file( project_dir "dependencies/header_start.hpp" );
+			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" );
@@ -83,7 +122,7 @@ int gen_main()
 			Code timing       = scan_file( project_dir "dependencies/timing.hpp" );
 
 			header.print_fmt( roll_own_dependencies_guard_start );
-			header.print( header_start );
+			header.print( platform );
 			header.print_fmt( "\nGEN_NS_BEGIN\n" );
 
 			header.print( macros );
@@ -113,6 +152,7 @@ int gen_main()
 		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" );
@@ -126,13 +166,18 @@ int gen_main()
 
 		header.print_fmt("#pragma region Types\n");
 		header.print( types );
-		header.print( ecode );
-		header.print( eoperator );
-		header.print( especifier );
+		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");
 
@@ -140,7 +185,8 @@ int gen_main()
 
 		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
-		header.print( ast_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 );
@@ -187,7 +233,7 @@ int gen_main()
 			if ( generate_scanner )
 			{
 				header.print_fmt( "\n#pragma region Parsing\n" );
-			header.print( scan_file( project_dir "dependencies/parsing.cpp" ) );
+				header.print( scan_file( project_dir "dependencies/parsing.cpp" ) );
 				header.print_fmt( "#pragma endregion Parsing\n\n" );
 			}
 
@@ -195,16 +241,19 @@ int gen_main()
 			header.print_fmt( roll_own_dependencies_guard_end );
 		}
 
-		Code static_data 	 = scan_file( project_dir "components/static_data.cpp" );
-		Code ast_case_macros = scan_file( project_dir "components/ast_case_macros.cpp" );
-		Code ast             = scan_file( project_dir "components/ast.cpp" );
-		Code interface       = scan_file( project_dir "components/interface.cpp" );
-		Code upfront         = scan_file( project_dir "components/interface.upfront.cpp" );
-		Code parsing         = scan_file( project_dir "components/interface.parsing.cpp" );
-		Code untyped         = scan_file( project_dir "components/interface.untyped.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              = 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)) );
+		CodeNS   parser_nspace = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
 
 		header.print_fmt( "\nGEN_NS_BEGIN\n");
 		header.print( static_data );
@@ -212,14 +261,17 @@ int gen_main()
 		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( parser_nspace );
-		header.print( parsing );
+		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");

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

@@ -6,20 +6,22 @@
 		<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>psh ./scripts/clean.ps1</CleanCommand>
+		<CleanCommand>pwsh ./scripts/clean.ps1</CleanCommand>
 		<BuildWorkingDirectory></BuildWorkingDirectory>
 		<CancelBuild></CancelBuild>
-		<RunCommand>./test/gen/build/gencpp.exe</RunCommand>
-		<RunCommandWorkingDirectory></RunCommandWorkingDirectory>
+		<Exe>./test/gen/build/gencpp.exe</Exe>
+		<Args></Args>
+		<WorkingDirectory></WorkingDirectory>
 		<DebugCommand>pwsh ./scripts/build.ps1</DebugCommand>
-		<ExePathCommand>./test/gen/build/gencpp.exe</ExePathCommand>
 		<DebugSln></DebugSln>
 		<UseVisualStudioEnvBat>true</UseVisualStudioEnvBat>
+		<CaptureExeOutput>false</CaptureExeOutput>
 		<Configurations>
 			<Configuration>Debug</Configuration>
 			<Configuration>Release</Configuration>
@@ -43,6 +45,9 @@
 			<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>

gencpp.vcxproj

@@ -262,6 +262,7 @@
     <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" />
@@ -313,11 +314,14 @@
     <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" />
@@ -330,6 +334,7 @@
     <ClCompile Include="project\dependencies\strings.cpp" />
     <ClCompile Include="project\dependencies\string_ops.cpp" />
     <ClCompile Include="project\dependencies\timing.cpp" />
+    <ClCompile Include="project\Example.cpp" />
     <ClCompile Include="project\gen.cpp" />
     <ClCompile Include="project\gen.dep.cpp" />
     <ClCompile Include="singleheader\singleheader.cpp" />
@@ -361,6 +366,9 @@
     <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

@@ -42,9 +42,6 @@
     <ClCompile Include="test\test.parsing.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\components\temp\etoktype.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="project\components\ast.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -66,9 +63,6 @@
     <ClCompile Include="project\components\static_data.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\components\untyped.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="project\bootstrap.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -132,6 +126,18 @@
     <ClCompile Include="project\components\gen\etoktype.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="project\Example.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\parser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\lexer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\code_serialization.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="project\gen.hpp">
@@ -182,18 +188,6 @@
     <ClInclude Include="test\upfront.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\components\temp\ast_inlines.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\temp\ecode.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\temp\eoperator.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\components\temp\especifier.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="project\components\ast.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -293,6 +287,9 @@
     <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" />
@@ -305,7 +302,6 @@
     <None Include="test\Readme.md" />
     <None Include="scripts\genccp.natstepfilter" />
     <None Include="scripts\gencpp.refactor" />
-    <None Include="project\components\temp\Readme.md" />
     <None Include="project\enums\AttributeTokens.csv" />
     <None Include="project\enums\ECode.csv" />
     <None Include="project\enums\EOperator.csv" />

project/Readme.md

@@ -10,8 +10,7 @@ Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<depe
 
 Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
 
-**TODO : Right now the library is not finished, as such the first self-hosting iteration is still WIP**  
-Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.  
+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.  
@@ -31,6 +30,13 @@ Feature Macros:
 * `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.
 
+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:
+
+* `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: 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)*
+
 ## On multi-threading
 
 Currently unsupported. I want the library to be *stable* and *correct*, with the addition of exhausting all basic single-threaded optimizations before I consider multi-threading.
@@ -52,7 +58,7 @@ Names or Content fields are interned strings and thus showed be cached using `ge
 
 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.
 
-The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.  
+The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.
 
 ## A note on compilation and runtime generation speed
 

project/auxillary/builder.cpp

@@ -7,14 +7,13 @@ 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 );
+	result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
 
 	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
 	return result;
@@ -22,20 +21,20 @@ Builder Builder::open( char const* path )
 
 void Builder::pad_lines( s32 num )
 {
-	Buffer.append( "\n" );
+	append( & Buffer,  "\n" );
 }
 
 void Builder::print( Code code )
 {
-	String   str = code->to_string();
-	// const sw len = str.length();
+	String   str = to_string(code);
+	// const ssize len = str.length();
 	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
-	Buffer.append( str );
+	append( & Buffer, str );
 }
 
 void Builder::print_fmt( char const* fmt, ... )
 {
-	sw   res;
+	ssize   res;
 	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
 
 	va_list va;
@@ -44,17 +43,17 @@ void Builder::print_fmt( char const* fmt, ... )
 	va_end( va );
 
 	// log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf );
-	Buffer.append( buf, res );
+	append( (String*) & Buffer, (char const*)buf, res );
 }
 
 void Builder::write()
 {
-	bool result = file_write( & File, Buffer, Buffer.length() );
+	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 );
-	Buffer.free();
+	free(& Buffer);
 }

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

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

project/auxillary/scanner.hpp

@@ -6,6 +6,7 @@
 // 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;
@@ -16,15 +17,15 @@ Code scan_file( char const* path )
 		GEN_FATAL( "scan_file: Could not open: %s", path );
 	}
 
-	sw fsize = file_size( & file );
+	ssize fsize = file_size( & file );
 	if ( fsize <= 0 )
 	{
 		GEN_FATAL("scan_file: %s is empty", path );
 	}
 
-	String str = String::make_reserve( GlobalAllocator, fsize );
+	String str = string_make_reserve( GlobalAllocator, fsize );
 		file_read( & file, str, fsize );
-		str.get_header().Length = 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.
@@ -38,7 +39,7 @@ Code scan_file( char const* path )
 		const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
 
 		bool        found_directive = false;
-		char const* scanner         = str.Data;
+		char const* scanner         = (char const*)str;
 		s32         left            = fsize;
 		while ( left )
 		{
@@ -93,19 +94,18 @@ Code scan_file( char const* path )
 						move_fwd();
 
 					// sptr skip_size = fsize - left;
-					if ( (scanner + 2) >= ( str.Data + fsize ) )
+					if ( (scanner + 2) >= ( (char const*) str + fsize ) )
 					{
 						mem_move( str, scanner, left );
-						str.get_header().Length = left;
+						get_header(str)->Length = left;
 						break;
 					}
 
 					mem_move( str, scanner, left );
-					str.get_header().Length = left;
+					get_header(str)->Length = left;
 
 					break;
 				}
-
 			}
 
 			move_fwd();
@@ -116,7 +116,7 @@ Code scan_file( char const* path )
 	}
 
 	file_close( & file );
-	return untyped_str( str );
+	return untyped_str( to_strc(str) );
 }
 
 #if 0

project/bootstrap.cpp

@@ -1,6 +1,8 @@
 #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"
@@ -20,16 +22,56 @@ 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 header_start = scan_file( "dependencies/header_start.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" );
@@ -45,8 +87,8 @@ int gen_main()
 		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\n" );
-		header.print( header_start );
+		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 );
@@ -80,7 +122,7 @@ int gen_main()
 		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\n" );
+		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" );
 
@@ -112,6 +154,7 @@ int gen_main()
 		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" );
@@ -131,13 +174,18 @@ int gen_main()
 
 		header.print_fmt( "#pragma region Types\n" );
 		header.print( types );
-		header.print( ecode );
-		header.print( eoperator );
-		header.print( especifier );
+		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" );
 
@@ -146,7 +194,8 @@ int gen_main()
 		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
 		header.print( fmt_newline );
-		header.print( ast_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 );
@@ -181,38 +230,49 @@ int gen_main()
 
 	// 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        interface	    = scan_file( "components/interface.cpp" );
-		Code        upfront 	    = scan_file( "components/interface.upfront.cpp" );
-		Code 	    parsing 	    = scan_file( "components/interface.parsing.cpp" );
-		Code        untyped 	    = scan_file( "components/interface.untyped.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)) );
+		//CodeNS   nspaced_etoktype = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
+		CodeBody nspaced_etoktype = def_global_body( args(
+			untyped_str(txt("GEN_NS_PARSER_BEGIN\n")),
+			etoktype,
+			untyped_str(txt("GEN_NS_PARSER_END\n"))
+		));
 
 		Builder
 		src = Builder::open( "gen/gen.cpp" );
 		src.print_fmt( generation_notice );
 		src.print( push_ignores );
 		src.print( src_start );
-		src.print_fmt( "GEN_NS_BEGIN\n");
+		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( nspaced_etoktype );
-		src.print( parsing );
+		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" );
@@ -270,7 +330,7 @@ int gen_main()
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 		header.print( parsing );
 		header.print( scanner );
-		header.print_fmt( "GEN_NS_END\n" );
+		header.print_fmt( "\nGEN_NS_END\n" );
 		header.write();
 	}
 
@@ -285,7 +345,7 @@ int gen_main()
 		src.print( def_include( txt("gen.scanner.hpp") ) );
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
 		src.print( parsing );
-		src.print( scanner );
+		// src.print( scanner );
 		src.print_fmt( "GEN_NS_END\n" );
 		src.write();
 	}

project/components/ast.hpp

@@ -11,6 +11,7 @@ struct AST_Body;
 struct AST_Attributes;
 struct AST_Comment;
 struct AST_Constructor;
+// struct AST_BaseClass;
 struct AST_Class;
 struct AST_Define;
 struct AST_Destructor;
@@ -28,50 +29,154 @@ 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_Typename;
 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;
-struct CodeBody;
+#endif
+Define_Code(Body);
 // These are to offer ease of use and optionally strong type safety for the AST.
-struct CodeAttributes;
-struct CodeComment;
-struct CodeClass;
-struct CodeConstructor;
-struct CodeDefine;
-struct CodeDestructor;
-struct CodeEnum;
-struct CodeExec;
-struct CodeExtern;
-struct CodeInclude;
-struct CodeFriend;
-struct CodeFn;
-struct CodeModule;
-struct CodeNS;
-struct CodeOperator;
-struct CodeOpCast;
-struct CodeParam;
-struct CodePreprocessCond;
-struct CodePragma;
-struct CodeSpecifiers;
-struct CodeStruct;
-struct CodeTemplate;
-struct CodeType;
-struct CodeTypedef;
-struct CodeUnion;
-struct CodeUsing;
-struct CodeVar;
+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);
 
-namespace Parser
-{
-	struct Token;
-}
+#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(Typename);
+Define_Code(Typedef);
+Define_Code(Union);
+Define_Code(Using);
+Define_Code(Var);
+#undef Define_Code
+
+GEN_NS_PARSER_BEGIN
+struct Token;
+GEN_NS_PARSER_END
+
+#if ! GEN_COMPILER_C
+template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
+#endif
+
+#pragma region Code Interface
+void        append       (Code code, Code other );
+char const* debug_str    (Code code);
+Code        duplicate    (Code code);
+Code*       entry        (Code code, u32 idx );
+bool        has_entries  (Code code);
+bool        is_body      (Code code);
+bool        is_equal     (Code code, Code other);
+bool        is_valid     (Code code);
+void        set_global   (Code code);
+String      to_string    (Code self );
+void        to_string    (Code self, String* result );
+char const* type_str     (Code self );
+bool        validate_body(Code self );
+#pragma endregion Code Interface
+
+#if ! GEN_COMPILER_C
 /*
 	AST* wrapper
 	- Not constantly have to append the '*' as this is written often..
@@ -79,56 +184,66 @@ namespace Parser
 */
 struct Code
 {
-#	pragma region Statics
-	// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
-	static Code Global;
+	AST* ast;
 
-	// Used to identify invalid generated code.
-	static Code Invalid;
-#	pragma endregion Statics
+#	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_Code( Typename )          \
-	char const* debug_str();               \
-	Code        duplicate();			   \
-	bool        is_equal( Code other );    \
-	bool        is_valid();                \
-	void        set_global();              \
-	String      to_string();               \
-	Typename&   operator = ( AST* other ); \
-	Typename&   operator = ( Code other ); \
-	bool        operator ==( Code other ); \
-	bool        operator !=( Code other ); \
+#	define Using_CodeOps( Typename )                                         \
+	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 );
+	void        append(Code other)        { return GEN_NS append(* this, other); }
+	Code*       entry(u32 idx)            { return GEN_NS entry(* this, idx); }
+	bool        has_entries()             { return GEN_NS has_entries(* this); }
+	String      to_string()               { return GEN_NS to_string(* this); }
+	void        to_string(String& result) { return GEN_NS to_string(* this, & result); }
+	char const* type_str()                { return GEN_NS type_str(* this); }
+	bool        validate_body()           { return GEN_NS validate_body(*this); }
+#endif
 
-	template< class Type >
-	Type cast()
-	{
-		return * rcast( Type*, this );
-	}
+	Using_CodeOps( Code );
 
-	AST* operator ->()
-	{
-		return ast;
-	}
+	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;
 	}
 
-	AST* ast;
+	       bool operator==(std::nullptr_t) const            { return ast == nullptr; }
+	       bool operator!=(std::nullptr_t) const            { return ast != nullptr; }
+	friend bool operator==(std::nullptr_t, const Code code) { return code.ast == nullptr; }
+	friend bool operator!=(std::nullptr_t, const Code code) { return code.ast != nullptr; }
 
 #ifdef GEN_ENFORCE_STRONG_CODE_TYPES
 #	define operator explicit operator
 #endif
+	operator CodeBody() const;
 	operator CodeAttributes() const;
+	// operator CodeBaseClass() const;
 	operator CodeComment() const;
-	operator CodeConstructor() const;
-	operator CodeDestructor() const;
 	operator CodeClass() const;
+	operator CodeConstructor() const;
 	operator CodeDefine() const;
+	operator CodeDestructor() const;
 	operator CodeExec() const;
 	operator CodeEnum() const;
 	operator CodeExtern() const;
@@ -145,475 +260,122 @@ struct Code
 	operator CodeSpecifiers() const;
 	operator CodeStruct() const;
 	operator CodeTemplate() const;
-	operator CodeType() const;
+	operator CodeTypename() const;
 	operator CodeTypedef() const;
 	operator CodeUnion() const;
 	operator CodeUsing() const;
 	operator CodeVar() const;
-	operator CodeBody() 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;
 
+constexpr static
+int AST_ArrSpecs_Cap =
+(
+		AST_POD_Size
+		- sizeof(AST*) * 3
+		- sizeof(parser::Token*)
+		- sizeof(AST*)
+		- sizeof(StringCached)
+		- sizeof(CodeType)
+		- sizeof(ModuleFlag)
+		- sizeof(int)
+)
+/ sizeof(int) - 1; // -1 for 4 extra bytes
+
 /*
 	Simple AST POD with functionality to seralize into C++ syntax.
 */
 struct AST
 {
-#	pragma region Member Functions
-	void        append     ( AST* other );
-	char const* debug_str  ();
-	AST*        duplicate  ();
-	Code&       entry      ( u32 idx );
-	bool        has_entries();
-	bool        is_equal   ( AST* other );
-	char const* type_str();
-	bool        validate_body();
-
-	neverinline String to_string();
-
-	template< class Type >
-	Type cast()
-	{
-		return * this;
-	}
-
-	operator Code();
-	operator CodeBody();
-	operator CodeAttributes();
-	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();
-#	pragma endregion Member Functions
-
-	constexpr static
-	int 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
-
 	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
+			Code      InlineCmt;       // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
+			Code      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+			Code      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
+				Code  InitializerList; // Constructor
+				Code  ParentType;      // Class, Struct, ParentType->Next has a possible list of interfaces.
+				Code  ReturnType;      // Function, Operator, Typename
+				Code  UnderlyingType;  // Enum, Typedef
+				Code  ValueType;       // Parameter, Variable
 			};
 			union {
-				AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
-				AST*  Params;          // Constructor, Function, Operator, Template, Typename
+				Code  Macro;           // Parameter
+				Code  BitfieldSize;    // Variable (Class/Struct Data Member)
+				Code  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
+				Code  ArrExpr;          // Typename
+				Code  Body;             // Class, Constructor, Destructor, Enum, Friend, Function, Namespace, Struct, Union
+				Code  Declaration;      // Friend, Template
+				Code  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 )
+				Code  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
+				Code  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
+				Code  PostNameMacro;     // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
 			};
 		};
 		StringCached  Content;          // Attributes, Comment, Execution, Include
 		struct {
-			SpecifierT ArrSpecs[ArrSpecs_Cap]; // Specifiers
-			AST*       NextSpecs;                   // Specifiers; If ArrSpecs is full, then NextSpecs is used.
+			Specifier  ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
+			Code       NextSpecs;              // Specifiers; If ArrSpecs is full, then NextSpecs is used.
 		};
 	};
 	union {
-		AST* Prev;
-		AST* Front;
-		AST* Last;
+		Code Prev;
+		Code Front;
+		Code Last;
 	};
 	union {
-		AST* Next;
-		AST* Back;
+		Code Next;
+		Code Back;
 	};
-	Parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
-	AST*              Parent;
+	parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
+	Code              Parent;
 	StringCached      Name;
-	CodeT             Type;
+	CodeType          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;
+		Operator      Op;
 		AccessSpec    ParentAccess;
 		s32           NumEntries;
+		s32           VarConstructorInit;  // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
+		b32           EnumUnderlyingMacro; // Used by enums incase the user wants to wrap underlying type specification in a macro
 	};
 };
+static_assert( sizeof(AST) == AST_POD_Size, "ERROR: AST POD is not size of AST_POD_Size" );
 
-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*  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*  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
-			};
-		};
-		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;
-	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;
-	};
-};
-
-struct test {
-	SpecifierT ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
-	AST* NextSpecs;                   // Specifiers; If ArrSpecs is full, then NextSpecs is used.
-};
-
-constexpr int pls = sizeof(test);
-
-// 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" );
+#if ! GEN_COMPILER_C
+// Uses an implicitly overloaded cast from the AST to the desired code type.
+// Necessary if the user wants GEN_ENFORCE_STRONG_CODE_TYPES
+struct  InvalidCode_ImplictCaster;
+#define InvalidCode (InvalidCode_ImplictCaster{})
+#else
+#define InvalidCode Code_Invalid
+#endif
 
 // Used when the its desired when omission is allowed in a definition.
-#define NoCode      { nullptr }
-#define CodeInvalid (* Code::Invalid.ast) // Uses an implicitly overloaded cast from the AST to the desired code type.
-
-#pragma region Code Types
-
-struct CodeBody
-{
-	Using_Code( CodeBody );
-
-	void append( Code other )
-	{
-		raw()->append( other.ast );
-	}
-	void append( CodeBody body )
-	{
-		for ( Code entry : body )
-		{
-			append( entry );
-		}
-	}
-	bool has_entries()
-	{
-		return rcast( AST*, ast )->has_entries();
-	}
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Body* operator->()
-	{
-		return ast;
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-#pragma region Iterator
-	Code begin()
-	{
-		if ( ast )
-			return { rcast( AST*, ast)->Front };
-
-		return { nullptr };
-	}
-	Code end()
-	{
-		return { rcast(AST*, ast)->Back->Next };
-	}
-#pragma endregion Iterator
-
-	AST_Body* ast;
-};
-
-struct CodeClass
-{
-	Using_Code( CodeClass );
-
-	void add_interface( CodeType interface );
-
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-	AST_Class* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr");
-			return nullptr;
-		}
-		return ast;
-	}
-	AST_Class* ast;
-};
-
-struct CodeParam
-{
-	Using_Code( CodeParam );
-
-	void append( CodeParam other );
-
-	CodeParam get( s32 idx );
-	bool has_entries();
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Param* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr!");
-			return nullptr;
-		}
-		return ast;
-	}
-	operator Code()
-	{
-		return { (AST*)ast };
-	}
-#pragma region Iterator
-	CodeParam begin()
-	{
-		if ( ast )
-			return { ast };
-
-		return { nullptr };
-	}
-	CodeParam end()
-	{
-		return { (AST_Param*) rcast( AST*, ast)->Last };
-	}
-	CodeParam& operator++();
-	CodeParam operator*()
-	{
-		return * this;
-	}
-#pragma endregion Iterator
-
-	AST_Param* ast;
-};
-
-struct CodeSpecifiers
-{
-	Using_Code( CodeSpecifiers );
-
-	bool append( SpecifierT spec )
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
-			return false;
-		}
-
-		if ( raw()->NumEntries == AST::ArrSpecs_Cap )
-		{
-			log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST::ArrSpecs_Cap );
-			return false;
-		}
-
-		raw()->ArrSpecs[ raw()->NumEntries ] = spec;
-		raw()->NumEntries++;
-		return true;
-	}
-	s32 has( SpecifierT spec )
-	{
-		for ( s32 idx = 0; idx < raw()->NumEntries; idx++ )
-		{
-			if ( raw()->ArrSpecs[ raw()->NumEntries ] == spec )
-				return idx;
-		}
-
-		return -1;
-	}
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Specifiers* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr!");
-			return nullptr;
-		}
-		return ast;
-	}
-	operator Code()
-	{
-		return { (AST*) ast };
-	}
-#pragma region Iterator
-	SpecifierT* begin()
-	{
-		if ( ast )
-			return & raw()->ArrSpecs[0];
-
-		return nullptr;
-	}
-	SpecifierT* end()
-	{
-		return raw()->ArrSpecs + raw()->NumEntries;
-	}
-#pragma endregion Iterator
-
-	AST_Specifiers* ast;
-};
-
-struct CodeStruct
-{
-	Using_Code( CodeStruct );
-
-	void add_interface( CodeType interface );
-
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-	AST_Struct* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr");
-			return nullptr;
-		}
-		return ast;
-	}
-	AST_Struct* ast;
-};
-
-#define Define_CodeType( Typename )     \
-	struct Code##Typename               \
-	{                                   \
-		Using_Code( Code ## Typename ); \
-		AST*            raw();          \
-		operator        Code();         \
-		AST_##Typename* operator->();   \
-		AST_##Typename* ast;            \
-	}
-
-Define_CodeType( Attributes );
-Define_CodeType( Comment );
-Define_CodeType( Constructor );
-Define_CodeType( Define );
-Define_CodeType( Destructor );
-Define_CodeType( Enum );
-Define_CodeType( Exec );
-Define_CodeType( Extern );
-Define_CodeType( Include );
-Define_CodeType( Friend );
-Define_CodeType( Fn );
-Define_CodeType( Module );
-Define_CodeType( NS );
-Define_CodeType( Operator );
-Define_CodeType( OpCast );
-Define_CodeType( Pragma );
-Define_CodeType( PreprocessCond );
-Define_CodeType( Template );
-Define_CodeType( Type );
-Define_CodeType( Typedef );
-Define_CodeType( Union );
-Define_CodeType( Using );
-Define_CodeType( Var );
-
-#undef Define_CodeType
-#undef Using_Code
-
-#pragma endregion Code Types
+#define NullCode    { nullptr }

project/components/ast_case_macros.cpp

@@ -1,78 +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:
+	case CT_PlatformAttributes:                  \
+	case CT_Class_Body:                          \
+	case CT_Enum_Body:                           \
+	case CT_Extern_Linkage:                      \
+	case CT_Function_Body:                       \
+	case CT_Function_Fwd:                        \
+	case CT_Global_Body:                         \
+	case CT_Namespace:                           \
+	case CT_Namespace_Body:                      \
+	case CT_Operator:                            \
+	case CT_Operator_Fwd:                        \
+	case CT_Parameters:                          \
+	case CT_Specifiers:                          \
+	case CT_Struct_Body:                         \
+	case CT_Typename:
 #	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
 
 #	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:
+	case CT_Access_Public:                          \
+	case CT_Access_Protected:                       \
+	case CT_Access_Private:                         \
+	case CT_PlatformAttributes:                     \
+	case CT_Class_Body:                             \
+	case CT_Enum_Body:                              \
+	case CT_Extern_Linkage:                         \
+	case CT_Friend:                                 \
+	case CT_Function_Body:                          \
+	case CT_Function_Fwd:                           \
+	case CT_Global_Body:                            \
+	case CT_Namespace:                              \
+	case CT_Namespace_Body:                         \
+	case CT_Operator:                               \
+	case CT_Operator_Fwd:                           \
+	case CT_Operator_Member:                        \
+	case CT_Operator_Member_Fwd:                    \
+	case CT_Parameters:                             \
+	case CT_Specifiers:                             \
+	case CT_Struct_Body:                            \
+	case CT_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_GLOBAL_UNALLOWED_TYPES     \
+	case CT_Access_Public:                         \
+	case CT_Access_Protected:                      \
+	case CT_Access_Private:                        \
+	case CT_PlatformAttributes:                    \
+	case CT_Class_Body:                            \
+	case CT_Enum_Body:                             \
+	case CT_Execution:                             \
+	case CT_Friend:                                \
+	case CT_Function_Body:                         \
+	case CT_Namespace_Body:                        \
+	case CT_Operator_Member:                       \
+	case CT_Operator_Member_Fwd:                   \
+	case CT_Parameters:                            \
+	case CT_Specifiers:                            \
+	case CT_Struct_Body:                           \
+	case CT_Typename:
 #	define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES         GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
 #	define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
 
 #	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:
+	case CT_Access_Public:                        \
+	case CT_Access_Protected:                     \
+	case CT_Access_Private:                       \
+	case CT_PlatformAttributes:                   \
+	case CT_Class_Body:                           \
+	case CT_Enum_Body:                            \
+	case CT_Execution:                            \
+	case CT_Friend:                               \
+	case CT_Function_Body:                        \
+	case CT_Namespace_Body:                       \
+	case CT_Operator_Member:                      \
+	case CT_Operator_Member_Fwd:                  \
+	case CT_Parameters:                           \
+	case CT_Specifiers:                           \
+	case CT_Struct_Body:                          \
+	case CT_Typename:

project/components/gen/ecode.hpp

@@ -5,140 +5,135 @@
 
 // This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
 
-namespace ECode
+enum CodeType_Def : u32
 {
-	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
+	CT_Invalid,
+	CT_Untyped,
+	CT_NewLine,
+	CT_Comment,
+	CT_Access_Private,
+	CT_Access_Protected,
+	CT_Access_Public,
+	CT_PlatformAttributes,
+	CT_Class,
+	CT_Class_Fwd,
+	CT_Class_Body,
+	CT_Constructor,
+	CT_Constructor_Fwd,
+	CT_Destructor,
+	CT_Destructor_Fwd,
+	CT_Enum,
+	CT_Enum_Fwd,
+	CT_Enum_Body,
+	CT_Enum_Class,
+	CT_Enum_Class_Fwd,
+	CT_Execution,
+	CT_Export_Body,
+	CT_Extern_Linkage,
+	CT_Extern_Linkage_Body,
+	CT_Friend,
+	CT_Function,
+	CT_Function_Fwd,
+	CT_Function_Body,
+	CT_Global_Body,
+	CT_Module,
+	CT_Namespace,
+	CT_Namespace_Body,
+	CT_Operator,
+	CT_Operator_Fwd,
+	CT_Operator_Member,
+	CT_Operator_Member_Fwd,
+	CT_Operator_Cast,
+	CT_Operator_Cast_Fwd,
+	CT_Parameters,
+	CT_Preprocess_Define,
+	CT_Preprocess_Include,
+	CT_Preprocess_If,
+	CT_Preprocess_IfDef,
+	CT_Preprocess_IfNotDef,
+	CT_Preprocess_ElIf,
+	CT_Preprocess_Else,
+	CT_Preprocess_EndIf,
+	CT_Preprocess_Pragma,
+	CT_Specifiers,
+	CT_Struct,
+	CT_Struct_Fwd,
+	CT_Struct_Body,
+	CT_Template,
+	CT_Typedef,
+	CT_Typename,
+	CT_Union,
+	CT_Union_Body,
+	CT_Using,
+	CT_Using_Namespace,
+	CT_Variable,
+	CT_NumTypes
+};
+typedef enum CodeType_Def CodeType;
+
+inline StrC to_str( CodeType 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"            },
 	};
-
-	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;
+	return lookup[type];
+}

project/components/gen/eoperator.hpp

@@ -5,106 +5,109 @@
 
 // This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
 
-namespace EOperator
+enum Operator_Def : u32
 {
-	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,
-		NumOps
+	Op_Invalid,
+	Op_Assign,
+	Op_Assign_Add,
+	Op_Assign_Subtract,
+	Op_Assign_Multiply,
+	Op_Assign_Divide,
+	Op_Assign_Modulo,
+	Op_Assign_BAnd,
+	Op_Assign_BOr,
+	Op_Assign_BXOr,
+	Op_Assign_LShift,
+	Op_Assign_RShift,
+	Op_Increment,
+	Op_Decrement,
+	Op_Unary_Plus,
+	Op_Unary_Minus,
+	Op_UnaryNot,
+	Op_Add,
+	Op_Subtract,
+	Op_Multiply,
+	Op_Divide,
+	Op_Modulo,
+	Op_BNot,
+	Op_BAnd,
+	Op_BOr,
+	Op_BXOr,
+	Op_LShift,
+	Op_RShift,
+	Op_LAnd,
+	Op_LOr,
+	Op_LEqual,
+	Op_LNot,
+	Op_Lesser,
+	Op_Greater,
+	Op_LesserEqual,
+	Op_GreaterEqual,
+	Op_Subscript,
+	Op_Indirection,
+	Op_AddressOf,
+	Op_MemberOfPointer,
+	Op_PtrToMemOfPtr,
+	Op_FunctionCall,
+	Op_Comma,
+	Op_New,
+	Op_NewArray,
+	Op_Delete,
+	Op_DeleteArray,
+	NumOps
+};
+typedef enum Operator_Def Operator;
+
+inline StrC to_str( Operator 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[]" },
 	};
-
-	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( "," ),      ","      },
-		};
-		return lookup[ op ];
-	}
-
-}    // namespace EOperator
-
-using OperatorT = EOperator::Type;
+	return lookup[op];
+}

project/components/gen/especifier.hpp

@@ -5,94 +5,89 @@
 
 // This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
 
-namespace ESpecifier
+enum Specifier_Def : u32
 {
-	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,
-		Volatile,
-		Virtual,
-		Const,
-		Final,
-		NoExceptions,
-		Override,
-		Pure,
-		NumSpecifiers
+	Spec_Invalid,
+	Spec_Consteval,
+	Spec_Constexpr,
+	Spec_Constinit,
+	Spec_Explicit,
+	Spec_External_Linkage,
+	Spec_ForceInline,
+	Spec_Global,
+	Spec_Inline,
+	Spec_Internal_Linkage,
+	Spec_Local_Persist,
+	Spec_Mutable,
+	Spec_NeverInline,
+	Spec_Ptr,
+	Spec_Ref,
+	Spec_Register,
+	Spec_RValue,
+	Spec_Static,
+	Spec_Thread_Local,
+	Spec_Virtual,
+	Spec_Const,
+	Spec_Final,
+	Spec_NoExceptions,
+	Spec_Override,
+	Spec_Pure,
+	Spec_Volatile,
+	Spec_NumSpecifiers
+};
+typedef enum Specifier_Def Specifier;
+
+inline bool is_trailing( Specifier specifier )
+{
+	return specifier > Spec_Virtual;
+}
+
+inline StrC to_str( Specifier 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];
+}
 
-	bool is_trailing( Type specifier )
+inline Specifier to_specifier( StrC str )
+{
+	local_persist u32 keymap[Spec_NumSpecifiers];
+	do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 	{
-		return specifier > Virtual;
+		StrC enum_str = to_str( (Specifier)index );
+		keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
 	}
-
-	StrC to_str( Type type )
+	do_once_end u32 hash = crc32( str.Ptr, str.Len );
+	for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 	{
-		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( "volatile" ),      "volatile"     },
-			{ sizeof( "virtual" ),       "virtual"      },
-			{ sizeof( "const" ),         "const"        },
-			{ sizeof( "final" ),         "final"        },
-			{ sizeof( "noexcept" ),      "noexcept"     },
-			{ sizeof( "override" ),      "override"     },
-			{ sizeof( "= 0" ),           "= 0"          },
-		};
-		return lookup[ type ];
+		if ( keymap[index] == hash )
+			return (Specifier)index;
 	}
-
-	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;
+	return Spec_Invalid;
+}

project/components/gen/etoktype.cpp

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

project/components/header_end.hpp

@@ -7,7 +7,7 @@
 #pragma region Constants
 
 #ifndef GEN_GLOBAL_BUCKET_SIZE
-#	define GEN_GLOBAL_BUCKET_SIZE megabytes(4)
+#	define GEN_GLOBAL_BUCKET_SIZE megabytes(8)
 #endif
 #ifndef GEN_CODEPOOL_NUM_BLOCKS
 #	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(16)
@@ -31,7 +31,7 @@
 #	define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
 #endif
 #ifndef GEN_BUILDER_STR_BUFFER_RESERVE
-#	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(1)
+#	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(2)
 #endif
 
 // These constexprs are used for allocation behavior of data structures
@@ -42,7 +42,7 @@ 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 uw  Global_BucketSize         = GEN_GLOBAL_BUCKET_SIZE;
+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;
 
@@ -63,7 +63,6 @@ extern CodeAttributes attrib_api_import;
 extern Code module_global_fragment;
 extern Code module_private_fragment;
 
-// Exposed, but this is really used for parsing.
 extern Code fmt_newline;
 
 extern CodePragma pragma_once;
@@ -98,45 +97,46 @@ 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;
+extern CodeTypename t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
+extern CodeTypename t_auto;
+extern CodeTypename t_void;
+extern CodeTypename t_int;
+extern CodeTypename t_bool;
+extern CodeTypename t_char;
+extern CodeTypename t_wchar_t;
+extern CodeTypename t_class;
+extern CodeTypename 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 CodeTypename t_b32;
 
-	extern CodeType t_s8;
-	extern CodeType t_s16;
-	extern CodeType t_s32;
-	extern CodeType t_s64;
+	extern CodeTypename t_s8;
+	extern CodeTypename t_s16;
+	extern CodeTypename t_s32;
+	extern CodeTypename t_s64;
 
-	extern CodeType t_u8;
-	extern CodeType t_u16;
-	extern CodeType t_u32;
-	extern CodeType t_u64;
+	extern CodeTypename t_u8;
+	extern CodeTypename t_u16;
+	extern CodeTypename t_u32;
+	extern CodeTypename t_u64;
 
-	extern CodeType t_sw;
-	extern CodeType t_uw;
+	extern CodeTypename t_ssize;
+	extern CodeTypename t_usize;
 
-	extern CodeType t_f32;
-	extern CodeType t_f64;
+	extern CodeTypename t_f32;
+	extern CodeTypename t_f64;
 #endif
 
 #pragma endregion Constants
 
 #pragma region Macros
 
+#ifndef token_fmt
 #	define gen_main main
 
-#	define __ NoCode
+#	define __ NullCode
 
 	//	Convienence for defining any name used with the gen api.
 	//  Lets you provide the length and string literal to the functions without the need for the DSL.
@@ -152,9 +152,15 @@ extern CodeType t_typename;
 
 	// 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.

project/components/header_start.hpp

@@ -17,15 +17,3 @@
 #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

@@ -3,94 +3,174 @@
 #include "interface.hpp"
 #endif
 
-void AST::append( AST* other )
+#pragma region Code
+inline
+void append( Code self, Code other )
 {
+	GEN_ASSERT(self.ast  != nullptr);
+	GEN_ASSERT(other.ast != nullptr);
+
 	if ( other->Parent )
-		other = other->duplicate();
+		other = duplicate(other);
 
-	other->Parent = this;
+	other->Parent = self;
 
-	if ( Front == nullptr )
+	if ( self->Front == nullptr )
 	{
-		Front = other;
-		Back  = other;
+		self->Front = other;
+		self->Back  = other;
 
-		NumEntries++;
+		self->NumEntries++;
 		return;
 	}
 
-	AST*
-		Current       = Back;
+	Code
+	Current       = self->Back;
 	Current->Next = other;
 	other->Prev   = Current;
-	Back          = other;
-	NumEntries++;
+	self->Back    = other;
+	self->NumEntries++;
 }
-
-Code& AST::entry( u32 idx )
+inline
+bool is_body(Code self)
 {
-	AST** current = & Front;
+	GEN_ASSERT(self != nullptr);
+	switch (self->Type)
+	{
+		case CT_Enum_Body:
+		case CT_Class_Body:
+		case CT_Union_Body:
+		case CT_Export_Body:
+		case CT_Global_Body:
+		case CT_Struct_Body:
+		case CT_Function_Body:
+		case CT_Namespace_Body:
+		case CT_Extern_Linkage_Body:
+			return true;
+	}
+	return false;
+}
+inline
+Code* entry( Code self, u32 idx )
+{
+	GEN_ASSERT(self.ast != nullptr);
+	Code* current = & self->Front;
 	while ( idx >= 0 && current != nullptr )
 	{
 		if ( idx == 0 )
-			return * rcast( Code*, current);
+			return rcast( Code*, current);
 
 		current = & ( * current )->Next;
 		idx--;
 	}
 
-	return * rcast( Code*, current);
+	return rcast( Code*, current);
 }
-
-bool AST::has_entries()
+inline
+bool is_valid(Code self)
 {
-	return NumEntries;
+	return self.ast != nullptr && self.ast->Type != CT_Invalid;
 }
-
-char const* AST::type_str()
+inline
+bool has_entries(AST* self)
 {
-	return ECode::to_str( Type );
+	GEN_ASSERT(self != nullptr);
+	return self->NumEntries > 0;
 }
-
-AST::operator Code()
+inline
+void set_global(Code self)
 {
-	return { this };
-}
+	if ( self.ast == nullptr )
+	{
+		log_failure("Code::set_global: Cannot set code as global, AST is null!");
+		return;
+	}
 
+	self->Parent.ast = Code_Global.ast;
+}
+inline
 Code& Code::operator ++()
 {
 	if ( ast )
-		ast = ast->Next;
+		ast = ast->Next.ast;
 
-	return *this;
+	return * this;
 }
-
-void CodeClass::add_interface( CodeType type )
+inline
+char const* type_str(Code self)
 {
-	CodeType possible_slot = ast->ParentType;
+	GEN_ASSERT(self != nullptr);
+	return to_str( self->Type );
+}
+#pragma endregion Code
+
+#pragma region CodeBody
+inline
+void append( CodeBody self, Code other )
+{
+	GEN_ASSERT(other.ast != nullptr);
+
+	if (is_body(other)) {
+		append( self, cast(CodeBody, other) );
+		return;
+	}
+
+	append( cast(Code, self), other );
+}
+inline
+void append( CodeBody self, CodeBody body )
+{
+	GEN_ASSERT(self.ast != nullptr);
+
+	for ( Code entry : body ) {
+		append( self, entry );
+	}
+}
+inline
+Code begin( CodeBody body) {
+	if ( body.ast )
+		return { rcast( AST*, body.ast)->Front };
+	return { nullptr };
+}
+inline
+Code end(CodeBody body ){
+	return { nullptr };
+}
+#pragma endregion CodeBody
+
+#pragma region CodeClass
+inline
+void add_interface( CodeClass self, CodeTypename type )
+{
+	GEN_ASSERT(self.ast !=nullptr);
+	CodeTypename 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.
-		ast->ParentAccess = AccessSpec::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 = (AST_Typename*) possible_slot->Next.ast;
 	}
 
 	possible_slot.ast = type.ast;
 }
+#pragma endregion CodeClass
 
-void CodeParam::append( CodeParam other )
+#pragma region CodeParam
+inline
+void append( CodeParam appendee, CodeParam other )
 {
-	AST* self  = (AST*) ast;
-	AST* entry = (AST*) other.ast;
+	GEN_ASSERT(appendee.ast != nullptr);
+	Code self  = cast(Code, appendee);
+	Code entry = cast(Code, other);
 
 	if ( entry->Parent )
-		entry = entry->duplicate();
+		entry = GEN_NS duplicate( entry );
 
 	entry->Parent = self;
 
@@ -106,71 +186,177 @@ void CodeParam::append( CodeParam other )
 	self->Last       = entry;
 	self->NumEntries++;
 }
-
-CodeParam CodeParam::get( s32 idx )
+inline
+CodeParam get(CodeParam self, s32 idx )
 {
-	CodeParam param = *this;
+	GEN_ASSERT(self.ast != nullptr);
+	CodeParam param = * self;
 	do
 	{
 		if ( ! ++ param )
 			return { nullptr };
 
-		return { (AST_Param*) param.raw()->Next };
+		param = cast(Code, param)->Next;
 	}
 	while ( --idx );
 
-	return { nullptr };
+	return param;
 }
-
-bool CodeParam::has_entries()
+inline
+bool has_entries(CodeParam self)
 {
-	return ast->NumEntries > 0;
+	GEN_ASSERT(self.ast != nullptr);
+	return self->NumEntries > 0;
 }
-
+inline
 CodeParam& CodeParam::operator ++()
 {
 	ast = ast->Next.ast;
 	return * this;
 }
-
-void CodeStruct::add_interface( CodeType type )
+inline
+CodeParam begin(CodeParam params)
 {
-	CodeType possible_slot = ast->ParentType;
+	if ( params.ast )
+		return { params.ast };
+
+	return { nullptr };
+}
+inline
+CodeParam end(CodeParam params)
+{
+	// return { (AST_Param*) rcast( AST*, ast)->Last };
+	return { nullptr };
+}
+#pragma endregion CodeParam
+
+#pragma region CodeSpecifiers
+inline
+bool append(CodeSpecifiers self, Specifier spec )
+{
+	if ( self.ast == nullptr )
+	{
+		log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
+		return false;
+	}
+	if ( self->NumEntries == AST_ArrSpecs_Cap )
+	{
+		log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
+		return false;
+	}
+
+	self->ArrSpecs[ self->NumEntries ] = spec;
+	self->NumEntries++;
+	return true;
+}
+inline
+s32 has(CodeSpecifiers self, Specifier spec)
+{
+	GEN_ASSERT(self.ast != nullptr);
+	for ( s32 idx = 0; idx < self->NumEntries; idx++ ) {
+		if ( self->ArrSpecs[ idx ] == spec )
+			return idx;
+	}
+	return -1;
+}
+inline
+s32 remove( CodeSpecifiers self, Specifier to_remove )
+{
+	AST_Specifiers* ast = self.ast;
+	if ( ast == nullptr )
+	{
+		log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
+		return -1;
+	}
+	if ( self->NumEntries == AST_ArrSpecs_Cap )
+	{
+		log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
+		return -1;
+	}
+
+	s32 result = -1;
+
+	s32 curr = 0;
+	s32 next = 0;
+	for(; next < self->NumEntries; ++ curr, ++ next)
+	{
+		Specifier spec = self->ArrSpecs[next];
+		if (spec == to_remove)
+		{
+			result = next;
+
+			next ++;
+			if (next >= self->NumEntries)
+				break;
+
+			spec = self->ArrSpecs[next];
+		}
+
+		self->ArrSpecs[ curr ] = spec;
+	}
+
+	if (result > -1) {
+		self->NumEntries --;
+	}
+	return result;
+}
+inline
+Specifier* begin(CodeSpecifiers self)
+{
+	if ( self.ast )
+		return & self->ArrSpecs[0];
+
+	return nullptr;
+}
+inline
+Specifier* end(CodeSpecifiers self)
+{
+	return self->ArrSpecs + self->NumEntries;
+}
+#pragma endregion CodeSpecifiers
+
+#pragma region CodeStruct
+inline
+void add_interface(CodeStruct self, CodeTypename type )
+{
+	CodeTypename 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.
-		ast->ParentAccess = AccessSpec::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 = (AST_Typename*) possible_slot->Next.ast;
 	}
 
 	possible_slot.ast = type.ast;
 }
+#pragma endregion Code
 
-CodeBody def_body( CodeT type )
+#pragma region Interface
+inline
+CodeBody def_body( CodeType 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:
+		case CT_Class_Body:
+		case CT_Enum_Body:
+		case CT_Export_Body:
+		case CT_Extern_Linkage:
+		case CT_Function_Body:
+		case CT_Global_Body:
+		case CT_Namespace_Body:
+		case CT_Struct_Body:
+		case CT_Union_Body:
 			break;
 
 		default:
-			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
-			return (CodeBody)Code::Invalid;
+			log_failure( "def_body: Invalid type %s", (char const*)to_str(type) );
+			return (CodeBody)Code_Invalid;
 	}
 
 	Code
@@ -179,7 +365,8 @@ CodeBody def_body( CodeT type )
 	return (CodeBody)result;
 }
 
-StrC token_fmt_impl( sw num, ... )
+inline
+StrC token_fmt_impl( ssize num, ... )
 {
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
@@ -187,8 +374,9 @@ StrC token_fmt_impl( sw num, ... )
 
 	va_list va;
 	va_start(va, num );
-	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
+	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
 	va_end(va);
 
 	return { result, buf };
 }
+#pragma endregion Interface

project/components/interface.cpp

@@ -1,15 +1,17 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #pragma once
-#include "ast.cpp"
+#include "code_serialization.cpp"
 #endif
 
-internal void init_parser();
-internal void deinit_parser();
+namespace parser {
+internal void init();
+internal void deinit();
+}
 
 internal
-void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
 {
-	Arena* last = & Global_AllocatorBuckets.back();
+	Arena* last = back(& Global_AllocatorBuckets);
 
 	switch ( type )
 	{
@@ -17,18 +19,18 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
 		{
 			if ( ( last->TotalUsed + size ) > last->TotalSize )
 			{
-				Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
+				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
 
 				if ( bucket.PhysicalStart == nullptr )
 					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
-				if ( ! Global_AllocatorBuckets.append( bucket ) )
+				if ( ! append( & Global_AllocatorBuckets, bucket ) )
 					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
-				last = & Global_AllocatorBuckets.back();
+				last = back(& Global_AllocatorBuckets);
 			}
 
-			return alloc_align( * last, size, alignment );
+			return alloc_align( allocator_info(last), size, alignment );
 		}
 		case EAllocation_FREE:
 		{
@@ -44,15 +46,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
 		{
 			if ( last->TotalUsed + size > last->TotalSize )
 			{
-				Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
+				Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
 
 				if ( bucket.PhysicalStart == nullptr )
 					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
-				if ( ! Global_AllocatorBuckets.append( bucket ) )
+				if ( ! append( & Global_AllocatorBuckets, bucket ) )
 					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
-				last = & Global_AllocatorBuckets.back();
+				last = back(& Global_AllocatorBuckets);
 			}
 
 			void* result = alloc_align( last->Backing, size, alignment );
@@ -72,78 +74,78 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
 internal
 void define_constants()
 {
-	Code::Global          = make_code();
-	Code::Global->Name    = get_cached_string( txt("Global Code") );
-	Code::Global->Content = Code::Global->Name;
+	Code_Global          = make_code();
+	Code_Global->Name    = get_cached_string( txt("Global Code") );
+	Code_Global->Content = Code_Global->Name;
 
-	Code::Invalid = make_code();
-	Code::Invalid.set_global();
+	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("") );
-	t_empty.set_global();
+	t_empty       = (CodeTypename) make_code();
+	t_empty->Type = CT_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:") );
-	access_private.set_global();
+	access_private->Type = CT_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:") );
-	access_protected.set_global();
+	access_protected->Type = CT_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:") );
-	access_public.set_global();
+	access_public->Type = CT_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));
-	attrib_api_export.set_global();
+	set_global(attrib_api_export);
 
 	attrib_api_import = def_attributes( code(GEN_API_Import_Code));
-	attrib_api_import.set_global();
+	set_global(attrib_api_import);
 
 	module_global_fragment          = make_code();
-	module_global_fragment->Type    = ECode::Untyped;
+	module_global_fragment->Type    = CT_Untyped;
 	module_global_fragment->Name    = get_cached_string( txt("module;") );
 	module_global_fragment->Content = module_global_fragment->Name;
-	module_global_fragment.set_global();
+	set_global(module_global_fragment);
 
 	module_private_fragment          = make_code();
-	module_private_fragment->Type    = ECode::Untyped;
+	module_private_fragment->Type    = CT_Untyped;
 	module_private_fragment->Name    = get_cached_string( txt("module : private;") );
 	module_private_fragment->Content = module_private_fragment->Name;
-	module_private_fragment.set_global();
+	set_global(module_private_fragment);
 
 	fmt_newline = make_code();
-	fmt_newline->Type = ECode::NewLine;
-	fmt_newline.set_global();
+	fmt_newline->Type = CT_NewLine;
+	set_global(fmt_newline);
 
 	pragma_once          = (CodePragma) make_code();
-	pragma_once->Type    = ECode::Preprocess_Pragma;
+	pragma_once->Type    = CT_Preprocess_Pragma;
 	pragma_once->Name    = get_cached_string( txt("once") );
 	pragma_once->Content = pragma_once->Name;
-	pragma_once.set_global();
+	set_global(pragma_once);
 
-	param_varadic            = (CodeType) make_code();
-	param_varadic->Type      = ECode::Parameters;
+	param_varadic            = (CodeTypename) make_code();
+	param_varadic->Type      = CT_Parameters;
 	param_varadic->Name      = get_cached_string( txt("...") );
 	param_varadic->ValueType = t_empty;
-	param_varadic.set_global();
+	set_global(param_varadic);
 
 	preprocess_else = (CodePreprocessCond) make_code();
-	preprocess_else->Type = ECode::Preprocess_Else;
-	preprocess_else.set_global();
+	preprocess_else->Type = CT_Preprocess_Else;
+	set_global(preprocess_else);
 
 	preprocess_endif = (CodePreprocessCond) make_code();
-	preprocess_endif->Type = ECode::Preprocess_EndIf;
-	preprocess_endif.set_global();
+	preprocess_endif->Type = CT_Preprocess_EndIf;
+	set_global(preprocess_endif);
 
 #	define def_constant_code_type( Type_ )   \
 		t_##Type_ = def_type( name(Type_) ); \
-		t_##Type_.set_global();
+		set_global(t_##Type_);
 
 	def_constant_code_type( auto );
 	def_constant_code_type( void );
@@ -167,62 +169,66 @@ void define_constants()
 	def_constant_code_type( u32 );
 	def_constant_code_type( u64 );
 
-	def_constant_code_type( sw );
-	def_constant_code_type( uw );
+	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
 
-#	pragma push_macro( "forceinline" )
-#	pragma push_macro( "global" )
-#	pragma push_macro( "internal" )
-#	pragma push_macro( "local_persist" )
-#	pragma push_macro( "neverinline" )
+
+#	define def_constant_spec( Type_, ... )                                  \
+		spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
+		set_global(spec_##Type_);
+
+#	pragma push_macro("forceinline")
+#	pragma push_macro("global")
+#	pragma push_macro("internal")
+#	pragma push_macro("local_persist")
+#	pragma push_macro("neverinline")
 #	undef forceinline
 #	undef global
 #	undef internal
 #	undef local_persist
 #	undef neverinline
+	def_constant_spec( const,            Spec_Const );
+	def_constant_spec( consteval,        Spec_Consteval );
+	def_constant_spec( constexpr,        Spec_Constexpr );
+	def_constant_spec( constinit,        Spec_Constinit );
+	def_constant_spec( extern_linkage,   Spec_External_Linkage );
+	def_constant_spec( final, 		     Spec_Final );
+	def_constant_spec( forceinline,      Spec_ForceInline );
+	def_constant_spec( global,           Spec_Global );
+	def_constant_spec( inline,           Spec_Inline );
+	def_constant_spec( internal_linkage, Spec_Internal_Linkage );
+	def_constant_spec( local_persist,    Spec_Local_Persist );
+	def_constant_spec( mutable,          Spec_Mutable );
+	def_constant_spec( neverinline,      Spec_NeverInline );
+	def_constant_spec( noexcept,         Spec_NoExceptions );
+	def_constant_spec( override,         Spec_Override );
+	def_constant_spec( ptr,              Spec_Ptr );
+	def_constant_spec( pure,             Spec_Pure )
+	def_constant_spec( ref,              Spec_Ref );
+	def_constant_spec( register,         Spec_Register );
+	def_constant_spec( rvalue,           Spec_RValue );
+	def_constant_spec( static_member,    Spec_Static );
+	def_constant_spec( thread_local,     Spec_Thread_Local );
+	def_constant_spec( virtual, 		 Spec_Virtual );
+	def_constant_spec( volatile, 	     Spec_Volatile)
 
-#	define def_constant_spec( Type_, ... )                                  \
-		spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
-		spec_##Type_.set_global();
+	spec_local_persist = def_specifiers( 1, Spec_Local_Persist );
+	set_global(spec_local_persist);
 
-	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)
+#	pragma pop_macro("forceinline")
+#	pragma pop_macro("global")
+#	pragma pop_macro("internal")
+#	pragma pop_macro("local_persist")
+#	pragma pop_macro("neverinline")
 
-	spec_local_persist = def_specifiers( 1, ESpecifier::Local_Persist );
-	spec_local_persist.set_global();
+#	pragma push_macro("enum_underlying")
 
-#	pragma pop_macro( "forceinline" )
-#	pragma pop_macro( "global" )
-#	pragma pop_macro( "internal" )
-#	pragma pop_macro( "local_persist" )
-#	pragma pop_macro( "neverinline" )
+#	pragma pop_macro("enum_underlying")
 
 #	undef def_constant_spec
 }
@@ -233,28 +239,27 @@ void init()
 	{
 		GlobalAllocator = AllocatorInfo { & Global_Allocator_Proc, nullptr };
 
-		Global_AllocatorBuckets = Array<Arena>::init_reserve( heap(), 128 );
+		Global_AllocatorBuckets = array_init_reserve<Arena>( heap(), 128 );
 
 		if ( Global_AllocatorBuckets == nullptr )
 			GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
 
-		Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
+		Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
 
 		if ( bucket.PhysicalStart == nullptr )
 			GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
 
-		Global_AllocatorBuckets.append( bucket );
-
+		append( & Global_AllocatorBuckets, bucket );
 	}
 
 	// Setup the arrays
 	{
-		CodePools = Array<Pool>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
+		CodePools = array_init_reserve<Pool>( Allocator_DataArrays, InitSize_DataArrays );
 
 		if ( CodePools == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
 
-		StringArenas = Array<Arena>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
+		StringArenas = array_init_reserve<Arena>( Allocator_DataArrays, InitSize_DataArrays );
 
 		if ( StringArenas == nullptr )
 			GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
@@ -262,92 +267,97 @@ void init()
 
 	// Setup the code pool and code entries arena.
 	{
-		Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+		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" );
 
-		CodePools.append( code_pool );
+		append( & CodePools, code_pool );
 
-		LexArena = Arena::init_from_allocator( Allocator_Lexer, LexAllocator_Size );
+		LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
 
-		Arena string_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+		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" );
 
-		StringArenas.append( string_arena );
+		append( & StringArenas, string_arena );
 	}
 
 	// Setup the hash tables
 	{
-		StringCache = StringTable::init( Allocator_StringTable );
+		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();
-	init_parser();
+	parser::init();
 }
 
 void deinit()
 {
-	uw index = 0;
-	uw left  = CodePools.num();
+	usize index = 0;
+	usize left  = num(CodePools);
 	do
 	{
 		Pool* code_pool = & CodePools[index];
-		code_pool->free();
+		free(code_pool);
 		index++;
 	}
 	while ( left--, left );
 
 	index = 0;
-	left  = StringArenas.num();
+	left  = num(StringArenas);
 	do
 	{
 		Arena* string_arena = & StringArenas[index];
-		string_arena->free();
+		free(string_arena);
 		index++;
 	}
 	while ( left--, left );
 
-	StringCache.destroy();
+	destroy(& StringCache);
 
-	CodePools.free();
-	StringArenas.free();
+	free( & CodePools);
+	free( & StringArenas);
 
-	LexArena.free();
+	free(& LexArena);
+
+	free(& PreprocessorDefines);
 
 	index = 0;
-	left  = Global_AllocatorBuckets.num();
+	left  = num(Global_AllocatorBuckets);
 	do
 	{
 		Arena* bucket = & Global_AllocatorBuckets[ index ];
-		bucket->free();
+		free(bucket);
 		index++;
 	}
 	while ( left--, left );
 
-	Global_AllocatorBuckets.free();
-	deinit_parser();
+	free(Global_AllocatorBuckets);
+	parser::deinit();
 }
 
 void reset()
 {
 	s32 index = 0;
-	s32 left  = CodePools.num();
+	s32 left  = num(CodePools);
 	do
 	{
 		Pool* code_pool = & CodePools[index];
-		code_pool->clear();
+		clear(* code_pool);
 		index++;
 	}
 	while ( left--, left );
 
 	index = 0;
-	left  = StringArenas.num();
+	left  = num(StringArenas);
 	do
 	{
 		Arena* string_arena = & StringArenas[index];
@@ -356,28 +366,28 @@ void reset()
 	}
 	while ( left--, left );
 
-	StringCache.clear();
+	clear(StringCache);
 
 	define_constants();
 }
 
 AllocatorInfo get_string_allocator( s32 str_length )
 {
-	Arena* last = & StringArenas.back();
+	Arena* last = back(& StringArenas);
 
-	uw size_req = str_length + sizeof(String::Header) + sizeof(char*);
+	usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
 
-	if ( last->TotalUsed + size_req > last->TotalSize )
+	if ( last->TotalUsed + ssize(size_req) > last->TotalSize )
 	{
-		Arena new_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
+		Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
-		if ( ! StringArenas.append( new_arena ) )
+		if ( ! append( & StringArenas, new_arena ) )
 			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
 
-		last = & StringArenas.back();
+		last = back(& StringArenas);
 	}
 
-	return * last;
+	return allocator_info(last);
 }
 
 // Will either make or retrive a code string.
@@ -386,48 +396,48 @@ 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 = StringCache.get( key );
+		StringCached* result = get(StringCache, key );
 
 		if ( result )
 			return * result;
 	}
 
-	String result = String::make( get_string_allocator( str.Len ), str );
-	StringCache.set( key, result );
+	String result = string_make( get_string_allocator( str.Len ), str );
+	set(& StringCache, key, { length(result), result } );
 
-	return result;
+	return { length(result), result };
 }
 
 // Used internally to retireve a Code object form the CodePool.
 Code make_code()
 {
-	Pool* allocator = & CodePools.back();
+	Pool* allocator = back( & CodePools);
 	if ( allocator->FreeList == nullptr )
 	{
-		Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
+		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 ( ! CodePools.append( code_pool ) )
+		if ( ! append( & CodePools, code_pool ) )
 			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
 
-		allocator = & CodePools.back();
+		allocator = back( & CodePools);
 	}
 
-	Code result { rcast( AST*, alloc( * allocator, sizeof(AST) )) };
-	// mem_set( result.ast, 0, sizeof(AST) );
-	result->Type = ECode::Invalid;
+	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;
+	// 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;
 }

project/components/interface.hpp

@@ -29,7 +29,6 @@ StringCached get_cached_string( StrC str );
 Code make_code();
 
 // Set these before calling gen's init() procedure.
-// Data
 
 void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
 void set_allocator_code_pool   ( AllocatorInfo pool_allocator );
@@ -43,77 +42,129 @@ void set_allocator_type_table  ( AllocatorInfo type_reg_allocator );
 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 );
+struct Opts_def_struct {
+	Code           body;
+	CodeTypename   parent;
+	AccessSpec     parent_access;
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+	CodeTypename*  interfaces;
+	s32            num_interfaces;
+};
+CodeClass def_class( StrC name, Opts_def_struct otps GEN_PARAM_DEFAULT );
 
-CodeConstructor def_constructor( CodeParam params = NoCode, Code initializer_list = NoCode, Code body = NoCode );
+struct Opts_def_constructor {
+	CodeParam params;
+	Code      initializer_list;
+	Code      body;
+};
+CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
 
 CodeDefine def_define( StrC name, StrC content );
 
-CodeDestructor def_destructor( Code body = NoCode, CodeSpecifiers specifiers = NoCode );
+struct Opts_def_destructor {
+	Code           body;
+	CodeSpecifiers specifiers;
+};
+CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
 
-CodeEnum def_enum( StrC name
-	, Code         body      = NoCode,      CodeType       type       = NoCode
-	, EnumT        specifier = EnumRegular, CodeAttributes attributes = NoCode
-	, ModuleFlag   mflags    = ModuleFlag::None );
+struct Opts_def_enum {
+	Code           body;
+	CodeTypename   type;
+	EnumT          specifier;
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+};
+CodeEnum def_enum( StrC name, Opts_def_enum opts GEN_PARAM_DEFAULT );
 
 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 );
+struct Opts_def_function {
+	CodeParam       params;
+	CodeTypename    ret_type;
+	Code            body;
+	CodeSpecifiers  specs;
+	CodeAttributes  attrs;
+	ModuleFlag      mflags;
+};
+CodeFn def_function( StrC name, Opts_def_function opts GEN_PARAM_DEFAULT );
 
-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 );
+struct Opts_def_include   { b32        foreign; };
+struct Opts_def_module    { ModuleFlag mflags;  };
+struct Opts_def_namespace { ModuleFlag mflags;  };
+CodeInclude def_include  ( StrC content,         Opts_def_include   opts GEN_PARAM_DEFAULT );
+CodeModule  def_module   ( StrC name,            Opts_def_module    opts GEN_PARAM_DEFAULT );
+CodeNS      def_namespace( StrC name, Code body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
 
-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 );
+struct Opts_def_operator {
+	CodeParam       params;
+	CodeTypename    ret_type;
+	Code            body;
+	CodeSpecifiers  specifiers;
+	CodeAttributes  attributes;
+	ModuleFlag      mflags;
+};
+CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
 
-CodeOpCast def_operator_cast( CodeType type, Code body = NoCode, CodeSpecifiers specs = NoCode );
+struct Opts_def_operator_cast {
+	Code           body;
+	CodeSpecifiers specs;
+};
+CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
 
-CodeParam  def_param ( CodeType type, StrC name, Code value = NoCode );
+struct Opts_def_param { Code value; };
+CodeParam  def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT );
 CodePragma def_pragma( StrC directive );
 
 CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
 
-CodeSpecifiers def_specifier( SpecifierT specifier );
+CodeSpecifiers def_specifier( Specifier 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 );
+CodeStruct def_struct( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
 
-CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag::None );
+struct Opts_def_template { ModuleFlag mflags; };
+CodeTemplate def_template( CodeParam params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
 
-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 );
+struct Opts_def_type {
+	Code           arrayexpr;
+	CodeSpecifiers specifiers;
+	CodeAttributes attributes;
+};
+CodeTypename def_type( StrC name, Opts_def_type opts GEN_PARAM_DEFAULT );
 
-CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );
+struct Opts_def_typedef {
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+};
+CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
 
-CodeUsing def_using( StrC name, CodeType type = NoCode
-	, CodeAttributes attributess = NoCode
-	, ModuleFlag     mflags      = ModuleFlag::None );
+struct Opts_def_union {
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+};
+CodeUnion def_union( StrC name, Code body, Opts_def_union opts GEN_PARAM_DEFAULT );
+
+struct Opts_def_using {
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+};
+CodeUsing def_using( StrC name, Code type, Opts_def_using opts GEN_PARAM_DEFAULT );
 
 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 );
+struct Opts_def_variable
+{
+	Code           value;
+	CodeSpecifiers specifiers;
+	CodeAttributes attributes;
+	ModuleFlag     mflags;
+};
+CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable opts GEN_PARAM_DEFAULT ); 
 
 // Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
-CodeBody def_body( CodeT type );
+CodeBody def_body( CodeTypename 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.
@@ -135,7 +186,7 @@ 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 );
+CodeSpecifiers def_specifiers      ( s32 num, Specifier* specs );
 CodeBody       def_struct_body     ( s32 num, ... );
 CodeBody       def_struct_body     ( s32 num, Code* codes );
 CodeBody       def_union_body      ( s32 num, ... );
@@ -145,6 +196,42 @@ CodeBody       def_union_body      ( s32 num, Code* codes );
 
 #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  );
@@ -159,7 +246,7 @@ 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        );
+CodeTypename    parse_type         ( StrC type_def        );
 CodeTypedef     parse_typedef      ( StrC typedef_def     );
 CodeUnion       parse_union        ( StrC union_def       );
 CodeUsing       parse_using        ( StrC using_def       );
@@ -169,9 +256,9 @@ CodeVar         parse_variable     ( StrC var_def         );
 
 #pragma region Untyped text
 
-sw   token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
+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( sw, ... );
+StrC token_fmt_impl( ssize, ... );
 
 Code untyped_str      ( StrC content);
 Code untyped_fmt      ( char const* fmt, ... );

project/components/interface.untyped.cpp

@@ -3,21 +3,21 @@
 #include "interface.parsing.cpp"
 #endif
 
-sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
+ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 {
 	char const* buf_begin = buf;
-	sw          remaining = buf_size;
+	ssize       remaining = buf_size;
 
 	local_persist
 	Arena tok_map_arena;
 
-	HashTable<StrC> tok_map;
+	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<StrC>::init( tok_map_arena );
+		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;
 
@@ -27,8 +27,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 			StrC        value = va_arg( va, StrC );
 
 			u32 key = crc32( token, str_len(token) );
-
-			tok_map.set( key, value );
+			set(& tok_map, key, value );
 		}
 	}
 
@@ -37,7 +36,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 
 	while ( current )
 	{
-		sw len = 0;
+		ssize len = 0;
 
 		while ( current && current != '<' && remaining )
 		{
@@ -64,11 +63,11 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 			char const* token = fmt + 1;
 
 			u32       key   = crc32( token, tok_len );
-			StrC*     value = tok_map.get( key );
+			StrC*     value = get(tok_map, key );
 
 			if ( value )
 			{
-				sw          left = value->Len;
+				ssize          left = value->Len;
 				char const* str  = value->Ptr;
 
 				while ( left-- )
@@ -94,10 +93,10 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 		}
 	}
 
-	tok_map.clear();
-	tok_map_arena.free();
+	clear(tok_map);
+	free(& tok_map_arena);
 
-	sw result = buf_size - remaining;
+	ssize result = buf_size - remaining;
 
 	return result;
 }
@@ -107,19 +106,19 @@ Code untyped_str( StrC content )
 	if ( content.Len == 0 )
 	{
 		log_failure( "untyped_str: empty string" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	Code
 	result          = make_code();
 	result->Name    = get_cached_string( content );
-	result->Type    = ECode::Untyped;
+	result->Type    = CT_Untyped;
 	result->Content = result->Name;
 
 	if ( result->Name == nullptr )
 	{
 		log_failure( "untyped_str: could not cache string" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	return result;
@@ -130,7 +129,7 @@ Code untyped_fmt( char const* fmt, ...)
 	if ( fmt == nullptr )
 	{
 		log_failure( "untyped_fmt: null format string" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	local_persist thread_local
@@ -138,19 +137,19 @@ Code untyped_fmt( char const* fmt, ...)
 
 	va_list va;
 	va_start(va, fmt);
-	sw length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	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->Type    = CT_Untyped;
 	result->Content = get_cached_string( { length, buf } );
 
 	if ( result->Name == nullptr )
 	{
 		log_failure( "untyped_fmt: could not cache string" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	return result;
@@ -161,7 +160,7 @@ Code untyped_token_fmt( s32 num_tokens, ... )
 	if ( num_tokens == 0 )
 	{
 		log_failure( "untyped_token_fmt: zero tokens" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	local_persist thread_local
@@ -169,19 +168,19 @@ Code untyped_token_fmt( s32 num_tokens, ... )
 
 	va_list va;
 	va_start(va, num_tokens);
-	sw length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
+	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->Type    = CT_Untyped;
 	result->Content = result->Name;
 
 	if ( result->Name == nullptr )
 	{
 		log_failure( "untyped_fmt: could not cache string" );
-		return CodeInvalid;
+		return InvalidCode;
 	}
 
 	return result;

project/components/src_start.cpp

@@ -9,4 +9,3 @@
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 #	include "gen.dep.cpp"
 #endif
-

project/components/static_data.cpp

@@ -9,6 +9,7 @@
 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 };
 
@@ -71,34 +72,36 @@ 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 CodeTypename t_empty;
+global CodeTypename t_auto;
+global CodeTypename t_void;
+global CodeTypename t_int;
+global CodeTypename t_bool;
+global CodeTypename t_char;
+global CodeTypename t_wchar_t;
+global CodeTypename t_class;
+global CodeTypename t_typename;
+
+global Array< StringCached > PreprocessorDefines;
 
 #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-global CodeType t_b32;
+global CodeTypename t_b32;
 
-global CodeType t_s8;
-global CodeType t_s16;
-global CodeType t_s32;
-global CodeType t_s64;
+global CodeTypename t_s8;
+global CodeTypename t_s16;
+global CodeTypename t_s32;
+global CodeTypename t_s64;
 
-global CodeType t_u8;
-global CodeType t_u16;
-global CodeType t_u32;
-global CodeType t_u64;
+global CodeTypename t_u8;
+global CodeTypename t_u16;
+global CodeTypename t_u32;
+global CodeTypename t_u64;
 
-global CodeType t_sw;
-global CodeType t_uw;
+global CodeTypename t_ssize;
+global CodeTypename t_usize;
 
-global CodeType t_f32;
-global CodeType t_f64;
+global CodeTypename t_f32;
+global CodeTypename t_f64;
 #endif
 
 #pragma endregion Constants

project/components/types.hpp

@@ -3,7 +3,7 @@
 #include "header_start.hpp"
 #endif
 
-using LogFailType = sw(*)(char const*, ...);
+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.
@@ -13,63 +13,73 @@ using LogFailType = sw(*)(char const*, ...);
 	#define log_failure GEN_FATAL
 #endif
 
-enum class AccessSpec : u32
+enum AccessSpec enum_underlying(u32)
 {
-	Default,
-	Public,
-	Protected,
-	Private,
+	AccessSpec_Default,
+	AccessSpec_Private,
+	AccessSpec_Protected,
+	AccessSpec_Public,
 
-	Num_AccessSpec,
-	Invalid,
+	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 ] = {
+	char const* lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
 		"",
-		"public",
-		"protected",
 		"private",
+		"protected",
+		"public",
 	};
 
-	if ( type > AccessSpec::Public )
+	if ( type > AccessSpec_Public )
 		return "Invalid";
 
 	return lookup[ (u32)type ];
 }
 
-
-enum CodeFlag : u32
+enum CodeFlag enum_underlying(u32)
 {
-	FunctionType  = bit(0),
-	ParamPack     = bit(1),
-	Module_Export = bit(2),
-	Module_Import = bit(3),
+	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 class EnumT : u8
+enum EnumDecl enum_underlying(u8)
 {
-	Regular,
-	Class
+	EnumDecl_Regular,
+	EnumDecl_Class,
+
+	EnumT_SizeDef = GEN_U8_MAX,
 };
+typedef u8 EnumT;
 
-constexpr EnumT EnumClass   = EnumT::Class;
-constexpr EnumT EnumRegular = EnumT::Regular;
-
-enum class ModuleFlag : u32
+enum ModuleFlag enum_underlying(u32)
 {
-	None    = 0,
-	Export  = bit(0),
-	Import  = bit(1),
+	ModuleFlag_None    = 0,
+	ModuleFlag_Export  = bit(0),
+	ModuleFlag_Import  = bit(1),
 
 	Num_ModuleFlags,
-	Invalid,
-};
+	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
@@ -79,26 +89,25 @@ StrC to_str( ModuleFlag flag )
 		{ sizeof("import"), "import" },
 	};
 
-	if ( flag > ModuleFlag::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 class EPreprocessCond : u32
+enum EPreprocessCond enum_underlying(u32)
 {
-	If,
-	IfDef,
-	IfNotDef,
-	ElIf
-};
+	PreprocessCond_If,
+	PreprocessCond_IfDef,
+	PreprocessCond_IfNotDef,
+	PreprocessCond_ElIf,
 
-constexpr EPreprocessCond PreprocessCond_If       = EPreprocessCond::If;
-constexpr EPreprocessCond PreprocessCond_IfDef    = EPreprocessCond::IfDef;
-constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
-constexpr EPreprocessCond PreprocessCond_ElIf     = EPreprocessCond::ElIf;
+	EPreprocessCond_SizeDef = GEN_U32_MAX,
+};
+static_assert( size_of(EPreprocessCond) == size_of(u32), "EPreprocessCond not u32 size" );

project/dependencies/basic_types.hpp

@@ -1,5 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
+#	include "platform.hpp"
 #	include "macros.hpp"
 #endif
 
@@ -47,21 +48,21 @@
 #if defined( GEN_COMPILER_MSVC )
 #	if _MSC_VER < 1300
 typedef unsigned char  u8;
-typedef signed char    s8;
+typedef signed   char  s8;
 typedef unsigned short u16;
-typedef signed short   s16;
+typedef signed   short s16;
 typedef unsigned int   u32;
-typedef signed int     s32;
+typedef signed   int   s32;
 #    else
 typedef unsigned __int8  u8;
-typedef signed __int8    s8;
+typedef signed   __int8  s8;
 typedef unsigned __int16 u16;
-typedef signed __int16   s16;
+typedef signed   __int16 s16;
 typedef unsigned __int32 u32;
-typedef signed __int32   s32;
+typedef signed   __int32 s32;
 #    endif
 typedef unsigned __int64 u64;
-typedef signed __int64   s64;
+typedef signed   __int64 s64;
 #else
 #	include <stdint.h>
 
@@ -85,10 +86,10 @@ 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    uw;
-typedef ptrdiff_t sw;
+typedef size_t    usize;
+typedef ptrdiff_t ssize;
 
-static_assert( sizeof( uw ) == sizeof( sw ), "sizeof(uw) != sizeof(sw)" );
+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 )
@@ -122,4 +123,21 @@ 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/debug.hpp

@@ -24,7 +24,7 @@
 	{                                                                                        \
 		if ( ! ( cond ) )                                                                    \
 		{                                                                                    \
-			assert_handler( #cond, __FILE__, zpl_cast( s64 ) __LINE__, msg, ##__VA_ARGS__ ); \
+			assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ );   \
 			GEN_DEBUG_TRAP();                                                                \
 		}                                                                                    \
 	} while ( 0 )
@@ -34,18 +34,14 @@
 // NOTE: Things that shouldn't happen with a message!
 #define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
 
-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 );
-
 #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__); \
+		                                                   \
+		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__);      \
 		GEN_PANIC(buf);                                    \
 	}                                                      \
 	while (0)
@@ -53,11 +49,15 @@ void process_exit( u32 code );
 
 #	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

@@ -7,10 +7,11 @@
 
 #if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
 
-internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_len_ )
+internal
+wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
 {
 	wchar_t* w_text = NULL;
-	sw       len = 0, w_len = 0, w_len1 = 0;
+	ssize       len = 0, w_len = 0, w_len1 = 0;
 	if ( text == NULL )
 	{
 		if ( w_len_ )
@@ -24,7 +25,7 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
 			*w_len_ = w_len;
 		return NULL;
 	}
-	w_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, zpl_cast( int ) len, NULL, 0 );
+	w_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), NULL, 0 );
 	if ( w_len == 0 )
 	{
 		if ( w_len_ )
@@ -32,7 +33,7 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
 		return NULL;
 	}
 	w_text = alloc_array( a, wchar_t, w_len + 1 );
-	w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, zpl_cast( int ) len, w_text, zpl_cast( int ) w_len );
+	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 );
@@ -46,7 +47,8 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
 	return w_text;
 }
 
-internal GEN_FILE_SEEK_PROC( _win32_file_seek )
+internal
+GEN_FILE_SEEK_PROC( _win32_file_seek )
 {
 	LARGE_INTEGER li_offset;
 	li_offset.QuadPart = offset;
@@ -60,12 +62,13 @@ internal GEN_FILE_SEEK_PROC( _win32_file_seek )
 	return true;
 }
 
-internal GEN_FILE_READ_AT_PROC( _win32_file_read )
+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_ = zpl_cast( DWORD )( size > GEN_I32_MAX ? GEN_I32_MAX : size );
+	DWORD size_ = scast( DWORD, ( size > GEN_I32_MAX ? GEN_I32_MAX : size ));
 	DWORD bytes_read_;
 	if ( ReadFile( fd.p, buffer, size_, &bytes_read_, NULL ) )
 	{
@@ -77,9 +80,10 @@ internal GEN_FILE_READ_AT_PROC( _win32_file_read )
 	return result;
 }
 
-internal GEN_FILE_WRITE_AT_PROC( _win32_file_write )
+internal
+GEN_FILE_WRITE_AT_PROC( _win32_file_write )
 {
-	DWORD size_ = zpl_cast( DWORD )( size > GEN_I32_MAX ? GEN_I32_MAX : size );
+	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 ) )
@@ -91,14 +95,16 @@ internal GEN_FILE_WRITE_AT_PROC( _win32_file_write )
 	return false;
 }
 
-internal GEN_FILE_CLOSE_PROC( _win32_file_close )
+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 )
+neverinline
+GEN_FILE_OPEN_PROC( _win32_file_open )
 {
 	DWORD    desired_access;
 	DWORD    creation_disposition;
@@ -176,7 +182,8 @@ neverinline GEN_FILE_OPEN_PROC( _win32_file_open )
 #else    // POSIX
 #	include <fcntl.h>
 
-internal GEN_FILE_SEEK_PROC( _posix_file_seek )
+internal
+GEN_FILE_SEEK_PROC( _posix_file_seek )
 {
 #	if defined( GEN_SYSTEM_OSX )
 	s64 res = lseek( fd.i, offset, whence );
@@ -190,10 +197,11 @@ internal GEN_FILE_SEEK_PROC( _posix_file_seek )
 	return true;
 }
 
-internal GEN_FILE_READ_AT_PROC( _posix_file_read )
+internal
+GEN_FILE_READ_AT_PROC( _posix_file_read )
 {
 	unused( stop_at_newline );
-	sw res = pread( fd.i, buffer, size, offset );
+	ssize res = pread( fd.i, buffer, size, offset );
 	if ( res < 0 )
 		return false;
 	if ( bytes_read )
@@ -201,19 +209,20 @@ internal GEN_FILE_READ_AT_PROC( _posix_file_read )
 	return true;
 }
 
-internal GEN_FILE_WRITE_AT_PROC( _posix_file_write )
+internal
+GEN_FILE_WRITE_AT_PROC( _posix_file_write )
 {
-	sw  res;
+	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( zpl_cast( int ) fd.i, buffer, size );
+		res = write( scast( int, fd.i), buffer, size );
 	}
 	else
 	{
-		res = pwrite( zpl_cast( int ) fd.i, buffer, size, offset );
+		res = pwrite( scast( int, fd.i), buffer, size, offset );
 	}
 	if ( res < 0 )
 		return false;
@@ -222,14 +231,16 @@ internal GEN_FILE_WRITE_AT_PROC( _posix_file_write )
 	return true;
 }
 
-internal GEN_FILE_CLOSE_PROC( _posix_file_close )
+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 )
+neverinline
+GEN_FILE_OPEN_PROC( _posix_file_open )
 {
 	s32 os_mode;
 	switch ( mode & GEN_FILE_MODES )
@@ -292,7 +303,7 @@ 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 ].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 ) );
@@ -329,7 +340,7 @@ FileError file_close( FileInfo* f )
 		return EFileError_INVALID;
 
 	if ( f->filename )
-		free( heap(), zpl_cast( char* ) f->filename );
+		free( heap(), ccast( char*, f->filename ));
 
 #if defined( GEN_SYSTEM_WINDOWS )
 	if ( f->fd.p == INVALID_HANDLE_VALUE )
@@ -364,14 +375,14 @@ FileError file_close( FileInfo* f )
 FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename )
 {
 	FileError err = EFileError_NONE;
-	sw        len = str_len( filename );
+	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( zpl_cast( char* ) f->filename, zpl_cast( char* ) filename, len + 1 );
+	mem_copy( ccast( char*, f->filename), ccast( char*, filename), len + 1 );
 
 	return err;
 }
@@ -430,7 +441,7 @@ FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const
 
 	if ( file_open( &file, filepath ) == EFileError_NONE )
 	{
-		sw fsize = zpl_cast( sw ) file_size( &file );
+		ssize fsize = scast( ssize , file_size( &file ));
 		if ( fsize > 0 )
 		{
 			result.data = alloc( a, zero_terminate ? fsize + 1 : fsize );
@@ -438,7 +449,7 @@ FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const
 			file_read_at( &file, result.data, result.size, 0 );
 			if ( zero_terminate )
 			{
-				u8* str      = zpl_cast( u8* ) result.data;
+				u8* str      = rcast( u8*, result.data);
 				str[ fsize ] = '\0';
 			}
 		}
@@ -452,26 +463,28 @@ struct _memory_fd
 {
 	u8            magic;
 	u8*           buf;    //< zpl_array OR plain buffer if we can't write
-	sw            cursor;
+	ssize         cursor;
 	AllocatorInfo allocator;
 
 	FileStreamFlags flags;
-	sw              cap;
+	ssize           cap;
 };
 
 #define GEN__FILE_STREAM_FD_MAGIC 37
 
-GEN_DEF_INLINE FileDescriptor _file_stream_fd_make( _memory_fd* d );
-GEN_DEF_INLINE _memory_fd*    _file_stream_from_fd( FileDescriptor fd );
+FileDescriptor _file_stream_fd_make( _memory_fd* d );
+_memory_fd*    _file_stream_from_fd( FileDescriptor fd );
 
-GEN_IMPL_INLINE FileDescriptor _file_stream_fd_make( _memory_fd* d )
+inline
+FileDescriptor _file_stream_fd_make( _memory_fd* d )
 {
 	FileDescriptor fd = { 0 };
 	fd.p              = ( void* )d;
 	return fd;
 }
 
-GEN_IMPL_INLINE _memory_fd* _file_stream_from_fd( FileDescriptor 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 );
@@ -492,7 +505,7 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator )
 	d->allocator = allocator;
 	d->flags     = EFileStream_CLONE_WRITABLE;
 	d->cap       = 0;
-	d->buf       = Array<u8>::init( allocator );
+	d->buf       = array_init<u8>( allocator );
 
 	if ( ! d->buf )
 		return false;
@@ -506,7 +519,7 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator )
 	return true;
 }
 
-b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw size, FileStreamFlags flags )
+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 ) );
@@ -518,7 +531,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw siz
 	d->flags     = flags;
 	if ( d->flags & EFileStream_CLONE_WRITABLE )
 	{
-		Array<u8> arr = Array<u8>::init_reserve( allocator, size );
+		Array<u8> arr = array_init_reserve<u8>( allocator, size );
 		d->buf = arr;
 
 		if ( ! d->buf )
@@ -527,7 +540,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw siz
 		mem_copy( d->buf, buffer, size );
 		d->cap = size;
 
-		arr.get_header()->Num = size;
+		get_header(arr)->Num = size;
 	}
 	else
 	{
@@ -543,7 +556,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw siz
 	return true;
 }
 
-u8* file_stream_buf( FileInfo* file, sw* size )
+u8* file_stream_buf( FileInfo* file, ssize* size )
 {
 	GEN_ASSERT_NOT_NULL( file );
 	_memory_fd* d = _file_stream_from_fd( file->fd );
@@ -552,10 +565,11 @@ u8* file_stream_buf( FileInfo* file, sw* size )
 	return d->buf;
 }
 
-internal GEN_FILE_SEEK_PROC( _memory_file_seek )
+internal
+GEN_FILE_SEEK_PROC( _memory_file_seek )
 {
 	_memory_fd* d      = _file_stream_from_fd( fd );
-	sw          buflen = d->cap;
+	ssize          buflen = d->cap;
 
 	if ( whence == ESeekWhence_BEGIN )
 		d->cursor = 0;
@@ -568,7 +582,8 @@ internal GEN_FILE_SEEK_PROC( _memory_file_seek )
 	return true;
 }
 
-internal GEN_FILE_READ_AT_PROC( _memory_file_read )
+internal
+GEN_FILE_READ_AT_PROC( _memory_file_read )
 {
 	// unused( stop_at_newline );
 	_memory_fd* d = _file_stream_from_fd( fd );
@@ -578,25 +593,26 @@ internal GEN_FILE_READ_AT_PROC( _memory_file_read )
 	return true;
 }
 
-internal GEN_FILE_WRITE_AT_PROC( _memory_file_write )
+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;
 
-	sw buflen   = d->cap;
-	sw extralen = max( 0, size - ( buflen - offset ) );
-	sw rwlen    = size - extralen;
-	sw new_cap  = buflen + extralen;
+	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 ( arr.get_header()->Capacity < new_cap )
+		if ( get_header(arr)->Capacity < usize(new_cap) )
 		{
-			if ( ! arr.grow( ( s64 )( new_cap ) ) )
+			if ( ! grow( & arr, ( s64 )( new_cap ) ) )
 				return false;
 			d->buf = arr;
 		}
@@ -610,7 +626,7 @@ internal GEN_FILE_WRITE_AT_PROC( _memory_file_write )
 
 		mem_copy( d->buf + offset + rwlen, pointer_add_const( buffer, rwlen ), extralen );
 		d->cap = new_cap;
-		arr.get_header()->Capacity = new_cap;
+		get_header(arr)->Capacity = new_cap;
 	}
 	else
 	{
@@ -622,7 +638,8 @@ internal GEN_FILE_WRITE_AT_PROC( _memory_file_write )
 	return true;
 }
 
-internal GEN_FILE_CLOSE_PROC( _memory_file_close )
+internal
+GEN_FILE_CLOSE_PROC( _memory_file_close )
 {
 	_memory_fd*   d         = _file_stream_from_fd( fd );
 	AllocatorInfo allocator = d->allocator;
@@ -630,7 +647,7 @@ internal GEN_FILE_CLOSE_PROC( _memory_file_close )
 	if ( d->flags & EFileStream_CLONE_WRITABLE )
 	{
 		Array<u8> arr = { d->buf };
-		arr.free();
+		free(& arr);
 	}
 
 	free( allocator, d );

project/dependencies/filesystem.hpp

@@ -48,8 +48,8 @@ union FileDescriptor
 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, sw size, s64 offset, sw* bytes_read, b32 stop_at_newline )
-#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, sw size, s64 offset, sw* bytes_written )
+#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 )
 
@@ -161,7 +161,7 @@ FileError file_open_mode( FileInfo* file, FileMode mode, char const* filename );
 	* @param  buffer Buffer to read to
 	* @param  size   Size to read
 	*/
-GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
+b32 file_read( FileInfo* file, void* buffer, ssize size );
 
 /**
 	* Reads file at a specific offset
@@ -171,7 +171,7 @@ GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
 	* @param  offset     Offset to read from
 	* @param  bytes_read How much data we've actually read
 	*/
-GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offset );
+b32 file_read_at( FileInfo* file, void* buffer, ssize size, s64 offset );
 
 /**
 	* Reads file safely
@@ -181,13 +181,13 @@ GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offs
 	* @param  offset     Offset to read from
 	* @param  bytes_read How much data we've actually read
 	*/
-GEN_DEF_INLINE b32 file_read_at_check( FileInfo* file, void* buffer, sw size, s64 offset, sw* bytes_read );
+b32 file_read_at_check( FileInfo* file, void* buffer, ssize size, s64 offset, ssize* bytes_read );
 
 struct FileContents
 {
 	AllocatorInfo allocator;
 	void*         data;
-	sw            size;
+	ssize            size;
 };
 
 constexpr b32 zero_terminate    = true;
@@ -214,20 +214,20 @@ s64 file_size( FileInfo* file );
 	* @param  file
 	* @param  offset Offset to seek to
 	*/
-GEN_DEF_INLINE s64 file_seek( FileInfo* file, s64 offset );
+s64 file_seek( FileInfo* file, s64 offset );
 
 /**
 	* Seeks the file cursor to the end of the file
 	* @param  file
 	*/
-GEN_DEF_INLINE s64 file_seek_to_end( FileInfo* 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
 	*/
-GEN_DEF_INLINE s64 file_tell( FileInfo* file );
+s64 file_tell( FileInfo* file );
 
 /**
 	* Writes to a file
@@ -235,7 +235,7 @@ GEN_DEF_INLINE s64 file_tell( FileInfo* file );
 	* @param  buffer Buffer to read from
 	* @param  size   Size to read
 	*/
-GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
+b32 file_write( FileInfo* file, void const* buffer, ssize size );
 
 /**
 	* Writes to file at a specific offset
@@ -245,7 +245,7 @@ GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
 	* @param  offset        Offset to write to
 	* @param  bytes_written How much data we've actually written
 	*/
-GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s64 offset );
+b32 file_write_at( FileInfo* file, void const* buffer, ssize size, s64 offset );
 
 /**
 	* Writes to file safely
@@ -255,88 +255,7 @@ GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s
 	* @param  offset        Offset to write to
 	* @param  bytes_written How much data we've actually written
 	*/
-GEN_DEF_INLINE b32 file_write_at_check( FileInfo* file, void const* buffer, sw size, s64 offset, sw* bytes_written );
-
-GEN_IMPL_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;
-}
-
-GEN_IMPL_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;
-}
-
-GEN_IMPL_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;
-}
-
-GEN_IMPL_INLINE b32 file_read( FileInfo* f, void* buffer, sw 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;
-}
-
-GEN_IMPL_INLINE b32 file_read_at( FileInfo* f, void* buffer, sw size, s64 offset )
-{
-	return file_read_at_check( f, buffer, size, offset, NULL );
-}
-
-GEN_IMPL_INLINE b32 file_read_at_check( FileInfo* f, void* buffer, sw size, s64 offset, sw* 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 );
-}
-
-GEN_IMPL_INLINE b32 file_write( FileInfo* f, void const* buffer, sw 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;
-}
-
-GEN_IMPL_INLINE b32 file_write_at( FileInfo* f, void const* buffer, sw size, s64 offset )
-{
-	return file_write_at_check( f, buffer, size, offset, NULL );
-}
-
-GEN_IMPL_INLINE b32 file_write_at_check( FileInfo* f, void const* buffer, sw size, s64 offset, sw* bytes_written )
-{
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-
-	return f->ops.write_at( f->fd, buffer, size, offset, bytes_written );
-}
-
-
+b32 file_write_at_check( FileInfo* file, void const* buffer, ssize size, s64 offset, ssize* bytes_written );
 
 enum FileStreamFlags : u32
 {
@@ -363,15 +282,103 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator );
 	* @param  size     Buffer's size
 	* @param  flags
 	*/
-b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw size, FileStreamFlags 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, sw* 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

@@ -27,11 +27,11 @@ global u32 const _crc32_table[ 256 ] = {
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
 
-u32 crc32( void const* data, sw len )
+u32 crc32( void const* data, ssize len )
 {
-	sw        remaining;
-	u32       result = ~( zpl_cast( u32 ) 0 );
-	u8 const* c      = zpl_cast( u8 const* ) data;
+	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;
@@ -77,11 +77,11 @@ global u64 const _crc64_table[ 256 ] = {
 	0xa6df411fbfb21ca3ull, 0xdc0731d78f8795daull, 0x536fa08fdfd90e51ull, 0x29b7d047efec8728ull,
 };
 
-u64 crc64( void const* data, sw len )
+u64 crc64( void const* data, ssize len )
 {
-	sw        remaining;
-	u64       result = ( zpl_cast( u64 ) 0 );
-	u8 const* c      = zpl_cast( u8 const* ) data;
+	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;

project/dependencies/hashing.hpp

@@ -5,7 +5,7 @@
 
 #pragma region Hashing
 
-u32 crc32( void const* data, sw len );
-u64 crc64( void const* data, sw len );
+u32 crc32( void const* data, ssize len );
+u64 crc64( void const* data, ssize len );
 
 #pragma endregion Hashing

project/dependencies/macros.hpp

@@ -1,52 +1,99 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "header_start.hpp"
+#   pragma once
 #endif
 
 #pragma region Macros
 
-#define zpl_cast( Type ) ( Type )
-
-// Keywords
-
+#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
-
-#ifdef GEN_COMPILER_MSVC
-#	define forceinline __forceinline
-#	define neverinline __declspec( noinline )
-#elif defined(GEN_COMPILER_GCC)
-#	define forceinline inline __attribute__((__always_inline__))
-#	define neverinline __attribute__( ( __noinline__ ) )
-#elif defined(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
 
-// Bits
+#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
 
-// Casting
 
-#define ccast( Type, Value ) ( * const_cast< Type* >( & (Value) ) )
-#define pcast( Type, Value ) ( * reinterpret_cast< Type* >( & ( Value ) ) )
-#define rcast( Type, Value ) reinterpret_cast< Type >( Value )
-#define scast( Type, Value ) static_cast< Type >( Value )
+#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
 
-// Num Arguments (Varadics)
-// #if defined(__GNUC__) || defined(__clang__)
-// Supports 0-50 arguments
+#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,  \
@@ -61,7 +108,7 @@
 		N, ...                                             \
 	) N
 
-	// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
+// ## 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, \
@@ -76,93 +123,117 @@
 		 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
 		 0                                       \
 	)
+#endif
 
-// #else
-// This doesn't work on latest msvc so I had to use /Zc:preprocessor flag.
-
-// Supports 1-50 arguments
-// #define num_args_impl(                                  \
-// 		_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
-
-// #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, \
-// 		 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  \
-// 	)
-// #endif
-
-// Stringizing
-#define stringize_va( ... ) #__VA_ARGS__
-#define stringize( ... )    stringize_va( __VA_ARGS__ )
-
-// Function do once
-
-#define do_once()          \
-	do                     \
-	{                      \
-		static             \
-		bool Done = false; \
-		if ( Done )        \
-			return;        \
-		Done = true;       \
-	}                      \
-	while(0)
-
-#define do_once_start      \
-	do                     \
-	{                      \
-		static             \
-		bool Done = false; \
-		if ( Done )        \
-			break;         \
-		Done = true;
-
-#define do_once_end        \
-	}                      \
-	while(0);
-
-#define labeled_scope_start if ( false ) {
-#define labeled_scope_end   }
-
+#ifndef clamp
 #define clamp( x, lower, upper )      min( max( ( x ), ( lower ) ), ( upper ) )
-#define count_of( x )                 ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( sw )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
+#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 ) ) )
-#define max( a, b )                   ( ( a ) > ( b ) ? ( a ) : ( b ) )
-#define min( a, b )                   ( ( a ) < ( b ) ? ( a ) : ( b ) )
-#define size_of( x )                  ( sw )( sizeof( x ) )
+#endif
+#ifndef size_of
+#define size_of( x )                  ( ssize )( sizeof( x ) )
+#endif
 
-#if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
-#	define offset_of( Type, element ) ( ( GEN_NS( gen_sw ) ) & ( ( ( Type* )0 )->element ) )
+#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
 
-template< class Type >
-void swap( Type& a, Type& b )
-{
-	Type tmp = a;
-	a = b;
-	b = tmp;
-}
+#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.
+#define foreach(Type, entry_id, iterable) for ( Type entry_id = begin(iterable); entry_id != end(iterable); entry_id = next(iterable, entry_id) )
+
+#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
+
+#if ! defined(GEN_PARAM_DEFAULT) && ! GEN_COMPILER_C
+#	define GEN_PARAM_DEFAULT = {}
+#else
+#	define GEN_PARAM_DEFAULT
+#endif
 
 #pragma endregion Macros

project/dependencies/memory.cpp

@@ -5,7 +5,7 @@
 
 #pragma region Memory
 
-void* mem_copy( void* dest, void const* source, sw n )
+void* mem_copy( void* dest, void const* source, ssize n )
 {
 	if ( dest == NULL )
 	{
@@ -15,25 +15,25 @@ void* mem_copy( void* dest, void const* source, sw n )
 	return memcpy( dest, source, n );
 }
 
-void const* mem_find( void const* data, u8 c, sw n )
+void const* mem_find( void const* data, u8 c, ssize n )
 {
-	u8 const* s = zpl_cast( u8 const* ) data;
-	while ( ( zpl_cast( uptr ) s & ( sizeof( uw ) - 1 ) ) && n && *s != c )
+	u8 const* s = rcast( u8 const*, data);
+	while ( ( rcast( uptr, s) & ( sizeof( usize ) - 1 ) ) && n && *s != c )
 	{
 		s++;
 		n--;
 	}
 	if ( n && *s != c )
 	{
-		sw const* w;
-		sw        k = GEN__ONES * c;
-		w           = zpl_cast( sw const* ) s;
-		while ( n >= size_of( sw ) && ! GEN__HAS_ZERO( *w ^ k ) )
+		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( sw );
+			n -= size_of( ssize );
 		}
-		s = zpl_cast( u8 const* ) w;
+		s = rcast( u8 const*, w);
 		while ( n && *s != c )
 		{
 			s++;
@@ -41,7 +41,7 @@ void const* mem_find( void const* data, u8 c, sw n )
 		}
 	}
 
-	return n ? zpl_cast( void const* ) s : NULL;
+	return n ? rcast( void const*, s ) : NULL;
 }
 
 #define GEN_HEAP_STATS_MAGIC 0xDEADC0DE
@@ -49,8 +49,8 @@ void const* mem_find( void const* data, u8 c, sw n )
 struct _heap_stats
 {
 	u32 magic;
-	sw  used_memory;
-	sw  alloc_count;
+	ssize  used_memory;
+	ssize  alloc_count;
 };
 
 global _heap_stats _heap_stats_info;
@@ -61,13 +61,13 @@ void heap_stats_init( void )
 	_heap_stats_info.magic = GEN_HEAP_STATS_MAGIC;
 }
 
-sw heap_stats_used_memory( void )
+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;
 }
 
-sw heap_stats_alloc_count( void )
+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;
@@ -82,11 +82,11 @@ void heap_stats_check( void )
 
 struct _heap_alloc_info
 {
-	sw    size;
+	ssize    size;
 	void* physical_start;
 };
 
-void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+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 );
@@ -95,16 +95,16 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
 		alignment = GEN_DEFAULT_MEMORY_ALIGNMENT;
 
 #ifdef GEN_HEAP_ANALYSIS
-	sw alloc_info_size      = size_of( _heap_alloc_info );
-	sw alloc_info_remainder = ( alloc_info_size % alignment );
-	sw track_size           = max( alloc_info_size, alignment ) + alloc_info_remainder;
+	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  = zpl_cast( _heap_alloc_info* ) old_memory - 1;
+				_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;
@@ -195,11 +195,11 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
 #ifdef GEN_HEAP_ANALYSIS
 	if ( type == EAllocation_ALLOC )
 	{
-		_heap_alloc_info* alloc_info = zpl_cast( _heap_alloc_info* )( zpl_cast( char* ) ptr + alloc_info_remainder );
+		_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                           = zpl_cast( void* )( alloc_info + 1 );
+		ptr                           = rcast( void*, alloc_info + 1 );
 		_heap_stats_info.used_memory += alloc_info->size;
 		_heap_stats_info.alloc_count++;
 	}
@@ -209,7 +209,7 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
 }
 
 #pragma region VirtualMemory
-VirtualMemory vm_from_memory( void* data, sw size )
+VirtualMemory vm_from_memory( void* data, ssize size )
 {
 	VirtualMemory vm;
 	vm.data = data;
@@ -218,7 +218,7 @@ VirtualMemory vm_from_memory( void* data, sw size )
 }
 
 #if defined( GEN_SYSTEM_WINDOWS )
-VirtualMemory vm_alloc( void* addr, sw size )
+VirtualMemory vm_alloc( void* addr, ssize size )
 {
 	VirtualMemory vm;
 	GEN_ASSERT( size > 0 );
@@ -234,7 +234,7 @@ b32 vm_free( VirtualMemory vm )
 	{
 		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 > zpl_cast( uw ) vm.size )
+		if ( info.BaseAddress != vm.data || info.AllocationBase != vm.data || info.State != MEM_COMMIT || info.RegionSize > scast( usize, vm.size) )
 		{
 			return false;
 		}
@@ -246,7 +246,7 @@ b32 vm_free( VirtualMemory vm )
 	return true;
 }
 
-VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size )
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
 {
 	VirtualMemory new_vm = { 0 };
 	void*             ptr;
@@ -270,7 +270,7 @@ b32 vm_purge( VirtualMemory vm )
 	return true;
 }
 
-sw virtual_memory_page_size( sw* alignment_out )
+ssize virtual_memory_page_size( ssize* alignment_out )
 {
 	SYSTEM_INFO info;
 	GetSystemInfo( &info );
@@ -285,7 +285,7 @@ sw virtual_memory_page_size( sw* alignment_out )
 #	ifndef MAP_ANONYMOUS
 #		define MAP_ANONYMOUS MAP_ANON
 #	endif
-VirtualMemory vm_alloc( void* addr, sw size )
+VirtualMemory vm_alloc( void* addr, ssize size )
 {
 	VirtualMemory vm;
 	GEN_ASSERT( size > 0 );
@@ -300,10 +300,10 @@ b32 vm_free( VirtualMemory vm )
 	return true;
 }
 
-VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size )
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
 {
 	void*  ptr;
-	sw trail_size;
+	ssize trail_size;
 	GEN_ASSERT( vm.size >= lead_size + size );
 
 	ptr        = pointer_add( vm.data, lead_size );
@@ -322,10 +322,10 @@ b32 vm_purge( VirtualMemory vm )
 	return err != 0;
 }
 
-sw virtual_memory_page_size( sw* alignment_out )
+ssize virtual_memory_page_size( ssize* alignment_out )
 {
 	// TODO: Is this always true?
-	sw result = zpl_cast( sw ) sysconf( _SC_PAGE_SIZE );
+	ssize result = scast( ssize, sysconf( _SC_PAGE_SIZE ));
 	if ( alignment_out )
 		*alignment_out = result;
 	return result;
@@ -334,7 +334,7 @@ sw virtual_memory_page_size( sw* alignment_out )
 
 #pragma endregion VirtualMemory
 
-void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+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;
@@ -346,10 +346,10 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
 		case EAllocation_ALLOC :
 			{
 				void* end        = pointer_add( arena->PhysicalStart, arena->TotalUsed );
-				sw    total_size = align_forward_i64( size, alignment );
+				ssize    total_size = align_forward_i64( size, alignment );
 
 				// NOTE: Out of memory
-				if ( arena->TotalUsed + total_size > (sw) arena->TotalSize )
+				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!!)");
@@ -384,9 +384,9 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
 	return ptr;
 }
 
-void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+void* pool_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
 {
-	Pool* pool = zpl_cast( Pool* ) allocator_data;
+	Pool* pool = rcast( Pool*, allocator_data);
 	void* ptr  = NULL;
 
 	// unused( old_size );
@@ -401,9 +401,9 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
 				GEN_ASSERT( alignment == pool->BlockAlign );
 				GEN_ASSERT( pool->FreeList != NULL );
 
-				next_free        = *zpl_cast( uptr* ) pool->FreeList;
+				next_free        = * rcast( uptr*, pool->FreeList);
 				ptr              = pool->FreeList;
-				pool->FreeList   = zpl_cast( void* ) next_free;
+				pool->FreeList   = rcast( void*, next_free);
 				pool->TotalSize += pool->BlockSize;
 
 				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
@@ -417,8 +417,8 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
 				if ( old_memory == NULL )
 					return NULL;
 
-				next             = zpl_cast( uptr* ) old_memory;
-				*next            = zpl_cast( uptr ) pool->FreeList;
+				next             = rcast( uptr*, old_memory);
+				*next            = rcast( uptr, pool->FreeList);
 				pool->FreeList   = old_memory;
 				pool->TotalSize -= pool->BlockSize;
 			}
@@ -426,7 +426,7 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
 
 		case EAllocation_FREE_ALL :
 			{
-				sw    actual_block_size, block_index;
+				ssize    actual_block_size, block_index;
 				void* curr;
 				uptr* end;
 
@@ -437,13 +437,13 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
 				curr = pool->PhysicalStart;
 				for ( block_index = 0; block_index < pool->NumBlocks - 1; block_index++ )
 				{
-					uptr* next = zpl_cast( uptr* ) curr;
-					*next      = zpl_cast( uptr ) curr + actual_block_size;
+					uptr* next = rcast( uptr*, curr);
+					* next     = rcast( uptr, curr) + actual_block_size;
 					curr       = pointer_add( curr, actual_block_size );
 				}
 
-				end            = zpl_cast( uptr* ) curr;
-				*end           = zpl_cast( uptr ) NULL;
+				end            = rcast( uptr*, curr);
+				* end          = scast( uptr, NULL);
 				pool->FreeList = pool->PhysicalStart;
 			}
 			break;
@@ -457,11 +457,11 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
 	return ptr;
 }
 
-Pool Pool::init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align )
+Pool pool_init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align )
 {
 	Pool pool = {};
 
-	sw    actual_block_size, pool_size, block_index;
+	ssize    actual_block_size, pool_size, block_index;
 	void *data, *curr;
 	uptr* end;
 
@@ -495,16 +495,16 @@ Pool Pool::init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw b
 	return pool;
 }
 
-void Pool::clear()
+void clear(Pool& pool)
 {
-	sw    actual_block_size, block_index;
+	ssize actual_block_size, block_index;
 	void* curr;
 	uptr* end;
 
-	actual_block_size = BlockSize + BlockAlign;
+	actual_block_size = pool.BlockSize + pool.BlockAlign;
 
-	curr = PhysicalStart;
-	for ( block_index = 0; block_index < NumBlocks - 1; block_index++ )
+	curr = pool.PhysicalStart;
+	for ( block_index = 0; block_index < pool.NumBlocks - 1; block_index++ )
 	{
 		uptr* next = ( uptr* ) curr;
 		*next      = ( uptr  ) curr + actual_block_size;
@@ -514,7 +514,7 @@ void Pool::clear()
 	end  =  ( uptr* ) curr;
 	*end =  ( uptr )  NULL;
 
-	FreeList = PhysicalStart;
+	pool.FreeList = pool.PhysicalStart;
 }
 
 #pragma endregion Memory

project/dependencies/memory.hpp

@@ -5,48 +5,56 @@
 
 #pragma region Memory
 
-#define kilobytes( x ) ( ( x ) * ( s64 )( 1024 ) )
+#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          ( zpl_cast( uw ) - 1 / GEN_U8_MAX )
+#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 )
+#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.
-GEN_DEF_INLINE b32 is_power_of_two( sw x );
+b32 is_power_of_two( ssize x );
 
 //! Aligns address to specified alignment.
-GEN_DEF_INLINE void* align_forward( void* ptr, sw alignment );
+void* align_forward( void* ptr, ssize alignment );
 
 //! Aligns value to a specified alignment.
-GEN_DEF_INLINE s64 align_forward_i64( s64 value, sw alignment );
+s64 align_forward_i64( s64 value, ssize alignment );
 
 //! Moves pointer forward by bytes.
-GEN_DEF_INLINE void* pointer_add( void* ptr, sw bytes );
+void* pointer_add( void* ptr, ssize bytes );
 
 //! Moves pointer forward by bytes.
-GEN_DEF_INLINE void const* pointer_add_const( void const* ptr, sw bytes );
+void const* pointer_add_const( void const* ptr, ssize bytes );
 
 //! Calculates difference between two addresses.
-GEN_DEF_INLINE sw pointer_diff( void const* begin, void const* end );
+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, sw size );
+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, sw size );
+void const* mem_find( void const* data, u8 byte_value, ssize size );
 
 //! Copy memory from source to destination.
-GEN_DEF_INLINE void* mem_move( void* dest, void const* source, sw size );
+void* mem_move( void* dest, void const* source, ssize size );
 
 //! Set constant value at memory location with specified size.
-GEN_DEF_INLINE void* mem_set( void* data, u8 byte_value, sw 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.
-GEN_DEF_INLINE void zero_size( void* ptr, sw size );
+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
@@ -54,24 +62,23 @@ GEN_DEF_INLINE void zero_size( void* ptr, sw size );
 //! Clears up an array.
 #define zero_array( a, count ) zero_size( ( a ), size_of( *( a ) ) * count )
 
-enum AllocType : u8
+enum AllocType_Def //enum_underlying(u8)
 {
 	EAllocation_ALLOC,
 	EAllocation_FREE,
 	EAllocation_FREE_ALL,
 	EAllocation_RESIZE,
 };
+typedef enum AllocType_Def AllocType;
 
-using AllocatorProc = void* ( void* allocator_data, AllocType type
-	, sw size, sw alignment
-	, void* old_memory, sw old_size
-	, u64 flags );
+typedef void*(AllocatorProc)( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
 
-struct AllocatorInfo
+struct AllocatorInfo_Def
 {
 	AllocatorProc* Proc;
 	void*          Data;
 };
+typedef struct AllocatorInfo_Def AllocatorInfo;
 
 enum AllocFlag
 {
@@ -87,22 +94,22 @@ enum AllocFlag
 #endif
 
 //! Allocate memory with default alignment.
-GEN_DEF_INLINE void* alloc( AllocatorInfo a, sw size );
+void* alloc( AllocatorInfo a, ssize size );
 
 //! Allocate memory with specified alignment.
-GEN_DEF_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment );
+void* alloc_align( AllocatorInfo a, ssize size, ssize alignment );
 
 //! Free allocated memory.
-GEN_DEF_INLINE void free( AllocatorInfo a, void* ptr );
+void free( AllocatorInfo a, void* ptr );
 
 //! Free all memory allocated by an allocator.
-GEN_DEF_INLINE void free_all( AllocatorInfo a );
+void free_all( AllocatorInfo a );
 
 //! Resize an allocated memory.
-GEN_DEF_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size );
+void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size );
 
 //! Resize an allocated memory with specified alignment.
-GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw 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 ) )
@@ -114,20 +121,20 @@ GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw n
 /* 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 );
-sw   heap_stats_used_memory( void );
-sw   heap_stats_alloc_count( void );
-void heap_stats_check( void );
+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
-GEN_DEF_INLINE void* default_resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
+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, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+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 ) { return { heap_allocator_proc, nullptr }; }
+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 )
@@ -135,203 +142,502 @@ constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr };
 //! Helper to free memory allocated by heap allocator.
 #define mfree( ptr ) free( heap(), ptr )
 
-GEN_IMPL_INLINE b32 is_power_of_two( sw x )
+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 ) );
 }
 
-GEN_IMPL_INLINE void* align_forward( void* ptr, sw alignment )
+inline
+mem_ptr align_forward( void* ptr, ssize alignment )
 {
-	uptr p;
-
 	GEN_ASSERT( is_power_of_two( alignment ) );
+	uptr p       = to_uptr(ptr);
+	uptr forward = (p + ( alignment - 1 ) ) & ~( alignment - 1 );
 
-	p = zpl_cast( uptr ) ptr;
-	return zpl_cast( void* )( ( p + ( alignment - 1 ) ) & ~( alignment - 1 ) );
+	return to_mem_ptr(forward);
 }
 
-GEN_IMPL_INLINE s64 align_forward_i64( s64 value, sw alignment )
-{
-	return value + ( alignment - value % alignment ) % alignment;
+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) );
 }
 
-GEN_IMPL_INLINE void* pointer_add( void* ptr, sw bytes )
+inline
+void* mem_move( void* destination, void const* source, ssize byte_count )
 {
-	return zpl_cast( void* )( zpl_cast( u8* ) ptr + bytes );
-}
-
-GEN_IMPL_INLINE void const* pointer_add_const( void const* ptr, sw bytes )
-{
-	return zpl_cast( void const* )( zpl_cast( u8 const* ) ptr + bytes );
-}
-
-GEN_IMPL_INLINE sw pointer_diff( void const* begin, void const* end )
-{
-	return zpl_cast( sw )( zpl_cast( u8 const* ) end - zpl_cast( u8 const* ) begin );
-}
-
-GEN_IMPL_INLINE void* mem_move( void* dest, void const* source, sw n )
-{
-	if ( dest == NULL )
+	if ( destination == NULL )
 	{
 		return NULL;
 	}
 
-	u8*       d = zpl_cast( u8* ) dest;
-	u8 const* s = zpl_cast( u8 const* ) source;
+	u8*       dest_ptr = rcast( u8*, destination);
+	u8 const* src_ptr  = rcast( u8 const*, source);
 
-	if ( d == s )
-		return d;
-	if ( s + n <= d || d + n <= s )    // NOTE: Non-overlapping
-		return mem_copy( d, s, n );
+	if ( dest_ptr == src_ptr )
+		return dest_ptr;
 
-	if ( d < s )
+	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 ( zpl_cast( uptr ) s % size_of( sw ) == zpl_cast( uptr ) d % size_of( sw ) )
+		if ( to_uptr(src_ptr) % size_of( ssize ) == to_uptr(dest_ptr) % size_of( ssize ) )
 		{
-			while ( zpl_cast( uptr ) d % size_of( sw ) )
+			while ( pcast( uptr, dest_ptr) % size_of( ssize ) )
 			{
-				if ( ! n-- )
-					return dest;
-				*d++ = *s++;
+				if ( ! byte_count-- )
+					return destination;
+
+				*dest_ptr++ = *src_ptr++;
 			}
-			while ( n >= size_of( sw ) )
+			while ( byte_count >= size_of( ssize ) )
 			{
-				*zpl_cast( sw* ) d  = *zpl_cast( sw* ) s;
-				n                  -= size_of( sw );
-				d                  += size_of( sw );
-				s                  += size_of( sw );
+				* 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 ( ; n; n-- )
-			*d++ = *s++;
+		for ( ; byte_count; byte_count-- )
+			*dest_ptr++ = *src_ptr++;
 	}
 	else
 	{
-		if ( ( zpl_cast( uptr ) s % size_of( sw ) ) == ( zpl_cast( uptr ) d % size_of( sw ) ) )
+		if ( ( to_uptr(src_ptr) % size_of( ssize ) ) == ( to_uptr(dest_ptr) % size_of( ssize ) ) )
 		{
-			while ( zpl_cast( uptr )( d + n ) % size_of( sw ) )
+			while ( to_uptr( dest_ptr + byte_count ) % size_of( ssize ) )
 			{
-				if ( ! n-- )
-					return dest;
-				d[ n ] = s[ n ];
+				if ( ! byte_count-- )
+					return destination;
+
+				dest_ptr[ byte_count ] = src_ptr[ byte_count ];
 			}
-			while ( n >= size_of( sw ) )
+			while ( byte_count >= size_of( ssize ) )
 			{
-				n                         -= size_of( sw );
-				*zpl_cast( sw* )( d + n )  = *zpl_cast( sw* )( s + n );
+				byte_count                              -= size_of( ssize );
+				* rcast(ssize*, dest_ptr + byte_count )  = * rcast( ssize const*, src_ptr + byte_count );
 			}
 		}
-		while ( n )
-			n--, d[ n ] = s[ n ];
+		while ( byte_count )
+			byte_count--, dest_ptr[ byte_count ] = src_ptr[ byte_count ];
 	}
 
-	return dest;
+	return destination;
 }
 
-GEN_IMPL_INLINE void* mem_set( void* dest, u8 c, sw n )
+inline
+void* mem_set( void* destination, u8 fill_byte, ssize byte_count )
 {
-	if ( dest == NULL )
+	if ( destination == NULL )
 	{
 		return NULL;
 	}
 
-	u8* s = zpl_cast( u8* ) dest;
-	sw  k;
-	u32 c32 = ( ( u32 )-1 ) / 255 * c;
+	ssize align_offset;
+	u8*   dest_ptr  = rcast( u8*, destination);
+	u32   fill_word = ( ( u32 )-1 ) / 255 * fill_byte;
 
-	if ( n == 0 )
-		return dest;
-	s[ 0 ] = s[ n - 1 ] = c;
-	if ( n < 3 )
-		return dest;
-	s[ 1 ] = s[ n - 2 ] = c;
-	s[ 2 ] = s[ n - 3 ] = c;
-	if ( n < 7 )
-		return dest;
-	s[ 3 ] = s[ n - 4 ] = c;
-	if ( n < 9 )
-		return dest;
+	if ( byte_count == 0 )
+		return destination;
 
-	k  = -zpl_cast( sptr ) s & 3;
-	s += k;
-	n -= k;
-	n &= -4;
+	dest_ptr[ 0 ] = dest_ptr[ byte_count - 1 ] = fill_byte;
+	if ( byte_count < 3 )
+		return destination;
 
-	*zpl_cast( u32* )( s + 0 )     = c32;
-	*zpl_cast( u32* )( s + n - 4 ) = c32;
-	if ( n < 9 )
-		return dest;
-	*zpl_cast( u32* )( s + 4 )      = c32;
-	*zpl_cast( u32* )( s + 8 )      = c32;
-	*zpl_cast( u32* )( s + n - 12 ) = c32;
-	*zpl_cast( u32* )( s + n - 8 )  = c32;
-	if ( n < 25 )
-		return dest;
-	*zpl_cast( u32* )( s + 12 )     = c32;
-	*zpl_cast( u32* )( s + 16 )     = c32;
-	*zpl_cast( u32* )( s + 20 )     = c32;
-	*zpl_cast( u32* )( s + 24 )     = c32;
-	*zpl_cast( u32* )( s + n - 28 ) = c32;
-	*zpl_cast( u32* )( s + n - 24 ) = c32;
-	*zpl_cast( u32* )( s + n - 20 ) = c32;
-	*zpl_cast( u32* )( s + n - 16 ) = c32;
+	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;
 
-	k  = 24 + ( zpl_cast( uptr ) s & 4 );
-	s += k;
-	n -= k;
+	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 c64 = ( zpl_cast( u64 ) c32 << 32 ) | c32;
-		while ( n > 31 )
+		u64 fill_doubleword = ( scast( u64, fill_word) << 32 ) | fill_word;
+		while ( byte_count > 31 )
 		{
-			*zpl_cast( u64* )( s + 0 )  = c64;
-			*zpl_cast( u64* )( s + 8 )  = c64;
-			*zpl_cast( u64* )( s + 16 ) = c64;
-			*zpl_cast( u64* )( s + 24 ) = c64;
+			* 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;
 
-			n -= 32;
-			s += 32;
+			byte_count -= 32;
+			dest_ptr += 32;
 		}
 	}
 
-	return dest;
+	return destination;
 }
 
-GEN_IMPL_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment )
-{
+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 );
 }
 
-GEN_IMPL_INLINE void* alloc( AllocatorInfo a, sw size )
-{
+inline
+void* alloc( AllocatorInfo a, ssize size ) {
 	return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
 }
 
-GEN_IMPL_INLINE void free( AllocatorInfo a, void* ptr )
-{
+inline
+void free( AllocatorInfo a, void* ptr ) {
 	if ( ptr != nullptr )
 		a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
 }
 
-GEN_IMPL_INLINE void free_all( AllocatorInfo a )
-{
+inline
+void free_all( AllocatorInfo a ) {
 	a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
 }
 
-GEN_IMPL_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size )
-{
+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 );
 }
 
-GEN_IMPL_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw 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 );
 }
 
-GEN_IMPL_INLINE void* default_resize_align( AllocatorInfo a, void* old_memory, sw old_size, sw new_size, sw alignment )
+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 );
@@ -351,207 +657,19 @@ GEN_IMPL_INLINE void* default_resize_align( AllocatorInfo a, void* old_memory, s
 	}
 	else
 	{
-		void* new_memory = alloc_align( a, new_size, alignment );
+		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;
 	}
 }
 
-GEN_IMPL_INLINE void zero_size( void* ptr, sw size )
-{
+inline
+void zero_size( void* ptr, ssize size ) {
 	mem_set( ptr, 0, size );
 }
 
-struct VirtualMemory
-{
-	void*  data;
-	sw size;
-};
-
-//! Initialize virtual memory from existing data.
-VirtualMemory vm_from_memory( void* data, sw 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, sw size );
-
-//! Release the virtual memory.
-b32 vm_free( VirtualMemory vm );
-
-//! Trim virtual memory.
-VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size );
-
-//! Purge virtual memory.
-b32 gen_vm_purge( VirtualMemory vm );
-
-//! Retrieve VM's page size and alignment.
-sw gen_virtual_memory_page_size( sw* alignment_out );
-
-struct Arena
-{
-	static
-	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
-
-	static
-	Arena init_from_memory( void* start, sw size )
-	{
-		return
-		{
-			{ nullptr, nullptr },
-			start,
-			size,
-			0,
-			0
-		};
-	}
-
-	static
-	Arena init_from_allocator( AllocatorInfo backing, sw size )
-	{
-		Arena result =
-		{
-		backing,
-		alloc( backing, size),
-		size,
-		0,
-		0
-		};
-		return result;
-	}
-
-	static
-	Arena init_sub( Arena& parent, sw size )
-	{
-		return init_from_allocator( parent.Backing, size );
-	}
-
-	sw alignment_of( sw alignment )
-	{
-		sw alignment_offset, result_pointer, mask;
-		GEN_ASSERT( is_power_of_two( alignment ) );
-
-		alignment_offset = 0;
-		result_pointer   = (sw) PhysicalStart + TotalUsed;
-		mask             = alignment - 1;
-
-		if ( result_pointer & mask )
-			alignment_offset = alignment - ( result_pointer & mask );
-
-		return alignment_offset;
-	}
-
-	void check()
-	{
-		GEN_ASSERT( TempCount == 0 );
-	}
-
-	void free()
-	{
-		if ( Backing.Proc )
-		{
-			gen::free( Backing, PhysicalStart );
-			PhysicalStart = nullptr;
-		}
-	}
-
-	sw size_remaining( sw alignment )
-	{
-		sw result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
-		return result;
-	}
-
-	AllocatorInfo Backing;
-	void*         PhysicalStart;
-	sw            TotalSize;
-	sw            TotalUsed;
-	sw            TempCount;
-
-	operator AllocatorInfo()
-	{
-		return { allocator_proc, this };
-	}
-};
-
-// 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
-{
-	static
-	FixedArena init()
-	{
-		FixedArena result = { Arena::init_from_memory( result.memory, Size ), {0} };
-		return result;
-	}
-
-	sw size_remaining( sw alignment )
-	{
-		return arena.size_remaining( alignment );
-	}
-
-	operator AllocatorInfo()
-	{
-		return { Arena::allocator_proc, &arena };
-	}
-
-	Arena arena;
-	char  memory[ Size ];
-};
-
-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 ) >;
-
-struct Pool
-{
-	static
-	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
-
-	static
-	Pool init( AllocatorInfo backing, sw num_blocks, sw block_size )
-	{
-		return init_align( backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
-	}
-
-	static
-	Pool init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align );
-
-	void clear();
-
-	void free()
-	{
-		if ( Backing.Proc )
-		{
-			gen::free( Backing, PhysicalStart );
-		}
-	}
-
-	AllocatorInfo Backing;
-	void*         PhysicalStart;
-	void*         FreeList;
-	sw            BlockSize;
-	sw            BlockAlign;
-	sw            TotalSize;
-	sw            NumBlocks;
-
-	operator AllocatorInfo()
-	{
-		return { allocator_proc, this };
-	}
-};
-
 #pragma endregion Memory

project/dependencies/parsing.cpp

@@ -23,7 +23,7 @@ u8 adt_make_branch( ADT_Node* node, AllocatorInfo backing, char const* name, b32
 	node->type   = type;
 	node->name   = name;
 	node->parent = parent;
-	node->nodes  = Array<ADT_Node>::init( backing );
+	node->nodes  = array_init<ADT_Node>( backing );
 
 	if ( ! node->nodes )
 		return EADT_ERROR_OUT_OF_MEMORY;
@@ -36,12 +36,12 @@ u8 adt_destroy_branch( ADT_Node* node )
 	GEN_ASSERT_NOT_NULL( node );
 	if ( ( node->type == EADT_TYPE_OBJECT || node->type == EADT_TYPE_ARRAY ) && node->nodes )
 	{
-		for ( sw i = 0; i < node->nodes.num(); ++i )
+		for ( ssize i = 0; i < scast(ssize, num(node->nodes)); ++i )
 		{
 			adt_destroy_branch( node->nodes + i );
 		}
 
-		node->nodes.free();
+		free(& node->nodes);
 	}
 	return 0;
 }
@@ -66,7 +66,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
 		return NULL;
 	}
 
-	for ( sw i = 0; i < node->nodes.num(); i++ )
+	for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ )
 	{
 		if ( ! str_compare( node->nodes[ i ].name, name ) )
 		{
@@ -76,7 +76,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
 
 	if ( deep_search )
 	{
-		for ( sw i = 0; i < node->nodes.num(); i++ )
+		for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ )
 		{
 			ADT_Node* res = adt_find( node->nodes + i, name, deep_search );
 
@@ -111,7 +111,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 				file_stream_open( &tmp, heap(), ( u8* )back, size_of( back ), EFileStream_WRITABLE );
 				adt_print_number( &tmp, node );
 
-				sw  fsize = 0;
+				ssize  fsize = 0;
 				u8* buf   = file_stream_buf( &tmp, &fsize );
 
 				if ( ! str_compare( ( char const* )buf, value ) )
@@ -132,7 +132,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 
 internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
 {
-	for ( sw i = 0; i < node->nodes.num(); i++ )
+	for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ )
 	{
 		if ( ! str_compare( node->nodes[ i ].name, name ) )
 		{
@@ -207,7 +207,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 			/* run a value comparison against any child that is an object node */
 			else if ( node->type == EADT_TYPE_ARRAY )
 			{
-				for ( sw i = 0; i < node->nodes.num(); i++ )
+				for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ )
 				{
 					ADT_Node* child = &node->nodes[ i ];
 					if ( child->type != EADT_TYPE_OBJECT )
@@ -225,7 +225,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 		/* [value] */
 		else
 		{
-			for ( sw i = 0; i < node->nodes.num(); i++ )
+			for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ )
 			{
 				ADT_Node* child = &node->nodes[ i ];
 				if ( _adt_get_value( child, l_b2 ) )
@@ -256,8 +256,8 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	/* handle array index lookup */
 	else
 	{
-		sw idx = ( sw )str_to_i64( buf, NULL, 10 );
-		if ( idx >= 0 && idx < node->nodes.num() )
+		ssize idx = ( ssize )str_to_i64( buf, NULL, 10 );
+		if ( idx >= 0 && idx < scast(ssize, num(node->nodes)) )
 		{
 			found_node = &node->nodes[ idx ];
 
@@ -272,7 +272,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	return found_node;
 }
 
-ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
+ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index )
 {
 	if ( ! parent || ( parent->type != EADT_TYPE_OBJECT && parent->type != EADT_TYPE_ARRAY ) )
 	{
@@ -282,15 +282,16 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
 	if ( ! parent->nodes )
 		return NULL;
 
-	if ( index < 0 || index > parent->nodes.num() )
+	if ( index < 0 || index > scast(ssize, num(parent->nodes)) )
 		return NULL;
 
 	ADT_Node o = { 0 };
 	o.parent   = parent;
-	if ( ! parent->nodes.append_at( o, index ) )
+	if ( ! append_at( & parent->nodes, o, index ) )
 		return NULL;
 
-	return parent->nodes + index;
+	ADT_Node* node = & parent->nodes[index];
+	return node;
 }
 
 ADT_Node* adt_alloc( ADT_Node* parent )
@@ -303,7 +304,7 @@ ADT_Node* adt_alloc( ADT_Node* parent )
 	if ( ! parent->nodes )
 		return NULL;
 
-	return adt_alloc_at( parent, parent->nodes.num() );
+	return adt_alloc_at( parent, num(parent->nodes) );
 }
 
 b8 adt_set_obj( ADT_Node* obj, char const* name, AllocatorInfo backing )
@@ -337,7 +338,7 @@ b8 adt_set_int( ADT_Node* obj, char const* name, s64 value )
 	return true;
 }
 
-ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index )
+ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index )
 {
 	GEN_ASSERT_NOT_NULL( node );
 	GEN_ASSERT_NOT_NULL( new_parent );
@@ -357,7 +358,7 @@ ADT_Node* adt_move_node( ADT_Node* node, ADT_Node* new_parent )
 	GEN_ASSERT_NOT_NULL( node );
 	GEN_ASSERT_NOT_NULL( new_parent );
 	GEN_ASSERT( new_parent->type == EADT_TYPE_ARRAY || new_parent->type == EADT_TYPE_OBJECT );
-	return adt_move_node_at( node, new_parent, new_parent->nodes.num() );
+	return adt_move_node_at( node, new_parent, num(new_parent->nodes) );
 }
 
 void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node )
@@ -366,8 +367,8 @@ void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node )
 	GEN_ASSERT_NOT_NULL( other_node );
 	ADT_Node* parent                     = node->parent;
 	ADT_Node* other_parent               = other_node->parent;
-	sw        index                      = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
-	sw        index2                     = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
+	ssize        index                      = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
+	ssize        index2                     = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
 	ADT_Node  temp                       = parent->nodes[ index ];
 	temp.parent                          = other_parent;
 	other_parent->nodes[ index2 ].parent = parent;
@@ -380,8 +381,8 @@ void adt_remove_node( ADT_Node* node )
 	GEN_ASSERT_NOT_NULL( node );
 	GEN_ASSERT_NOT_NULL( node->parent );
 	ADT_Node* parent = node->parent;
-	sw        index  = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
-	parent->nodes.remove_at( index );
+	ssize        index  = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
+	remove_at( parent->nodes, index );
 }
 
 ADT_Node* adt_append_obj( ADT_Node* parent, char const* name )
@@ -389,7 +390,7 @@ ADT_Node* adt_append_obj( ADT_Node* parent, char const* name )
 	ADT_Node* o = adt_alloc( parent );
 	if ( ! o )
 		return NULL;
-	if ( adt_set_obj( o, name, parent->nodes.get_header()->Allocator ) )
+	if ( adt_set_obj( o, name, get_header(parent->nodes)->Allocator ) )
 	{
 		adt_remove_node( o );
 		return NULL;
@@ -402,7 +403,9 @@ ADT_Node* adt_append_arr( ADT_Node* parent, char const* name )
 	ADT_Node* o = adt_alloc( parent );
 	if ( ! o )
 		return NULL;
-	if ( adt_set_arr( o, name, parent->nodes.get_header()->Allocator ) )
+
+	ArrayHeader* node_header = get_header(parent->nodes);
+	if ( adt_set_arr( o, name, node_header->Allocator ) )
 	{
 		adt_remove_node( o );
 		return NULL;
@@ -447,7 +450,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str )
 	while ( *e )
 		++e;
 
-	while ( *p && ( str_find( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
+	while ( *p && ( char_first_occurence( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
 	{
 		++p;
 	}
@@ -476,7 +479,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 	u8        node_props = 0;
 
 	/* skip false positives and special cases */
-	if ( ! ! str_find( "eE", *p ) || ( ! ! str_find( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
+	if ( ! ! char_first_occurence( "eE", *p ) || ( ! ! char_first_occurence( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
 	{
 		return ++base_str;
 	}
@@ -484,7 +487,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 	node_type = EADT_TYPE_INTEGER;
 	neg_zero  = false;
 
-	sw   ib        = 0;
+	ssize   ib        = 0;
 	char buf[ 48 ] = { 0 };
 
 	if ( *e == '+' )
@@ -550,9 +553,9 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 
 	f32  eb          = 10;
 	char expbuf[ 6 ] = { 0 };
-	sw   expi        = 0;
+	ssize   expi        = 0;
 
-	if ( *e && ! ! str_find( "eE", *e ) )
+	if ( *e && ! ! char_first_occurence( "eE", *e ) )
 	{
 		++e;
 		if ( *e == '+' || *e == '-' || char_is_digit( *e ) )
@@ -595,7 +598,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 
 #ifndef GEN_PARSER_DISABLE_ANALYSIS
 		char *q = buf, *base_string = q, *base_string2 = q;
-		base_string           = zpl_cast( char* ) str_skip( base_string, '.' );
+		base_string           = ccast( char*, str_skip( base_string, '.' ));
 		*base_string          = '\0';
 		base_string2          = base_string + 1;
 		char* base_string_off = base_string2;
@@ -748,7 +751,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
 	{
 		p = str_skip_any( p, escaped_chars );
 		_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
-		if ( *p && ! ! str_find( escaped_chars, *p ) )
+		if ( *p && ! ! char_first_occurence( escaped_chars, *p ) )
 		{
 			_adt_fprintf( file, "%s%c", escape_symbol, *p );
 			p++;
@@ -816,13 +819,13 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	char* beginChar;
 	char* endChar;
 
-	sw columnIndex       = 0;
-	sw totalColumnIndex = 0;
+	ssize columnIndex       = 0;
+	ssize totalColumnIndex = 0;
 
 	do
 	{
 		char delimiter = 0;
-		currentChar = zpl_cast( char* ) str_trim( currentChar, false );
+		currentChar = ccast( char*, str_trim( currentChar, false ));
 
 		if ( *currentChar == 0 )
 			break;
@@ -846,7 +849,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 		#endif
 			do
 			{
-				endChar = zpl_cast( char* ) str_skip( endChar, '"' );
+				endChar = ccast( char*, str_skip( endChar, '"' ));
 
 				if ( *endChar && *( endChar + 1 ) == '"' )
 				{
@@ -865,7 +868,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			}
 
 			*endChar    = 0;
-			currentChar = zpl_cast( char* ) str_trim( endChar + 1, true );
+			currentChar = ccast( char*, str_trim( endChar + 1, true ));
 			delimiter   = * currentChar;
 
 			/* unescape escaped quotes (so that unescaped text escapes :) */
@@ -902,7 +905,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 
 			if ( * endChar )
 			{
-				currentChar = zpl_cast( char* ) str_trim( endChar, true );
+				currentChar = ccast( char*, str_trim( endChar, true ));
 
 				while ( char_is_space( *( endChar - 1 ) ) )
 				{
@@ -946,12 +949,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			}
 		}
 
-		if ( columnIndex >= root->nodes.num() )
+		if ( columnIndex >= scast(ssize, num(root->nodes)) )
 		{
 			adt_append_arr( root, NULL );
 		}
 
-		root->nodes[ columnIndex ].nodes.append( rowItem );
+		append( & root->nodes[ columnIndex ].nodes, rowItem );
 
 		if ( delimiter == delim )
 		{
@@ -979,7 +982,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	}
 	while ( *currentChar );
 
-	if ( root->nodes.num() == 0 )
+	if (num( root->nodes) == 0 )
 	{
 		GEN_CSV_ASSERT( "unexpected end of input. stream is empty." );
 		error = ECSV_Error__UNEXPECTED_END_OF_INPUT;
@@ -989,12 +992,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	/* consider first row as a header. */
 	if ( has_header )
 	{
-		for ( sw i = 0; i < root->nodes.num(); i++ )
+		for ( ssize i = 0; i < scast(ssize, num(root->nodes)); i++ )
 		{
 			CSV_Object* col = root->nodes + i;
 			CSV_Object* hdr = col->nodes;
 			col->name       = hdr->string;
-			col->nodes.remove_at( 0 );
+			remove_at(col->nodes, 0 );
 		}
 	}
 
@@ -1057,11 +1060,11 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 	GEN_ASSERT_NOT_NULL( file );
 	GEN_ASSERT_NOT_NULL( obj );
 	GEN_ASSERT( obj->nodes );
-	sw cols = obj->nodes.num();
+	ssize cols = num(obj->nodes);
 	if ( cols == 0 )
 		return;
 
-	sw rows = obj->nodes[ 0 ].nodes.num();
+	ssize rows = num(obj->nodes[ 0 ].nodes);
 	if ( rows == 0 )
 		return;
 
@@ -1069,7 +1072,7 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 
 	if ( has_headers )
 	{
-		for ( sw i = 0; i < cols; i++ )
+		for ( ssize i = 0; i < cols; i++ )
 		{
 			_csv_write_header( file, &obj->nodes[ i ] );
 			if ( i + 1 != cols )
@@ -1080,9 +1083,9 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 		str_fmt_file( file, "\n" );
 	}
 
-	for ( sw r = 0; r < rows; r++ )
+	for ( ssize r = 0; r < rows; r++ )
 	{
-		for ( sw i = 0; i < cols; i++ )
+		for ( ssize i = 0; i < cols; i++ )
 		{
 			_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
 			if ( i + 1 != cols )
@@ -1099,9 +1102,10 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
 	FileInfo tmp;
 	file_stream_new( &tmp, a );
 	csv_write_delimiter( &tmp, obj, delimiter );
-	sw     fsize;
+
+	ssize  fsize;
 	u8*    buf    = file_stream_buf( &tmp, &fsize );
-	String output = String::make_length( a, ( char* )buf, fsize );
+	String output = string_make_length( a, ( char* )buf, fsize );
 	file_close( &tmp );
 	return output;
 }

project/dependencies/parsing.hpp

@@ -83,7 +83,7 @@ struct ADT_Node
 	union
 	{
 		char const*     string;
-		Array<ADT_Node> nodes;    ///< zpl_array
+		Array(ADT_Node) nodes;    ///< zpl_array
 
 		struct
 		{
@@ -178,7 +178,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search );
 	* @param index
 	* @return zpl_adt_node * node
 	*/
-ADT_Node* adt_alloc_at( ADT_Node* parent, sw index );
+ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index );
 
 /**
 	* @brief Allocate an unitialised node within a container.
@@ -196,7 +196,7 @@ ADT_Node* adt_alloc( ADT_Node* parent );
 	* @param index
 	* @return zpl_adt_node * node
 	*/
-ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index );
+ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index );
 
 /**
 	* @brief Move an existing node to a new container.
@@ -400,31 +400,33 @@ enum CSV_Error : u32
 
 typedef ADT_Node CSV_Object;
 
-GEN_DEF_INLINE 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 );
+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 );
 
-GEN_DEF_INLINE void   csv_write( FileInfo* file, CSV_Object* obj );
-GEN_DEF_INLINE 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 );
+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 */
 
-GEN_IMPL_INLINE u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
+inline
+u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
 {
 	return csv_parse_delimiter( root, text, allocator, has_header, ',' );
 }
 
-GEN_IMPL_INLINE void csv_write( FileInfo* file, CSV_Object* obj )
+inline
+void csv_write( FileInfo* file, CSV_Object* obj )
 {
 	csv_write_delimiter( file, obj, ',' );
 }
 
-GEN_IMPL_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* 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

@@ -1,4 +1,6 @@
-#pragma once
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#endif
 
 #pragma region Platform Detection
 
@@ -74,13 +76,18 @@
 /* Platform compiler */
 
 #if defined( _MSC_VER )
-#	define GEN_COMPILER_MSVC 1
+#	define GEN_COMPILER_CLANG 0
+#	define GEN_COMPILER_MSVC  1
+#	define GEN_COMPILER_GCC   0
 #elif defined( __GNUC__ )
-#	define GEN_COMPILER_GCC 1
+#	define GEN_COMPILER_CLANG 0
+#	define GEN_COMPILER_MSVC  0
+#	define GEN_COMPILER_GCC   1
 #elif defined( __clang__ )
 #	define GEN_COMPILER_CLANG 1
-#elif defined( __MINGW32__ )
-#	define GEN_COMPILER_MINGW 1
+#	define GEN_COMPILER_MSVC  0
+#	define GEN_COMPILER_GCC   1
+#else
 #	error Unknown compiler
 #endif
 
@@ -99,8 +106,13 @@
 #  define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
 #endif
 
-#define GEN_DEF_INLINE  static
-#define GEN_IMPL_INLINE static inline
+#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
 
@@ -113,13 +125,38 @@
 #		include <intrin.h>
 #	endif
 
+#if GEN_COMPILER_C
+#include <assert.h>
+#endif
+
 #pragma endregion Mandatory Includes
 
-#ifdef GEN_DONT_USE_NAMESPACE
-#	define GEN_NS
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
+#if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
+#	if GEN_COMPILER_C
+#		define GEN_NS_PARSER_BEGIN
+#		define GEN_NS_PARSER_END
+#		define GEN_USING_NS_PARSER
+#		define GEN_NS_ENUM_BEGIN
+#		define GEN_NS_ENUM_END
+#		define GEN_NS
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	else
+#		define GEN_NS_PARSER_BEGIN namespace parser {
+#		define GEN_NS_PARSER_END   }
+#		define GEN_USING_NS_PARSER using namespace parser
+#		define GEN_NS_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_PARSER_BEGIN namespace parser {
+#	define GEN_NS_PARSER_END   }
+#	define GEN_USING_NS_PARSER using namespace parser
+#	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   }

project/dependencies/printing.cpp

@@ -41,10 +41,10 @@ struct _format_info
 	s32 precision;
 };
 
-internal sw _print_string( char* text, sw max_len, _format_info* info, char const* str )
+internal ssize _print_string( char* text, ssize max_len, _format_info* info, char const* str )
 {
-	sw    res = 0, len = 0;
-	sw    remaining = max_len;
+	ssize res = 0, len = 0;
+	ssize remaining = max_len;
 	char* begin     = text;
 
 	if ( str == NULL && max_len >= 6 )
@@ -75,7 +75,7 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
 
 		if ( info->width > res )
 		{
-			sw padding = info->width - len;
+			ssize padding = info->width - len;
 
 			char pad = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
 			while ( padding-- > 0 && remaining-- > 0 )
@@ -86,7 +86,7 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
 	{
 		if ( info && ( info->width > res ) )
 		{
-			sw   padding = info->width - len;
+			ssize   padding = info->width - len;
 			char pad     = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
 			while ( padding-- > 0 && remaining-- > 0 )
 				*text++ = pad, res++;
@@ -108,16 +108,16 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
 	return res;
 }
 
-internal sw _print_char( char* text, sw max_len, _format_info* info, char arg )
+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 sw _print_repeated_char( char* text, sw max_len, _format_info* info, char arg )
+internal ssize _print_repeated_char( char* text, ssize max_len, _format_info* info, char arg )
 {
-	sw  res = 0;
+	ssize  res = 0;
 	s32 rem = ( info ) ? ( info->width > 0 ) ? info->width : 1 : 1;
 	res     = rem;
 	while ( rem-- > 0 )
@@ -126,24 +126,24 @@ internal sw _print_repeated_char( char* text, sw max_len, _format_info* info, ch
 	return res;
 }
 
-internal sw _print_i64( char* text, sw max_len, _format_info* info, s64 value )
+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 sw _print_u64( char* text, sw max_len, _format_info* info, u64 value )
+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 sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexadecimal, f64 arg )
+internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is_hexadecimal, f64 arg )
 {
 	// TODO: Handle exponent notation
-	sw    width, len, remaining = max_len;
+	ssize    width, len, remaining = max_len;
 	char* text_begin = text;
 
 	if ( arg )
@@ -163,7 +163,7 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
 			text++;
 		}
 
-		value  = zpl_cast( u64 ) arg;
+		value  = scast( u64, arg);
 		len    = _print_u64( text, remaining, NULL, value );
 		text  += len;
 
@@ -184,14 +184,14 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
 			text++;
 			while ( info->precision-- > 0 )
 			{
-				value  = zpl_cast( u64 )( arg * mult );
+				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  -= zpl_cast( f64 ) value / mult;
+				arg  -= scast( f64, value / mult);
 				mult *= 10;
 			}
 		}
@@ -239,15 +239,15 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
 	return ( text - text_begin );
 }
 
-neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
+neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
 {
 	char const* text_begin = text;
-	sw          remaining  = max_len, res;
+	ssize          remaining  = max_len, res;
 
 	while ( *fmt )
 	{
 		_format_info info = { 0 };
-		sw           len  = 0;
+		ssize        len  = 0;
 		info.precision    = -1;
 
 		while ( *fmt && *fmt != '%' && remaining )
@@ -311,7 +311,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 		}
 		else
 		{
-			info.width = zpl_cast( s32 ) str_to_i64( fmt, zpl_cast( char** ) & fmt, 10 );
+			info.width = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
 			if ( info.width != 0 )
 			{
 				info.flags |= GEN_FMT_WIDTH;
@@ -329,7 +329,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 			}
 			else
 			{
-				info.precision = zpl_cast( s32 ) str_to_i64( fmt, zpl_cast( char** ) & fmt, 10 );
+				info.precision = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
 			}
 			info.flags &= ~GEN_FMT_ZERO;
 		}
@@ -411,7 +411,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 				break;
 
 			case 'c' :
-				len = _print_char( text, remaining, &info, zpl_cast( char ) va_arg( va, int ) );
+				len = _print_char( text, remaining, &info, scast( char, va_arg( va, int ) ));
 				break;
 
 			case 's' :
@@ -420,9 +420,18 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 
 			case 'S':
 			{
+				if ( *(fmt + 1) == 'C' )
+				{
+					++ fmt;
+					StrC gen_str   = va_arg( va, StrC);
+					info.precision = gen_str.Len;
+					len            = _print_string( text, remaining, &info, gen_str.Ptr );
+					break;
+				}
+
 				String gen_str = String { va_arg( va, char*) };
 
-				info.precision = gen_str.length();
+				info.precision = length(gen_str);
 				len            = _print_string( text, remaining, &info, gen_str );
 			}
 			break;
@@ -455,25 +464,25 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 				switch ( info.flags & GEN_FMT_INTS )
 				{
 					case GEN_FMT_CHAR :
-						value = zpl_cast( u64 ) zpl_cast( u8 ) va_arg( va, int );
+						value = scast( u64, scast( u8, va_arg( va, int )));
 						break;
 					case GEN_FMT_SHORT :
-						value = zpl_cast( u64 ) zpl_cast( u16 ) va_arg( va, int );
+						value = scast( u64, scast( u16, va_arg( va, int )));
 						break;
-					case GEN_FMT_LONG :
-						value = zpl_cast( u64 ) va_arg( va, unsigned long );
+					case GEN_FMT_LONG:
+						value = scast( u64, va_arg( va, unsigned long ));
 						break;
 					case GEN_FMT_LLONG :
-						value = zpl_cast( u64 ) va_arg( va, unsigned long long );
+						value = scast( u64, va_arg( va, unsigned long long ));
 						break;
 					case GEN_FMT_SIZE :
-						value = zpl_cast( u64 ) va_arg( va, uw );
+						value = scast( u64, va_arg( va, usize ));
 						break;
 					case GEN_FMT_INTPTR :
-						value = zpl_cast( u64 ) va_arg( va, uptr );
+						value = scast( u64, va_arg( va, uptr ));
 						break;
 					default :
-						value = zpl_cast( u64 ) va_arg( va, unsigned int );
+						value = scast( u64, va_arg( va, unsigned int ));
 						break;
 				}
 
@@ -485,25 +494,25 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 				switch ( info.flags & GEN_FMT_INTS )
 				{
 					case GEN_FMT_CHAR :
-						value = zpl_cast( s64 ) zpl_cast( s8 ) va_arg( va, int );
+						value = scast( s64, scast( s8, va_arg( va, int )));
 						break;
 					case GEN_FMT_SHORT :
-						value = zpl_cast( s64 ) zpl_cast( s16 ) va_arg( va, int );
+						value = scast( s64, scast( s16, va_arg( va, int )));
 						break;
 					case GEN_FMT_LONG :
-						value = zpl_cast( s64 ) va_arg( va, long );
+						value = scast( s64, va_arg( va, long ));
 						break;
 					case GEN_FMT_LLONG :
-						value = zpl_cast( s64 ) va_arg( va, long long );
+						value = scast( s64, va_arg( va, long long ));
 						break;
 					case GEN_FMT_SIZE :
-						value = zpl_cast( s64 ) va_arg( va, uw );
+						value = scast( s64, va_arg( va, usize ));
 						break;
 					case GEN_FMT_INTPTR :
-						value = zpl_cast( s64 ) va_arg( va, uptr );
+						value = scast( s64, va_arg( va, uptr ));
 						break;
 					default :
-						value = zpl_cast( s64 ) va_arg( va, int );
+						value = scast( s64, va_arg( va, int ));
 						break;
 				}
 
@@ -540,17 +549,17 @@ char* str_fmt_buf( char const* fmt, ... )
 	return str;
 }
 
-sw str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
+ssize str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
 {
 	local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ];
-	sw                              len = str_fmt_va( buf, size_of( buf ), fmt, va );
+	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;
 }
 
-sw str_fmt_file( struct FileInfo* f, char const* fmt, ... )
+ssize str_fmt_file( struct FileInfo* f, char const* fmt, ... )
 {
-	sw      res;
+	ssize      res;
 	va_list va;
 	va_start( va, fmt );
 	res = str_fmt_file_va( f, fmt, va );
@@ -558,9 +567,9 @@ sw str_fmt_file( struct FileInfo* f, char const* fmt, ... )
 	return res;
 }
 
-sw str_fmt( char* str, sw n, char const* fmt, ... )
+ssize str_fmt( char* str, ssize n, char const* fmt, ... )
 {
-	sw      res;
+	ssize      res;
 	va_list va;
 	va_start( va, fmt );
 	res = str_fmt_va( str, n, fmt, va );
@@ -568,19 +577,19 @@ sw str_fmt( char* str, sw n, char const* fmt, ... )
 	return res;
 }
 
-sw str_fmt_out_va( char const* fmt, va_list va )
+ssize str_fmt_out_va( char const* fmt, va_list va )
 {
 	return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
 }
 
-sw str_fmt_out_err_va( char const* fmt, va_list 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 );
 }
 
-sw str_fmt_out_err( char const* fmt, ... )
+ssize str_fmt_out_err( char const* fmt, ... )
 {
-	sw      res;
+	ssize      res;
 	va_list va;
 	va_start( va, fmt );
 	res = str_fmt_out_err_va( fmt, va );

project/dependencies/printing.hpp

@@ -12,23 +12,23 @@ struct FileInfo;
 #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 );
-sw    str_fmt           ( char* str, sw n, char const* fmt, ... );
-sw    str_fmt_va        ( char* str, sw n, char const* fmt, va_list va );
-sw    str_fmt_out_va    ( char const* fmt, va_list va );
-sw    str_fmt_out_err   ( char const* fmt, ... );
-sw    str_fmt_out_err_va( char const* fmt, va_list va );
-sw    str_fmt_file      ( FileInfo* f, char const* fmt, ... );
-sw    str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+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
-sw log_fmt(char const* fmt, ...)
+ssize log_fmt(char const* fmt, ...)
 {
-	sw res;
+	ssize res;
 	va_list va;
 
 	va_start(va, fmt);

project/dependencies/string_ops.cpp

@@ -7,7 +7,7 @@
 #pragma region String Ops
 
 internal
-sw _scan_zpl_i64( const char* text, s32 base, s64* value )
+ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
 {
 	const char* text_begin = text;
 	s64         result     = 0;
@@ -56,7 +56,7 @@ global const char _num_to_char_table[] =
 
 s64 str_to_i64( const char* str, char** end_ptr, s32 base )
 {
-	sw  len;
+	ssize  len;
 	s64 value;
 
 	if ( ! base )
@@ -85,7 +85,7 @@ void i64_to_str( s64 value, char* string, s32 base )
 		value    = -value;
 	}
 
-	v = zpl_cast( u64 ) value;
+	v = scast( u64, value);
 	if ( v != 0 )
 	{
 		while ( v > 0 )
@@ -207,7 +207,7 @@ f64 str_to_f64( const char* str, char** end_ptr )
 	result = sign * ( frac ? ( value / scale ) : ( value * scale ) );
 
 	if ( end_ptr )
-		*end_ptr = zpl_cast( char* ) str;
+		* end_ptr = rcast( char*, ccast(char*, str) );
 
 	return result;
 }

project/dependencies/string_ops.hpp

@@ -5,41 +5,41 @@
 
 #pragma region String Ops
 
-GEN_DEF_INLINE const char* char_first_occurence( const char* str, char c );
-constexpr auto str_find = &char_first_occurence;
+const char* char_first_occurence( const char* str, char c );
 
-GEN_DEF_INLINE b32   char_is_alpha( char c );
-GEN_DEF_INLINE b32   char_is_alphanumeric( char c );
-GEN_DEF_INLINE b32   char_is_digit( char c );
-GEN_DEF_INLINE b32   char_is_hex_digit( char c );
-GEN_DEF_INLINE b32   char_is_space( char c );
-GEN_DEF_INLINE char  char_to_lower( char c );
-GEN_DEF_INLINE char  char_to_upper( 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 );
 
-GEN_DEF_INLINE s32  digit_to_int( char c );
-GEN_DEF_INLINE s32  hex_digit_to_int( char c );
+s32  digit_to_int( char c );
+s32  hex_digit_to_int( char c );
 
-GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2 );
-GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2, sw len );
-GEN_DEF_INLINE char*       str_copy( char* dest, const char* source, sw len );
-GEN_DEF_INLINE sw          str_copy_nulpad( char* dest, const char* source, sw len );
-GEN_DEF_INLINE sw          str_len( const char* str );
-GEN_DEF_INLINE sw          str_len( const char* str, sw max_len );
-GEN_DEF_INLINE char*       str_reverse( char* str );    // NOTE: ASCII only
-GEN_DEF_INLINE char const* str_skip( char const* str, char c );
-GEN_DEF_INLINE char const* str_skip_any( char const* str, char const* char_list );
-GEN_DEF_INLINE char const* str_trim( char const* str, b32 catch_newline );
+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
-GEN_DEF_INLINE void str_to_lower( char* str );
-GEN_DEF_INLINE void str_to_upper( char* str );
+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 );
 
-GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
+inline
+const char* char_first_occurence( const char* s, char c )
 {
 	char ch = c;
 	for ( ; *s != ch; s++ )
@@ -50,59 +50,67 @@ GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
 	return s;
 }
 
-GEN_IMPL_INLINE b32 char_is_alpha( char c )
+inline
+b32 char_is_alpha( char c )
 {
 	if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE b32 char_is_alphanumeric( char c )
+inline
+b32 char_is_alphanumeric( char c )
 {
 	return char_is_alpha( c ) || char_is_digit( c );
 }
 
-GEN_IMPL_INLINE b32 char_is_digit( char c )
+inline
+b32 char_is_digit( char c )
 {
 	if ( c >= '0' && c <= '9' )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE b32 char_is_hex_digit( char c )
+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;
 }
 
-GEN_IMPL_INLINE b32 char_is_space( char c )
+inline
+b32 char_is_space( char c )
 {
 	if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE char char_to_lower( char c )
+inline
+char char_to_lower( char c )
 {
 	if ( c >= 'A' && c <= 'Z' )
 		return 'a' + ( c - 'A' );
 	return c;
 }
 
-GEN_IMPL_INLINE char char_to_upper( char c )
+inline char char_to_upper( char c )
 {
 	if ( c >= 'a' && c <= 'z' )
 		return 'A' + ( c - 'a' );
 	return c;
 }
 
-GEN_IMPL_INLINE s32 digit_to_int( char c )
+inline
+s32 digit_to_int( char c )
 {
 	return char_is_digit( c ) ? c - '0' : c - 'W';
 }
 
-GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
+inline
+s32 hex_digit_to_int( char c )
 {
 	if ( char_is_digit( c ) )
 		return digit_to_int( c );
@@ -113,7 +121,8 @@ GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
 	return -1;
 }
 
-GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
+inline
+s32 str_compare( const char* s1, const char* s2 )
 {
 	while ( *s1 && ( *s1 == *s2 ) )
 	{
@@ -122,7 +131,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
 	return *( u8* )s1 - *( u8* )s2;
 }
 
-GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
+inline
+s32 str_compare( const char* s1, const char* s2, ssize len )
 {
 	for ( ; len > 0; s1++, s2++, len-- )
 	{
@@ -134,7 +144,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
 	return 0;
 }
 
-GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
+inline
+char* str_copy( char* dest, const char* source, ssize len )
 {
 	GEN_ASSERT_NOT_NULL( dest );
 	if ( source )
@@ -154,9 +165,10 @@ GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
 	return dest;
 }
 
-GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
+inline
+ssize str_copy_nulpad( char* dest, const char* source, ssize len )
 {
-	sw result = 0;
+	ssize result = 0;
 	GEN_ASSERT_NOT_NULL( dest );
 	if ( source )
 	{
@@ -178,7 +190,8 @@ GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
 	return result;
 }
 
-GEN_IMPL_INLINE sw str_len( const char* str )
+inline
+ssize str_len( const char* str )
 {
 	if ( str == NULL )
 	{
@@ -190,17 +203,19 @@ GEN_IMPL_INLINE sw str_len( const char* str )
 	return str - p;
 }
 
-GEN_IMPL_INLINE sw str_len( const char* str, sw max_len )
+inline
+ssize str_len( const char* str, ssize max_len )
 {
-	const char* end = zpl_cast( const char* ) mem_find( str, 0, max_len );
+	const char* end = rcast(const char*, mem_find( str, 0, max_len ));
 	if ( end )
 		return end - str;
 	return max_len;
 }
 
-GEN_IMPL_INLINE char* str_reverse( char* str )
+inline
+char* str_reverse( char* str )
 {
-	sw    len  = str_len( str );
+	ssize    len  = str_len( str );
 	char* a    = str + 0;
 	char* b    = str + len - 1;
 	len       /= 2;
@@ -212,7 +227,8 @@ GEN_IMPL_INLINE char* str_reverse( char* str )
 	return str;
 }
 
-GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
+inline
+char const* str_skip( char const* str, char c )
 {
 	while ( *str && *str != c )
 	{
@@ -221,11 +237,12 @@ GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
 	return str;
 }
 
-GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list )
+inline
+char const* str_skip_any( char const* str, char const* char_list )
 {
-	char const* closest_ptr     = zpl_cast( char const* ) pointer_add( ( void* )str, str_len( str ) );
-	sw          char_list_count = str_len( char_list );
-	for ( sw i = 0; i < char_list_count; i++ )
+	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 );
@@ -233,7 +250,8 @@ GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list
 	return closest_ptr;
 }
 
-GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
+inline
+char const* str_trim( char const* str, b32 catch_newline )
 {
 	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
 	{
@@ -242,7 +260,8 @@ GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
 	return str;
 }
 
-GEN_IMPL_INLINE void str_to_lower( char* str )
+inline
+void str_to_lower( char* str )
 {
 	if ( ! str )
 		return;
@@ -253,7 +272,8 @@ GEN_IMPL_INLINE void str_to_lower( char* str )
 	}
 }
 
-GEN_IMPL_INLINE void str_to_upper( char* str )
+inline
+void str_to_upper( char* str )
 {
 	if ( ! str )
 		return;

project/dependencies/strings.cpp

@@ -4,20 +4,9 @@
 #endif
 
 #pragma region String
-
-String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
+String string_make_length( AllocatorInfo allocator, char const* str, ssize length )
 {
-	va_list va;
-	va_start( va, fmt );
-	str_fmt_va( buf, buf_size, fmt, va );
-	va_end( va );
-
-	return make( allocator, buf );
-}
-
-String String::make_length( AllocatorInfo allocator, char const* str, sw length )
-{
-	constexpr sw header_size = sizeof( Header );
+	constexpr ssize header_size = sizeof( StringHeader );
 
 	s32   alloc_size = header_size + length + 1;
 	void* allocation = alloc( allocator, alloc_size );
@@ -25,8 +14,8 @@ String String::make_length( AllocatorInfo allocator, char const* str, sw length
 	if ( allocation == nullptr )
 		return { nullptr };
 
-	Header&
-	header = * rcast(Header*, allocation);
+	StringHeader&
+	header = * rcast(StringHeader*, allocation);
 	header = { allocator, length, length };
 
 	String  result = { rcast( char*, allocation) + header_size };
@@ -41,9 +30,9 @@ String String::make_length( AllocatorInfo allocator, char const* str, sw length
 	return result;
 }
 
-String String::make_reserve( AllocatorInfo allocator, sw capacity )
+String string_make_reserve( AllocatorInfo allocator, ssize capacity )
 {
-	constexpr sw header_size = sizeof( Header );
+	constexpr ssize header_size = sizeof( StringHeader );
 
 	s32   alloc_size = header_size + capacity + 1;
 	void* allocation = alloc( allocator, alloc_size );
@@ -53,8 +42,8 @@ String String::make_reserve( AllocatorInfo allocator, sw capacity )
 
 	mem_set( allocation, 0, alloc_size );
 
-	Header*
-		header            = rcast(Header*, allocation);
+	StringHeader*
+	header            = rcast(StringHeader*, allocation);
 	header->Allocator = allocator;
 	header->Capacity  = capacity;
 	header->Length    = 0;
@@ -62,69 +51,4 @@ String String::make_reserve( AllocatorInfo allocator, sw capacity )
 	String result = { rcast(char*, allocation) + header_size };
 	return result;
 }
-
-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 make( allocator, buf );
-}
-
-bool String::append_fmt( char const* fmt, ... )
-{
-	sw   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( buf, res );
-}
-
-bool String::make_space_for( char const* str, sw add_len )
-{
-	sw available = avail_space();
-
-	// NOTE: Return if there is enough space left
-	if ( available >= add_len )
-	{
-		return true;
-	}
-	else
-	{
-		sw new_len, old_size, new_size;
-
-		void* ptr;
-		void* new_ptr;
-
-		AllocatorInfo allocator = get_header().Allocator;
-		Header*       header	= nullptr;
-
-		new_len  = grow_formula( length() + add_len );
-		ptr      = & get_header();
-		old_size = size_of( Header ) + length() + 1;
-		new_size = size_of( Header ) + new_len + 1;
-
-		new_ptr = resize( allocator, ptr, old_size, new_size );
-
-		if ( new_ptr == nullptr )
-			return false;
-
-		header            = zpl_cast( Header* ) new_ptr;
-		header->Allocator = allocator;
-		header->Capacity  = new_len;
-
-		Data = rcast( char*, header + 1 );
-
-		return str;
-	}
-}
 #pragma endregion String

project/dependencies/timing.cpp

@@ -23,7 +23,7 @@
 	{
 		u32 hi, lo;
 		__asm__ __volatile__( "rdtsc" : "=a"( lo ), "=d"( hi ) );
-		return ( zpl_cast( u64 ) lo ) | ( ( zpl_cast( u64 ) hi ) << 32 );
+		return scast( u64, lo ) | ( scast( u64, hi ) << 32 );
 	}
 	#elif defined( __powerpc__ )
 	u64 read_cpu_time_stamp_counter( void )

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

@@ -41,3 +41,7 @@ MemberOfPointer, "->"
 PtrToMemOfPtr,   "->*"
 FunctionCall,    "()"
 Comma,           ","
+New,             "new"
+NewArray,        "new[]"
+Delete,          "delete"
+DeleteArray,     "delete[]"

project/enums/ESpecifier.csv

@@ -17,10 +17,10 @@ Register,         register
 RValue,           &&
 Static,           static
 Thread_Local,     thread_local
-Volatile,         volatile
 Virtual,          virtual
 Const,            const
 Final,            final
 NoExceptions,     noexcept
 Override,         override
 Pure,             = 0
+Volatile,         volatile

project/enums/ETokType.csv

@@ -77,10 +77,12 @@ 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"

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.cpp

@@ -20,10 +20,13 @@ GEN_NS_BEGIN
 
 #include "components/ast_case_macros.cpp"
 #include "components/ast.cpp"
+#include "components/code_serialization.cpp"
 
 #include "components/interface.cpp"
 #include "components/interface.upfront.cpp"
 #include "components/gen/etoktype.cpp"
+#include "components/lexer.cpp"
+#include "components/parser.cpp"
 #include "components/interface.parsing.cpp"
 #include "components/interface.untyped.cpp"
 

project/gen.dep.hpp

@@ -1,7 +1,7 @@
 // This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)
 #pragma once
 
-#include "dependencies/header_start.hpp"
+#include "dependencies/platform.hpp"
 
 GEN_NS_BEGIN
 

project/gen.hpp

@@ -19,6 +19,7 @@ GEN_NS_BEGIN
 #include "components/gen/especifier.hpp"
 
 #include "components/ast.hpp"
+#include "components/code_types.hpp"
 #include "components/ast_types.hpp"
 
 #include "components/interface.hpp"

project/helpers/helper.hpp

@@ -11,31 +11,33 @@ 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) );
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
-	file_read_contents( scratch, zero_terminate, path );
+	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) );
+	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 )
+	for ( ADT_Node& node : enum_strs )
 	{
 		char const* code = node.string;
-		enum_entries.append_fmt( "%s,\n", code );
-		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
+
+		append_fmt( & enum_entries, "CT_%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 };"));
+	CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", to_strc(enum_entries), "enum CodeType_Def : u32 { <entries> CT_NumTypes };"));
 
-#pragma push_macro( "local_persist" )
+#pragma push_macro("local_persist")
 #undef local_persist
-	CodeFn to_str = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
-		StrC to_str( Type type )
+	CodeFn to_str = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize(
+		inline
+		StrC to_str( CodeType type )
 		{
 			local_persist
 			StrC lookup[] {
@@ -45,20 +47,21 @@ CodeBody gen_ecode( char const* path )
 			return lookup[ type ];
 		}
 	)));
-#pragma pop_macro( "local_persist" )
+#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) ) );
+	//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) ) );
+	CodeTypedef code_t = parse_typedef(code(typedef enum CodeType_Def CodeType; ));
 
-	return def_global_body( args( nspace, code_t, fmt_newline ) );
+	return def_global_body( args( enum_code, code_t, to_str, fmt_newline ) );
 }
 
 CodeBody gen_eoperator( char const* path )
 {
 	char scratch_mem[kilobytes(4)];
-	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
-	file_read_contents( scratch, zero_terminate, path );
+	file_read_contents( allocator_info(& scratch), zero_terminate, path );
 
 	CSV_Object csv_nodes;
 	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
@@ -66,30 +69,31 @@ CodeBody gen_eoperator( char const* path )
 	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) );
+	String enum_entries   = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
 
-	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	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;
 
-		enum_entries.append_fmt( "%s,\n", enum_str );
-		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		append_fmt( & enum_entries, "Op_%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
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", to_strc(enum_entries), stringize(
+		enum Operator_Def : u32
 		{
 			<entries>
 			NumOps
 		};
 	)));
 
-#pragma push_macro( "local_persist" )
+#pragma push_macro("local_persist")
 #undef local_persist
-	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
-		StrC to_str( Type op )
+	CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), stringize(
+		inline
+		StrC to_str( Operator op )
 		{
 			local_persist
 			StrC lookup[] {
@@ -99,21 +103,21 @@ CodeBody gen_eoperator( char const* path )
 			return lookup[ op ];
 		}
 	)));
-#pragma pop_macro( "local_persist" )
+#pragma pop_macro("local_persist")
 
-	CodeNS nspace = def_namespace( name(EOperator), def_namespace_body( args( enum_code, to_str ) ) );
+	//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) ) );
+	CodeTypedef operator_t = parse_typedef(code( typedef enum Operator_Def Operator; ));
 
-	CodeUsing operator_t = def_using( name(OperatorT), def_type( name(EOperator::Type) ) );
-
-	return def_global_body( args( nspace, operator_t, fmt_newline ) );
+	return def_global_body( args( enum_code, operator_t, to_str, fmt_newline ) );
 }
 
 CodeBody gen_especifier( char const* path )
 {
 	char scratch_mem[kilobytes(4)];
-	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
-	file_read_contents( scratch, zero_terminate, path );
+	file_read_contents( allocator_info(& scratch), zero_terminate, path );
 
 	CSV_Object csv_nodes;
 	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
@@ -121,45 +125,47 @@ CodeBody gen_especifier( char const* path )
 	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) );
+	String enum_entries   = string_make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
 
-	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	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;
 
-		enum_entries.append_fmt( "%s,\n", enum_str );
-		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		append_fmt( & enum_entries, "Spec_%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
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", to_strc(enum_entries), stringize(
+		enum Specifier_Def : u32
 		{
 			<entries>
-			NumSpecifiers
+			Spec_NumSpecifiers
 		};
 	)));
 
-	CodeFn is_trailing = parse_function(token_fmt("specifier", (StrC)to_str_entries, stringize(
-		bool is_trailing( Type specifier )
+	CodeFn is_trailing = parse_function(token_fmt("specifier", to_strc(to_str_entries), stringize(
+		inline
+		bool is_trailing( Specifier specifier )
 		{
-			return specifier > Virtual;
+			return specifier > Spec_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" )
+#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(
-		StrC to_str( Type type )
+	CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), stringize(
+		inline
+		StrC to_str( Specifier type )
 		{
 			local_persist
 			StrC lookup[] {
@@ -170,15 +176,16 @@ CodeBody gen_especifier( char const* path )
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
-		Type to_type( StrC str )
+	CodeFn to_type = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize(
+		inline
+		Specifier to_specifier( StrC str )
 		{
 			local_persist
-			u32 keymap[ NumSpecifiers ];
+			u32 keymap[ Spec_NumSpecifiers ];
 			do_once_start
-				for ( u32 index = 0; index < NumSpecifiers; index++ )
+				for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 				{
-					StrC enum_str = to_str( (Type)index );
+					StrC enum_str = to_str( (Specifier)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
@@ -188,39 +195,41 @@ CodeBody gen_especifier( char const* path )
 
 			u32 hash = crc32( str.Ptr, str.Len );
 
-			for ( u32 index = 0; index < NumSpecifiers; index++ )
+			for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
 			{
 				if ( keymap[index] == hash )
-					return (Type)index;
+					return (Specifier)index;
 			}
 
-			return Invalid;
+			return Spec_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" )
+#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 ) ) );
+	//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) ) );
+	CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier_Def Specifier; ));
 
-	CodeUsing specifier_t = def_using( name(SpecifierT), def_type( name(ESpecifier::Type) ) );
-
-	return def_global_body( args( nspace, specifier_t, fmt_newline ) );
+	return def_global_body( args( enum_code, specifier_t, is_trailing, to_str, to_type, 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) );
+	Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
-	FileContents enum_content = file_read_contents( scratch, zero_terminate, etok_path );
+	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, zero_terminate, attr_path );
+	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 );
@@ -230,58 +239,60 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 	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) );
+	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 (uw idx = 0; idx < enum_strs.num(); idx++)
+	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;
 
-		enum_entries.append_fmt( "%s,\n", enum_str );
-		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+		append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
+		append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
 	}
 
-	for ( uw idx = 0; idx < attribute_strs.num(); idx++ )
+	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;
 
-		attribute_entries.append_fmt( "%s,\n", attribute_str );
-		to_str_attributes.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
-		attribute_define_entries.append_fmt( "Entry( %s, %s )", attribute_str, entry_to_str );
+		append_fmt( & attribute_entries, "Tok_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( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
 
-		if ( idx < attribute_strs.num() - 1 )
-			attribute_define_entries.append( " \\\n");
+		if ( idx < num(attribute_strs) - 1 )
+			append( & attribute_define_entries, " \\\n");
 		else
-			attribute_define_entries.append( "\n");
+			append( & attribute_define_entries, "\n");
 	}
 
-#pragma push_macro( "GEN_DEFINE_ATTRIBUTE_TOKENS" )
+#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" )
+	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), to_strc(attribute_define_entries)  );
+#pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
 
-	CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, "attribute_toks", (StrC)attribute_entries, stringize(
-		enum Type : u32
+	// We cannot parse this enum, it has Attribute names as enums
+	CodeEnum enum_code = parse_enum(token_fmt("entries", to_str(enum_entries), "attribute_toks", to_str(attribute_entries), stringize(
+		enum TokType_Def : u32
 		{
 			<entries>
 			<attribute_toks>
-			NumTokens
+			Tok_NumTokens
 		};
 	)));
 
-#pragma push_macro( "local_persist" )
-#pragma push_macro( "do_once_start" )
-#pragma push_macro( "do_once_end" )
+#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(
-		StrC to_str( Type type )
+	CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), "attribute_toks", to_strc(to_str_attributes), stringize(
+		inline
+		StrC to_str( TokType type )
 		{
 			local_persist
 			StrC lookup[] {
@@ -293,15 +304,16 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 		}
 	)));
 
-	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
-		Type to_type( StrC str )
+	CodeFn to_type = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize(
+		inline
+		TokType to_toktype( StrC str )
 		{
 			local_persist
-			u32 keymap[ NumTokens ];
+			u32 keymap[ Tok_NumTokens ];
 			do_once_start
-				for ( u32 index = 0; index < NumTokens; index++ )
+				for ( u32 index = 0; index < Tok_NumTokens; index++ )
 				{
-					StrC enum_str = to_str( (Type)index );
+					StrC enum_str = to_str( (TokType)index );
 
 					// We subtract 1 to remove the null terminator
 					// This is because the tokens lexed are not null terminated.
@@ -311,103 +323,56 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 
 			u32 hash = crc32( str.Ptr, str.Len );
 
-			for ( u32 index = 0; index < NumTokens; index++ )
+			for ( u32 index = 0; index < Tok_NumTokens; index++ )
 			{
 				if ( keymap[index] == hash )
-					return (Type)index;
+					return (TokType)index;
 			}
 
-			return Invalid;
+			return Tok_Invalid;
 		}
 	)));
-#pragma pop_macro( "local_persist" )
-#pragma pop_macro( "do_once_start" )
-#pragma pop_macro( "do_once_end" )
+#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) ) );
+	//CodeNS    nspace     = def_namespace( name(ETokType), def_namespace_body( args( attribute_entires_def, enum_code, to_str, to_type ) ) );
+	CodeTypedef td_toktype = parse_typedef( code( typedef enum TokType_Def TokType; ));
 
-	return def_global_body( args( nspace, td_toktype ) );
+	return def_global_body( args(
+		attribute_entires_def,
+		enum_code,
+		td_toktype,
+		to_str,
+		to_type
+	));
 }
 
 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
-		char const* <typename>::debug_str()
-		{
-			if ( ast == nullptr )
-				return "Code::debug_str: AST is null!";
-
-			return rcast(AST*, ast)->debug_str();
-		}
-		Code <typename>::duplicate()
-		{
-			if ( ast == nullptr )
-			{
-				log_failure("Code::duplicate: Cannot duplicate code, AST is null!");
-				return Code::Invalid;
-			}
-
-			return { rcast(AST*, ast)->duplicate() };
-		}
-		bool <typename>::is_equal( Code other )
-		{
-			if ( ast == nullptr || other.ast == nullptr )
-			{
-				log_failure("Code::is_equal: Cannot compare code, AST is null!");
-				return false;
-			}
-
-			return rcast(AST*, ast)->is_equal( other.ast );
-		}
-		bool <typename>::is_valid()
-		{
-			return (AST*) ast != nullptr && rcast( AST*, ast)->Type != CodeT::Invalid;
-		}
-		void <typename>::set_global()
-		{
-			if ( ast == nullptr )
-			{
-				log_failure("Code::set_global: Cannot set code as global, AST is null!");
-				return;
-			}
-
-			rcast(AST*, ast)->Parent = Code::Global.ast;
-		}
-		String <typename>::to_string()
-		{
-			if ( ast == nullptr )
-			{
-			log_failure("Code::to_string: Cannot convert code to string, AST is null!");
-			return { nullptr };
-			}
-
-			return rcast(AST*, ast)->to_string();
-		}
+		inline
 		<typename>& <typename>::operator =( Code other )
 		{
 			if ( other.ast && other->Parent )
 			{
-				ast = rcast( decltype(ast), other.ast->duplicate() );
-				rcast( AST*, ast)->Parent = nullptr;
+				ast         = rcast( decltype(ast),  GEN_NS duplicate(other).ast);
+				ast->Parent = { nullptr };
 			}
 
-			ast = rcast( decltype(ast), other.ast );
-			return *this;
-		}
-		bool <typename>::operator ==( Code other )
-		{
-			return (AST*) ast == other.ast;
-		}
-		bool <typename>::operator !=( Code other )
-		{
-			return (AST*) ast != other.ast;
+			ast = rcast( decltype( ast ), other.ast );
+			return * this;
 		}
+		inline
 		<typename>::operator bool()
 		{
 			return ast != nullptr;
@@ -415,14 +380,12 @@ CodeBody gen_ast_inlines()
 	);
 
 	char const* codetype_impl_tmpl = stringize(
-		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 )
@@ -434,6 +397,8 @@ CodeBody gen_ast_inlines()
 		}
 		\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 ));
@@ -459,43 +424,38 @@ CodeBody gen_ast_inlines()
 	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_type     = parse_global_body( token_fmt( "typename", StrC name(CodeTypename),       code_impl_tmpl ));
 	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef),        code_impl_tmpl ));
 	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", StrC name(CodeUnion),          code_impl_tmpl ));
 	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", StrC name(CodeUsing),          code_impl_tmpl ));
 	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", StrC name(CodeVar),            code_impl_tmpl ));
 
-	impl_code_attr.    append( parse_global_body( token_fmt( "typename", StrC name(Attributes),     codetype_impl_tmpl )));
-	impl_code_cmt.     append( parse_global_body( token_fmt( "typename", StrC name(Comment),        codetype_impl_tmpl )));
-	impl_code_constr.  append( parse_global_body( token_fmt( "typename", StrC name(Constructor),    codetype_impl_tmpl )));
-	impl_code_define.  append( parse_global_body( token_fmt( "typename", StrC name(Define),         codetype_impl_tmpl )));
-	impl_code_destruct.append( parse_global_body( token_fmt( "typename", StrC name(Destructor),     codetype_impl_tmpl )));
-	impl_code_enum.    append( parse_global_body( token_fmt( "typename", StrC name(Enum),           codetype_impl_tmpl )));
-	impl_code_exec.    append( parse_global_body( token_fmt( "typename", StrC name(Exec),           codetype_impl_tmpl )));
-	impl_code_extern.  append( parse_global_body( token_fmt( "typename", StrC name(Extern),         codetype_impl_tmpl )));
-	impl_code_include. append( parse_global_body( token_fmt( "typename", StrC name(Include),        codetype_impl_tmpl )));
-	impl_code_friend.  append( parse_global_body( token_fmt( "typename", StrC name(Friend),         codetype_impl_tmpl )));
-	impl_code_fn.      append( parse_global_body( token_fmt( "typename", StrC name(Fn),             codetype_impl_tmpl )));
-	impl_code_module.  append( parse_global_body( token_fmt( "typename", StrC name(Module),         codetype_impl_tmpl )));
-	impl_code_ns.      append( parse_global_body( token_fmt( "typename", StrC name(NS),             codetype_impl_tmpl )));
-	impl_code_op.      append( parse_global_body( token_fmt( "typename", StrC name(Operator),       codetype_impl_tmpl )));
-	impl_code_opcast.  append( parse_global_body( token_fmt( "typename", StrC name(OpCast),         codetype_impl_tmpl )));
-	impl_code_pragma . append( parse_global_body( token_fmt( "typename", StrC name(Pragma),         codetype_impl_tmpl )));
-	impl_code_precond. append( parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), codetype_impl_tmpl )));
-	impl_code_tmpl.    append( parse_global_body( token_fmt( "typename", StrC name(Template),       codetype_impl_tmpl )));
-	impl_code_type.    append( parse_global_body( token_fmt( "typename", StrC name(Type),           codetype_impl_tmpl )));
-	impl_code_typedef. append( parse_global_body( token_fmt( "typename", StrC name(Typedef),        codetype_impl_tmpl )));
-	impl_code_union.   append( parse_global_body( token_fmt( "typename", StrC name(Union),          codetype_impl_tmpl )));
-	impl_code_using.   append( parse_global_body( token_fmt( "typename", StrC name(Using),          codetype_impl_tmpl )));
-	impl_code_var.     append( parse_global_body( token_fmt( "typename", StrC name(Var),            codetype_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(Typename),       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(
-		AST::operator Code<typename>()
-		{
-			return { rcast( AST_<typename>*, this ) };
-		}
-
-		Code::operator Code<typename>() const
+		inline Code::operator Code<typename>() const
 		{
 			return { (AST_<typename>*) ast };
 		}
@@ -524,7 +484,7 @@ CodeBody gen_ast_inlines()
 	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_type      = parse_global_body( token_fmt( "typename", StrC name(Typename),       cast_tmpl ));
 	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", StrC name(Typedef),        cast_tmpl ));
 	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", StrC name(Union),          cast_tmpl ));
 	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", StrC name(Using),          cast_tmpl ));

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;
+

project/helpers/pop_ignores.inline.hpp

@@ -1,7 +1,7 @@
-#if __clang__
+#ifdef __clang__
 #	pragma clang diagnostic pop
 #endif
 
-#if __GNUC__
+#ifdef __GNUC__
 #	pragma GCC diagnostic pop
 #endif

project/helpers/push_ignores.inline.hpp

@@ -1,14 +1,16 @@
-#if __clang__
+#ifdef __clang__
 #	pragma clang diagnostic push
 #	pragma clang diagnostic ignored "-Wunused-const-variable"
+#	pragma clang diagnostic ignored "-Wunused-but-set-variable"
 #	pragma clang diagnostic ignored "-Wswitch"
 #	pragma clang diagnostic ignored "-Wunused-variable"
 #   pragma clang diagnostic ignored "-Wunknown-pragmas"
 #	pragma clang diagnostic ignored "-Wvarargs"
 #	pragma clang diagnostic ignored "-Wunused-function"
+#	pragma clang diagnostic ignored "-Wbraced-scalar-init"
 #endif
 
-#if __GNUC__
+#ifdef __GNUC__
 #	pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wunknown-pragmas"
 #	pragma GCC diagnostic ignored "-Wcomment"

project/helpers/undef.macros.hpp

@@ -24,8 +24,6 @@
 #undef forceinline
 #undef neverinline
 
-#undef zpl_cast
-
 #undef global
 #undef internal
 #undef local_persist

scripts/.clang-format

@@ -86,7 +86,7 @@ CompactNamespaces: true
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth : 4
 
-ContinuationIndentWidth: 0
+ContinuationIndentWidth: 4
 
 Cpp11BracedListStyle: false
 
@@ -151,17 +151,17 @@ SpaceBeforeRangeBasedForLoopColon: true
 SpaceBeforeSquareBrackets: false
 SpacesBeforeTrailingComments: 4
 
-SpaceInEmptyBlock: true
+SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
-SpacesInAngles: true
-SpacesInCStyleCastParentheses: true
-SpacesInConditionalStatement: true
-SpacesInContainerLiterals: true
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
 SpacesInLineCommentPrefix:
   Minimum: 1
   Maximum: 20
 SpacesInParentheses: true
-SpacesInSquareBrackets: true
+SpacesInSquareBrackets: false
 
 Standard: c++17
 

scripts/build.ci.ps1

@@ -2,17 +2,50 @@
 # It will most likely need a partial rewrite to segment the build process into separate script invocations based on the OS.
 # That or just rewrite it in an sh script and call it a day.
 
-Import-Module ./helpers/target_arch.psm1
-$devshell  = Join-Path $PSScriptRoot 'helpers/devshell.ps1'
-$path_root = git rev-parse --show-toplevel
+$target_arch        = Join-Path $PSScriptRoot 'helpers/target_arch.psm1'
+$devshell           = Join-Path $PSScriptRoot 'helpers/devshell.ps1'
+$format_cpp	        = Join-Path $PSScriptRoot 'helpers/format_cpp.psm1'
+$refactor_unreal    = Join-Path $PSScriptRoot 'refactor_unreal.ps1'
+$incremental_checks = Join-Path $PSScriptRoot 'helpers/incremental_checks.ps1'
+$vendor_toolchain   = Join-Path $PSScriptRoot 'helpers/vendor_toolchain.ps1'
+
+Import-Module $target_arch
+
+function Get-ScriptRepoRoot {
+    $currentPath = $PSScriptRoot
+    while ($currentPath -ne $null -and $currentPath -ne "")
+	{
+        if (Test-Path (Join-Path $currentPath ".git")) {
+            return $currentPath
+        }
+        # Also check for .git file which indicates a submodule
+        $gitFile = Join-Path $currentPath ".git"
+        if (Test-Path $gitFile -PathType Leaf)
+		{
+            $gitContent = Get-Content $gitFile
+            if ($gitContent -match "gitdir: (.+)") {
+                return $currentPath
+            }
+        }
+        $currentPath = Split-Path $currentPath -Parent
+    }
+    throw "Unable to find repository root"
+}
+$path_root = Get-ScriptRepoRoot
+
+Import-Module $target_arch
+Import-Module $format_cpp
 
 Push-Location $path_root
 
 #region Arguments
        $vendor       = $null
        $release      = $null
+	   $verbose      = $false
 [bool] $bootstrap    = $false
 [bool] $singleheader = $false
+[bool] $c_library    = $false
+[bool] $unreal       = $false
 [bool] $test         = $false
 
 [array] $vendors = @( "clang", "msvc" )
@@ -21,11 +54,14 @@ Push-Location $path_root
 
 if ( $args ) { $args | ForEach-Object {
 	switch ($_){
-		{ $_ -in $vendors }   { $vendor      = $_; break }
+		{ $_ -in $vendors }   { $vendor       = $_; break }
+		"verbose"			  { $verbose      = $true }
 		"release"             { $release      = $true }
 		"debug"               { $release      = $false }
 		"bootstrap"           { $bootstrap    = $true }
 		"singleheader"        { $singleheader = $true }
+		"c_library"           { $c_library    = $true }
+		"unreal"              { $unreal       = $true }
 		"test"                { $test         = $true }
 	}
 }}
@@ -47,300 +83,31 @@ if ( $release -eq $null ) {
 	write-host "No build type specified, assuming debug"
 	$release = $false
 }
+elseif ( $release -eq $false ) {
+	$debug = $true
+}
+else {
+	$optimize = $true
+}
 
-if ( $bootstrap -eq $false -and $singleheader -eq $false -and $test -eq $false ) {
+if ( $bootstrap -eq $false -and $singleheader -eq $false -and $c_library -eq $false -and $unreal -eq $false -and $test -eq $false ) {
 	throw "No build target specified. One must be specified, this script will not assume one"
 }
 
+
+. $vendor_toolchain
+. $incremental_checks
+
 write-host "Building gencpp with $vendor"
 write-host "Build Type: $(if ($release) {"Release"} else {"Debug"} )"
 
-function run-compiler
-{
-	param( $compiler, $unit, $compiler_args )
-
-	write-host "`Compiling $unit"
-	write-host "Compiler config:"
-	$compiler_args | ForEach-Object {
-		write-host $_ -ForegroundColor Cyan
-	}
-
-	$time_taken = Measure-Command {
-		& $compiler $compiler_args 2>&1 | ForEach-Object {
-			$color = 'White'
-			switch ($_){
-				{ $_ -match "error"   } { $color = 'Red'   ; break }
-				{ $_ -match "warning" } { $color = 'Yellow'; break }
-			}
-			write-host `t $_ -ForegroundColor $color
-		}
-	}
-
-	if ( Test-Path($unit) ) {
-		write-host "$unit compile finished in $($time_taken.TotalMilliseconds) ms"
-	}
-	else {
-		write-host "Compile failed for $unit" -ForegroundColor Red
-	}
-}
-
-function run-linker
-{
-	param( $linker, $binary, $linker_args )
-
-	write-host "`Linking $binary"
-	write-host "Linker config:"
-	$linker_args | ForEach-Object {
-		write-host $_ -ForegroundColor Cyan
-	}
-
-	$time_taken = Measure-Command {
-		& $linker $linker_args 2>&1 | ForEach-Object {
-			$color = 'White'
-			switch ($_){
-				{ $_ -match "error"   } { $color = 'Red'   ; break }
-				{ $_ -match "warning" } { $color = 'Yellow'; break }
-			}
-			write-host `t $_ -ForegroundColor $color
-		}
-	}
-
-	if ( Test-Path($binary) ) {
-		write-host "$binary linking finished in $($time_taken.TotalMilliseconds) ms"
-	}
-	else {
-		write-host "Linking failed for $binary" -ForegroundColor Red
-	}
-}
-
-function run-compile-and-link
-{
-	param( $vendor, $unit, $compiler_args, $linker_args )
-
-	write-host "`Compiling & Linking $unit"
-	write-host "Compiler config:"
-	$compiler_args | ForEach-Object {
-		write-host $_ -ForegroundColor Cyan
-	}
-	write-host "Linker config:"
-	$linker_args | ForEach-Object {
-		write-host $_ -ForegroundColor Cyan
-	}
-
-	$time_taken = Measure-Command {
-		& $vendor $compiler_args $linker_args 2>&1 | ForEach-Object {
-			$color = 'White'
-			switch ($_){
-				{ $_ -match "error"   } { $color = 'Red'   ; break }
-				{ $_ -match "warning" } { $color = 'Yellow'; break }
-			}
-			write-host `t $_ -ForegroundColor $color
-		}
-	}
-
-	# if ( Test-Path($binary) ) {
-	# 	write-host "$binary compile & link finished in $($time_taken.TotalMilliseconds) ms"
-	# }
-	# else {
-	# 	write-host "Compile & Link failed for $binary" -ForegroundColor Red
-	# }
-}
-
-if ( $vendor -match "clang" )
-{
-	# https://clang.llvm.org/docs/ClangCommandLineReference.html
-	$flag_compile                    = '-c'
-	$flag_color_diagnostics          = '-fcolor-diagnostics'
-	$flag_no_color_diagnostics       = '-fno-color-diagnostics'
-	$flag_debug                      = '-g'
-	$flag_debug_codeview             = '-gcodeview'
-	$flag_define                     = '-D'
-	$flag_preprocess 			     = '-E'
-	$flag_include                    = '-I'
-	$flag_library					 = '-l'
-	$flag_library_path				 = '-L'
-	$flag_link_win                   = '-Wl,'
-	$flag_link_win_subsystem_console = '/SUBSYSTEM:CONSOLE'
-	$flag_link_win_machine_32        = '/MACHINE:X86'
-	$flag_link_win_machine_64        = '/MACHINE:X64'
-	$flag_link_win_debug             = '/DEBUG'
-	$flag_link_win_pdb 			     = '/PDB:'
-	$flag_link_win_path_output       = '/OUT:'
-	$flag_no_optimization 		     = '-O0'
-	$flag_path_output                = '-o'
-	$flag_preprocess_non_intergrated = '-no-integrated-cpp'
-	$flag_profiling_debug            = '-fdebug-info-for-profiling'
-	$flag_target_arch				 = '-target'
-	$flag_wall 					     = '-Wall'
-	$flag_warning 					 = '-W'
-	$flag_warning_as_error 		     = '-Werror'
-	$flag_win_nologo 			     = '/nologo'
-
-	$ignore_warning_ms_include = 'no-microsoft-include'
-
-	$target_arch = Get-TargetArchClang
-
-	$warning_ignores = @(
-		$ignore_warning_ms_include
-	)
-
-	# https://learn.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=msvc-170
-	$libraries = @(
-		'Kernel32' # For Windows API
-		# 'msvcrt', # For the C Runtime (Dynamically Linked)
-		# 'libucrt',
-		'libcmt'    # For the C Runtime (Static Linkage)
-	)
-
-	function build-simple
-	{
-		param( $includes, $unit, $executable )
-		Write-Host "build-simple: clang"
-
-		$object = $executable -replace '\.exe', '.obj'
-		$pdb    = $executable -replace '\.exe', '.pdb'
-
-		$compiler_args = @(
-			$flag_no_color_diagnostics,
-			$flag_target_arch, $target_arch,
-			$flag_wall,
-			$flag_preprocess_non_intergrated,
-			( $flag_define + 'GEN_TIME' ),
-			# ( $flag_path_output + $object ),
-			( $flag_path_output + $executable )
-			( $flag_include + $includes )
-		)
-		if ( $release -eq $false ) {
-			$compiler_args += ( $flag_define + 'Build_Debug' )
-			$compiler_args += $flag_debug, $flag_debug_codeview, $flag_profiling_debug
-			$compiler_args += $flag_no_optimization
-		}
-
-		$warning_ignores | ForEach-Object {
-			$compiler_args += $flag_warning + $_
-		}
-
-		# $compiler_args += $flag_preprocess
-
-		# $compiler_args += $flag_compile, $unit
-		# run-compiler $compiler $unit $compiler_args
-
-		$linker_args = @(
-			$flag_link_win_subsystem_console,
-			$flag_link_win_machine_64,
-			$( $flag_link_win_path_output + $executable )
-		)
-		if ( $release -eq $false ) {
-			$linker_args += $flag_link_win_debug
-			$linker_args += $flag_link_win_pdb + $pdb
-		}
-		else {
-		}
-
-		$libraries | ForEach-Object {
-			$linker_args += $_ + '.lib'
-		}
-
-		# $linker_args += $object
-		# run-linker $linker $executable $linker_args
-
-		$compiler_args += $unit
-		# $linker_args += $object
-		run-compile-and-link $compiler $unit $compiler_args
-	}
-
-	$compiler = 'clang++'
-	$linker   = 'lld-link'
-}
-
-if ( $vendor -match "msvc" )
-{
-	# https://learn.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-by-category?view=msvc-170
-	$flag_compile			      = '/c'
-	$flag_debug                   = '/Zi'
-	$flag_define		          = '/D'
-	$flag_include                 = '/I'
-	$flag_full_src_path           = '/FC'
-	$flag_nologo                  = '/nologo'
-	$flag_dll 				      = '/LD'
-	$flag_dll_debug 			  = '/LDd'
-	$flag_linker 		          = '/link'
-	$flag_link_debug 			  = '/DEBUG'
-	$flag_link_pdb 				  = '/PDB:'
-	$flag_link_machine_32         = '/MACHINE:X86'
-	$flag_link_machine_64         = '/MACHINE:X64'
-	$flag_link_path_output 	      = '/OUT:'
-	$flag_link_rt_dll             = '/MD'
-	$flag_link_rt_dll_debug       = '/MDd'
-	$flag_link_rt_static          = '/MT'
-	$flag_link_rt_static_debug    = '/MTd'
-	$flag_link_subsystem_console  = '/SUBSYSTEM:CONSOLE'
-	$flag_link_subsystem_windows  = '/SUBSYSTEM:WINDOWS'
-	$flag_no_optimization		  = '/Od'
-	$flag_out_name                = '/OUT:'
-	$flag_path_interm             = '/Fo'
-	$flag_path_debug              = '/Fd'
-	$flag_path_output             = '/Fe'
-	$flag_preprocess_conform      = '/Zc:preprocessor'
-
-	# This works because this project uses a single unit to build
-	function build-simple
-	{
-		param( $includes, $unit, $executable )
-		Write-Host "build-simple: msvc"
-
-		$object = $executable -replace '\.exe', '.obj'
-		$pdb    = $executable -replace '\.exe', '.pdb'
-
-		$compiler_args = @(
-			$flag_nologo,
-			$flag_preprocess_conform,
-			$flag_debug,
-			( $flag_define + 'GEN_TIME' ),
-			$flag_full_src_path,
-			( $flag_path_interm + $path_build + '\' ),
-			( $flag_path_output + $path_build + '\' )
-		)
-		if ( $release -eq $false ) {
-			$compiler_args += ( $flag_define + 'Build_Debug' )
-			$compiler_args += ( $flag_path_debug + $path_build + '\' )
-			$compiler_args += $flag_link_rt_static_debug
-			$compiler_args += $flag_no_optimization
-		}
-		else {
-			$compiler_args += $flag_link_rt_static
-		}
-		$compiler_args += $includes | ForEach-Object { $flag_include + $_ }
-		$compiler_args += $flag_compile, $unit
-		run-compiler $compiler $unit $compiler_args
-
-		$linker_args = @(
-			$flag_nologo,
-			$flag_link_machine_64,
-			$flag_link_subsystem_console,
-			( $flag_link_path_output + $executable )
-		)
-		if ( $release -eq $false ) {
-			$linker_args += $flag_link_debug
-			$linker_args += $flag_link_pdb + $pdb
-		}
-		else {
-		}
-
-		$linker_args += $object
-		run-linker $linker $executable $linker_args
-	}
-
-	$compiler = 'cl'
-	$linker   = 'link'
-}
-#endregion Configuration
-
 #region Building
 $path_build        = Join-Path $path_root build
 $path_project      = Join-Path $path_root project
 $path_scripts      = Join-Path $path_root scripts
-$path_singleheader = Join-Path $path_root singleheader
+$path_c_library    = join-Path $path_root gen_c_library
+$path_singleheader = Join-Path $path_root gen_singleheader
+$path_unreal       = Join-Path $path_root gen_unreal_engine
 $path_test         = Join-Path $path_root test
 
 if ( $bootstrap )
@@ -359,11 +126,18 @@ if ( $bootstrap )
 		New-Item -ItemType Directory -Path $path_comp_gen
 	}
 
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
 	$includes   = @( $path_project)
 	$unit       = join-path $path_project "bootstrap.cpp"
 	$executable = join-path $path_build   "bootstrap.exe"
 
-	build-simple $includes $unit $executable
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
 
 	Push-Location $path_project
 		if ( Test-Path( $executable ) ) {
@@ -394,7 +168,14 @@ if ( $singleheader )
 	$unit       = join-path $path_singleheader "singleheader.cpp"
 	$executable = join-path $path_build        "singleheader.exe"
 
-	build-simple $includes $unit $executable
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
 
 	Push-Location $path_singleheader
 		if ( Test-Path( $executable ) ) {
@@ -409,11 +190,117 @@ if ( $singleheader )
 	Pop-Location
 }
 
+if ( $c_library )
+{
+	$path_build = join-path $path_c_library build
+	$path_gen   = join-path $path_c_library gen
+
+	if ( -not(Test-Path($path_build) )) {
+		New-Item -ItemType Directory -Path $path_build
+	}
+	if ( -not(Test-Path($path_gen) )) {
+		New-Item -ItemType Directory -Path $path_gen
+	}
+
+	$includes    = @( $path_project )
+	$unit       = join-path $path_c_library "c_library.cpp"
+	$executable = join-path $path_build     "c_library.exe"
+
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
+
+	Push-Location $path_c_library
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning c_library generator"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+
+	$unit       = join-path $path_c_library "gen.c"
+	$executable = join-path $path_build     "gen_c_library_test.exe"
+
+	if ($vendor -eq "clang") {
+		$compiler_args += "-x"
+		$compiler_args += "c"
+	} elseif ($vendor -eq "msvc") {
+		$compiler_args += "/TC"
+	}
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
+
+	Push-Location $path_c_library
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning c_library test"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+}
+
+if ( $unreal )
+{
+	$path_build = join-path $path_unreal build
+	$path_gen   = join-path $path_unreal gen
+
+	if ( -not(Test-Path($path_build) )) {
+		New-Item -ItemType Directory -Path $path_build
+	}
+	if ( -not(Test-Path($path_gen) )) {
+		New-Item -ItemType Directory -Path $path_gen
+	}
+
+	$includes    = @( $path_project )
+	$unit       = join-path $path_unreal "unreal.cpp"
+	$executable = join-path $path_build  "unreal.exe"
+
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
+
+	Push-Location $path_unreal
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning unreal variant generator"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`n Unreal variant generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+
+	. $refactor_unreal
+}
+
 if ( $test )
 {
-	$path_gen       = join-path $path_test gen
-	$path_gen_build = join-path $path_gen  build
-	$path_build     = join-path $path_test build
+	$path_gen          = join-path $path_test gen
+	$path_gen_build    = join-path $path_gen  build
+	$path_build        = join-path $path_test build
+	$path_original     = join-path $path_gen  original
+	$path_components   = join-path $path_original components
+	$path_dependencies = join-path $path_original dependencies
+	$path_helpers      = join-path $path_original helpers
 
 	if ( -not(Test-Path($path_build) )) {
 		New-Item -ItemType Directory -Path $path_build
@@ -424,6 +311,18 @@ if ( $test )
 	if ( -not(Test-Path($path_gen_build) ))  {
 		New-Item -ItemType Directory -Path $path_gen_build
 	}
+	if ( -not(test-path $path_original)) {
+		new-item -ItemType Directory -Path $path_original
+	}
+	if ( -not(test-path $path_components)) {
+		new-item -ItemType Directory -Path $path_components
+	}
+	if ( -not(test-path $path_dependencies)) {
+		new-item -ItemType Directory -Path $path_dependencies
+	}
+	if ( -not(test-path $path_helpers)) {
+		new-item -ItemType Directory -Path $path_helpers
+	}
 
 	$path_bootstrap = join-path $path_project gen
 
@@ -431,7 +330,14 @@ if ( $test )
 	$unit       = join-path $path_test  "test.cpp"
 	$executable = join-path $path_build "test.exe"
 
-	build-simple $includes $unit $executable
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
 
 	Push-Location $path_test
 		Write-Host $path_test
@@ -449,33 +355,10 @@ if ( $test )
 #endregion Building
 
 #region Formatting
-function format-cpp
-{
-	param( $path, $include, $exclude )
-
-	# Format generated gencpp
-	Write-Host "`nBeginning format"
-	$formatParams = @(
-		'-i'          # In-place
-		'-style=file:./scripts/.clang-format'
-		'-verbose'
-	)
-
-	$targetFiles = @(
-		Get-ChildItem -Recurse -Path $path -Include $include -Exclude $exclude
-			| Select-Object -ExpandProperty FullName
-	)
-
-	$time_taken = Measure-Command {
-		clang-format $formatParams $targetFiles
-	}
-	Write-Host "`nFormatting complete in $($time_taken.TotalMilliseconds) ms"
-}
-
-if ( $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
+push-location $path_scripts
+if ( $true -and $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
 {
 	$path_gen      = join-path $path_project gen
-	$path_comp_gen = join-path $path_project components/gen
 	$include  = @(
 		'gen.hpp', 'gen.cpp',
 		'gen.dep.hpp', 'gen.dep.cpp',
@@ -483,11 +366,12 @@ if ( $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
 		'gen.scanner.hpp', 'gen.scanner.cpp'
 	)
 	$exclude  = $null
-	format-cpp $path_gen $include $exclude
+	# format-cpp $path_gen $include $exclude
 	format-cpp $path_comp_gen @( 'ast_inlines.hpp', 'ecode.hpp', 'especifier.hpp', 'eoperator.hpp', 'etoktype.cpp' ) $null
+
 }
 
-if ( $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp")) )
+if ( $false -and $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp")) )
 {
 	$path_gen = join-path $path_singleheader gen
 	$include  = @(
@@ -497,6 +381,19 @@ if ( $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp"))
 	format-cpp $path_gen $include $exclude
 }
 
+if ( $false -and $unreal -and (Test-Path( Join-Path $path_unreal "gen/gen.hpp")) )
+{
+	$path_gen = join-path $path_unreal gen
+	$include  = @(
+		'gen.hpp', 'gen.cpp',
+		'gen.dep.hpp', 'gen.dep.cpp',
+		'gen.builder.hpp', 'gen.builder.cpp'
+		'gen.scanner.hpp', 'gen.scanner.cpp'
+	)
+	$exclude  = $null
+	format-cpp $path_gen $include $exclude
+}
+
 if ( $test -and $false )
 {
 	$path_gen = join-path $path_test gen
@@ -506,6 +403,7 @@ if ( $test -and $false )
 	$exclude  = $null
 	format-cpp $path_gen $include $exclude
 }
+pop-location
 #endregion Formatting
 
 Pop-Location # $path_root

scripts/c_library.refactor

@@ -0,0 +1,24 @@
+ __VERSION 1
+
+// This is a example template to be used with the refactor program
+// Use it to refactor the naming convention of this library to your own.
+// Can be used as an aid to help use use your project's implementation if it fullfills the dependencies of this project.
+// Example: Most likely have a memory and string library already, just rename the functions and make sure the args are the same.
+// Program: https://github.com/Ed94/refactor
+
+// NOTE: Due to the current limitations of the program, not every symbol in the library can be renamed.
+// This is due to the program not actually parsing C/C++.
+
+// not       : Ignore
+// include   : #includes
+// word      : Alphanumeric or underscore
+// namespace : Prefix search and replace (c-namspaces).
+// regex     : Unavailable in __VERSION 1.
+
+// Precedence (highest to lowest):
+// word, namespace, regex
+
+// Gen Macro namespace
+// namespace GEN_, new_namespace_
+
+// TODO(Ed): This will be large as nearly all symbols will need to optionally support getting prefixed with gen_ or something else the user wants.

scripts/gencpp.natvis

@@ -121,6 +121,20 @@
 		</Expand>
 	</Type>
 
+	<Type Name="gen::AST_Constructor">
+		<DisplayString>{Name} Type: {Type}</DisplayString>
+		<Expand>
+			<Item Name="InlineCmt">InlineCmt</Item>
+			<Item Name="Specs">Specs</Item>
+			<Item Name="InitializerList">InitializerList</Item>
+			<Item Name="Params">Params</Item>
+			<Item Name="Body">Body</Item>
+			<Item Name="Parent">Parent</Item>
+			<Item Name="Prev">Prev</Item>
+			<Item Name="Next">Next</Item>
+		</Expand>
+	</Type>
+
 	<Type Name="gen::AST_Class">
 		<DisplayString>{Name} Type: {Type}</DisplayString>
 		<Expand>
@@ -671,11 +685,11 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::Parser::Token">
+	<Type Name="gen::parser::Token">
 		<DisplayString>Length:{Length} Text:{Text, [Length]s} Type:{Type}</DisplayString>
 	</Type>
 
-	<Type Name="gen::Parser::TokArray">
+	<Type Name="gen::parser::TokArray">
 		<DisplayString>Current[ { Arr[Idx] } ] Idx:{ Idx }</DisplayString>
 	</Type>
 

scripts/gencpp.refactor

@@ -43,9 +43,6 @@
 // word GEN_COMPILER_MINGW, new_name
 // word GEN_COMPILER_MSVC,  new_name
 
-    // General
-// word zpl_cast, new_name
-
 // word global,        new_name
 // word internal,      new_name
 // word local_persist, new_name
@@ -150,8 +147,8 @@
 // word u16,  new_name
 // word u32,  new_name
 // word u64,  new_name
-// word uw,   new_name
-// word sw,   new_name
+// word usize,   new_name
+// word ssize,   new_name
 // word sptr, new_name
 // word uptr, new_name
 // word f32,  new_name
@@ -256,7 +253,7 @@
 
 // word log_failure, new_name
 
-// word NoCode,      new_name
+// word NullCode,      new_name
 // word CodeInvalid, new_name
 
 // ------------ gencpp common

scripts/helpers/devshell.ps1

@@ -23,5 +23,6 @@ if ( -not (Test-Path $vs_devshell) ) {
 
 # Launch the Visual Studio Developer Shell
 Push-Location
+write-host @args
 & $vs_devshell @args
 Pop-Location

scripts/helpers/format_cpp.psm1

@@ -0,0 +1,26 @@
+# format_cpp.psm1
+
+function format-cpp
+{
+	param( $path, $include, $exclude )
+
+	# Format generated gencpp
+	Write-Host "Beginning format"
+	$formatParams = @(
+		'-i'          # In-place
+		'-style=file:.clang-format'
+		'-verbose'
+	)
+
+	$targetFiles = @(
+		Get-ChildItem -Recurse -Path $path -Include $include -Exclude $exclude
+			| Select-Object -ExpandProperty FullName
+	)
+
+	$time_taken = Measure-Command {
+		clang-format $formatParams $targetFiles
+	}
+	Write-Host "Formatting complete in $($time_taken.TotalMilliseconds) ms`n"
+}
+
+Export-ModuleMember -Function format-cpp

scripts/helpers/incremental_checks.ps1

@@ -0,0 +1,73 @@
+# This is meant to be used with build.ps1, and is not a standalone script.
+
+function check-FileForChanges
+{
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$path_file
+    )
+
+    if (-not (Test-Path $path_file -PathType Leaf)) {
+        Write-Error "The provided path is not a valid file: $path_file"
+        return $false
+    }
+    $file_name = Split-Path $path_file -Leaf
+    $path_csv  = Join-Path $path_build ($file_name + "_file_hash.csv")
+
+    $csv_file_hash = $null
+    if (Test-Path $path_csv) {
+        $csv_file_hash = Import-Csv $path_csv | Select-Object -ExpandProperty value
+    }
+
+    $current_hash_info = Get-FileHash -Path $path_file -Algorithm MD5
+    $current_file_hash = $current_hash_info.Hash
+
+    # Save the current hash to the CSV
+    [PSCustomObject]@{
+        name  = $path_file
+        value = $current_file_hash
+    } | Export-Csv $path_csv -NoTypeInformation
+
+    if ($csv_file_hash -and $csv_file_hash -eq $current_file_hash) {
+        return $false
+    } else {
+        return $true
+    }
+}
+
+# Check to see if the module has changed files since the last build
+function check-ModuleForChanges
+{
+	param( [string]$path_module, [array]$excludes )
+
+	$module_name = split-path $path_module -leaf
+	$path_csv    = Join-Path $path_build ($module_name + "_module_hashes.csv")
+
+	$csv_file_hashes = $null
+	if ( test-path $path_csv ) {
+		$csv_file_hashes = @{}
+		import-csv $path_csv | foreach-object {
+			$csv_file_hashes[ $_.name ] = $_.value
+		}
+	}
+
+	$file_hashes = @{}
+	get-childitem -path $path_module -recurse -file -Exclude $excludes | foreach-object {
+		$id                 = $_.fullname
+		$hash_info          = get-filehash -path $id -Algorithm MD5
+		$file_hashes[ $id ] = $hash_info.Hash
+	}
+
+	$file_hashes.GetEnumerator() | foreach-object { [PSCustomObject]$_ } |
+		export-csv $path_csv -NoTypeInformation
+
+	if ( -not $csv_file_hashes )                         { return $true }
+	if ( $csv_file_hashes.Count -ne $file_hashes.Count ) { return $true }
+
+	foreach ( $key in $csv_file_hashes.Keys ) {
+		if ( $csv_file_hashes[ $key ] -ne $file_hashes[ $key ] ) {
+			return $true
+		}
+	}
+	return $false
+}