Uncomment formatting comments in build script (forgot to after completing fixes)

Related to https://github.com/Ed94/gencpp/issues/25

.gitignore

@@ -1,13 +1,17 @@
 .idea
 
-build/*
+**/build/*
 .vs
 
 **/*.gen.*
 **/gen/gen.hpp
 **/gen/gen.cpp
-**/gen/gen_dep.hpp
-**/gen/gen_dep.cpp
+**/gen/gen.dep.hpp
+**/gen/gen.dep.cpp
+**/gen/gen.builder.hpp
+**/gen/gen.builder.cpp
+**/gen/gen.scanner.hpp
+**/gen/gen.scanner.cpp
 
 gencpp.hpp
 gencpp.cpp
@@ -26,4 +30,5 @@ bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
-[Ll]ogs/
+[Ll]ogs/
+vc140.pdb

.vscode/c_cpp_properties.json

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

.vscode/launch.json

@@ -8,9 +8,9 @@
 			"type": "lldb",
 			"request": "launch",
 			"name": "Debug gentime lldb",
-			"program": "${workspaceFolder}/test/gen/build/gencpp.exe",
+			"program": "${workspaceFolder}/test/test.exe",
 			"args": [],
-			"cwd": "${workspaceFolder}/test/gen/",
+			"cwd": "${workspaceFolder}/test/",
 			"postRunCommands": [
 			]
 		},
@@ -18,16 +18,16 @@
 			"type": "cppvsdbg",
 			"request": "launch",
 			"name": "Debug gentime vsdbg",
-			"program": "${workspaceFolder}/test/gen/build/gencpp.exe",
+			"program": "${workspaceFolder}/test/build/test.exe",
 			"args": [],
-			"cwd": "${workspaceFolder}/test/gen/",
+			"cwd": "${workspaceFolder}/test/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
 		},
 		{
 			"type": "cppvsdbg",
 			"request": "launch",
 			"name": "Debug bootstrap vsdbg",
-			"program": "${workspaceFolder}/project/build/gencpp_bootstrap.exe",
+			"program": "${workspaceFolder}/project/build/bootstrap.exe",
 			"args": [],
 			"cwd": "${workspaceFolder}/project/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"

.vscode/settings.json

@@ -18,7 +18,13 @@
 		"algorithm": "cpp",
 		"limits": "cpp",
 		"concepts": "cpp",
-		"*.rh": "cpp"
+		"*.rh": "cpp",
+		"chrono": "cpp",
+		"string": "cpp",
+		"filesystem": "cpp",
+		"format": "cpp",
+		"ratio": "cpp",
+		"xstring": "cpp"
 	},
 	"C_Cpp.intelliSenseEngineFallback": "disabled",
 	"mesonbuild.configureOnOpen": true,

Readme.md

@@ -6,24 +6,17 @@ The library API is a composition of code element constructors.
 These build up a code AST to then serialize with a file builder.
 
 This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto),  
-its not meant to be a black box metaprogramming utility, its meant for the user to extend for their project domain.
-
-### TOC
-
-* [Notes](#notes)
-* [Usage](#usage)
-* [Building](#building)
+its not meant to be a black box metaprogramming utility, it should be easy to intergrate into a user's project domain.
 
 ## Notes
 
 The project has reached an *alpha* state, all the current functionality works for the test cases but it will most likely break in many other cases.  
-The [issues](https://github.com/Ed94/gencpp/issues) marked with v1.0 Feature indicate whats left before the library is considered feature complete.
 
 A `natvis` and `natstepfilter` are provided in the scripts directory.
 
 ***The editor and scanner have not been implemented yet. The scanner will come first, then the editor.***
 
-A C variant is hosted [here](https://github.com/Ed94/genc); I haven't gotten headwind on it, should be easier to make than this...
+A C variant is hosted [here](https://github.com/Ed94/genc); I will complete it when this library is feature complete, it should be easier to make than this...
 
 ## Usage
 
@@ -31,7 +24,7 @@ A metaprogram is built to generate files before the main program is built. We'll
 
 `gen.cpp` \`s  `main()` is defined as `gen_main()` which the user will have to define once for their program. There they will dictate everything that should be generated.
 
-In order to keep the locality of this code within the same files the following pattern may be used:
+In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't required at all):
 
 Within `program.cpp` :
 
@@ -47,6 +40,8 @@ u32 gen_main()
 }
 #endif
 
+// "Stage" agnostic code.
+
 #ifndef GEN_TIME
 #include "program.gen.cpp"
 
@@ -62,6 +57,7 @@ Example using each construction interface:
 
 ### Upfront
 
+Validation and construction through a functional interface.
 
 ```cpp
 Code t_uw           = def_type( name(uw) );
@@ -81,6 +77,8 @@ Code header;
 
 ### Parse
 
+Validation through ast construction.
+
 ```cpp
 Code header = parse_struct( code(
     struct ArrayHeader
@@ -95,6 +93,8 @@ Code header = parse_struct( code(
 
 ### Untyped
 
+No validation, just glorified text injection.
+
 ```cpp
 Code header = code_str(
     struct ArrayHeader

docs/Parsing.md

@@ -1,12 +1,36 @@
 # Parsing
 
 The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.  
-This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept under 5000 loc.
+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) under 5000 loc.
 
+The parsing implementation supports the following for the user:
+
+```cpp
+CodeClass       parse_class        ( StrC class_def       );
+CodeConstructor parse_constructor  ( StrC constructor_def );
+CodeDestructor  parse_destructor   ( StrC destructor_def  );
+CodeEnum        parse_enum         ( StrC enum_def        );
+CodeBody        parse_export_body  ( StrC export_def      );
+CodeExtern      parse_extern_link  ( StrC exten_link_def  );
+CodeFriend      parse_friend       ( StrC friend_def      );
+CodeFn          parse_function     ( StrC fn_def          );
+CodeBody        parse_global_body  ( StrC body_def        );
+CodeNS          parse_namespace    ( StrC namespace_def   );
+CodeOperator    parse_operator     ( StrC operator_def    );
+CodeOpCast      parse_operator_cast( StrC operator_def    );
+CodeStruct      parse_struct       ( StrC struct_def      );
+CodeTemplate    parse_template     ( StrC template_def    );
+CodeType        parse_type         ( StrC type_def        );
+CodeTypedef     parse_typedef      ( StrC typedef_def     );
+CodeUnion       parse_union        ( StrC union_def       );
+CodeUsing       parse_using        ( StrC using_def       );
+CodeVar         parse_variable     ( StrC var_def         );
+```
+
+***Parsing will aggregate any tokens within a function body or expression statement to an untyped Code AST.***
 
 Everything is done in one pass for both the preprocessor directives and the rest of the language.  
-The parser performs no macro expansion as the scope of gencpp feature-set is to only support the preprocessor for the goal of having rudimentary awareness of preprocessor ***conditionals***,  ***defines***, and ***includes***.  
-*(Conditionals and defines are a TODO)*
+The parser performs no macro expansion as the scope of gencpp feature-set is to only support the preprocessor for the goal of having rudimentary awareness of preprocessor ***conditionals***,  ***defines***, and ***includes***, and ***pragmas***.  
 
 The keywords supported for the preprocessor are:
 
@@ -16,34 +40,32 @@ The keywords supported for the preprocessor are:
 * ifdef
 * elif
 * endif
-* undef
+* pragma
 
-Just like with actual preprocessor, each directive # line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.
-All keywords except *include* are suppported as members of a scope for a class/struct, global, or namespace body.  
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.  
+If a directive is used with an unsupported keyword its will be processed as an untyped AST.
 
-Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).
+The preprocessor lines are stored as members of their associated scope they are parsed within. ( Global, Namespace, Class/Struct )
 
-The parsing implementation supports the following for the user:
+Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).  
+Exceptions:
 
-```cpp
-CodeClass     parse_class        ( StrC class_def     );
-CodeEnum      parse_enum         ( StrC enum_def      );
-CodeBody      parse_export_body  ( StrC export_def    );
-CodeExtern    parse_extern_link  ( StrC exten_link_def);
-CodeFriend    parse_friend       ( StrC friend_def    );
-CodeFn        parse_function     ( StrC fn_def        );
-CodeBody      parse_global_body  ( StrC body_def      );
-CodeNamespace parse_namespace    ( StrC namespace_def );
-CodeOperator  parse_operator     ( StrC operator_def  );
-CodeOpCast    parse_operator_cast( StrC operator_def  );
-CodeStruct    parse_struct       ( StrC struct_def    );
-CodeTemplate  parse_template     ( StrC template_def  );
-CodeType      parse_type         ( StrC type_def      );
-CodeTypedef   parse_typedef      ( StrC typedef_def   );
-CodeUnion     parse_union        ( StrC union_def     );
-CodeUsing     parse_using        ( StrC using_def     );
-CodeVar       parse_variable     ( StrC var_def       );
-```
+* function signatures are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
+* typedefs allow for a preprocessed macro: `typedef MACRO();`
 
-***Parsing will aggregate any tokens within a function body or expression statement to an untyped Code AST.***
+*(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
 
+The lexing and parsing takes shortcuts from whats expected in the standard.
+
+* Numeric literals are not checked for validity.
+* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
+  * *This includes the assignment of variables.*
+* Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
+  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function
+  * Or in the usual spot for class, structs, (*right after the declaration keyword*)
+  * typedefs have attributes with the type (`parse_type`)
+* As a general rule; if its not available from the upfront constructors, its not available in the parsing constructors.
+  * *Upfront constructors are not necessarily used in the parsing constructors, this is just a good metric to know what can be parsed.*
+* Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
+
+Empty lines used throughout the file are preserved for formatting purposes during ast serialization.

docs/Readme.md

@@ -40,27 +40,9 @@ Otherwise the library is free of any templates.
 
 ### *WHAT IS NOT PROVIDED*
 
-* Execution statement validation : Execution expressions are defined using the untyped AST.
-  * Lambdas (This naturally means its unsupported)
-* RAII : This needs support for constructors/destructor parsing
-  * Haven't gotten around to yet (its in the github issues)
-
-Keywords kept from "Modern C++":
-
-* constexpr : Great to store compile-time constants.
-* consteval : Technically fine, need to make sure to execute in moderation.
-* constinit : Better than constexpr at doing its job, however, its only c++ 20.
-* export    : Useful if c++ modules ever come around to actually being usable.
-* import    : ^^
-* module    : ^^
-
-When it comes to expressions:
-
 **There is no support for validating expressions.**  
 Its difficult to parse without enough benefits (At the metaprogramming level).  
 
-When it comes to templates:
-
 **Only trivial template support is provided.**  
 The intention is for only simple, non-recursive substitution.  
 The parameters of the template are treated like regular parameter AST entries.  
@@ -77,9 +59,9 @@ Use at your own mental peril.
 
 ### The Data & Interface
 
-As mentioned in [Usage](#usage), the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
+As mentioned in root readme, the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
 
-The AST is managed by the library and provided the user via its interface.  
+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:
@@ -88,39 +70,44 @@ Data layout of AST struct:
 union {
     struct
     {
-        AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
-        AST*      Specs;          // Function, Operator, Type symbol, Variable
+        AST*      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+        AST*      Specs;           // Function, Operator, Type symbol, Variable
         union {
-            AST*  ParentType;     // Class, Struct
-            AST*  ReturnType;     // Function, Operator
-            AST*  UnderlyingType; // Enum, Typedef
-            AST*  ValueType;      // Parameter, Variable
+            AST*  InitializerList; // Constructor, Destructor
+            AST*  ParentType;      // Class, Struct
+            AST*  ReturnType;      // Function, Operator
+            AST*  UnderlyingType;  // Enum, Typedef
+            AST*  ValueType;       // Parameter, Variable
         };
-        AST*      Params;         // Function, Operator, Template
         union {
-            AST*  ArrExpr;        // Type Symbol
-            AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
-            AST*  Declaration;    // Friend, Template
-            AST*  Value;          // Parameter, Variable
+            AST*  BitfieldSize;    // Varaiable (Class/Struct Data Member)
+            AST*  Params;          // Function, Operator, Template
+        };
+        union {
+            AST*  ArrExpr;         // Type Symbol
+            AST*  Body;            // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+            AST*  Declaration;     // Friend, Template
+            AST*  Value;           // Parameter, Variable
         };
     };
-    StringCached  Content;        // Attributes, Comment, Execution, Include
+    StringCached  Content;                     // Attributes, Comment, Execution, Include
     SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
 };
 union {
     AST* Prev;
-    AST* Front; // Used by CodeBody
-    AST* Last;  // Used by CodeParam
+    AST* Front;
+    AST* Last;
 };
 union {
     AST* Next;
-    AST* Back;  // Used by CodeBody
+    AST* Back;
 };
 AST*              Parent;
 StringCached      Name;
 CodeT             Type;
 ModuleFlag        ModuleFlags;
 union {
+    b32           IsFunction; // Used by typedef to not serialize the name field.
     OperatorT     Op;
     AccessSpec    ParentAccess;
     s32           NumEntries;
@@ -144,7 +131,7 @@ uw ArrSpecs_Cap =
     - sizeof(StringCached)
     - sizeof(CodeT)
     - sizeof(ModuleFlag)
-    - sizeof(s32)
+    - sizeof(u32)
 )
 / sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
 ```
@@ -154,7 +141,7 @@ uw ArrSpecs_Cap =
 Data Notes:
 
 * The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `gen_string_allocator`, `get_cached_string`, `make_code`.
+  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
 * Both AST and Code have member symbols but their data layout is enforced to be POD types.
 * This library treats memory failures as fatal.
@@ -167,15 +154,15 @@ Data Notes:
 * Linked lists used children nodes on bodies, and parameters.
 * Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
 * Allocations can be tuned by defining the folloiwng macros:
-  * `GEN_BUILDER_STR_BUFFER_RESERVE`
-  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
   * `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
-  * `GEN_LEX_ALLOCATOR_SIZE`
+  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
+  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
   * `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
   * `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
   * `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
-  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
   * `GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE` : token_fmt_va uses local_persit memory of this size for the hashtable.
+  * `GEN_LEX_ALLOCATOR_SIZE`
+  * `GEN_BUILDER_STR_BUFFER_RESERVE`
 
 The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
 
@@ -186,7 +173,6 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeConstructor
 * CodeDefine
 * CodeDestructor
-* CodePreprocessCond
 * CodeEnum
 * CodeExec
 * CodeExtern
@@ -194,10 +180,12 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeFriend
 * CodeFn
 * CodeModule
-* CodeNamespace
+* CodeNS
 * CodeOperator
 * CodeOpCast
 * CodeParam : Has support for `for-range` iterating across parameters.
+* CodePreprocessCond
+* CodePragma
 * CodeSpecifiers : Has support for `for-range` iterating across specifiers.
 * CodeStruct
 * CodeTemplate
@@ -220,7 +208,7 @@ Retrieving a raw version of the ast can be done using the `raw()` function defin
 ### Upfront Construction
 
 All component ASTs must be previously constructed, and provided on creation of the code AST.
-The construction will fail and return Code::Invalid otherwise.
+The construction will fail and return CodeInvalid otherwise.
 
 Interface :``
 
@@ -230,6 +218,7 @@ Interface :``
 * def_comment
 * def_class
 * def_constructor
+* def_define
 * def_destructor
 * def_enum
 * def_execution
@@ -244,6 +233,7 @@ Interface :``
 * def_operator_cast
 * def_param
 * def_params
+* def_preprocess_cond
 * def_specifier
 * def_specifiers
 * def_struct
@@ -320,19 +310,6 @@ Interface :
 * parse_using
 * parse_variable
 
-The lexing and parsing takes shortcuts from whats expected in the standard.
-
-* Numeric literals are not check for validity.
-* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
-  * *This includes the assignment of variables.*
-* Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
-  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function
-  * Or in the usual spot for class, structs, (*right after the declaration keyword*)
-  * typedefs have attributes with the type (`parse_type`)
-* As a general rule; if its not available from the upfront constructors, its not available in the parsing constructors.
-  * *Upfront constructors are not necessarily used in the parsing constructors, this is just a good metric to know what can be parsed.*
-* Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
-
 Usage:
 
 ```cpp
@@ -341,13 +318,6 @@ Code <name> = parse_<function name>( string with code );
 Code <name> = def_<function name>( ..., parse_<function name>(
     <string with code>
 ));
-
-Code <name> = make_<function name>( ... )
-{
-    <name>->add( parse_<function name>(
-        <string with code>
-    ));
-}
 ```
 
 ### Untyped constructions
@@ -390,7 +360,7 @@ Code <name> = code_str( <some code without "" quotes > )
 Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
 
 ```cpp
-StrC value = txt_StrC("Something");
+StrC value = txt("Something");
 
 char const* template_str = txt(
     Code with <key> to replace with token_values
@@ -407,12 +377,15 @@ The following are provided predefined by the library as they are commonly used:
 * `access_public`
 * `access_protected`
 * `access_private`
+* `attrib_api_export`
+* `attrib_api_import`
 * `module_global_fragment`
 * `module_private_fragment`
+* `fmt_newline`
+* `pragma_once`
 * `param_varaidc` (Used for varadic definitions)
 * `preprocess_else`
 * `preprocess_endif`
-* `pragma_once`
 * `spec_const`
 * `spec_consteval`
 * `spec_constexpr`
@@ -424,8 +397,10 @@ The following are provided predefined by the library as they are commonly used:
 * `spec_internal_linkage` (internal macro)
 * `spec_local_persist` (local_persist macro)
 * `spec_mutable`
+* `spec_neverinline`
 * `spec_override`
 * `spec_ptr`
+* `spec_pure`
 * `spec_ref`
 * `spec_register`
 * `spec_rvalue`
@@ -433,10 +408,6 @@ The following are provided predefined by the library as they are commonly used:
 * `spec_thread_local`
 * `spec_virtual`
 * `spec_volatile`
-* `spec_type_signed`
-* `spec_type_unsigned`
-* `spec_type_short`
-* `spec_type_long`
 * `t_empty` (Used for varaidc macros)
 * `t_auto`
 * `t_void`
@@ -476,7 +447,7 @@ and have the desired specifiers assigned to them beforehand.
 
 ## Code generation and modification
 
-There are three provided file interfaces:
+There are three provided auxillary interfaces:
 
 * Builder
 * Editor
@@ -491,11 +462,12 @@ Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FE
 * The code is provided via print( code ) function  will be serialized to its buffer.
 * When all serialization is finished, use the write() command to write the buffer to the file.
 
-### Editor is for editing a series of files based on a set of requests provided to it
+### Editor is for editing a series of files/asts based on a set of requests provided to it
 
 **Note: Not implemented yet**
 
 * The purpose is to overrite a specific file, it places its contents in a buffer to scan.
+* If editing an AST it will generate a new ast as a result (ASTs are not edited).
 * Requests are populated using the following interface:
   * add : Add code.
   * remove : Remove code.
@@ -515,7 +487,7 @@ Additionally if `GEN_FEATURE_EDITOR_REFACTOR` is defined, refactor( file_path, s
 Refactor is based of the refactor library and uses its interface.  
 It will on call add a request to the queue to run the refactor script on the file.
 
-### Scanner allows the user to generate Code ASTs by reading files
+### Scanner allows the user to sift through a series of files/asts based on a set of requests provided to it
 
 **Note: Not implemented yet**
 
@@ -524,8 +496,6 @@ It will on call add a request to the queue to run the refactor script on the fil
 
 The file will only be read from, no writing supported.
 
-One great use case is for example: generating the single-header library for gencpp!
-
 ### Additional Info (Editor and Scanner)
 
 When all requests have been populated, call process_requests().  

gencpp.10x

@@ -8,8 +8,8 @@
 		<ShowEmptyFolders>true</ShowEmptyFolders>
 		<IsVirtual>false</IsVirtual>
 		<IsFolder>false</IsFolder>
-		<BuildCommand>powershell ./scripts/build.ps1</BuildCommand>
-		<RebuildCommand>powershell ./scripts/rebuild.ps1</RebuildCommand>
+		<BuildCommand>powershell ./scripts/test.gen_run.ps1</BuildCommand>
+		<RebuildCommand></RebuildCommand>
 		<BuildFileCommand></BuildFileCommand>
 		<CleanCommand>powershell ./scripts/clean.ps1</CleanCommand>
 		<BuildWorkingDirectory></BuildWorkingDirectory>
@@ -38,7 +38,9 @@
 			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.19041.0\\cppwinrt</AdditionalIncludePath>
 			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\NETFXSDK\4.8\include\um</AdditionalIncludePath>
 		</AdditionalIncludePaths>
-		<Defines></Defines>
+		<Defines>
+			<Define>GEN_TIME</Define>
+		</Defines>
 		<ConfigProperties>
 			<ConfigAndPlatform>
 				<Name>Debug:x64</Name>

gencpp.vcxproj

@@ -98,49 +98,61 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <None Include=".editorconfig" />
+    <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" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
     <None Include="Readme.md" />
     <None Include="scripts\build.ci.ps1" />
     <None Include="scripts\build.ps1" />
     <None Include="scripts\clean.ps1" />
-    <None Include="scripts\gen.ps1" />
     <None Include="scripts\genccp.natstepfilter" />
     <None Include="scripts\gencpp.refactor" />
-    <None Include="scripts\get_sources.ps1" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="project\components\gen.data_structures.hpp" />
-    <ClInclude Include="project\components\gen.ecode.hpp" />
-    <ClInclude Include="project\components\gen.eoperator.hpp" />
-    <ClInclude Include="project\components\gen.especifier.hpp" />
-    <ClInclude Include="project\components\gen.header_end.hpp" />
-    <ClInclude Include="project\components\gen.header_start.hpp" />
-    <ClInclude Include="project\components\gen.interface.hpp" />
-    <ClInclude Include="project\components\gen.types.hpp" />
-    <ClInclude Include="project\dependencies\gen.basic_types.hpp" />
-    <ClInclude Include="project\dependencies\gen.containers.hpp" />
-    <ClInclude Include="project\dependencies\gen.debug.hpp" />
-    <ClInclude Include="project\dependencies\gen.file_handling.hpp" />
-    <ClInclude Include="project\dependencies\gen.hashing.hpp" />
-    <ClInclude Include="project\dependencies\gen.header_start.hpp" />
-    <ClInclude Include="project\dependencies\gen.macros.hpp" />
-    <ClInclude Include="project\dependencies\gen.memory.hpp" />
-    <ClInclude Include="project\dependencies\gen.parsing.hpp" />
-    <ClInclude Include="project\dependencies\gen.printing.hpp" />
-    <ClInclude Include="project\dependencies\gen.string.hpp" />
-    <ClInclude Include="project\dependencies\gen.string_ops.hpp" />
-    <ClInclude Include="project\dependencies\gen.timing.hpp" />
-    <ClInclude Include="project\filesystem\gen.builder.hpp" />
-    <ClInclude Include="project\filesystem\gen.editor.hpp" />
-    <ClInclude Include="project\filesystem\gen.scanner.hpp" />
+    <ClInclude Include="project\auxillary\builder.hpp" />
+    <ClInclude Include="project\auxillary\editor.hpp" />
+    <ClInclude Include="project\auxillary\scanner.hpp" />
+    <ClInclude Include="project\components\ast.hpp" />
+    <ClInclude Include="project\components\ast_types.hpp" />
+    <ClInclude Include="project\components\header_end.hpp" />
+    <ClInclude Include="project\components\header_start.hpp" />
+    <ClInclude Include="project\components\inlines.hpp" />
+    <ClInclude Include="project\components\interface.hpp" />
+    <ClInclude Include="project\components\temp\ast_inlines.hpp" />
+    <ClInclude Include="project\components\temp\ecode.hpp" />
+    <ClInclude Include="project\components\temp\eoperator.hpp" />
+    <ClInclude Include="project\components\temp\especifier.hpp" />
+    <ClInclude Include="project\components\types.hpp" />
+    <ClInclude Include="project\dependencies\basic_types.hpp" />
+    <ClInclude Include="project\dependencies\containers.hpp" />
+    <ClInclude Include="project\dependencies\debug.hpp" />
+    <ClInclude Include="project\dependencies\filesystem.hpp" />
+    <ClInclude Include="project\dependencies\hashing.hpp" />
+    <ClInclude Include="project\dependencies\header_start.hpp" />
+    <ClInclude Include="project\dependencies\macros.hpp" />
+    <ClInclude Include="project\dependencies\memory.hpp" />
+    <ClInclude Include="project\dependencies\parsing.hpp" />
+    <ClInclude Include="project\dependencies\printing.hpp" />
+    <ClInclude Include="project\dependencies\strings.hpp" />
+    <ClInclude Include="project\dependencies\string_ops.hpp" />
+    <ClInclude Include="project\dependencies\timing.hpp" />
     <ClInclude Include="project\gen.dep.hpp" />
     <ClInclude Include="project\gen.hpp" />
-    <ClInclude Include="project\helpers\gen.pop_ignores.inline.hpp" />
-    <ClInclude Include="project\helpers\gen.push_ignores.inline.hpp" />
-    <ClInclude Include="project\helpers\gen.undef.macros.hpp" />
-    <ClInclude Include="singleheader\components\gen.header_start.hpp" />
+    <ClInclude Include="project\helpers\helper.hpp" />
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\undef.macros.hpp" />
+    <ClInclude Include="singleheader\components\header_start.hpp" />
     <ClInclude Include="test\DummyInclude.hpp" />
     <ClInclude Include="test\Parsed\Buffer.Parsed.hpp" />
     <ClInclude Include="test\Parsed\HashTable.Parsed.hpp" />
@@ -157,57 +169,59 @@
     <ClInclude Include="test\Parsed\Sanity.Parsed.hpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="project\components\gen.ast.cpp" />
-    <ClCompile Include="project\components\gen.ast_case_macros.cpp" />
-    <ClCompile Include="project\components\gen.data.cpp" />
-    <ClCompile Include="project\components\gen.etoktype.cpp" />
-    <ClCompile Include="project\components\gen.impl_start.cpp" />
-    <ClCompile Include="project\components\gen.interface.cpp" />
-    <ClCompile Include="project\components\gen.interface.parsing.cpp" />
-    <ClCompile Include="project\components\gen.interface.upfront.cpp" />
-    <ClCompile Include="project\components\gen.untyped.cpp" />
-    <ClCompile Include="project\dependencies\gen.debug.cpp" />
-    <ClCompile Include="project\dependencies\gen.file_handling.cpp" />
-    <ClCompile Include="project\dependencies\gen.hashing.cpp" />
-    <ClCompile Include="project\dependencies\gen.impl_start.cpp" />
-    <ClCompile Include="project\dependencies\gen.memory.cpp" />
-    <ClCompile Include="project\dependencies\gen.parsing.cpp" />
-    <ClCompile Include="project\dependencies\gen.printing.cpp" />
-    <ClCompile Include="project\dependencies\gen.string.cpp" />
-    <ClCompile Include="project\dependencies\gen.string_ops.cpp" />
-    <ClCompile Include="project\dependencies\gen.timing.cpp" />
-    <ClCompile Include="project\gen.bootstrap.cpp" />
+    <ClCompile Include="project\auxillary\builder.cpp" />
+    <ClCompile Include="project\auxillary\scanner.cpp" />
+    <ClCompile Include="project\bootstrap.cpp" />
+    <ClCompile Include="project\components\ast.cpp" />
+    <ClCompile Include="project\components\ast_case_macros.cpp" />
+    <ClCompile Include="project\components\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\src_start.cpp" />
+    <ClCompile Include="project\components\static_data.cpp" />
+    <ClCompile Include="project\components\temp\etoktype.cpp" />
+    <ClCompile Include="project\components\untyped.cpp" />
+    <ClCompile Include="project\dependencies\debug.cpp" />
+    <ClCompile Include="project\dependencies\filesystem.cpp" />
+    <ClCompile Include="project\dependencies\hashing.cpp" />
+    <ClCompile Include="project\dependencies\memory.cpp" />
+    <ClCompile Include="project\dependencies\parsing.cpp" />
+    <ClCompile Include="project\dependencies\printing.cpp" />
+    <ClCompile Include="project\dependencies\src_start.cpp" />
+    <ClCompile Include="project\dependencies\strings.cpp" />
+    <ClCompile Include="project\dependencies\string_ops.cpp" />
+    <ClCompile Include="project\dependencies\timing.cpp" />
     <ClCompile Include="project\gen.cpp" />
     <ClCompile Include="project\gen.dep.cpp" />
-    <ClCompile Include="singleheader\gen.singleheader.cpp" />
+    <ClCompile Include="singleheader\singleheader.cpp" />
+    <ClCompile Include="test\parsed\test.parsing.cpp" />
     <ClCompile Include="test\parsing.cpp" />
     <ClCompile Include="test\sanity.cpp" />
     <ClCompile Include="test\SOA.cpp" />
     <ClCompile Include="test\test.cpp" />
     <ClCompile Include="test\test.parsing.cpp" />
+    <ClCompile Include="test\test.singleheader_ast.cpp" />
     <ClCompile Include="test\test.Upfront.cpp" />
     <ClCompile Include="test\upfront.cpp" />
+    <ClCompile Include="test\upfront\test.upfront.cpp" />
+    <ClCompile Include="test\validate_bootstrap.cpp" />
+    <ClCompile Include="test\validate_singleheader.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />
     <Natvis Include="scripts\gencpp.natvis" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="project\components\AttributeTokens.csv" />
-    <Content Include="project\components\ECode.csv" />
-    <Content Include="project\components\EOperator.csv" />
-    <Content Include="project\components\ESpecifier.csv" />
-    <Content Include="project\components\ETokType.csv" />
-    <Content Include="project\meson.build" />
+    <Content Include="project\enums\AttributeTokens.csv" />
+    <Content Include="project\enums\ECode.csv" />
+    <Content Include="project\enums\EOperator.csv" />
+    <Content Include="project\enums\ESpecifier.csv" />
+    <Content Include="project\enums\ETokType.csv" />
     <Content Include="scripts\.clang-format" />
-    <Content Include="scripts\bootstrap.ci.ps1" />
-    <Content Include="scripts\bootstrap.ps1" />
-    <Content Include="scripts\msvc\build_msvc.ps1" />
-    <Content Include="scripts\msvc\devshell.ps1" />
+    <Content Include="scripts\helpers\devshell.ps1" />
+    <Content Include="scripts\helpers\target_arch.psm1" />
     <Content Include="scripts\refactor.ps1" />
-    <Content Include="scripts\singleheader.ci.ps1" />
-    <Content Include="scripts\singleheader.ps1" />
-    <Content Include="singleheader\meson.build" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

gencpp.vcxproj.filters

@@ -18,18 +18,9 @@
     <ClCompile Include="project\gen.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckcpp.cc">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="test\test.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="singleheader\gen\gen.singleheader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="test\test.Upfront.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -51,28 +42,91 @@
     <ClCompile Include="test\test.parsing.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\components\gen.ast.cpp">
+    <ClCompile Include="project\components\temp\etoktype.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\components\gen.interface.parsing.cpp">
+    <ClCompile Include="project\components\ast.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\components\gen.interface.upfront.cpp">
+    <ClCompile Include="project\components\ast_case_macros.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\dependencies\gen.dep.cpp">
+    <ClCompile Include="project\components\interface.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\dependencies\gen.file_handling.cpp">
+    <ClCompile Include="project\components\interface.parsing.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\dependencies\gen.memory.cpp">
+    <ClCompile Include="project\components\interface.upfront.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\dependencies\gen.parsing.cpp">
+    <ClCompile Include="project\components\src_start.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="project\dependencies\gen.printing.cpp">
+    <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>
+    <ClCompile Include="project\dependencies\debug.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\filesystem.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\hashing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\memory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\printing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\src_start.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\string_ops.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\strings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\timing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\builder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\scanner.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="singleheader\singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.singleheader_ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\parsed\test.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\upfront\test.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_bootstrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.untyped.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
@@ -80,27 +134,9 @@
     <ClInclude Include="project\gen.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\gen.undef.macros.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="test\DummyInclude.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="test\gen\array.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\buffer.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\hashtable.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\ring.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="test\gen\sanity.Upfront.gen.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="test\Parsed\Buffer.Parsed.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -137,82 +173,106 @@
     <ClInclude Include="project\gen.dep.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\gen.editor.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\gen.pop_ignores.inline.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\gen.push_ignores.inline.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="project\gen.scanner.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="test\parsing.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="test\upfront.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\components\gen.data_structures.hpp">
+    <ClInclude Include="project\components\temp\ast_inlines.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\components\gen.interface.hpp">
+    <ClInclude Include="project\components\temp\ecode.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\components\gen.types.hpp">
+    <ClInclude Include="project\components\temp\eoperator.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.basic_types.hpp">
+    <ClInclude Include="project\components\temp\especifier.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.containers.hpp">
+    <ClInclude Include="project\components\ast.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.dep.hpp">
+    <ClInclude Include="project\components\ast_types.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.file_handling.hpp">
+    <ClInclude Include="project\components\header_end.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.header_start.hpp">
+    <ClInclude Include="project\components\header_start.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.macros.hpp">
+    <ClInclude Include="project\components\inlines.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.memory.hpp">
+    <ClInclude Include="project\components\interface.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.parsing.hpp">
+    <ClInclude Include="project\components\types.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.printing.hpp">
+    <ClInclude Include="project\helpers\helper.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.string.hpp">
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\dependencies\gen.string_ops.hpp">
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\filesystem\gen.builder.hpp">
+    <ClInclude Include="project\helpers\undef.macros.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\filesystem\gen.editor.hpp">
+    <ClInclude Include="project\dependencies\basic_types.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\filesystem\gen.scanner.hpp">
+    <ClInclude Include="project\dependencies\containers.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\helpers\gen.pop_ignores.inline.hpp">
+    <ClInclude Include="project\dependencies\debug.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\helpers\gen.push_ignores.inline.hpp">
+    <ClInclude Include="project\dependencies\filesystem.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="project\helpers\gen.undef.macros.hpp">
+    <ClInclude Include="project\dependencies\hashing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\memory.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\printing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\string_ops.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\strings.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\timing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\builder.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\editor.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\scanner.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="singleheader\components\header_start.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
@@ -222,13 +282,21 @@
     <None Include="scripts\build.ci.ps1" />
     <None Include="scripts\build.ps1" />
     <None Include="scripts\clean.ps1" />
-    <None Include="scripts\get_sources.ps1" />
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
-    <None Include="scripts\gen.ps1" />
     <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" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />

project/Readme.md

@@ -1,7 +1,6 @@
 # Documentation
 
-The library is fragmented into a series of headers and sources files meant to be scanned in and then generated to a tailored format for the target
-`gen` files.
+The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a tailored format for the target `gen` files.
 
 The principal (user) files are `gen.hpp` and `gen.cpp`.  
 They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
@@ -12,9 +11,8 @@ Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<depe
 The fle processors are in their own respective files. (Ex: `file_processors/<file_processor>.<hpp/cpp>` )  
 They directly include `depedencies/file_handling.<hpp/cpp>` as the core library does not include file processing by defualt.
 
-**TODO : Right now the library is not finished structurally, as such the first self-hosting iteration is still WIP**  
+**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.  
-(sort of a verification that the generated version is equivalent).
 
 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.  
@@ -28,7 +26,6 @@ Feature Macros:
   * This is auto-generated if using the bootstrap or single-header generation
   * *Note: The user will use the `AttributeTokens.csv` when the library is fully self-hosting.*
 * `GEN_DEFINE_LIBRARY_CORE_CONSTANTS` : Optional typename codes as they are non-standard to C/C++ and not necessary to library usage
-* `GEN_DONT_USE_NAMESPACE` : By default, the library is wrapped in a `gen` namespace, this will disable that expose it to the global scope.
 * `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
 * `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
 * `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
@@ -36,13 +33,13 @@ Feature Macros:
 
 ## On multi-threading
 
-Currently unsupported. The following changes would have to be made:
+Currently unsupported.
 
 ## Extending the library
 
 This library is relatively very small, and can be extended without much hassle.
 
-The convention you'll see used throughout the API of the library is as follows:
+The convention you'll see used throughout the interface of the library is as follows:
 
 1. Check name or parameters to make sure they are valid for the construction requested
 2. Create a code object using `make_code`.
@@ -55,3 +52,4 @@ 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.
 When the scanner is implemented, this will be even easier to customize.
+

project/auxillary/builder.cpp

@@ -0,0 +1,59 @@
+#include "builder.hpp"
+
+Builder Builder::open( char const* path )
+{
+	Builder result;
+
+	FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
+
+	if ( error != EFileError_NONE )
+	{
+		log_failure( "gen::File::open - Could not open file: %s", path);
+		return result;
+	}
+
+	result.Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+
+	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
+	return result;
+}
+
+void Builder::pad_lines( s32 num )
+{
+	Buffer.append( "\n" );
+}
+
+void Builder::print( Code code )
+{
+	String   str = code->to_string();
+	const sw len = str.length();
+
+	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
+	Buffer.append( str );
+}
+
+void Builder::print_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 );
+
+	// log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf );
+	Buffer.append( buf, res );
+}
+
+void Builder::write()
+{
+	bool result = file_write( & File, Buffer, Buffer.length() );
+
+	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();
+}

project/auxillary/builder.hpp

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

project/auxillary/editor.hpp

@@ -1,9 +1,6 @@
 #pragma once
-
 #include "gen.scanner.hpp"
 
-namespace gen {
-
 struct Policy
 {
 	// Nothing for now.
@@ -68,6 +65,3 @@ struct Editor
 
 	bool process_requests( Array<Receipt> out_receipts );
 };
-
-// namespace gen
-};

project/auxillary/scanner.cpp

@@ -0,0 +1 @@
+#include "scanner.hpp"

project/auxillary/scanner.hpp

@@ -0,0 +1,133 @@
+#pragma once
+#include "gen.hpp"
+
+// This is a simple file reader that reads the entire file into memory.
+// It has an extra option to skip the first few lines for undesired includes.
+// This is done so that includes can be kept in dependency and component files so that intellisense works.
+Code scan_file( char const* path, bool skip_initial_directives = true )
+{
+	FileInfo file;
+
+	FileError error = file_open_mode( & file, EFileMode_READ, path );
+	if ( error != EFileError_NONE )
+	{
+		GEN_FATAL( "scan_file: Could not open: %s", path );
+	}
+
+	sw fsize = file_size( & file );
+	if ( fsize <= 0 )
+	{
+		GEN_FATAL("scan_file: %s is empty", path );
+	}
+
+	String str = String::make_reserve( GlobalAllocator, fsize );
+		file_read( & file, str, fsize );
+		str.get_header().Length = fsize;
+
+	if ( skip_initial_directives )
+	{
+	#define current (*scanner)
+		StrC toks[] {
+			txt( "pragma once" ),
+			txt( "include" )
+		};
+
+		char* scanner = str;
+		while ( current != '\r' && current != '\n' )
+		{
+			for ( StrC tok : toks )
+			{
+				if ( current == '#' )
+				{
+					++ scanner;
+				}
+
+				if ( strncmp( scanner, tok.Ptr, tok.Len ) == 0 )
+				{
+					scanner += tok.Len;
+					while ( scanner < ( str.Data + str.length() ) && current != '\r' && current != '\n' )
+					{
+						++ scanner;
+					}
+
+					// Skip the line
+					sptr skip_size = sptr( scanner - str.Data );
+					if ( (scanner + 2) >= ( str.Data + str.length() ) )
+					{
+						sptr new_length = sptr( str.get_header().Length ) - skip_size;
+						mem_move( str, scanner, new_length );
+						str.get_header().Length = new_length;
+						break;
+					}
+
+					if ( current == '\r' )
+					{
+						skip_size += 2;
+						scanner   += 2;
+					}
+					else
+					{
+						skip_size += 1;
+						scanner   += 1;
+					}
+
+					sptr new_length = sptr( str.get_header().Length ) - skip_size;
+					mem_move( str, scanner, new_length );
+					str.get_header().Length = new_length;
+
+					scanner = str;
+				}
+			}
+
+			++ scanner;
+		}
+	#undef current
+	}
+
+	file_close( & file );
+	return untyped_str( str );
+}
+
+#if 0
+struct Policy
+{
+	// Nothing for now.
+};
+
+struct SymbolInfo
+{
+	StringCached File;
+	char const*  Marker;
+	Code         Signature;
+};
+
+struct Scanner
+{
+	struct RequestEntry
+	{
+		SymbolInfo Info;
+	};
+
+	struct Receipt
+	{
+		StringCached File;
+		Code         Defintion;
+		bool         Result;
+	};
+
+	AllocatorInfo MemAlloc;
+
+	static void set_allocator( AllocatorInfo allocator );
+
+	Array<FileInfo>     Files;
+	String              Buffer;
+	Array<RequestEntry> Requests;
+
+	void add_files( s32 num, char const** files );
+
+	void add( SymbolInfo signature, Policy policy );
+
+	bool process_requests( Array<Receipt> out_receipts );
+};
+#endif
+

project/bootstrap.cpp

@@ -0,0 +1,293 @@
+#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"
+
+using namespace gen;
+
+constexpr char const* generation_notice =
+"// This file was generated automatially by gen.bootstrap.cpp "
+"(See: https://github.com/Ed94/gencpp)\n\n";
+
+constexpr bool DontSkipInitialDirectives = false;
+
+int gen_main()
+{
+	gen::init();
+
+	Code push_ignores = scan_file( "helpers/push_ignores.inline.hpp", DontSkipInitialDirectives );
+	Code pop_ignores  = scan_file( "helpers/pop_ignores.inline.hpp", DontSkipInitialDirectives );
+
+	// gen_dep.hpp
+	{
+		Code header_start = scan_file( "dependencies/header_start.hpp", DontSkipInitialDirectives );
+		Code macros 	  = scan_file( "dependencies/macros.hpp" );
+		Code basic_types  = scan_file( "dependencies/basic_types.hpp" );
+		Code debug        = scan_file( "dependencies/debug.hpp" );
+		Code memory	      = scan_file( "dependencies/memory.hpp" );
+		Code string_ops   = scan_file( "dependencies/string_ops.hpp" );
+		Code printing     = scan_file( "dependencies/printing.hpp" );
+		Code containers   = scan_file( "dependencies/containers.hpp" );
+		Code hashing 	  = scan_file( "dependencies/hashing.hpp" );
+		Code strings      = scan_file( "dependencies/strings.hpp" );
+		Code filesystem   = scan_file( "dependencies/filesystem.hpp" );
+		Code timing       = scan_file( "dependencies/timing.hpp" );
+
+		Builder
+		header = Builder::open("gen/gen.dep.hpp");
+		header.print_fmt( generation_notice );
+		header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n\n" );
+		header.print( header_start );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		header.print( macros );
+		header.print( basic_types );
+		header.print( debug );
+		header.print( memory );
+		header.print( string_ops );
+		header.print( printing );
+		header.print( containers );
+		header.print( hashing );
+		header.print( strings );
+		header.print( filesystem );
+		header.print( timing );
+
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.write();
+	}
+
+	// gen_dep.cpp
+	{
+		Code src_start  = scan_file( "dependencies/src_start.cpp" );
+		Code debug      = scan_file( "dependencies/debug.cpp" );
+		Code string_ops = scan_file( "dependencies/string_ops.cpp" );
+		Code printing   = scan_file( "dependencies/printing.cpp" );
+		Code memory     = scan_file( "dependencies/memory.cpp" );
+		Code hashing    = scan_file( "dependencies/hashing.cpp" );
+		Code strings    = scan_file( "dependencies/strings.cpp" );
+		Code filesystem = scan_file( "dependencies/filesystem.cpp" );
+		Code timing     = scan_file( "dependencies/timing.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.dep.cpp" );
+		src.print_fmt( generation_notice );
+		src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n\n" );
+		src.print( src_start );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+
+		src.print( debug );
+		src.print( string_ops );
+		src.print( printing );
+		src.print( hashing );
+		src.print( memory );
+		src.print( strings );
+		src.print( filesystem );
+		src.print( timing );
+
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.write();
+	}
+
+	// gen.hpp
+	{
+		Code header_start = scan_file( "components/header_start.hpp" );
+		Code types        = scan_file( "components/types.hpp" );
+		Code ast          = scan_file( "components/ast.hpp" );
+		Code ast_types    = scan_file( "components/ast_types.hpp" );
+		Code interface    = scan_file( "components/interface.hpp" );
+		Code inlines      = scan_file( "components/inlines.hpp" );
+		Code header_end   = scan_file( "components/header_end.hpp" );
+
+		CodeBody ecode       = gen_ecode     ( "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+		Builder
+		header = Builder::open( "gen/gen.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( push_ignores );
+		header.print( header_start );
+		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
+
+		header.print_fmt( "#pragma region Types\n" );
+		header.print( types );
+		header.print( ecode );
+		header.print( eoperator );
+		header.print( especifier );
+		header.print_fmt( "#pragma endregion Types\n\n" );
+
+		header.print_fmt( "#pragma region AST\n" );
+		header.print( ast );
+		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( ast_inlines );
+		header.print_fmt( "#pragma endregion Inlines\n" );
+
+		header.print( header_end );
+		header.print_fmt( "GEN_NS_END\n\n" );
+		header.print( pop_ignores );
+		header.write();
+
+		Builder
+		header_ecode = Builder::open( "components/gen/ecode.hpp" );
+		header_ecode.print( pragma_once );
+		header_ecode.print_fmt( generation_notice );
+		header_ecode.print( ecode );
+		header_ecode.write();
+
+		Builder
+		header_eoperator = Builder::open( "components/gen/eoperator.hpp" );
+		header_eoperator.print( pragma_once );
+		header_eoperator.print_fmt( generation_notice );
+		header_eoperator.print( eoperator );
+		header_eoperator.write();
+
+		Builder
+		header_especifier = Builder::open( "components/gen/especifier.hpp" );
+		header_especifier.print( pragma_once );
+		header_especifier.print_fmt( generation_notice );
+		header_especifier.print( especifier );
+		header_especifier.write();
+
+		Builder
+		header_ast_inlines = Builder::open( "components/gen/ast_inlines.hpp" );
+		header_ast_inlines.print( pragma_once );
+		header_ast_inlines.print_fmt( generation_notice );
+		header_ast_inlines.print( ast_inlines );
+		header_ast_inlines.write();
+	}
+
+	// gen.cpp
+	{
+		Code        src_start       = scan_file( "components/src_start.cpp" );
+		Code        static_data 	= scan_file( "components/static_data.cpp" );
+		Code        ast_case_macros = scan_file( "components/ast_case_macros.cpp" );
+		Code        ast			    = scan_file( "components/ast.cpp" );
+		Code        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" );
+
+		CodeBody etoktype         = gen_etoktype( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
+		CodeNS   nspaced_etoktype = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
+
+		Builder
+		src = Builder::open( "gen/gen.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( push_ignores );
+		src.print( src_start );
+		src.print_fmt( "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_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( untyped );
+		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
+		src.print_fmt( "#pragma endregion Interface\n\n" );
+
+		src.print_fmt( "GEN_NS_END\n\n");
+		src.print( pop_ignores );
+		src.write();
+
+		Builder
+		src_etoktype = Builder::open( "components/gen/etoktype.cpp" );
+		src_etoktype.print_fmt( generation_notice );
+		src_etoktype.print( pragma_once );
+		src_etoktype.print( nspaced_etoktype );
+		src_etoktype.write();
+	}
+
+	// gen_builder.hpp
+	{
+		Code builder = scan_file( "auxillary/builder.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.builder.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( def_include( txt("gen.hpp") ));
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+		header.print( builder );
+		header.print_fmt( "GEN_NS_END\n" );
+		header.write();
+	}
+
+	// gen_builder.cpp
+	{
+		Code builder = scan_file( "auxillary/builder.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.builder.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( def_include( txt("gen.builder.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( builder );
+		src.print_fmt( "\nGEN_NS_END\n" );
+		src.write();
+	}
+
+	// gen_scanner.hpp
+	{
+		Code parsing = scan_file( "dependencies/parsing.hpp" );
+		Code scanner = scan_file( "auxillary/scanner.hpp" );
+
+		Builder
+		header = Builder::open( "gen/gen.scanner.hpp" );
+		header.print_fmt( generation_notice );
+		header.print_fmt( "#pragma once\n\n" );
+		header.print( def_include( txt("gen.hpp") ) );
+		header.print_fmt( "\nGEN_NS_BEGIN\n" );
+		header.print( parsing );
+		header.print( scanner );
+		header.print_fmt( "GEN_NS_END\n" );
+		header.write();
+	}
+
+	// gen_scanner.cpp
+	{
+		Code parsing = scan_file( "dependencies/parsing.cpp" );
+		Code scanner = scan_file( "auxillary/scanner.cpp" );
+
+		Builder
+		src = Builder::open( "gen/gen.scanner.cpp" );
+		src.print_fmt( generation_notice );
+		src.print( def_include( txt("gen.scanner.hpp") ) );
+		src.print_fmt( "\nGEN_NS_BEGIN\n" );
+		src.print( parsing );
+		src.print( scanner );
+		src.print_fmt( "GEN_NS_END\n" );
+		src.write();
+	}
+
+	gen::deinit();
+	return 0;
+}

project/components/ast.cpp

@@ -1,4 +1,5 @@
-#pragma region AST
+#pragma once
+#include "static_data.cpp"
 
 Code Code::Global;
 Code Code::Invalid;
@@ -28,7 +29,11 @@ String AST::to_string()
 		using namespace ECode;
 
 		case Invalid:
-			log_failure("Attempted to serialize invalid code! - %s", Parent ? Parent->debug_str() : Name );
+			log_failure("Attempted to serialize invalid code! - %S", Parent ? Parent->debug_str() : Name );
+		break;
+
+		case NewLine:
+			result.append("\n");
 		break;
 
 		case Untyped:
@@ -38,25 +43,35 @@ String AST::to_string()
 
 		case Comment:
 		{
-			static char line[MaxCommentLineLength];
+			if ( Prev && Prev->Type != Comment && Prev->Type != NewLine )
+				result.append( "\n" );
 
-			s32 left  = Content.length();
-			s32 index = 0;
+			static char line[ MaxCommentLineLength ];
+
+			char const* end       = & scast(String, Content).back();
+			char*       scanner   = Content.Data;
+			s32         curr      = 0;
 			do
 			{
-				s32 length = 0;
-				while ( left && Content[index] != '\n' )
+				char const* next   = scanner;
+				s32         length = 0;
+				while ( next != end && scanner[ length ] != '\n' )
 				{
+					next = scanner + length;
 					length++;
-					left--;
 				}
+				length++;
 
-				str_copy( line, Content, length );
-				line[length] = '\0';
+				str_copy( line, scanner, length );
+				result.append_fmt( "//%.*s", length, line );
+				mem_set( line, 0, MaxCommentLineLength );
 
-				result.append_fmt( "// %s", line );
+				scanner += length;
 			}
-			while ( left--, left > 0 );
+			while ( scanner <= end );
+
+			if ( result.back() != '\n' )
+				result.append( "\n" );
 		}
 		break;
 
@@ -80,40 +95,39 @@ String AST::to_string()
 
 				if ( Attributes )
 				{
-					result.append_fmt( "%s ", Attributes->to_string() );
+					result.append_fmt( "%S ", Attributes->to_string() );
 				}
 
 				if ( ParentType )
 				{
 					char const* access_level = to_str( ParentAccess );
 
-					result.append_fmt( "%s : %s %s\n{\n%s\n};"
-						, Name
-						, access_level
-						, ParentType->to_string()
-						, Body->to_string()
-					);
+					result.append_fmt( "%S : %s %S", Name, access_level, ParentType );
 
-					CodeType interface = Next->cast<CodeType>();
+					CodeType interface = Next->cast< CodeType >();
 					if ( interface )
-						result.append("\n");
+						result.append( "\n" );
 
 					while ( interface )
 					{
-						result.append_fmt( ", %s", interface.to_string() );
-
-						interface = interface->Next->cast<CodeType>();
+						result.append_fmt( ", %S", interface.to_string() );
+						interface = interface->Next ? interface->Next->cast< CodeType >() : Code { nullptr };
 					}
+
+					result.append_fmt( "\n{\n%S\n}", Body->to_string() );
 				}
 				else
 				{
-					result.append_fmt( "%s \n{\n%s\n};", Name, Body->to_string() );
+					result.append_fmt( "%S \n{\n%S\n}", Name, Body->to_string() );
 				}
 			}
 			else
 			{
-				result.append_fmt( "class %s\n{\n%s\n};", Name, Body->to_string() );
+				result.append_fmt( "class %S\n{\n%S\n}", Name, Body->to_string() );
 			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -123,9 +137,76 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "class %s %s;", Attributes->to_string(), Name );
+				result.append_fmt( "class %S %S", Attributes->to_string(), Name );
 
-			else result.append_fmt( "class %s;", Name );
+			else result.append_fmt( "class %S", Name );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
+		}
+		break;
+
+		case Constructor:
+		{
+			result.append( Parent->Name );
+
+			if ( Params )
+				result.append_fmt( "( %S )", Params->to_string() );
+			else
+				result.append( "(void)" );
+
+			if ( InitializerList )
+				result.append_fmt( " : %S", InitializerList->to_string() );
+
+			result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
+		}
+		break;
+
+		case Constructor_Fwd:
+		{
+			result.append( Parent->Name );
+
+			if ( Params )
+				result.append_fmt( "( %S )", Params->to_string() );
+			else
+				result.append( "(void);\n" );
+		}
+		break;
+
+		case Destructor:
+		{
+			if ( Specs )
+			{
+				CodeSpecifiers specs = Specs->cast<CodeSpecifiers>();
+
+				if ( specs.has( ESpecifier::Virtual ) )
+					result.append_fmt( "virtual ~%S()", Parent->Name );
+				else
+					result.append_fmt( "~%S()", Parent->Name );
+			}
+			else
+				result.append_fmt( "~%S()", Parent->Name );
+
+			result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
+		}
+		break;
+
+		case Destructor_Fwd:
+		{
+			if ( Specs )
+			{
+				CodeSpecifiers specs = Specs->cast<CodeSpecifiers>();
+
+				if ( specs.has( ESpecifier::Virtual ) )
+					result.append_fmt( "virtual ~%S();\n", Parent->Name );
+				else
+					result.append_fmt( "~%S()", Parent->Name );
+
+				if ( specs.has( ESpecifier::Pure ) )
+					result.append( " = 0;\n" );
+			}
+			else
+				result.append_fmt( "~%S();\n", Parent->Name );
 		}
 		break;
 
@@ -139,24 +220,21 @@ String AST::to_string()
 				result.append( "enum " );
 
 				if ( Attributes )
-					result.append_fmt( "%s ", Attributes->to_string() );
+					result.append_fmt( "%S ", Attributes->to_string() );
 
 				if ( UnderlyingType )
-					result.append_fmt( "%s : %s\n{\n%s\n};"
+					result.append_fmt( "%S : %S\n{\n%S\n}"
 						, Name
 						, UnderlyingType->to_string()
 						, Body->to_string()
 					);
 
-				else result.append_fmt( "%s\n{\n%s\n};"
-					, Name
-					, Body->to_string()
-				);
+				else result.append_fmt( "%S\n{\n%S\n}", Name, Body->to_string() );
 			}
-			else result.append_fmt( "enum %s\n{\n%s\n};"
-				, Name
-				, Body->to_string()
-			);
+			else result.append_fmt( "enum %S\n{\n%S\n}", Name, Body->to_string() );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -166,9 +244,12 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
-			result.append_fmt( "enum %s : %s;", Name, UnderlyingType->to_string() );
+			result.append_fmt( "enum %S : %S", Name, UnderlyingType->to_string() );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -183,31 +264,25 @@ String AST::to_string()
 
 				if ( Attributes )
 				{
-					result.append_fmt( "%s ", Attributes->to_string() );
+					result.append_fmt( "%S ", Attributes->to_string() );
 				}
 
 				if ( UnderlyingType )
 				{
-					result.append_fmt( "%s : %s\n{\n%s\n};"
-						, Name
-						, UnderlyingType->to_string()
-						, Body->to_string()
-					);
+					result.append_fmt( "%S : %S\n{\n%S\n}", Name, UnderlyingType->to_string(), Body->to_string() );
 				}
 				else
 				{
-					result.append_fmt( "%s\n{\n%s\n};"
-						, Name
-						, Body->to_string()
-					);
+					result.append_fmt( "%S\n{\n%S\n}", Name, Body->to_string() );
 				}
 			}
 			else
 			{
-				result.append_fmt( "enum class %s\n{\n%s\n};"
-					, Body->to_string()
-				);
+				result.append_fmt( "enum class %S\n{\n%S\n}", Body->to_string() );
 			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -219,9 +294,12 @@ String AST::to_string()
 			result.append( "enum class " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
-			result.append_fmt( "%s : %s;", Name, UnderlyingType->to_string() );
+			result.append_fmt( "%S : %S", Name, UnderlyingType->to_string() );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -233,26 +311,23 @@ String AST::to_string()
 			s32  left = NumEntries;
 			while ( left-- )
 			{
-				result.append_fmt( "%s\n", curr.to_string() );
+				result.append_fmt( "%S", curr.to_string() );
 				++curr;
 			}
 
-			result.append_fmt( "};" );
+			result.append_fmt( "};\n" );
 		}
 		break;
 
 		case Extern_Linkage:
-			result.append_fmt( "extern \"%s\"\n{\n%s\n}"
-				, Name
-				, Body->to_string()
-			);
+			result.append_fmt( "extern \"%S\"\n{\n%S\n}\n", Name, Body->to_string() );
 		break;
 
 		case Friend:
-			result.append_fmt( "friend %s", Declaration->to_string() );
+			result.append_fmt( "friend %S", Declaration->to_string() );
 
 			if ( result[ result.length() -1 ] != ';' )
-				result.append( ";" );
+				result.append( ";\n" );
 		break;
 
 		case Function:
@@ -261,37 +336,36 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
 			if ( Specs )
-				result.append_fmt( "%s\n", Specs->to_string() );
+				result.append_fmt( "%S", Specs->to_string() );
 
 			if ( ReturnType )
-				result.append_fmt( "%s %s(", ReturnType->to_string(), Name );
+				result.append_fmt( "%S %S(", ReturnType->to_string(), Name );
 
 			else
-				result.append_fmt( "%s(", Name );
+				result.append_fmt( "%S(", Name );
 
 			if ( Params )
-				result.append_fmt( "%s)", Params->to_string() );
+				result.append_fmt( "%S)", Params->to_string() );
 
 			else
 				result.append( "void)" );
 
 			if ( Specs )
 			{
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %.*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 			}
 
-			result.append_fmt( "\n{\n%s\n}"
-				, Body->to_string()
-			);
+			result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
 		}
 		break;
 
@@ -301,35 +375,36 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
 			if ( Specs )
-				result.append_fmt( "%s\n", Specs->to_string() );
+				result.append_fmt( "%S", Specs->to_string() );
 
 			if ( ReturnType )
-				result.append_fmt( "%s %s(", ReturnType->to_string(), Name );
+				result.append_fmt( "%S %S(", ReturnType->to_string(), Name );
 
 			else
-				result.append_fmt( "%s(", Name );
+				result.append_fmt( "%S(", Name );
 
 			if ( Params )
-				result.append_fmt( "%s)", Params->to_string() );
+				result.append_fmt( "%S)", Params->to_string() );
 
 			else
 				result.append( "void)" );
 
 			if ( Specs )
 			{
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %.*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 			}
 
-			result.append( ";" );
+			result.append( ";\n" );
 		}
 		break;
 
@@ -340,17 +415,14 @@ String AST::to_string()
 			if (((u32(ModuleFlag::Import) & u32(ModuleFlags)) == u32(ModuleFlag::Import)))
 				result.append("import ");
 
-			result.append_fmt( "%s;", Name );
+			result.append_fmt( "%S;\n", Name );
 			break;
 
 		case Namespace:
 			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
 				result.append( "export " );
 
-			result.append_fmt( "namespace %s\n{\n%s}"
-				, Name
-				, Body->to_string()
-			);
+			result.append_fmt( "namespace %S\n{\n%S\n}\n", Name , Body->to_string() );
 		break;
 
 		case Operator:
@@ -360,32 +432,33 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
 			if ( Attributes )
-				result.append_fmt( "%s\n", Attributes->to_string() );
+				result.append_fmt( "%S\n", Attributes->to_string() );
 
 			if ( ReturnType )
-				result.append_fmt( "%s %s (", ReturnType->to_string(), Name );
+				result.append_fmt( "%S %S (", ReturnType->to_string(), Name );
 
 			if ( Params )
-				result.append_fmt( "%s)", Params->to_string() );
+				result.append_fmt( "%S)", Params->to_string() );
 
 			else
 				result.append( "void)" );
 
 			if ( Specs )
 			{
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %.*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 			}
 
-			result.append_fmt( "\n{\n%s\n}"
+			result.append_fmt( "\n{\n%S\n}\n"
 				, Body->to_string()
 			);
 		}
@@ -398,31 +471,32 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S\n", Attributes->to_string() );
 
 			if ( Specs )
-				result.append_fmt( "%s", Specs->to_string() );
+				result.append_fmt( "%S\n", Specs->to_string() );
 
-			result.append_fmt( "%s %s (", ReturnType->to_string(), Name );
+			result.append_fmt( "%S %S (", ReturnType->to_string(), Name );
 
 			if ( Params )
-				result.append_fmt( "%s)", Params->to_string() );
+				result.append_fmt( "%S)", Params->to_string() );
 
 			else
 				result.append_fmt( "void)" );
 
 			if ( Specs )
 			{
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %.*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 			}
 
-			result.append( ";" );
+			result.append( ";\n" );
 		}
 		break;
 
@@ -430,67 +504,112 @@ String AST::to_string()
 		{
 			if ( Specs )
 			{
-				result.append_fmt( "operator %s()" );
+				if ( Name && Name.length() )
+					result.append_fmt( "%Soperator %S()", Name, ValueType->to_string() );
+				else
+					result.append_fmt( "operator %S()", ValueType->to_string() );
 
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %.*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 
-				result.append_fmt( "\n{\n%s\n}", Body->to_string() );
+				result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
 				break;
 			}
 
-			result.append_fmt("operator %s()\n{\n%s\n}", ValueType->to_string(), Body->to_string() );
+			if ( Name && Name.length() )
+				result.append_fmt("%Soperator %S()\n{\n%S\n}\n", Name, ValueType->to_string(), Body->to_string() );
+			else
+				result.append_fmt("operator %S()\n{\n%S\n}\n", ValueType->to_string(), Body->to_string() );
 		}
 		break;
 
 		case Operator_Cast_Fwd:
 			if ( Specs )
 			{
-				result.append_fmt( "operator %s()" );
+				result.append_fmt( "operator %S()", ValueType->to_string() );
 
-				CodeSpecifiers specs = cast<CodeSpecifiers>();
-
-				for ( SpecifierT spec : specs )
+				for ( SpecifierT spec : Specs->cast<CodeSpecifiers>() )
 				{
 					if ( ESpecifier::is_trailing( spec ) )
-						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+					{
+						StrC spec_str = ESpecifier::to_str( spec );
+						result.append_fmt( " %*s", spec_str.Len, spec_str.Ptr );
+					}
 				}
 
-				result.append_fmt( ";", Body->to_string() );
+				result.append( ";" );
 				break;
 			}
 
-			result.append_fmt("operator %s();", ValueType->to_string() );
+			result.append_fmt("operator %S();\n", ValueType->to_string() );
 		break;
 
 		case Parameters:
 		{
+			if ( ValueType == nullptr )
+			{
+				result.append_fmt( "%S", Name );
+				break;
+			}
+
 			if ( Name )
-				result.append_fmt( "%s %s", ValueType->to_string(), Name );
+				result.append_fmt( "%S %S", ValueType->to_string(), Name );
 
 			else
-				result.append_fmt( "%s", ValueType->to_string() );
+				result.append_fmt( "%S", ValueType->to_string() );
 
 			if ( Value )
-				result.append_fmt( "= %s", Value->to_string() );
+				result.append_fmt( "= %S", Value->to_string() );
 
 			if ( NumEntries - 1 > 0)
 			{
 				for ( CodeParam param :  CodeParam { (AST_Param*) Next } )
 				{
-					result.append_fmt( ", %s", param.to_string() );
+					result.append_fmt( ", %S", param.to_string() );
 				}
 			}
 		}
 		break;
+		case Preprocess_Define:
+			result.append_fmt( "#define %S %S\n", Name, Content );
+		break;
 
-		case Preprocessor_Include:
-			result.append_fmt( "#include \"%s\"", Name );
+		case Preprocess_If:
+			result.append_fmt( "#if %S\n", Content );
+		break;
+
+		case Preprocess_IfDef:
+			result.append_fmt( "#ifdef %S\n", Content );
+		break;
+
+		case Preprocess_IfNotDef:
+			result.append_fmt( "#ifndef %S\n", Content );
+		break;
+
+		case Preprocess_Include:
+			result.append_fmt( "#include \"%S\"\n", Content );
+		break;
+
+		case Preprocess_ElIf:
+			result.append_fmt( "#elif %S\n", Content );
+		break;
+
+		case Preprocess_Else:
+			result.append_fmt( "#else\n" );
+		break;
+
+		case Preprocess_EndIf:
+			result.append_fmt( "#endif\n" );
+		break;
+
+		case Preprocess_Pragma:
+			result.append_fmt( "#pragma %S\n", Content );
 		break;
 
 		case Specifiers:
@@ -499,13 +618,14 @@ String AST::to_string()
 			s32 left = NumEntries;
 			while ( left-- )
 			{
-				if ( ESpecifier::is_trailing( ArrSpecs[idx])  )
+				if ( ESpecifier::is_trailing( ArrSpecs[idx]) && ArrSpecs[idx] != ESpecifier::Const )
 				{
 					idx++;
 					continue;
 				}
 
-				result.append_fmt( "%s ", (char const*)ESpecifier::to_str( ArrSpecs[idx]) );
+				StrC spec = ESpecifier::to_str( ArrSpecs[idx] );
+				result.append_fmt( "%.*s ", spec.Len, spec.Ptr );
 				idx++;
 			}
 		}
@@ -518,7 +638,7 @@ String AST::to_string()
 
 			if ( Name == nullptr)
 			{
-				result.append( "struct\n{\n%s\n};", Body->to_string() );
+				result.append_fmt( "struct\n{\n%S\n};\n", Body->to_string() );
 				break;
 			}
 
@@ -527,41 +647,40 @@ String AST::to_string()
 				result.append( "struct " );
 
 				if ( Attributes )
-					result.append_fmt( "%s ", Attributes->to_string() );
+					result.append_fmt( "%S ", Attributes->to_string() );
 
 				if ( ParentType )
 				{
 					char const* access_level = to_str( ParentAccess );
 
-					result.append_fmt( "%s : %s %s\n{\n%s\n};"
-						, Name
-						, access_level
-						, ParentType->to_string()
-						, Body->to_string()
-					);
+					result.append_fmt( "%S : %s %S", Name, access_level, ParentType );
 
-					CodeType interface = Next->cast<CodeType>();
+					CodeType interface = Next->cast< CodeType >();
 					if ( interface )
-						result.append("\n");
+						result.append( "\n" );
 
 					while ( interface )
 					{
-						result.append_fmt( ", public %s", interface.to_string() );
+						result.append_fmt( ", %S", interface.to_string() );
 
-						interface = interface->Next->cast<CodeType>();
+						interface = interface->Next ? interface->Next->cast< CodeType >() : Code { nullptr };
 					}
+
+					result.append_fmt( "\n{\n%S\n}", Body->to_string() );
 				}
 				else
 				{
 					if ( Name )
-
-					result.append_fmt( "%s \n{\n%s\n};", Name, Body->to_string() );
+						result.append_fmt( "%S \n{\n%S\n}", Name, Body->to_string() );
 				}
 			}
 			else
 			{
-				result.append_fmt( "struct %s\n{\n%s\n};", Name, Body->to_string() );
+				result.append_fmt( "struct %S\n{\n%S\n}", Name, Body->to_string() );
 			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -571,9 +690,12 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "struct %s %s;", Attributes->to_string(), Name );
+				result.append_fmt( "struct %S %S", Attributes->to_string(), Name );
 
-			else result.append_fmt( "struct %s;", Name );
+			else result.append_fmt( "struct %S", Name );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -582,7 +704,7 @@ String AST::to_string()
 			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
 				result.append( "export " );
 
-			result.append_fmt( "template< %s >\n%s", Params->to_string(), Declaration->to_string() );
+			result.append_fmt( "template< %S >\n%S", Params->to_string(), Declaration->to_string() );
 		}
 		break;
 
@@ -593,15 +715,18 @@ String AST::to_string()
 
 			result.append( "typedef ");
 
-			result.append_fmt( "%s %s", UnderlyingType->to_string(), Name );
+			if ( IsFunction )
+				result.append( UnderlyingType->to_string() );
+			else
+				result.append_fmt( "%S %S", UnderlyingType->to_string(), Name );
 
 			if ( UnderlyingType->Type == Typename && UnderlyingType->ArrExpr )
 			{
-				result.append_fmt( "[%s];", UnderlyingType->ArrExpr->to_string() );
+				result.append_fmt( "[%S];", UnderlyingType->ArrExpr->to_string() );
 			}
 			else
 			{
-				result.append( ";" );
+				result.append( ";\n" );
 			}
 		}
 		break;
@@ -611,17 +736,17 @@ String AST::to_string()
 			if ( Attributes || Specs )
 			{
 				if ( Attributes )
-					result.append_fmt( "%s ", Attributes->to_string() );
+					result.append_fmt( "%S ", Attributes->to_string() );
 
 				if ( Specs )
-					result.append_fmt( "%s %s", Name, Specs->to_string() );
+					result.append_fmt( "%S %S", Name, Specs->to_string() );
 
 				else
-					result.append_fmt( "%s", Name );
+					result.append_fmt( "%S", Name );
 			}
 			else
 			{
-				result.append_fmt( "%s", Name );
+				result.append_fmt( "%S", Name );
 			}
 		}
 		break;
@@ -634,11 +759,11 @@ String AST::to_string()
 			result.append( "union " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
 			if ( Name )
 			{
-				result.append_fmt( "%s\n{\n%s\n};"
+				result.append_fmt( "%S\n{\n%S\n}"
 					, Name
 					, Body->to_string()
 				);
@@ -646,10 +771,13 @@ String AST::to_string()
 			else
 			{
 				// Anonymous union
-				result.append_fmt( "\n{\n%s\n};"
+				result.append_fmt( "\n{\n%S\n}"
 					, Body->to_string()
 				);
 			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";\n");
 		}
 		break;
 
@@ -659,24 +787,24 @@ String AST::to_string()
 				result.append( "export " );
 
 			if ( Attributes )
-				result.append_fmt( "%s ", Attributes->to_string() );
+				result.append_fmt( "%S ", Attributes->to_string() );
 
 			if ( UnderlyingType )
 			{
-				result.append_fmt( "using %s = %s", Name, UnderlyingType->to_string() );
+				result.append_fmt( "using %S = %S", Name, UnderlyingType->to_string() );
 
 				if ( UnderlyingType->ArrExpr )
-					result.append_fmt( "[%s]", UnderlyingType->ArrExpr->to_string() );
+					result.append_fmt( "[%S]", UnderlyingType->ArrExpr->to_string() );
 
-				result.append( ";" );
+				result.append( ";\n" );
 			}
 			else
-				result.append_fmt( "using %s;", Name );
+				result.append_fmt( "using %S;\n", Name );
 		}
 		break;
 
 		case Using_Namespace:
-			result.append_fmt( "using namespace %s;", Name );
+			result.append_fmt( "using namespace %s;\n", Name );
 		break;
 
 		case Variable:
@@ -687,34 +815,40 @@ String AST::to_string()
 			if ( Attributes || Specs )
 			{
 				if ( Attributes )
-					result.append_fmt( "%s ", Specs->to_string() );
+					result.append_fmt( "%S ", Specs->to_string() );
 
 				if ( Specs )
-					result.append_fmt( "%s\n", Specs->to_string() );
+					result.append_fmt( "%S\n", Specs->to_string() );
 
-				result.append_fmt( "%s %s", ValueType->to_string(), Name );
+				result.append_fmt( "%S %S", ValueType->to_string(), Name );
 
 				if ( ValueType->ArrExpr )
-					result.append_fmt( "[%s]", ValueType->ArrExpr->to_string() );
+					result.append_fmt( "[%S]", ValueType->ArrExpr->to_string() );
+
+				if ( BitfieldSize )
+					result.append_fmt( " : %S", BitfieldSize->to_string() );
 
 				if ( Value )
-					result.append_fmt( " = %s", Value->to_string() );
+					result.append_fmt( " = %S", Value->to_string() );
 
-				result.append( ";" );
+				result.append( ";\n" );
 
 				break;
 			}
 
-			if ( UnderlyingType->ArrExpr )
-				result.append_fmt( "%s %s[%s];", UnderlyingType->to_string(), Name, UnderlyingType->ArrExpr->to_string() );
+			if ( BitfieldSize )
+				result.append_fmt( "%S %S : %S;\n", ValueType->to_string(), Name, BitfieldSize->to_string() );
+
+			else if ( UnderlyingType->ArrExpr )
+				result.append_fmt( "%S %S[%S];\n", UnderlyingType->to_string(), Name, UnderlyingType->ArrExpr->to_string() );
 
 			else
-				result.append_fmt( "%s %s;", UnderlyingType->to_string(), Name );
+				result.append_fmt( "%S %S;\n", UnderlyingType->to_string(), Name );
 		}
 		break;
 
-		case Class_Body:
 		case Enum_Body:
+		case Class_Body:
 		case Extern_Linkage_Body:
 		case Function_Body:
 		case Global_Body:
@@ -726,7 +860,7 @@ String AST::to_string()
 			s32  left = NumEntries;
 			while ( left -- )
 			{
-				result.append_fmt( "%s\n", curr.to_string() );
+				result.append_fmt( "%S", curr.to_string() );
 				++curr;
 			}
 		}
@@ -803,7 +937,31 @@ bool AST::validate_body()
 			CheckEntries( GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES );
 		break;
 		case Global_Body:
-			CheckEntries( GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES );
+			for (Code entry : cast<CodeBody>())
+			{
+				switch (entry->Type)
+				{
+					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 Global_Body:
+					case Namespace_Body:
+					case Operator_Member:
+					case Operator_Member_Fwd:
+					case Parameters:
+					case Specifiers:
+					case Struct_Body:
+					case Typename:
+						log_failure("AST::validate_body: Invalid entry in body %s", entry.debug_str());
+					return false;
+				}
+			}
 		break;
 		case Namespace_Body:
 			CheckEntries( GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES );
@@ -831,5 +989,3 @@ bool AST::validate_body()
 
 #undef CheckEntries
 }
-
-#pragma endregion AST

project/components/ast.hpp

@@ -0,0 +1,583 @@
+#pragma once
+#include "types.hpp"
+#include "gen/ecode.hpp"
+#include "gen/eoperator.hpp"
+#include "gen/especifier.hpp"
+
+struct AST;
+struct AST_Body;
+struct AST_Attributes;
+struct AST_Comment;
+struct AST_Constructor;
+struct AST_Class;
+struct AST_Define;
+struct AST_Destructor;
+struct AST_Enum;
+struct AST_Exec;
+struct AST_Extern;
+struct AST_Include;
+struct AST_Friend;
+struct AST_Fn;
+struct AST_Module;
+struct AST_NS;
+struct AST_Operator;
+struct AST_OpCast;
+struct AST_Param;
+struct AST_Pragma;
+struct AST_PreprocessCond;
+struct AST_Specifiers;
+struct AST_Struct;
+struct AST_Template;
+struct AST_Type;
+struct AST_Typedef;
+struct AST_Union;
+struct AST_Using;
+struct AST_Var;
+
+struct Code;
+struct CodeBody;
+// These are to offer ease of use and optionally strong type safety for the AST.
+struct CodeAttributes;
+struct CodeComment;
+struct CodeConstructor;
+struct CodeDestructor;
+struct CodeClass;
+struct CodeDefine;
+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;
+
+/*
+	AST* wrapper
+	- Not constantly have to append the '*' as this is written often..
+	- Allows for implicit conversion to any of the ASTs (raw or filtered).
+*/
+struct Code
+{
+#	pragma region Statics
+	// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
+	static Code Global;
+
+	// Used to identify invalid generated code.
+	static Code Invalid;
+#	pragma endregion Statics
+
+	#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 ); \
+	operator bool();
+
+	Using_Code( Code );
+
+	template< class Type >
+	Type cast()
+	{
+		return * rcast( Type*, this );
+	}
+
+	AST* operator ->()
+	{
+		return ast;
+	}
+	Code& operator ++();
+	Code& operator*()
+	{
+		return *this;
+	}
+
+	AST* ast;
+
+#ifdef GEN_ENFORCE_STRONG_CODE_TYPES
+#	define operator explicit operator
+#endif
+	operator CodeAttributes() const;
+	operator CodeComment() const;
+	operator CodeConstructor() const;
+	operator CodeDestructor() const;
+	operator CodeClass() const;
+	operator CodeDefine() const;
+	operator CodeExec() const;
+	operator CodeEnum() const;
+	operator CodeExtern() const;
+	operator CodeInclude() const;
+	operator CodeFriend() const;
+	operator CodeFn() const;
+	operator CodeModule() const;
+	operator CodeNS() const;
+	operator CodeOperator() const;
+	operator CodeOpCast() const;
+	operator CodeParam() const;
+	operator CodePragma() const;
+	operator CodePreprocessCond() const;
+	operator CodeSpecifiers() const;
+	operator CodeStruct() const;
+	operator CodeTemplate() const;
+	operator CodeType() const;
+	operator CodeTypedef() const;
+	operator CodeUnion() const;
+	operator CodeUsing() const;
+	operator CodeVar() const;
+	operator CodeBody() const;
+	#undef operator
+};
+
+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 u32 AST_POD_Size = 128;
+
+/*
+	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
+	uw ArrSpecs_Cap =
+	(
+			AST_POD_Size
+			- sizeof(AST*) * 3
+			- sizeof(StringCached)
+			- sizeof(CodeT)
+			- sizeof(ModuleFlag)
+			- sizeof(u32)
+	)
+	/ sizeof(SpecifierT) - 1; // -1 for 4 extra bytes
+
+	union {
+		struct
+		{
+			AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+			AST*      Specs;          // Function, Operator, Type symbol, Variable
+			union {
+				AST*  InitializerList; // Constructor, Destructor
+				AST*  ParentType;      // Class, Struct
+				AST*  ReturnType;      // Function, Operator
+				AST*  UnderlyingType;  // Enum, Typedef
+				AST*  ValueType;       // Parameter, Variable
+			};
+			union {
+				AST*  BitfieldSize;    // Varaiable (Class/Struct Data Member)
+				AST*  Params;          // Function, Operator, Template
+			};
+			union {
+				AST*  ArrExpr;        // Type Symbol
+				AST*  Body;           // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+				AST*  Declaration;    // Friend, Template
+				AST*  Value;          // Parameter, Variable
+			};
+		};
+		StringCached  Content;        // Attributes, Comment, Execution, Include
+		SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
+	};
+	union {
+		AST* Prev;
+		AST* Front;
+		AST* Last;
+	};
+	union {
+		AST* Next;
+		AST* Back;
+	};
+	AST*              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	ModuleFlag        ModuleFlags;
+	union {
+		b32           IsFunction; // Used by typedef to not serialize the name field.
+		OperatorT     Op;
+		AccessSpec    ParentAccess;
+		s32           NumEntries;
+	};
+};
+
+struct AST_POD
+{
+	union {
+		struct
+		{
+			AST*      Attributes;     // Class, Enum, Function, Struct, Typename, Union, Using, Variable
+			AST*      Specs;          // Function, Operator, Type symbol, Variable
+			union {
+				AST*  InitializerList; // Constructor, Destructor
+				AST*  ParentType;      // Class, Struct
+				AST*  ReturnType;      // Function, Operator
+				AST*  UnderlyingType;  // Enum, Typedef
+				AST*  ValueType;       // Parameter, Variable
+			};
+			union {
+				AST*  BitfieldSize;    // Varaiable (Class/Struct Data Member)
+				AST*  Params;          // Function, Operator, Template
+			};
+			union {
+				AST*  ArrExpr;        // Type Symbol
+				AST*  Body;           // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+				AST*  Declaration;    // Friend, Template
+				AST*  Value;          // Parameter, Variable
+			};
+		};
+		StringCached  Content;        // Attributes, Comment, Execution, Include
+		SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
+	};
+	union {
+		AST* Prev;
+		AST* Front;
+		AST* Last;
+	};
+	union {
+		AST* Next;
+		AST* Back;
+	};
+	AST*              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	ModuleFlag        ModuleFlags;
+	union {
+		b32           IsFunction; // Used by typedef to not serialize the name field.
+		OperatorT     Op;
+		AccessSpec    ParentAccess;
+		s32           NumEntries;
+	};
+};
+
+// Its intended for the AST to have equivalent size to its POD.
+// All extra functionality within the AST namespace should just be syntatic sugar.
+static_assert( sizeof(AST)     == sizeof(AST_POD), "ERROR: AST IS NOT POD" );
+static_assert( sizeof(AST_POD) == AST_POD_Size,    "ERROR: AST POD is not size of AST_POD_Size" );
+
+// Used when the its desired when omission is allowed in a definition.
+#define NoCode      { nullptr }
+#define 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

project/components/ast_case_macros.cpp

@@ -49,7 +49,6 @@
 	case Execution: 					       \
 	case Friend: 						       \
 	case Function_Body: 				       \
-	case Global_Body: 					       \
 	case Namespace_Body: 				       \
 	case Operator_Member: 				       \
 	case Operator_Member_Fwd: 			       \

project/components/ast_types.hpp

@@ -0,0 +1,545 @@
+#pragma once
+#include "ast.hpp"
+
+#pragma region AST Types
+/*
+	Show only relevant members of the AST for its type.
+	AST* fields are replaced with Code types.
+		- Guards assignemnts to AST* fields to ensure the AST is duplicated if assigned to another parent.
+*/
+
+struct AST_Body
+{
+	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+	Code              Front;
+	Code              Back;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32 			  NumEntries;
+};
+static_assert( sizeof(AST_Body) == sizeof(AST), "ERROR: AST_Filtered is not the same size as AST");
+
+struct AST_Attributes
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Attributes) == sizeof(AST), "ERROR: AST_Attributes is not the same size as AST");
+
+struct AST_Comment
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Comment) == sizeof(AST), "ERROR: AST_Comment is not the same size as AST");
+
+struct AST_Class
+{
+	union {
+		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes  Attributes;
+			char 	        _PAD_SPECS_ [ sizeof(AST*) ];
+			CodeType        ParentType;
+			char 	        _PAD_PARAMS_[ sizeof(AST*) ];
+			CodeBody        Body;
+		};
+	};
+	CodeType                Last;
+	CodeType                Next;
+	Code                    Parent;
+	StringCached            Name;
+	CodeT                   Type;
+	ModuleFlag              ModuleFlags;
+	AccessSpec              ParentAccess;
+};
+static_assert( sizeof(AST_Class) == sizeof(AST), "ERROR: AST_Class is not the same size as AST");
+
+struct AST_Constructor
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char      _PAD_PROPERTIES_ [ sizeof(AST*) * 3 ];
+			Code      InitializerList;
+			CodeParam Params;
+			Code      Body;
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Constructor) == sizeof(AST), "ERROR: AST_Constructor is not the same size as AST");
+
+struct AST_Define
+{
+	union {
+		char 		  _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Define) == sizeof(AST), "ERROR: AST_Define is not the same size as AST");
+
+struct AST_Destructor
+{
+	union {
+		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char           _PAD_PROPERTIES_ [ sizeof(AST*) * 1 ];
+			CodeSpecifiers Specs;
+			char           _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
+			Code           Body;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	char                   _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Destructor) == sizeof(AST), "ERROR: AST_Destructor is not the same size as AST");
+
+struct AST_Enum
+{
+	union {
+		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes Attributes;
+			char           _PAD_SPEC_  [ sizeof(AST*) ];
+			CodeType       UnderlyingType;
+			char	       _PAD_PARAMS_[ sizeof(AST*) ];
+			CodeBody       Body;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Enum) == sizeof(AST), "ERROR: AST_Enum is not the same size as AST");
+
+struct AST_Exec
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char      _PAD_PROPERTIES_[ sizeof(AST*) * 5 ];
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Exec) == sizeof(AST), "ERROR: AST_Exec is not the same size as AST");
+
+struct AST_Extern
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char      _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
+			CodeBody  Body;
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Extern) == sizeof(AST), "ERROR: AST_Extern is not the same size as AST");
+
+struct AST_Include
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Include) == sizeof(AST), "ERROR: AST_Include is not the same size as AST");
+
+struct AST_Friend
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char      _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
+			Code      Declaration;
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Friend) == sizeof(AST), "ERROR: AST_Friend is not the same size as AST");
+
+struct AST_Fn
+{
+	union {
+		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes  Attributes;
+			CodeSpecifiers  Specs;
+			CodeType        ReturnType;
+			CodeParam 	    Params;
+			CodeBody        Body;
+		};
+	};
+	Code                    Prev;
+	Code                    Parent;
+	Code                    Next;
+	StringCached            Name;
+	CodeT                   Type;
+	ModuleFlag              ModuleFlags;
+	char 			        _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Fn) == sizeof(AST), "ERROR: AST_Fn is not the same size as AST");
+
+struct AST_Module
+{
+	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	ModuleFlag        ModuleFlags;
+	char 			  _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Module) == sizeof(AST), "ERROR: AST_Module is not the same size as AST");
+
+struct AST_NS
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct {
+			char 	  _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
+			CodeBody  Body;
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	ModuleFlag        ModuleFlags;
+	char 			  _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_NS) == sizeof(AST), "ERROR: AST_NS is not the same size as AST");
+
+struct AST_Operator
+{
+	union {
+		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes  Attributes;
+			CodeSpecifiers  Specs;
+			CodeType        ReturnType;
+			CodeParam 	    Params;
+			CodeBody        Body;
+		};
+	};
+	Code                    Prev;
+	Code                    Next;
+	Code                    Parent;
+	StringCached            Name;
+	CodeT                   Type;
+	ModuleFlag              ModuleFlags;
+	OperatorT               Op;
+};
+static_assert( sizeof(AST_Operator) == sizeof(AST), "ERROR: AST_Operator is not the same size as AST");
+
+struct AST_OpCast
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char 	       _PAD_PROPERTIES_[ sizeof(AST*)  ];
+			CodeSpecifiers Specs;
+			CodeType       ValueType;
+			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) ];
+			CodeBody       Body;
+		};
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_OpCast) == sizeof(AST), "ERROR: AST_OpCast is not the same size as AST");
+
+struct AST_Param
+{
+	union {
+		char 		  _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) * 2 ];
+			CodeType  ValueType;
+			char 	  _PAD_PROPERTIES_[ sizeof(AST*) ];
+			Code      Value;
+		};
+	};
+	CodeParam         Last;
+	CodeParam         Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32               NumEntries;
+};
+static_assert( sizeof(AST_Param) == sizeof(AST), "ERROR: AST_Param is not the same size as AST");
+
+struct AST_Pragma
+{
+	union {
+		char 		  _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Pragma) == sizeof(AST), "ERROR: AST_Pragma is not the same size as AST");
+
+struct AST_PreprocessCond
+{
+	union {
+		char 		  _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		StringCached  Content;
+	};
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_PreprocessCond is not the same size as AST");
+
+struct AST_Specifiers
+{
+	SpecifierT        ArrSpecs[ AST::ArrSpecs_Cap ];
+	Code              Prev;
+	Code              Next;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	s32               NumEntries;
+};
+	static_assert( sizeof(AST_Specifiers) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");
+
+struct AST_Struct
+{
+	union {
+		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes Attributes;
+			char 	       _PAD_SPECS_ [ sizeof(AST*) ];
+			CodeType       ParentType;
+			char 	       _PAD_PARAMS_[ sizeof(AST*) ];
+			CodeBody       Body;
+		};
+	};
+	CodeType               Last;
+	CodeType               Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	AccessSpec             ParentAccess;
+};
+static_assert( sizeof(AST_Struct) == sizeof(AST), "ERROR: AST_Struct is not the same size as AST");
+
+struct AST_Template
+{
+	union {
+		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
+			CodeParam 	   Params;
+			Code           Declaration;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Template) == sizeof(AST), "ERROR: AST_Template is not the same size as AST");
+
+struct AST_Type
+{
+	union {
+		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes Attributes;
+			CodeSpecifiers Specs;
+			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
+			Code           ArrExpr;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	char 			       _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same size as AST");
+
+struct AST_Typedef
+{
+	union {
+		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
+			Code           UnderlyingType;
+			char 	       _PAD_PROPERTIES_2_[ sizeof(AST*) * 2 ];
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	b32                    IsFunction;
+};
+static_assert( sizeof(AST_Typedef) == sizeof(AST), "ERROR: AST_Typedef is not the same size as AST");
+
+struct AST_Union
+{
+	union {
+		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes Attributes;
+			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
+			CodeBody       Body;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Union) == sizeof(AST), "ERROR: AST_Union is not the same size as AST");
+
+struct AST_Using
+{
+	union {
+		char 		        _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes  Attributes;
+			char 	        _PAD_SPECS_     [ sizeof(AST*) ];
+			CodeType        UnderlyingType;
+			char 	        _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
+		};
+	};
+	Code                    Prev;
+	Code                    Next;
+	Code                    Parent;
+	StringCached            Name;
+	CodeT                   Type;
+	ModuleFlag              ModuleFlags;
+	char 			        _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Using) == sizeof(AST), "ERROR: AST_Using is not the same size as AST");
+
+struct AST_Var
+{
+	union {
+		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
+		struct
+		{
+			CodeAttributes Attributes;
+			CodeSpecifiers Specs;
+			CodeType       ValueType;
+			Code           BitfieldSize;
+			Code           Value;
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	ModuleFlag             ModuleFlags;
+	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+};
+static_assert( sizeof(AST_Var) == sizeof(AST), "ERROR: AST_Var is not the same size as AST");
+
+#pragma endregion AST Types

project/components/ecode.hpp

@@ -1,78 +0,0 @@
-// This is the non-bootstraped version of the ECode. This will be obsolete once bootstrap is stress tested.
-
-namespace ECode
-{
-#	define Define_Types           \
-	Entry( Invalid )              \
-	Entry( Untyped )              \
-	Entry( Comment )              \
-	Entry( Access_Private )       \
-	Entry( Access_Protected )     \
-	Entry( Access_Public )        \
-	Entry( PlatformAttributes )   \
-	Entry( Class )                \
-	Entry( Class_Fwd )            \
-	Entry( Class_Body )           \
-	Entry( Enum )                 \
-	Entry( Enum_Fwd )             \
-	Entry( Enum_Body )            \
-	Entry( Enum_Class )           \
-	Entry( Enum_Class_Fwd )       \
-	Entry( Execution )            \
-	Entry( Export_Body )          \
-	Entry( Extern_Linkage )       \
-	Entry( Extern_Linkage_Body )  \
-	Entry( Friend )               \
-	Entry( Function )             \
-	Entry( Function_Fwd )         \
-	Entry( Function_Body )        \
-	Entry( Global_Body )          \
-	Entry( Module )               \
-	Entry( Namespace )            \
-	Entry( Namespace_Body )       \
-	Entry( Operator )             \
-	Entry( Operator_Fwd )         \
-	Entry( Operator_Member )      \
-	Entry( Operator_Member_Fwd )  \
-	Entry( Operator_Cast )		  \
-	Entry( Operator_Cast_Fwd )    \
-	Entry( Parameters )           \
-	Entry( Preprocessor_Include ) \
-	Entry( Specifiers )           \
-	Entry( Struct )               \
-	Entry( Struct_Fwd )           \
-	Entry( Struct_Body )          \
-	Entry( Template )             \
-	Entry( Typedef )              \
-	Entry( Typename )             \
-	Entry( Union )			      \
-	Entry( Union_Body) 		      \
-	Entry( Using )                \
-	Entry( Using_Namespace )      \
-	Entry( Variable )
-
-	enum Type : u32
-	{
-	#	define Entry( Type ) Type,
-		Define_Types
-	#	undef Entry
-
-		Num_Types
-	};
-
-	inline
-	StrC to_str( Type type )
-	{
-		static
-		StrC lookup[Num_Types] = {
-		#	define Entry( Type ) { sizeof(stringize(Type)), stringize(Type) },
-			Define_Types
-		#	undef Entry
-		};
-
-		return lookup[ type ];
-	}
-
-#	undef Define_Types
-}
-using CodeT = ECode::Type;

project/components/eoperator.hpp

@@ -1,75 +0,0 @@
-// This is the non-bootstraped version of the EOperator. This will be obsolete once bootstrap is stress tested.
-
-namespace EOperator
-{
-#	define Define_Operators       \
-	Entry( Invalid,         INVALID ) \
-	Entry( Assign,          =  )  \
-	Entry( Assign_Add,      += )  \
-	Entry( Assign_Subtract, -= )  \
-	Entry( Assign_Multiply, *= )  \
-	Entry( Assign_Divide,   /= )  \
-	Entry( Assign_Modulo,   %= )  \
-	Entry( Assign_BAnd,     &= )  \
-	Entry( Assign_BOr,      |= )  \
-	Entry( Assign_BXOr,     ^= )  \
-	Entry( Assign_LShift,   <<= ) \
-	Entry( Assign_RShift,   >>= ) \
-	Entry( Increment,       ++ )  \
-	Entry( Decrement,       -- )  \
-	Entry( Unary_Plus,      + )   \
-	Entry( Unary_Minus,     - )   \
-	Entry( UnaryNot,        ! )   \
-	Entry( Add,             + )   \
-	Entry( Subtract,        - )   \
-	Entry( Multiply,        * )   \
-	Entry( Divide,          / )   \
-	Entry( Modulo,          % )   \
-	Entry( BNot,            ~ )   \
-	Entry( BAnd,            & )   \
-	Entry( BOr,             | )   \
-	Entry( BXOr,            ^ )   \
-	Entry( LShift,          << )  \
-	Entry( RShift,          >> )  \
-	Entry( LAnd,            && )  \
-	Entry( LOr,             || )  \
-	Entry( LEqual,          == )  \
-	Entry( LNot,            != )  \
-	Entry( Lesser,          < )   \
-	Entry( Greater,         > )   \
-	Entry( LesserEqual,     <= )  \
-	Entry( GreaterEqual,    >= )  \
-	Entry( Subscript,       [] )  \
-	Entry( Indirection,     * )   \
-	Entry( AddressOf,       & )   \
-	Entry( MemberOfPointer, -> )  \
-	Entry( PtrToMemOfPtr,   ->* ) \
-	Entry( FunctionCall,    () )
-
-	enum Type : u32
-	{
-	#	define Entry( Type_, Token_ ) Type_,
-		Define_Operators
-	#	undef Entry
-		Comma,
-
-		Num_Ops,
-	};
-
-	inline
-	char const* to_str( Type op )
-	{
-		local_persist
-		char const* lookup[ Num_Ops ] = {
-		#	define Entry( Type_, Token_ ) stringize(Token_),
-			Define_Operators
-		#	undef Entry
-			","
-		};
-
-		return lookup[ op ];
-	}
-
-#	undef Define_Operators
-}
-using OperatorT = EOperator::Type;

project/components/especifier.hpp

@@ -1,104 +0,0 @@
-// This is the non-bootstraped version of the ESpecifier. This will be obsolete once bootstrap is stress tested.
-
-namespace ESpecifier
-{
-/*
-	Note: The following are handled separately:
-	attributes
-	alignas
-*/
-
-#	define Define_Specifiers                     \
-	Entry( Invalid,          INVALID )           \
-	Entry( Consteval,        consteval )         \
-	Entry( Constexpr,        constexpr )         \
-	Entry( Constinit,        constinit )         \
-	Entry( Explicit,         explicit )          \
-	Entry( External_Linkage, extern )            \
-	Entry( Global,           global )            \
-	Entry( Inline,           inline )            \
-	Entry( Internal_Linkage, internal )          \
-	Entry( Local_Persist,    local_persist )     \
-	Entry( Mutable,          mutable )           \
-	Entry( Ptr,              * )                 \
-	Entry( Ref,              & )                 \
-	Entry( Register,         register )          \
-	Entry( RValue,           && )                \
-	Entry( Static,           static  )           \
-	Entry( Thread_Local,     thread_local )      \
-	Entry( Volatile,         volatile )          \
-	Entry( Virtual,          virtual )           \
-	Entry( Const,            const )             \
-	Entry( Final,            final )             \
-	Entry( Override,         override )
-
-	enum Type : u32
-	{
-	#	define Entry( Specifier, Code ) Specifier,
-		Define_Specifiers
-	#	undef Entry
-
-		NumSpecifiers,
-	};
-
-	inline
-	bool is_trailing( Type specifier )
-	{
-		return specifier > Virtual;
-	}
-
-	// Specifier to string
-	inline
-	StrC to_str( Type specifier )
-	{
-		local_persist
-		StrC lookup[ NumSpecifiers ] = {
-		#	pragma push_macro( "global" )
-		#	pragma push_macro( "internal" )
-		#	pragma push_macro( "local_persist" )
-		#	undef global
-		#	undef internal
-		#	undef local_persist
-
-		#	define Entry( Spec_, Code_ ) { sizeof(stringize(Code_)), stringize(Code_) },
-			Define_Specifiers
-		#	undef Entry
-
-		#	pragma pop_macro( "global" )
-		#	pragma pop_macro( "internal" )
-		#	pragma pop_macro( "local_persist" )
-		};
-
-		return lookup[ specifier ];
-	}
-
-	inline
-	Type to_type( StrC str )
-	{
-		local_persist
-		u32 keymap[ NumSpecifiers ];
-		do_once_start
-			for ( u32 index = 0; index < NumSpecifiers; index++ )
-			{
-				StrC enum_str = to_str( (Type)index );
-
-				// We subtract 1 to remove the null terminator
-				// This is because the tokens lexed are not null terminated.
-				keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
-			}
-		do_once_end
-
-		u32 hash = crc32( str.Ptr, str.Len );
-
-		for ( u32 index = 0; index < NumSpecifiers; index++ )
-		{
-			if ( keymap[index] == hash )
-				return (Type)index;
-		}
-
-		return Invalid;
-	}
-
-#	undef Define_Specifiers
-}
-using SpecifierT = ESpecifier::Type;

project/components/etoktype.cpp

@@ -1,151 +0,0 @@
-namespace Parser
-{
-/*
-	This is a simple lexer that focuses on tokenizing only tokens relevant to the library.
-	It will not be capable of lexing C++ code with unsupported features.
-
-	For the sake of scanning files, it can scan preprocessor directives
-
-	Attributes_Start is only used to indicate the start of the user_defined attribute list.
-*/
-
-#ifndef GEN_DEFINE_ATTRIBUTE_TOKENS
-#	define GEN_DEFINE_ATTRIBUTE_TOKENS         \
-	Entry( API_Export, "GEN_API_Export_Code" ) \
-	Entry( API_Import, "GEN_API_Import_Code" )
-#endif
-
-#	define Define_TokType \
-	Entry( Invalid,                "INVALID" )          \
-	Entry( Access_Private,         "private" )          \
-	Entry( Access_Protected,       "protected" )        \
-	Entry( Access_Public,          "public" )           \
-	Entry( Access_MemberSymbol,    "." )                \
-	Entry( Access_StaticSymbol,    "::")                \
-	Entry( Ampersand,              "&" )                \
-	Entry( Ampersand_DBL,          "&&" )               \
-	Entry( Assign_Classifer,       ":" )                \
-	Entry( Attribute_Open, 	       "[[" )               \
-	Entry( Attribute_Close, 	   "]]" )               \
-	Entry( BraceCurly_Open,        "{" )                \
-	Entry( BraceCurly_Close,       "}" )                \
-	Entry( BraceSquare_Open,       "[" )                \
-	Entry( BraceSquare_Close,      "]" )                \
-	Entry( Capture_Start,          "(" )                \
-	Entry( Capture_End,            ")" )                \
-	Entry( Comment,                "comment" )          \
-	Entry( Char,                   "character" )        \
-	Entry( Comma,                  "," )                \
-	Entry( Decl_Class,             "class" )            \
-	Entry( Decl_GNU_Attribute,    "__attribute__" )     \
-	Entry( Decl_MSVC_Attribute,    "__declspec" )       \
-	Entry( Decl_Enum,              "enum" )             \
-	Entry( Decl_Extern_Linkage,    "extern" )           \
-	Entry( Decl_Friend,            "friend" )           \
-	Entry( Decl_Module,            "module" )           \
-	Entry( Decl_Namespace,         "namespace" )        \
-	Entry( Decl_Operator,          "operator" )         \
-	Entry( Decl_Struct,            "struct" )           \
-	Entry( Decl_Template,          "template" )         \
-	Entry( Decl_Typedef,           "typedef" )          \
-	Entry( Decl_Using,             "using" )            \
-	Entry( Decl_Union,             "union" )            \
-	Entry( Identifier,             "identifier" )       \
-	Entry( Module_Import,          "import" )           \
-	Entry( Module_Export,          "export" )           \
-	Entry( Number,                 "number" )           \
-	Entry( Operator,               "operator" )         \
-	Entry( Preprocess_Define,      "#define")           \
-	Entry( Preproces_Include,      "include" )          \
-	Entry( Preprocess_If,          "#if")               \
-	Entry( Preprocess_Elif,        "#elif")             \
-	Entry( Preprocess_Else,        "#else")             \
-	Entry( Preprocess_EndIf,       "#endif")            \
-	Entry( Spec_Alignas,           "alignas" )          \
-	Entry( Spec_Const,             "const" )            \
-	Entry( Spec_Consteval,         "consteval" )        \
-	Entry( Spec_Constexpr,         "constexpr" )        \
-	Entry( Spec_Constinit,         "constinit" )        \
-	Entry( Spec_Explicit, 		   "explicit" )         \
-	Entry( Spec_Extern,            "extern" )           \
-	Entry( Spec_Final, 		       "final" )            \
-	Entry( Spec_Global, 		   "global" )           \
-	Entry( Spec_Inline,            "inline" )           \
-	Entry( Spec_Internal_Linkage,  "internal" )         \
-	Entry( Spec_LocalPersist,      "local_persist" )    \
-	Entry( Spec_Mutable,           "mutable" )          \
-	Entry( Spec_Override,          "override" )         \
-	Entry( Spec_Static,            "static" )           \
-	Entry( Spec_ThreadLocal,       "thread_local" )     \
-	Entry( Spec_Volatile,          "volatile")          \
-	Entry( Star,                   "*" )                \
-	Entry( Statement_End,          ";" )                \
-	Entry( String,                 "string" )           \
-	Entry( Type_Unsigned, 	       "unsigned" )         \
-	Entry( Type_Signed,            "signed" )           \
-	Entry( Type_Short,             "short" )            \
-	Entry( Type_Long,              "long" )             \
-	Entry( Type_char, 			   "char" )             \
-	Entry( Type_int, 			   "int" )              \
-	Entry( Type_double, 		   "double" )           \
-	Entry( Varadic_Argument,       "..." )              \
-	Entry( Attributes_Start,       "__attrib_start__" )
-
-	namespace ETokType
-	{
-		enum Type : u32
-		{
-		#	define Entry( Name_, Str_ ) Name_,
-			Define_TokType
-			GEN_DEFINE_ATTRIBUTE_TOKENS
-		#	undef Entry
-			NumTokens,
-		};
-
-		internal inline
-		Type to_type( StrC str_tok )
-		{
-			local_persist
-			StrC lookup[(u32)NumTokens] =
-			{
-			#	define Entry( Name_, Str_ ) { sizeof(Str_), Str_ },
-				Define_TokType
-				GEN_DEFINE_ATTRIBUTE_TOKENS
-			#	undef Entry
-			};
-
-			for ( u32 index = 0; index < (u32)NumTokens; index++ )
-			{
-				s32         lookup_len = lookup[index].Len - 1;
-				char const* lookup_str = lookup[index].Ptr;
-
-				if ( lookup_len != str_tok.Len )
-					continue;
-
-				if ( str_compare( str_tok.Ptr, lookup_str, lookup_len ) == 0 )
-					return scast(Type, index);
-			}
-
-			return Invalid;
-		}
-
-		internal inline
-		char const* to_str( Type type )
-		{
-			local_persist
-			char const* lookup[(u32)NumTokens] =
-			{
-			#	define Entry( Name_, Str_ ) Str_,
-				Define_TokType
-				GEN_DEFINE_ATTRIBUTE_TOKENS
-			#	undef Entry
-			};
-
-			return lookup[(u32)type];
-		}
-	#	undef Define_TokType
-	};
-
-	using TokType = ETokType::Type;
-
-} // Parser

project/components/gen/ecode.hpp

@@ -0,0 +1,141 @@
+#pragma once
+
+// This file was generated automatially by gen.bootstrap.cpp (See: https://github.com/Ed94/gencpp)
+
+namespace ECode
+{
+	enum Type : u32
+	{
+		Invalid,
+		Untyped,
+		NewLine,
+		Comment,
+		Access_Private,
+		Access_Protected,
+		Access_Public,
+		PlatformAttributes,
+		Class,
+		Class_Fwd,
+		Class_Body,
+		Constructor,
+		Constructor_Fwd,
+		Destructor,
+		Destructor_Fwd,
+		Enum,
+		Enum_Fwd,
+		Enum_Body,
+		Enum_Class,
+		Enum_Class_Fwd,
+		Execution,
+		Export_Body,
+		Extern_Linkage,
+		Extern_Linkage_Body,
+		Friend,
+		Function,
+		Function_Fwd,
+		Function_Body,
+		Global_Body,
+		Module,
+		Namespace,
+		Namespace_Body,
+		Operator,
+		Operator_Fwd,
+		Operator_Member,
+		Operator_Member_Fwd,
+		Operator_Cast,
+		Operator_Cast_Fwd,
+		Parameters,
+		Preprocess_Define,
+		Preprocess_Include,
+		Preprocess_If,
+		Preprocess_IfDef,
+		Preprocess_IfNotDef,
+		Preprocess_ElIf,
+		Preprocess_Else,
+		Preprocess_EndIf,
+		Preprocess_Pragma,
+		Specifiers,
+		Struct,
+		Struct_Fwd,
+		Struct_Body,
+		Template,
+		Typedef,
+		Typename,
+		Union,
+		Union_Body,
+		Using,
+		Using_Namespace,
+		Variable,
+		NumTypes
+	};
+
+	StrC to_str( Type type )
+	{
+		local_persist StrC lookup[] {
+			{sizeof( "Invalid" ),              "Invalid"            },
+			{ sizeof( "Untyped" ),             "Untyped"            },
+			{ sizeof( "NewLine" ),             "NewLine"            },
+			{ sizeof( "Comment" ),             "Comment"            },
+			{ sizeof( "Access_Private" ),      "Access_Private"     },
+			{ sizeof( "Access_Protected" ),    "Access_Protected"   },
+			{ sizeof( "Access_Public" ),       "Access_Public"      },
+			{ sizeof( "PlatformAttributes" ),  "PlatformAttributes" },
+			{ sizeof( "Class" ),               "Class"              },
+			{ sizeof( "Class_Fwd" ),           "Class_Fwd"          },
+			{ sizeof( "Class_Body" ),          "Class_Body"         },
+			{ sizeof( "Constructor" ),         "Constructor"        },
+			{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"    },
+			{ sizeof( "Destructor" ),          "Destructor"         },
+			{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"     },
+			{ sizeof( "Enum" ),                "Enum"               },
+			{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"           },
+			{ sizeof( "Enum_Body" ),           "Enum_Body"          },
+			{ sizeof( "Enum_Class" ),          "Enum_Class"         },
+			{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"     },
+			{ sizeof( "Execution" ),           "Execution"          },
+			{ sizeof( "Export_Body" ),         "Export_Body"        },
+			{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"     },
+			{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body"},
+			{ sizeof( "Friend" ),              "Friend"             },
+			{ sizeof( "Function" ),            "Function"           },
+			{ sizeof( "Function_Fwd" ),        "Function_Fwd"       },
+			{ sizeof( "Function_Body" ),       "Function_Body"      },
+			{ sizeof( "Global_Body" ),         "Global_Body"        },
+			{ sizeof( "Module" ),              "Module"             },
+			{ sizeof( "Namespace" ),           "Namespace"          },
+			{ sizeof( "Namespace_Body" ),      "Namespace_Body"     },
+			{ sizeof( "Operator" ),            "Operator"           },
+			{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"       },
+			{ sizeof( "Operator_Member" ),     "Operator_Member"    },
+			{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd"},
+			{ sizeof( "Operator_Cast" ),       "Operator_Cast"      },
+			{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"  },
+			{ sizeof( "Parameters" ),          "Parameters"         },
+			{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"  },
+			{ sizeof( "Preprocess_Include" ),  "Preprocess_Include" },
+			{ sizeof( "Preprocess_If" ),       "Preprocess_If"      },
+			{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"   },
+			{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef"},
+			{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"    },
+			{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"    },
+			{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"   },
+			{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"  },
+			{ sizeof( "Specifiers" ),          "Specifiers"         },
+			{ sizeof( "Struct" ),              "Struct"             },
+			{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"         },
+			{ sizeof( "Struct_Body" ),         "Struct_Body"        },
+			{ sizeof( "Template" ),            "Template"           },
+			{ sizeof( "Typedef" ),             "Typedef"            },
+			{ sizeof( "Typename" ),            "Typename"           },
+			{ sizeof( "Union" ),               "Union"              },
+			{ sizeof( "Union_Body" ),          "Union_Body"         },
+			{ sizeof( "Using" ),               "Using"              },
+			{ sizeof( "Using_Namespace" ),     "Using_Namespace"    },
+			{ sizeof( "Variable" ),            "Variable"           },
+		};
+		return lookup[ type ];
+	}
+
+}    // namespace ECode
+
+using CodeT = ECode::Type;

project/components/gen/eoperator.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+// This file was generated automatially by gen.bootstrap.cpp (See: https://github.com/Ed94/gencpp)
+
+namespace EOperator
+{
+	enum Type : u32
+	{
+		Invalid,
+		Assign,
+		Assign_Add,
+		Assign_Subtract,
+		Assign_Multiply,
+		Assign_Divide,
+		Assign_Modulo,
+		Assign_BAnd,
+		Assign_BOr,
+		Assign_BXOr,
+		Assign_LShift,
+		Assign_RShift,
+		Increment,
+		Decrement,
+		Unary_Plus,
+		Unary_Minus,
+		UnaryNot,
+		Add,
+		Subtract,
+		Multiply,
+		Divide,
+		Modulo,
+		BNot,
+		BAnd,
+		BOr,
+		BXOr,
+		LShift,
+		RShift,
+		LAnd,
+		LOr,
+		LEqual,
+		LNot,
+		Lesser,
+		Greater,
+		LesserEqual,
+		GreaterEqual,
+		Subscript,
+		Indirection,
+		AddressOf,
+		MemberOfPointer,
+		PtrToMemOfPtr,
+		FunctionCall,
+		Comma,
+		NumOps
+	};
+
+	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;

project/components/gen/especifier.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+// This file was generated automatially by gen.bootstrap.cpp (See: https://github.com/Ed94/gencpp)
+
+namespace ESpecifier
+{
+	enum Type : u32
+	{
+		Invalid,
+		Consteval,
+		Constexpr,
+		Constinit,
+		Explicit,
+		External_Linkage,
+		ForceInline,
+		Global,
+		Inline,
+		Internal_Linkage,
+		Local_Persist,
+		Mutable,
+		NeverInline,
+		Ptr,
+		Ref,
+		Register,
+		RValue,
+		Static,
+		Thread_Local,
+		Volatile,
+		Virtual,
+		Const,
+		Final,
+		Override,
+		Pure,
+		NumSpecifiers
+	};
+
+	bool is_trailing( Type specifier )
+	{
+		return specifier > Virtual;
+	}
+
+	StrC to_str( Type type )
+	{
+		local_persist StrC lookup[] {
+			{sizeof( "INVALID" ),        "INVALID"      },
+			{ sizeof( "consteval" ),     "consteval"    },
+			{ sizeof( "constexpr" ),     "constexpr"    },
+			{ sizeof( "constinit" ),     "constinit"    },
+			{ sizeof( "explicit" ),      "explicit"     },
+			{ sizeof( "extern" ),        "extern"       },
+			{ sizeof( "forceinline" ),   "forceinline"  },
+			{ sizeof( "global" ),        "global"       },
+			{ sizeof( "inline" ),        "inline"       },
+			{ sizeof( "internal" ),      "internal"     },
+			{ sizeof( "local_persist" ), "local_persist"},
+			{ sizeof( "mutable" ),       "mutable"      },
+			{ sizeof( "neverinline" ),   "neverinline"  },
+			{ sizeof( "*" ),             "*"            },
+			{ sizeof( "&" ),             "&"            },
+			{ sizeof( "register" ),      "register"     },
+			{ sizeof( "&&" ),            "&&"           },
+			{ sizeof( "static" ),        "static"       },
+			{ sizeof( "thread_local" ),  "thread_local" },
+			{ sizeof( "volatile" ),      "volatile"     },
+			{ sizeof( "virtual" ),       "virtual"      },
+			{ sizeof( "const" ),         "const"        },
+			{ sizeof( "final" ),         "final"        },
+			{ sizeof( "override" ),      "override"     },
+			{ sizeof( "= 0" ),           "= 0"          },
+		};
+		return lookup[ type ];
+	}
+
+	Type to_type( StrC str )
+	{
+		local_persist u32 keymap[ NumSpecifiers ];
+		do_once_start for ( u32 index = 0; index < NumSpecifiers; index++ )
+		{
+			StrC enum_str   = to_str( ( Type )index );
+			keymap[ index ] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+		}
+		do_once_end u32 hash = crc32( str.Ptr, str.Len );
+		for ( u32 index = 0; index < NumSpecifiers; index++ )
+		{
+			if ( keymap[ index ] == hash )
+				return ( Type )index;
+		}
+		return Invalid;
+	}
+
+}    // namespace ESpecifier
+
+using SpecifierT = ESpecifier::Type;

project/components/gen/etoktype.cpp

@@ -0,0 +1,234 @@
+// This file was generated automatially by gen.bootstrap.cpp (See: https://github.com/Ed94/gencpp)
+
+#pragma once
+
+namespace Parser
+{
+	namespace ETokType
+	{
+#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( API_Export, GEN_API_Export_Code ) Entry( API_Import, GEN_API_Import_Code )
+
+		enum Type : u32
+		{
+			Invalid,
+			Access_Private,
+			Access_Protected,
+			Access_Public,
+			Access_MemberSymbol,
+			Access_StaticSymbol,
+			Ampersand,
+			Ampersand_DBL,
+			Assign_Classifer,
+			Attribute_Open,
+			Attribute_Close,
+			BraceCurly_Open,
+			BraceCurly_Close,
+			BraceSquare_Open,
+			BraceSquare_Close,
+			Capture_Start,
+			Capture_End,
+			Comment,
+			Comment_End,
+			Comment_Start,
+			Char,
+			Comma,
+			Decl_Class,
+			Decl_GNU_Attribute,
+			Decl_MSVC_Attribute,
+			Decl_Enum,
+			Decl_Extern_Linkage,
+			Decl_Friend,
+			Decl_Module,
+			Decl_Namespace,
+			Decl_Operator,
+			Decl_Struct,
+			Decl_Template,
+			Decl_Typedef,
+			Decl_Using,
+			Decl_Union,
+			Identifier,
+			Module_Import,
+			Module_Export,
+			NewLine,
+			Number,
+			Operator,
+			Preprocess_Hash,
+			Preprocess_Define,
+			Preprocess_If,
+			Preprocess_IfDef,
+			Preprocess_IfNotDef,
+			Preprocess_ElIf,
+			Preprocess_Else,
+			Preprocess_EndIf,
+			Preprocess_Include,
+			Preprocess_Pragma,
+			Preprocess_Content,
+			Preprocess_Macro,
+			Preprocess_Unsupported,
+			Spec_Alignas,
+			Spec_Const,
+			Spec_Consteval,
+			Spec_Constexpr,
+			Spec_Constinit,
+			Spec_Explicit,
+			Spec_Extern,
+			Spec_Final,
+			Spec_ForceInline,
+			Spec_Global,
+			Spec_Inline,
+			Spec_Internal_Linkage,
+			Spec_LocalPersist,
+			Spec_Mutable,
+			Spec_NeverInline,
+			Spec_Override,
+			Spec_Static,
+			Spec_ThreadLocal,
+			Spec_Volatile,
+			Spec_Virtual,
+			Star,
+			Statement_End,
+			StaticAssert,
+			String,
+			Type_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( "__comemnt__" ),         "__comemnt__"        },
+				{ 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

project/components/header_end.hpp

@@ -1,400 +1,14 @@
-#pragma region Inlines
-
-void AST::append( AST* other )
-{
-	if ( other->Parent )
-		other = other->duplicate();
-
-	other->Parent = this;
-
-	if ( Front == nullptr )
-	{
-		Front = other;
-		Back  = other;
-
-		NumEntries++;
-		return;
-	}
-
-	AST*
-		Current       = Back;
-	Current->Next = other;
-	other->Prev   = Current;
-	Back          = other;
-	NumEntries++;
-}
-
-char const* AST::debug_str()
-{
-	char const* fmt = stringize(
-		\nCode Debug:
-		\nType    : %s
-		\nParent  : %s
-		\nName    : %s
-		\nComment : %s
-	);
-
-	// These should be used immediately in a log.
-	// Thus if its desired to keep the debug str
-	// for multiple calls to bprintf,
-	// allocate this to proper string.
-	return str_fmt_buf( fmt
-		,	type_str()
-		,	Parent   ? Parent->Name : ""
-		,	Name     ? Name         : ""
-	);
-}
-
-Code& AST::entry( u32 idx )
-{
-	AST** current = & Front;
-	while ( idx >= 0 && current != nullptr )
-	{
-		if ( idx == 0 )
-			return * rcast( Code*, current);
-
-		current = & ( * current )->Next;
-		idx--;
-	}
-
-	return * rcast( Code*, current);
-}
-
-bool AST::has_entries()
-{
-	return NumEntries;
-}
-
-char const* AST::type_str()
-{
-	return ECode::to_str( Type );
-}
-
-AST::operator Code()
-{
-	return { this };
-}
-
-Code& Code::operator ++()
-{
-	if ( ast )
-		ast = ast->Next;
-
-	return *this;
-}
-
-#pragma region AST & Code Gen Common
-
-#define Define_CodeImpl( Typename )                                                  \
-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();                                            \
-}                                                                                    \
-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), other.ast );                                         \
-	return *this;                                                                    \
-}                                                                                    \
-bool Typename::operator ==( Code other )                                             \
-{                                                                                    \
-	return (AST*) ast == other.ast;                                                  \
-}                                                                                    \
-bool Typename::operator !=( Code other )                                             \
-{                                                                                    \
-	return (AST*) ast != other.ast;                                                  \
-}
-
-Define_CodeImpl( Code );
-Define_CodeImpl( CodeBody );
-Define_CodeImpl( CodeAttributes );
-Define_CodeImpl( CodeComment );
-Define_CodeImpl( CodeClass );
-Define_CodeImpl( CodeEnum );
-Define_CodeImpl( CodeExec );
-Define_CodeImpl( CodeExtern );
-Define_CodeImpl( CodeInclude );
-Define_CodeImpl( CodeFriend );
-Define_CodeImpl( CodeFn );
-Define_CodeImpl( CodeModule );
-Define_CodeImpl( CodeNamespace );
-Define_CodeImpl( CodeOperator );
-Define_CodeImpl( CodeOpCast );
-Define_CodeImpl( CodeParam );
-Define_CodeImpl( CodeSpecifiers );
-Define_CodeImpl( CodeStruct );
-Define_CodeImpl( CodeTemplate );
-Define_CodeImpl( CodeType );
-Define_CodeImpl( CodeTypedef );
-Define_CodeImpl( CodeUnion );
-Define_CodeImpl( CodeUsing );
-Define_CodeImpl( CodeVar );
-#undef Define_CodeImpl
-
-#define Define_AST_Cast( typename )              \
-AST::operator Code ## typename()                 \
-{                                                \
-	return { rcast( AST_ ## typename*, this ) }; \
-}
-
-Define_AST_Cast( Body );
-Define_AST_Cast( Attributes );
-Define_AST_Cast( Comment );
-Define_AST_Cast( Class );
-Define_AST_Cast( Enum );
-Define_AST_Cast( Exec );
-Define_AST_Cast( Extern );
-Define_AST_Cast( Include );
-Define_AST_Cast( Friend );
-Define_AST_Cast( Fn );
-Define_AST_Cast( Module );
-Define_AST_Cast( Namespace );
-Define_AST_Cast( Operator );
-Define_AST_Cast( OpCast );
-Define_AST_Cast( Param );
-Define_AST_Cast( Struct );
-Define_AST_Cast( Specifiers );
-Define_AST_Cast( Template );
-Define_AST_Cast( Type );
-Define_AST_Cast( Typedef );
-Define_AST_Cast( Union );
-Define_AST_Cast( Using );
-Define_AST_Cast( Var );
-#undef Define_AST_Cast
-
-#define Define_CodeCast( type )     \
-Code::operator Code ## type() const \
-{                                   \
-	return { (AST_ ## type*) ast }; \
-}
-
-Define_CodeCast( Attributes );
-Define_CodeCast( Comment );
-Define_CodeCast( Class );
-Define_CodeCast( Exec );
-Define_CodeCast( Enum );
-Define_CodeCast( Extern );
-Define_CodeCast( Include );
-Define_CodeCast( Friend );
-Define_CodeCast( Fn );
-Define_CodeCast( Module );
-Define_CodeCast( Namespace );
-Define_CodeCast( Operator );
-Define_CodeCast( OpCast );
-Define_CodeCast( Param );
-Define_CodeCast( Specifiers );
-Define_CodeCast( Struct );
-Define_CodeCast( Template );
-Define_CodeCast( Type );
-Define_CodeCast( Typedef );
-Define_CodeCast( Union );
-Define_CodeCast( Using );
-Define_CodeCast( Var );
-Define_CodeCast( Body);
-#undef Define_CodeCast
-
-#pragma endregion AST & Code Gen Common
-
-void CodeClass::add_interface( CodeType type )
-{
-	if ( ! ast->Next )
-	{
-		ast->Next = type;
-		ast->Last = ast->Next;
-		return;
-	}
-
-	ast->Next->Next = type;
-	ast->Last       = ast->Next->Next;
-}
-
-void CodeParam::append( CodeParam other )
-{
-	AST* self  = (AST*) ast;
-	AST* entry = (AST*) other.ast;
-
-	if ( entry->Parent )
-		entry = entry->duplicate();
-
-	entry->Parent = self;
-
-	if ( self->Last == nullptr )
-	{
-		self->Last = entry;
-		self->Next = entry;
-		self->NumEntries++;
-		return;
-	}
-
-	self->Last->Next = entry;
-	self->Last       = entry;
-	self->NumEntries++;
-}
-
-CodeParam CodeParam::get( s32 idx )
-{
-	CodeParam param = *this;
-	do
-	{
-		if ( ! ++ param )
-			return { nullptr };
-
-		return { (AST_Param*) param.raw()->Next };
-	}
-	while ( --idx );
-
-	return { nullptr };
-}
-
-bool CodeParam::has_entries()
-{
-	return ast->NumEntries > 0;
-}
-
-CodeParam& CodeParam::operator ++()
-{
-	ast = ast->Next.ast;
-	return * this;
-}
-
-void CodeStruct::add_interface( CodeType type )
-{
-	if ( ! ast->Next )
-	{
-		ast->Next = type;
-		ast->Last = ast->Next;
-	}
-
-	ast->Next->Next = type;
-	ast->Last       = ast->Next->Next;
-}
-
-CodeBody def_body( CodeT type )
-{
-	switch ( type )
-	{
-		using namespace ECode;
-		case Class_Body:
-		case Enum_Body:
-		case Export_Body:
-		case Extern_Linkage:
-		case Function_Body:
-		case Global_Body:
-		case Namespace_Body:
-		case Struct_Body:
-		case Union_Body:
-			break;
-
-		default:
-			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
-			return (CodeBody)Code::Invalid;
-	}
-
-	Code
-		result       = make_code();
-	result->Type = type;
-	return (CodeBody)result;
-}
-
-//! Do not use directly. Use the token_fmt macro instead.
-// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
-StrC token_fmt_impl( sw num, ... )
-{
-	local_persist thread_local
-	char buf[GEN_PRINTF_MAXLEN] = { 0 };
-	mem_set( buf, 0, GEN_PRINTF_MAXLEN );
-
-	va_list va;
-	va_start(va, num );
-	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
-	va_end(va);
-
-	return { result, buf };
-}
-
-#pragma endregion Inlines
+#pragma once
+#include "inlines.hpp"
+#include "gen/ast_inlines.hpp"
 
 #pragma region Constants
 
-#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-	// Predefined typename codes. Are set to readonly and are setup during gen::init()
-
-	extern CodeType t_b32;
-
-	extern CodeType t_s8;
-	extern CodeType t_s16;
-	extern CodeType t_s32;
-	extern CodeType t_s64;
-
-	extern CodeType t_u8;
-	extern CodeType t_u16;
-	extern CodeType t_u32;
-	extern CodeType t_u64;
-
-	extern CodeType t_sw;
-	extern CodeType t_uw;
-
-	extern CodeType t_f32;
-	extern CodeType t_f64;
-#endif
-
 #ifndef GEN_GLOBAL_BUCKET_SIZE
-#	define GEN_GLOBAL_BUCKET_SIZE megabytes(10)
+#	define GEN_GLOBAL_BUCKET_SIZE megabytes(4)
 #endif
 #ifndef GEN_CODEPOOL_NUM_BLOCKS
-#	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(64)
+#	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(16)
 #endif
 #ifndef GEN_SIZE_PER_STRING_ARENA
 #	define GEN_SIZE_PER_STRING_ARENA megabytes(1)
@@ -412,7 +26,7 @@ StrC token_fmt_impl( sw num, ... )
 #	define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(4)
 #endif
 #ifndef GEN_LEX_ALLOCATOR_SIZE
-#	define GEN_LEX_ALLOCATOR_SIZE megabytes(10)
+#	define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
 #endif
 #ifndef GEN_BUILDER_STR_BUFFER_RESERVE
 #	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(1)
@@ -437,6 +51,50 @@ constexpr s32 TokenFmt_TokenMap_MemSize	= GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
 constexpr s32 LexAllocator_Size         = GEN_LEX_ALLOCATOR_SIZE;
 constexpr s32 Builder_StrBufferReserve  = GEN_BUILDER_STR_BUFFER_RESERVE;
 
+extern Code access_public;
+extern Code access_protected;
+extern Code access_private;
+
+extern CodeAttributes attrib_api_export;
+extern CodeAttributes attrib_api_import;
+
+extern Code module_global_fragment;
+extern Code module_private_fragment;
+
+// Exposed, but this is really used for parsing.
+extern Code fmt_newline;
+
+extern CodePragma pragma_once;
+
+extern CodeParam param_varadic;
+
+extern CodePreprocessCond preprocess_else;
+extern CodePreprocessCond preprocess_endif;
+
+extern CodeSpecifiers spec_const;
+extern CodeSpecifiers spec_consteval;
+extern CodeSpecifiers spec_constexpr;
+extern CodeSpecifiers spec_constinit;
+extern CodeSpecifiers spec_extern_linkage;
+extern CodeSpecifiers spec_final;
+extern CodeSpecifiers spec_forceinline;
+extern CodeSpecifiers spec_global;
+extern CodeSpecifiers spec_inline;
+extern CodeSpecifiers spec_internal_linkage;
+extern CodeSpecifiers spec_local_persist;
+extern CodeSpecifiers spec_mutable;
+extern CodeSpecifiers spec_neverinline;
+extern CodeSpecifiers spec_override;
+extern CodeSpecifiers spec_ptr;
+extern CodeSpecifiers spec_pure;
+extern CodeSpecifiers spec_ref;
+extern CodeSpecifiers spec_register;
+extern CodeSpecifiers spec_rvalue;
+extern CodeSpecifiers spec_static_member;
+extern CodeSpecifiers spec_thread_local;
+extern CodeSpecifiers spec_virtual;
+extern CodeSpecifiers spec_volatile;
+
 extern CodeType t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
 extern CodeType t_auto;
 extern CodeType t_void;
@@ -447,40 +105,27 @@ extern CodeType t_wchar_t;
 extern CodeType t_class;
 extern CodeType t_typename;
 
-extern CodeParam param_varadic;
+#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+	// Predefined typename codes. Are set to readonly and are setup during gen::init()
 
-extern CodeAttributes attrib_api_export;
-extern CodeAttributes attrib_api_import;
+	extern CodeType t_b32;
 
-extern Code access_public;
-extern Code access_protected;
-extern Code access_private;
+	extern CodeType t_s8;
+	extern CodeType t_s16;
+	extern CodeType t_s32;
+	extern CodeType t_s64;
 
-extern Code module_global_fragment;
-extern Code module_private_fragment;
+	extern CodeType t_u8;
+	extern CodeType t_u16;
+	extern CodeType t_u32;
+	extern CodeType t_u64;
 
-extern Code pragma_once;
+	extern CodeType t_sw;
+	extern CodeType t_uw;
 
-extern CodeSpecifiers spec_const;
-extern CodeSpecifiers spec_consteval;
-extern CodeSpecifiers spec_constexpr;
-extern CodeSpecifiers spec_constinit;
-extern CodeSpecifiers spec_extern_linkage;
-extern CodeSpecifiers spec_final;
-extern CodeSpecifiers spec_global;
-extern CodeSpecifiers spec_inline;
-extern CodeSpecifiers spec_internal_linkage;
-extern CodeSpecifiers spec_local_persist;
-extern CodeSpecifiers spec_mutable;
-extern CodeSpecifiers spec_override;
-extern CodeSpecifiers spec_ptr;
-extern CodeSpecifiers spec_ref;
-extern CodeSpecifiers spec_register;
-extern CodeSpecifiers spec_rvalue;
-extern CodeSpecifiers spec_static_member;
-extern CodeSpecifiers spec_thread_local;
-extern CodeSpecifiers spec_virtual;
-extern CodeSpecifiers spec_volatile;
+	extern CodeType t_f32;
+	extern CodeType t_f64;
+#endif
 
 #pragma endregion Constants
 
@@ -499,11 +144,11 @@ extern CodeSpecifiers spec_volatile;
 
 #	define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
 
-#	define code_str( ... ) gen::untyped_str( code( __VA_ARGS__ ) )
-#	define code_fmt( ... ) gen::untyped_str( token_fmt( __VA_ARGS__ ) )
+#	define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
+#	define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
 
 	// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
-#	define token_fmt( ... ) gen::token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
+#	define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
 
 #pragma endregion Macros
 
@@ -512,6 +157,7 @@ extern CodeSpecifiers spec_volatile;
 	// Global allocator used for data with process lifetime.
 	extern AllocatorInfo  GlobalAllocator;
 	extern Array< Arena > Global_AllocatorBuckets;
+
 	extern Array< Pool >  CodePools;
 	extern Array< Arena > StringArenas;
 

project/components/header_start.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 /*
 	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
 
@@ -15,3 +17,15 @@
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 #	include "gen.dep.hpp"
 #endif
+
+#ifndef GEN_NS_BEGIN
+#	ifdef GEN_DONT_USE_NAMESPACE
+#		define GEN_NS
+#		define GEN_NS_BEGIN
+#		define GEN_NS_END
+#	else
+#		define GEN_NS       gen::
+#		define GEN_NS_BEGIN namespace gen {
+#		define GEN_NS_END   }
+#	endif
+#endif

project/components/inlines.hpp

@@ -0,0 +1,216 @@
+#pragma once
+#include "interface.hpp"
+
+void AST::append( AST* other )
+{
+	if ( other->Parent )
+		other = other->duplicate();
+
+	other->Parent = this;
+
+	if ( Front == nullptr )
+	{
+		Front = other;
+		Back  = other;
+
+		NumEntries++;
+		return;
+	}
+
+	AST*
+		Current       = Back;
+	Current->Next = other;
+	other->Prev   = Current;
+	Back          = other;
+	NumEntries++;
+}
+
+char const* AST::debug_str()
+{
+	if ( Parent )
+	{
+		char const* fmt = stringize(
+			\nType    : %s
+			\nParent  : %s %s
+			\nName    : %s
+		);
+
+		// These should be used immediately in a log.
+		// Thus if its desired to keep the debug str
+		// for multiple calls to bprintf,
+		// allocate this to proper string.
+		return str_fmt_buf( fmt
+			,	type_str()
+			,	Parent->Name
+			,   Parent->type_str()
+			,	Name     ? Name         : ""
+		);
+	}
+
+	char const* fmt = stringize(
+		\nType    : %s
+		\nName    : %s
+	);
+
+	// These should be used immediately in a log.
+	// Thus if its desired to keep the debug str
+	// for multiple calls to bprintf,
+	// allocate this to proper string.
+	return str_fmt_buf( fmt
+		,	type_str()
+		,	Name     ? Name         : ""
+	);
+}
+
+Code& AST::entry( u32 idx )
+{
+	AST** current = & Front;
+	while ( idx >= 0 && current != nullptr )
+	{
+		if ( idx == 0 )
+			return * rcast( Code*, current);
+
+		current = & ( * current )->Next;
+		idx--;
+	}
+
+	return * rcast( Code*, current);
+}
+
+bool AST::has_entries()
+{
+	return NumEntries;
+}
+
+char const* AST::type_str()
+{
+	return ECode::to_str( Type );
+}
+
+AST::operator Code()
+{
+	return { this };
+}
+
+Code& Code::operator ++()
+{
+	if ( ast )
+		ast = ast->Next;
+
+	return *this;
+}
+
+void CodeClass::add_interface( CodeType type )
+{
+	if ( ! ast->Next )
+	{
+		ast->Next = type;
+		ast->Last = ast->Next;
+		return;
+	}
+
+	ast->Next->Next = type;
+	ast->Last       = ast->Next->Next;
+}
+
+void CodeParam::append( CodeParam other )
+{
+	AST* self  = (AST*) ast;
+	AST* entry = (AST*) other.ast;
+
+	if ( entry->Parent )
+		entry = entry->duplicate();
+
+	entry->Parent = self;
+
+	if ( self->Last == nullptr )
+	{
+		self->Last = entry;
+		self->Next = entry;
+		self->NumEntries++;
+		return;
+	}
+
+	self->Last->Next = entry;
+	self->Last       = entry;
+	self->NumEntries++;
+}
+
+CodeParam CodeParam::get( s32 idx )
+{
+	CodeParam param = *this;
+	do
+	{
+		if ( ! ++ param )
+			return { nullptr };
+
+		return { (AST_Param*) param.raw()->Next };
+	}
+	while ( --idx );
+
+	return { nullptr };
+}
+
+bool CodeParam::has_entries()
+{
+	return ast->NumEntries > 0;
+}
+
+CodeParam& CodeParam::operator ++()
+{
+	ast = ast->Next.ast;
+	return * this;
+}
+
+void CodeStruct::add_interface( CodeType type )
+{
+	if ( ! ast->Next )
+	{
+		ast->Next = type;
+		ast->Last = ast->Next;
+	}
+
+	ast->Next->Next = type;
+	ast->Last       = ast->Next->Next;
+}
+
+CodeBody def_body( CodeT type )
+{
+	switch ( type )
+	{
+		using namespace ECode;
+		case Class_Body:
+		case Enum_Body:
+		case Export_Body:
+		case Extern_Linkage:
+		case Function_Body:
+		case Global_Body:
+		case Namespace_Body:
+		case Struct_Body:
+		case Union_Body:
+			break;
+
+		default:
+			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
+			return (CodeBody)Code::Invalid;
+	}
+
+	Code
+	result       = make_code();
+	result->Type = type;
+	return (CodeBody)result;
+}
+
+StrC token_fmt_impl( sw num, ... )
+{
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+	mem_set( buf, 0, GEN_PRINTF_MAXLEN );
+
+	va_list va;
+	va_start(va, num );
+	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
+	va_end(va);
+
+	return { result, buf };
+}

project/components/interface.cpp

@@ -1,3 +1,9 @@
+#pragma once
+#include "ast.cpp"
+
+internal void init_parser();
+internal void deinit_parser();
+
 internal
 void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
 {
@@ -12,10 +18,10 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
 				Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
 
 				if ( bucket.PhysicalStart == nullptr )
-					fatal( "Failed to create bucket for Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
 				if ( ! Global_AllocatorBuckets.append( bucket ) )
-					fatal( "Failed to append bucket to Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
 				last = & Global_AllocatorBuckets.back();
 			}
@@ -39,10 +45,10 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
 				Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
 
 				if ( bucket.PhysicalStart == nullptr )
-					fatal( "Failed to create bucket for Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
 
 				if ( ! Global_AllocatorBuckets.append( bucket ) )
-					fatal( "Failed to append bucket to Global_AllocatorBuckets");
+					GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
 
 				last = & Global_AllocatorBuckets.back();
 			}
@@ -65,12 +71,74 @@ internal
 void define_constants()
 {
 	Code::Global          = make_code();
-	Code::Global->Name    = get_cached_string( txt_StrC("Global Code") );
+	Code::Global->Name    = get_cached_string( txt("Global Code") );
 	Code::Global->Content = Code::Global->Name;
 
 	Code::Invalid = make_code();
 	Code::Invalid.set_global();
 
+	t_empty          = (CodeType) make_code();
+	t_empty->Type    = ECode::Typename;
+	t_empty->Name    = get_cached_string( txt("") );
+	t_empty.set_global();
+
+	access_private       = make_code();
+	access_private->Type = ECode::Access_Private;
+	access_private->Name = get_cached_string( txt("private:") );
+	access_private.set_global();
+
+	access_protected       = make_code();
+	access_protected->Type = ECode::Access_Protected;
+	access_protected->Name = get_cached_string( txt("protected:") );
+	access_protected.set_global();
+
+	access_public       = make_code();
+	access_public->Type = ECode::Access_Public;
+	access_public->Name = get_cached_string( txt("public:") );
+	access_public.set_global();
+
+	attrib_api_export = def_attributes( code(GEN_API_Export_Code));
+	attrib_api_export.set_global();
+
+	attrib_api_import = def_attributes( code(GEN_API_Import_Code));
+	attrib_api_import.set_global();
+
+	module_global_fragment          = make_code();
+	module_global_fragment->Type    = ECode::Untyped;
+	module_global_fragment->Name    = get_cached_string( txt("module;") );
+	module_global_fragment->Content = module_global_fragment->Name;
+	module_global_fragment.set_global();
+
+	module_private_fragment          = make_code();
+	module_private_fragment->Type    = ECode::Untyped;
+	module_private_fragment->Name    = get_cached_string( txt("module : private;") );
+	module_private_fragment->Content = module_private_fragment->Name;
+	module_private_fragment.set_global();
+
+	fmt_newline = make_code();
+	fmt_newline->Type = ECode::NewLine;
+	fmt_newline.set_global();
+
+	pragma_once          = (CodePragma) make_code();
+	pragma_once->Type    = ECode::Preprocess_Pragma;
+	pragma_once->Name    = get_cached_string( txt("once") );
+	pragma_once->Content = pragma_once->Name;
+	pragma_once.set_global();
+
+	param_varadic            = (CodeType) make_code();
+	param_varadic->Type      = ECode::Parameters;
+	param_varadic->Name      = get_cached_string( txt("...") );
+	param_varadic->ValueType = t_empty;
+	param_varadic.set_global();
+
+	preprocess_else = (CodePreprocessCond) make_code();
+	preprocess_else->Type = ECode::Preprocess_Else;
+	preprocess_else.set_global();
+
+	preprocess_endif = (CodePreprocessCond) make_code();
+	preprocess_endif->Type = ECode::Preprocess_EndIf;
+	preprocess_endif.set_global();
+
 #	define def_constant_code_type( Type_ )   \
 		t_##Type_ = def_type( name(Type_) ); \
 		t_##Type_.set_global();
@@ -105,62 +173,16 @@ void define_constants()
 #endif
 #	undef def_constant_code_type
 
-	t_empty          = (CodeType) make_code();
-	t_empty->Type    = ECode::Typename;
-	t_empty->Name    = get_cached_string( txt_StrC("") );
-	t_empty.set_global();
-
-	param_varadic            = (CodeType) make_code();
-	param_varadic->Type      = ECode::Parameters;
-	param_varadic->Name      = get_cached_string( txt_StrC("...") );
-	param_varadic->ValueType = t_empty;
-	param_varadic.set_global();
-
-	attrib_api_export = def_attributes( code(GEN_API_Export_Code));
-	attrib_api_export.set_global();
-
-	attrib_api_import = def_attributes( code(GEN_API_Import_Code));
-	attrib_api_import.set_global();
-
-	access_private       = make_code();
-	access_private->Type = ECode::Access_Private;
-	access_private->Name = get_cached_string( txt_StrC("private:") );
-	access_private.set_global();
-
-	access_protected       = make_code();
-	access_protected->Type = ECode::Access_Protected;
-	access_protected->Name = get_cached_string( txt_StrC("protected:") );
-	access_protected.set_global();
-
-	access_public       = make_code();
-	access_public->Type = ECode::Access_Public;
-	access_public->Name = get_cached_string( txt_StrC("public:") );
-	access_public.set_global();
-
-	module_global_fragment          = make_code();
-	module_global_fragment->Type    = ECode::Untyped;
-	module_global_fragment->Name    = get_cached_string( txt_StrC("module;") );
-	module_global_fragment->Content = module_global_fragment->Name;
-	module_global_fragment.set_global();
-
-	module_private_fragment          = make_code();
-	module_private_fragment->Type    = ECode::Untyped;
-	module_private_fragment->Name    = get_cached_string( txt_StrC("module : private;") );
-	module_private_fragment->Content = module_private_fragment->Name;
-	module_private_fragment.set_global();
-
-	pragma_once          = make_code();
-	pragma_once->Type    = ECode::Untyped;
-	pragma_once->Name    = get_cached_string( txt_StrC("#pragma once") );
-	pragma_once->Content = pragma_once->Name;
-	pragma_once.set_global();
-
+#	pragma push_macro( "forceinline" )
 #	pragma push_macro( "global" )
 #	pragma push_macro( "internal" )
 #	pragma push_macro( "local_persist" )
+#	pragma push_macro( "neverinline" )
+#	undef forceinline
 #	undef global
 #	undef internal
 #	undef local_persist
+#	undef neverinline
 
 #	define def_constant_spec( Type_, ... )                                  \
 		spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
@@ -172,13 +194,16 @@ void define_constants()
 	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( 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 );
@@ -190,9 +215,11 @@ void define_constants()
 	spec_local_persist = def_specifiers( 1, ESpecifier::Local_Persist );
 	spec_local_persist.set_global();
 
+#	pragma pop_macro( "forceinline" )
 #	pragma pop_macro( "global" )
 #	pragma pop_macro( "internal" )
 #	pragma pop_macro( "local_persist" )
+#	pragma pop_macro( "neverinline" )
 
 #	undef def_constant_spec
 }
@@ -206,12 +233,12 @@ void init()
 		Global_AllocatorBuckets = Array<Arena>::init_reserve( heap(), 128 );
 
 		if ( Global_AllocatorBuckets == nullptr )
-			fatal( "Failed to reserve memory for Global_AllocatorBuckets");
+			GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
 
 		Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
 
 		if ( bucket.PhysicalStart == nullptr )
-			fatal( "Failed to create first bucket for Global_AllocatorBuckets");
+			GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
 
 		Global_AllocatorBuckets.append( bucket );
 
@@ -222,12 +249,12 @@ void init()
 		CodePools = Array<Pool>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
 
 		if ( CodePools == nullptr )
-			fatal( "gen::init: Failed to initialize the CodePools array" );
+			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
 
 		StringArenas = Array<Arena>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
 
 		if ( StringArenas == nullptr )
-			fatal( "gen::init: Failed to initialize the StringArenas array" );
+			GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
 	}
 
 	// Setup the code pool and code entries arena.
@@ -235,7 +262,7 @@ void init()
 		Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
 
 		if ( code_pool.PhysicalStart == nullptr )
-			fatal( "gen::init: Failed to initialize the code pool" );
+			GEN_FATAL( "gen::init: Failed to initialize the code pool" );
 
 		CodePools.append( code_pool );
 
@@ -244,7 +271,7 @@ void init()
 		Arena string_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
 		if ( string_arena.PhysicalStart == nullptr )
-			fatal( "gen::init: Failed to initialize the string arena" );
+			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
 
 		StringArenas.append( string_arena );
 	}
@@ -254,10 +281,11 @@ void init()
 		StringCache = StringTable::init( Allocator_StringTable );
 
 		if ( StringCache.Entries == nullptr )
-			fatal( "gen::init: Failed to initialize the StringCache");
+			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
 	}
 
 	define_constants();
+	init_parser();
 }
 
 void deinit()
@@ -300,6 +328,7 @@ void deinit()
 	while ( left--, left );
 
 	Global_AllocatorBuckets.free();
+	deinit_parser();
 }
 
 void reset()
@@ -340,7 +369,7 @@ AllocatorInfo get_string_allocator( s32 str_length )
 		Arena new_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
 		if ( ! StringArenas.append( new_arena ) )
-			fatal( "gen::get_string_allocator: Failed to allocate a new string arena" );
+			GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
 
 		last = & StringArenas.back();
 	}
@@ -366,9 +395,7 @@ StringCached get_cached_string( StrC str )
 	return result;
 }
 
-/*
-	Used internally to retireve a Code object form the CodePool.
-	*/
+// Used internally to retireve a Code object form the CodePool.
 Code make_code()
 {
 	Pool* allocator = & CodePools.back();
@@ -377,10 +404,10 @@ Code make_code()
 		Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
 
 		if ( code_pool.PhysicalStart == nullptr )
-			fatal( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
+			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
 
 		if ( ! CodePools.append( code_pool ) )
-			fatal( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
+			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
 
 		allocator = & CodePools.back();
 	}

project/components/interface.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "ast_types.hpp"
+
 #pragma region Gen Interface
 
 // Initialize the library.
@@ -45,6 +48,12 @@ CodeClass def_class( StrC name
 	, ModuleFlag     mflags       = ModuleFlag::None
 	, CodeType*      interfaces   = nullptr, s32 num_interfaces = 0 );
 
+CodeConstructor def_constructor( CodeParam params = NoCode, Code initializer_list = NoCode, Code body = NoCode );
+
+CodeDefine def_define( StrC name, StrC content );
+
+CodeDestructor def_destructor( Code body = NoCode, CodeSpecifiers specifiers = NoCode );
+
 CodeEnum def_enum( StrC name
 	, Code         body      = NoCode,      CodeType       type       = NoCode
 	, EnumT        specifier = EnumRegular, CodeAttributes attributes = NoCode
@@ -61,16 +70,20 @@ CodeFn def_function( StrC name
 
 CodeInclude   def_include  ( StrC content );
 CodeModule    def_module   ( StrC name,            ModuleFlag mflags = ModuleFlag::None );
-CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag::None );
+CodeNS        def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag::None );
 
-CodeOperator def_operator( OperatorT op
+CodeOperator def_operator( OperatorT op, StrC nspace
 	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
 	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
 	, ModuleFlag     mflags     = ModuleFlag::None );
 
 CodeOpCast def_operator_cast( CodeType type, Code body = NoCode, CodeSpecifiers specs = NoCode );
 
-CodeParam      def_param    ( CodeType type, StrC name, Code value = NoCode );
+CodeParam  def_param ( CodeType type, StrC name, Code value = NoCode );
+CodePragma def_pragma( StrC directive );
+
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
+
 CodeSpecifiers def_specifier( SpecifierT specifier );
 
 CodeStruct def_struct( StrC name
@@ -130,29 +143,32 @@ CodeBody       def_union_body      ( s32 num, Code* codes );
 
 #pragma region Parsing
 
-CodeClass     parse_class        ( StrC class_def     );
-CodeEnum      parse_enum         ( StrC enum_def      );
-CodeBody      parse_export_body  ( StrC export_def    );
-CodeExtern    parse_extern_link  ( StrC exten_link_def);
-CodeFriend    parse_friend       ( StrC friend_def    );
-CodeFn        parse_function     ( StrC fn_def        );
-CodeBody      parse_global_body  ( StrC body_def      );
-CodeNamespace parse_namespace    ( StrC namespace_def );
-CodeOperator  parse_operator     ( StrC operator_def  );
-CodeOpCast    parse_operator_cast( StrC operator_def  );
-CodeStruct    parse_struct       ( StrC struct_def    );
-CodeTemplate  parse_template     ( StrC template_def  );
-CodeType      parse_type         ( StrC type_def      );
-CodeTypedef   parse_typedef      ( StrC typedef_def   );
-CodeUnion     parse_union        ( StrC union_def     );
-CodeUsing     parse_using        ( StrC using_def     );
-CodeVar       parse_variable     ( StrC var_def       );
+CodeClass       parse_class        ( StrC class_def       );
+CodeConstructor parse_constructor  ( StrC constructor_def );
+CodeDestructor  parse_destructor   ( StrC destructor_def  );
+CodeEnum        parse_enum         ( StrC enum_def        );
+CodeBody        parse_export_body  ( StrC export_def      );
+CodeExtern      parse_extern_link  ( StrC exten_link_def  );
+CodeFriend      parse_friend       ( StrC friend_def      );
+CodeFn          parse_function     ( StrC fn_def          );
+CodeBody        parse_global_body  ( StrC body_def        );
+CodeNS          parse_namespace    ( StrC namespace_def   );
+CodeOperator    parse_operator     ( StrC operator_def    );
+CodeOpCast      parse_operator_cast( StrC operator_def    );
+CodeStruct      parse_struct       ( StrC struct_def      );
+CodeTemplate    parse_template     ( StrC template_def    );
+CodeType        parse_type         ( StrC type_def        );
+CodeTypedef     parse_typedef      ( StrC typedef_def     );
+CodeUnion       parse_union        ( StrC union_def       );
+CodeUsing       parse_using        ( StrC using_def       );
+CodeVar         parse_variable     ( StrC var_def         );
 
 #pragma endregion Parsing
 
 #pragma region Untyped text
 
 sw   token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
+//! Do not use directly. Use the token_fmt macro instead.
 StrC token_fmt_impl( sw, ... );
 
 Code untyped_str      ( StrC content);

project/components/interface.untyped.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "interface.parsing.cpp"
+
 sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 {
 	char const* buf_begin = buf;
@@ -99,17 +102,35 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 
 Code untyped_str( StrC content )
 {
+	if ( content.Len == 0 )
+	{
+		log_failure( "untyped_str: empty string" );
+		return CodeInvalid;
+	}
+
 	Code
 	result          = make_code();
 	result->Name    = get_cached_string( content );
 	result->Type    = ECode::Untyped;
 	result->Content = result->Name;
 
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_str: could not cache string" );
+		return CodeInvalid;
+	}
+
 	return result;
 }
 
 Code untyped_fmt( char const* fmt, ...)
 {
+	if ( fmt == nullptr )
+	{
+		log_failure( "untyped_fmt: null format string" );
+		return CodeInvalid;
+	}
+
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
 
@@ -124,11 +145,23 @@ Code untyped_fmt( char const* fmt, ...)
 	result->Type    = ECode::Untyped;
 	result->Content = get_cached_string( { length, buf } );
 
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return CodeInvalid;
+	}
+
 	return result;
 }
 
 Code untyped_token_fmt( s32 num_tokens, ... )
 {
+	if ( num_tokens == 0 )
+	{
+		log_failure( "untyped_token_fmt: zero tokens" );
+		return CodeInvalid;
+	}
+
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
 
@@ -143,5 +176,11 @@ Code untyped_token_fmt( s32 num_tokens, ... )
 	result->Type    = ECode::Untyped;
 	result->Content = result->Name;
 
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return CodeInvalid;
+	}
+
 	return result;
 }

project/components/interface.upfront.cpp

@@ -1,3 +1,8 @@
+#pragma once
+#include "interface.cpp"
+
+#pragma region Upfront
+
 enum class OpValidateResult : u32
 {
 	Fail,
@@ -5,7 +10,6 @@ enum class OpValidateResult : u32
 	Member
 };
 
-inline
 OpValidateResult operator__validate( OperatorT op, CodeParam params_code, CodeType ret_type, CodeSpecifiers specifier )
 {
 	using namespace EOperator;
@@ -375,7 +379,7 @@ OpValidateResult operator__validate( OperatorT op, CodeParam params_code, CodeTy
 
 
 /*
-The implementaiton of the upfront constructors involves bascially doing three things:
+The implementaiton of the upfront constructors involves doing three things:
 * Validate the arguments given to construct the intended type of AST is valid.
 * Construct said AST type.
 * Lock the AST (set to readonly) and return the valid object.
@@ -420,6 +424,53 @@ CodeComment def_comment( StrC content )
 	return (CodeComment) result;
 }
 
+CodeConstructor def_constructor( CodeParam params, Code initializer_list, Code body )
+{
+	using namespace ECode;
+
+	if ( params && params->Type != Parameters )
+	{
+		log_failure("gen::def_constructor: params must be of Parameters type - %s", params.debug_str());
+		return CodeInvalid;
+	}
+
+	CodeConstructor
+	result = (CodeConstructor) make_code();
+
+	if ( params )
+	{
+		result->Params = params;
+	}
+
+	if ( initializer_list )
+	{
+		result->InitializerList = initializer_list;
+	}
+
+	if ( body )
+	{
+		switch ( body->Type )
+		{
+			case Function_Body:
+			case Untyped:
+			break;
+
+			default:
+				log_failure("gen::def_constructor: body must be either of Function_Body or Untyped type - %s", body.debug_str());
+				return CodeInvalid;
+		}
+
+		result->Type = Constructor;
+		result->Body = body;
+	}
+	else
+	{
+		result->Type = Constructor_Fwd;
+	}
+
+	return result;
+}
+
 CodeClass def_class( StrC name
 	, Code           body
 	, CodeType       parent, AccessSpec parent_access
@@ -489,6 +540,66 @@ CodeClass def_class( StrC name
 	return result;
 }
 
+CodeDefine def_define( StrC name, StrC content )
+{
+	using namespace ECode;
+
+	name_check( def_define, name );
+
+	if ( content.Len <= 0 || content.Ptr == nullptr )
+	{
+		log_failure( "gen::def_define: Invalid value provided" );
+		return CodeInvalid;
+	}
+
+	CodeDefine
+	result          = (CodeDefine) make_code();
+	result->Type    = Preprocess_Define;
+	result->Name    = get_cached_string( name );
+	result->Content = get_cached_string( content );
+
+	return result;
+}
+
+CodeDestructor def_destructor( Code body, CodeSpecifiers specifiers )
+{
+	using namespace ECode;
+
+	if ( specifiers && specifiers->Type != Specifiers )
+	{
+		log_failure( "gen::def_destructor: specifiers was not a 'Specifiers' type: %s", specifiers.debug_str() );
+		return CodeInvalid;
+	}
+
+	CodeDestructor result = (CodeDestructor) make_code();
+
+	if ( specifiers )
+		result->Specs = specifiers;
+
+	if ( body )
+	{
+		switch ( body->Type )
+		{
+			case Function_Body:
+			case Untyped:
+			break;
+
+			default:
+				log_failure("gen::def_destructor: body must be either of Function_Body or Untyped type - %s", body.debug_str());
+				return CodeInvalid;
+		}
+
+		result->Type = Destructor;
+		result->Body = body;
+	}
+	else
+	{
+		result->Type = Destructor_Fwd;
+	}
+
+	return result;
+}
+
 CodeEnum def_enum( StrC name
 	, Code       body,      CodeType       type
 	, EnumT      specifier, CodeAttributes attributes
@@ -719,7 +830,7 @@ CodeInclude def_include ( StrC path )
 
 	Code
 	result          = make_code();
-	result->Type    = ECode::Preprocessor_Include;
+	result->Type    = ECode::Preprocess_Include;
 	result->Name    = get_cached_string( path );
 	result->Content = result->Name;
 
@@ -740,7 +851,7 @@ CodeModule def_module( StrC name, ModuleFlag mflags )
 	return (CodeModule) result;
 }
 
-CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags )
+CodeNS def_namespace( StrC name, Code body, ModuleFlag mflags )
 {
 	using namespace ECode;
 
@@ -753,8 +864,8 @@ CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags )
 		return CodeInvalid;
 	}
 
-	CodeNamespace
-	result              = (CodeNamespace) make_code();
+	CodeNS
+	result              = (CodeNS) make_code();
 	result->Type        = Namespace;
 	result->Name        = get_cached_string( name );
 	result->ModuleFlags = mflags;
@@ -763,7 +874,7 @@ CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags )
 	return result;
 }
 
-CodeOperator def_operator( OperatorT op
+CodeOperator def_operator( OperatorT op, StrC nspace
 	, CodeParam      params_code, CodeType       ret_type, Code body
 	, CodeSpecifiers specifiers,  CodeAttributes attributes
 	, ModuleFlag     mflags )
@@ -789,8 +900,13 @@ CodeOperator def_operator( OperatorT op
 		return CodeInvalid;
 	}
 
-	char const* name = str_fmt_buf( "operator %s", to_str(op) );
+	char const* name = nullptr;
 
+	StrC op_str = to_str( op );
+	if ( nspace.Len > 0 )
+		name = str_fmt_buf( "%.*soperator %.*s", nspace.Len, nspace.Ptr, op_str.Len, op_str.Ptr );
+	else
+		name = str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr );
 	CodeOperator
 	result              = (CodeOperator) make_code();
 	result->Name        = get_cached_string( { str_len(name), name } );
@@ -910,6 +1026,57 @@ CodeParam def_param( CodeType type, StrC name, Code value )
 	return result;
 }
 
+CodePragma def_pragma( StrC directive )
+{
+	using namespace ECode;
+
+	if ( directive.Len <= 0 || directive.Ptr == nullptr )
+	{
+		log_failure( "gen::def_comment: Invalid comment provided:" );
+		return CodeInvalid;
+	}
+
+	CodePragma
+	result          = (CodePragma) make_code();
+	result->Type    = Preprocess_Pragma;
+	result->Content = get_cached_string( directive );
+
+	return result;
+}
+
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
+{
+	using namespace ECode;
+
+	if ( expr.Len <= 0 || expr.Ptr == nullptr )
+	{
+		log_failure( "gen::def_comment: Invalid comment provided:" );
+		return CodeInvalid;
+	}
+
+	CodePreprocessCond
+	result          = (CodePreprocessCond) make_code();
+	result->Content = get_cached_string( expr );
+
+	switch (type)
+	{
+		case EPreprocessCond::If:
+			result->Type = Preprocess_If;
+		break;
+		case EPreprocessCond::IfDef:
+			result->Type = Preprocess_IfDef;
+		break;
+		case EPreprocessCond::IfNotDef:
+			result->Type = Preprocess_IfNotDef;
+		break;
+		case EPreprocessCond::ElIf:
+			result->Type = Preprocess_ElIf;
+		break;
+	}
+
+	return result;
+}
+
 CodeSpecifiers def_specifier( SpecifierT spec )
 {
 	CodeSpecifiers
@@ -1060,7 +1227,6 @@ CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes, Module
 {
 	using namespace ECode;
 
-	name_check( def_typedef, name );
 	null_check( def_typedef, type );
 
 	switch ( type->Type )
@@ -1099,12 +1265,28 @@ CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes, Module
 
 	CodeTypedef
 	result              = (CodeTypedef) make_code();
-	result->Name        = get_cached_string( name );
 	result->Type        = ECode::Typedef;
 	result->ModuleFlags = mflags;
 
 	result->UnderlyingType = type;
 
+	if ( name.Len <= 0  )
+	{
+		if (type->Type != Untyped)
+		{
+			log_failure( "gen::def_typedef: name was empty and type was not untyped (indicating its a function typedef) - %s", type.debug_str() );
+			return CodeInvalid;
+		}
+
+		result->Name       = get_cached_string( type->Name );
+		result->IsFunction = true;
+	}
+	else
+	{
+		result->Name       = get_cached_string( name );
+		result->IsFunction = false;
+	}
+
 	return result;
 }
 
@@ -1239,27 +1421,6 @@ CodeVar def_variable( CodeType type, StrC name, Code value
 	return result;
 }
 
-/*
-Body related functions typically follow the same implementation pattern.
-Opted to use inline helper macros to get the implementaiton done.
-
-The implementation pattern is as follows:
-* Validate a valid parameter num was provided, or code array
-	def_body_start or def_body_code_array_start( <name of function >)
-
-* Begin the code entry do-while loop, make sure each entry is valid processing its type in the switc
-	def_body_code_validation_start( <name of function> )
-
-* Define the switch case statements between the macros.
-
-* Add the code entry, finish the closing implemenation for the do-while loop.
-	def_body_code_validation_end( <name of function> )
-
-* Lock the body AST and return it.
-
-If a function's implementation deviates from the macros then its just writen it out.
-*/
-
 #pragma region Helper Macros for def_**_body functions
 #define def_body_start( Name_ )                                               \
 using namespace ECode;                                                        \
@@ -1285,61 +1446,43 @@ if ( codes == nullptr )                                                        \
 	return CodeInvalid;                                                        \
 }
 
-#define def_body_code_validation_start( Name_ )                               \
-do                                                                            \
-{                                                                             \
-	Code_POD pod   = va_arg(va, Code_POD);                                    \
-	Code     entry = pcast(Code, pod);                                        \
-																			  \
-	if ( ! entry )                                                            \
-	{                                                                         \
-		log_failure("gen::" stringize(Name_) ": Provided an null entry");     \
-		return CodeInvalid;                                                   \
-	}                                                                         \
-																			  \
-	switch ( entry->Type )                                                    \
-	{
-
-#define def_body_code_array_validation_start( Name_ )                         \
-do                                                                            \
-{                                                                             \
-	Code entry = *codes; codes++;                                             \
-																			  \
-	if ( ! entry )                                                            \
-	{                                                                         \
-		log_failure("gen::" stringize(Name_) ": Provided an null entry");     \
-		return CodeInvalid;                                                   \
-	}                                                                         \
-																			  \
-	switch ( entry->Type )                                                    \
-	{
-
-#define def_body_code_validation_end( Name_ )                                                             \
-			log_failure("gen::" stringize(Name_) ": Entry type is not allowed: %s", entry.debug_str() );  \
-			return CodeInvalid;                                                                           \
-																										  \
-		default:                                                                                          \
-			break;                                                                                        \
-	}                                                                                                     \
-																										  \
-	result.append( entry );                                                                               \
-}                                                                                                         \
-while ( num--, num > 0 )
 #pragma endregion Helper Macros for def_**_body functions
 
 CodeBody def_class_body( s32 num, ... )
 {
 	def_body_start( def_class_body );
 
-	CodeBody
-	result       = (CodeBody) make_code();
-	result->Type = Class_Body;
+	CodeBody result = ( CodeBody )make_code();
+	result->Type    = Class_Body;
 
 	va_list va;
-	va_start(va, num);
-	def_body_code_validation_start( def_class_body );
-		GEN_AST_BODY_CLASS_UNALLOWED_TYPES
-	def_body_code_validation_end( def_class_body );
+	va_start( va, num );
+	do
+	{
+		Code_POD pod   = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::"
+						"def_class_body"
+						": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_CLASS_UNALLOWED_TYPES
+				log_failure("gen::" "def_class_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1353,9 +1496,30 @@ CodeBody def_class_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Function_Body;
 
-	def_body_code_array_validation_start( def_class_body );
-		GEN_AST_BODY_CLASS_UNALLOWED_TYPES
-	def_body_code_validation_end( def_class_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_class_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_CLASS_UNALLOWED_TYPES
+				log_failure("gen::" "def_class_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1383,7 +1547,7 @@ CodeBody def_enum_body( s32 num, ... )
 
 		if ( entry->Type != Untyped && entry->Type != Comment )
 		{
-			log_failure("gen::def_enum_body: Entry type is not allowed - %s. Must be of untyped or comment type.", entry.debug_str() ); \
+			log_failure("gen::def_enum_body: Entry type is not allowed - %s. Must be of untyped or comment type.", entry.debug_str() );
 			return CodeInvalid;
 		}
 
@@ -1415,7 +1579,7 @@ CodeBody def_enum_body( s32 num, Code* codes )
 
 		if ( entry->Type != Untyped && entry->Type != Comment )
 		{
-			log_failure("gen::def_enum_body: Entry type is not allowed: %s", entry.debug_str() ); \
+			log_failure("gen::def_enum_body: Entry type is not allowed: %s", entry.debug_str() );
 			return CodeInvalid;
 		}
 
@@ -1436,9 +1600,30 @@ CodeBody def_export_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_export_body );
-		GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
-	def_body_code_validation_end( def_export_body );
+	do
+	{
+		Code_POD pod = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_export_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
+				log_failure("gen::" "def_export_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1452,9 +1637,30 @@ CodeBody def_export_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Export_Body;
 
-	def_body_code_array_validation_start( def_export_body );
-		GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
-	def_body_code_validation_end( def_export_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_export_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
+				log_failure("gen::" "def_export_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1469,9 +1675,30 @@ CodeBody def_extern_link_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_extern_linkage_body );
-		GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
-	def_body_code_validation_end( def_extern_linkage_body );
+	do
+	{
+		Code_POD pod = va_arg(va, Code_POD);
+		Code entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
+				log_failure("gen::" "def_extern_linkage_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1485,9 +1712,31 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Extern_Linkage_Body;
 
-	def_body_code_array_validation_start( def_extern_linkage_body );
-		GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
-	def_body_code_validation_end( def_extern_linkage_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
+				log_failure("gen::" "def_extern_linkage_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1502,9 +1751,31 @@ CodeBody def_function_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_function_body );
-		GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
-	def_body_code_validation_end( def_function_body );
+	do
+	{
+		Code_POD pod   = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" stringize(def_function_body) ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+
+			GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
+				log_failure("gen::" stringize(def_function_body) ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1518,9 +1789,29 @@ CodeBody def_function_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Function_Body;
 
-	def_body_code_array_validation_start( def_function_body );
-		GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
-	def_body_code_validation_end( def_function_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_function_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
+				log_failure("gen::" "def_function_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1535,9 +1826,34 @@ CodeBody def_global_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_global_body );
-		GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
-	def_body_code_validation_end( def_global_body );
+	do
+	{
+		Code_POD pod   = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_global_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			case Global_Body:
+				result.append( entry.cast<CodeBody>() ) ;
+				continue;
+
+			GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
+				log_failure("gen::" "def_global_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return (*Code::Invalid.ast);
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1551,9 +1867,34 @@ CodeBody def_global_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Global_Body;
 
-	def_body_code_array_validation_start( def_global_body );
-		GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
-	def_body_code_validation_end( def_global_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_global_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			case Global_Body:
+				result.append( entry.cast<CodeBody>() ) ;
+				continue;
+
+			GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
+				log_failure("gen::" "def_global_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1568,9 +1909,30 @@ CodeBody def_namespace_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_namespace_body );
-		GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
-	def_body_code_validation_end( def_namespace_body );
+	do
+	{
+		Code_POD pod   = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_namespace_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
+				log_failure("gen::" "def_namespace_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1584,9 +1946,29 @@ CodeBody def_namespace_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Global_Body;
 
-	def_body_code_array_validation_start( def_namespace_body );
-		GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
-	def_body_code_validation_end( def_namespace_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_namespace_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
+				log_failure("gen::" "def_namespace_body" ": Entry type is not allowed: %s", entry.debug_str() );
+				return CodeInvalid;
+
+			default: break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1736,9 +2118,30 @@ CodeBody def_struct_body( s32 num, ... )
 
 	va_list va;
 	va_start(va, num);
-	def_body_code_validation_start( def_struct_body );
-		GEN_AST_BODY_STRUCT_UNALLOWED_TYPES
-	def_body_code_validation_end( def_struct_body );
+	do
+	{
+		Code_POD pod   = va_arg(va, Code_POD);
+		Code     entry = pcast(Code, pod);
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_struct_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_STRUCT_UNALLOWED_TYPES
+				log_failure("gen::" "def_struct_body" ": Entry type is not allowed: %s", entry.debug_str());
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 	va_end(va);
 
 	return result;
@@ -1752,9 +2155,30 @@ CodeBody def_struct_body( s32 num, Code* codes )
 	result       = (CodeBody) make_code();
 	result->Type = Struct_Body;
 
-	def_body_code_array_validation_start( def_struct_body );
-		GEN_AST_BODY_STRUCT_UNALLOWED_TYPES
-	def_body_code_validation_end( def_struct_body );
+	do
+	{
+		Code entry = *codes;
+		codes++;
+
+		if (!entry)
+		{
+			log_failure("gen::" "def_struct_body" ": Provided an null entry");
+			return CodeInvalid;
+		}
+
+		switch (entry->Type)
+		{
+			GEN_AST_BODY_STRUCT_UNALLOWED_TYPES
+				log_failure("gen::" "def_struct_body" ": Entry type is not allowed: %s", entry.debug_str() );
+				return CodeInvalid;
+
+			default:
+			break;
+		}
+
+		result.append(entry);
+	}
+	while (num--, num > 0);
 
 	return result;
 }
@@ -1782,7 +2206,7 @@ CodeBody def_union_body( s32 num, ... )
 
 		if ( entry->Type != Untyped && entry->Type != Comment )
 		{
-			log_failure("gen::def_union_body: Entry type is not allowed - %s. Must be of untyped or comment type.", entry.debug_str() ); \
+			log_failure("gen::def_union_body: Entry type is not allowed - %s. Must be of untyped or comment type.", entry.debug_str() );
 			return CodeInvalid;
 		}
 
@@ -1828,3 +2252,7 @@ CodeBody def_union_body( s32 num, CodeUnion* codes )
 #	undef name_check
 #	undef null_check
 #	undef null_or_invalid_check
+#	undef def_body_start
+#	undef def_body_code_array_start
+
+#pragma endregion Upfront

project/components/src_start.cpp

@@ -2,8 +2,11 @@
 #	error Gen.hpp : GEN_TIME not defined
 #endif
 
+#include "gen.hpp"
+
 //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
 //! Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 #	include "gen.dep.cpp"
 #endif
+

project/components/static_data.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "gen.hpp"
+
 #pragma region StaticData
 
 // TODO : Convert global allocation strategy to use a slab allocation strategy.
@@ -22,6 +25,49 @@ global AllocatorInfo Allocator_TypeTable   = heap();
 
 #pragma region Constants
 
+global Code access_public;
+global Code access_protected;
+global Code access_private;
+
+global CodeAttributes attrib_api_export;
+global CodeAttributes attrib_api_import;
+
+global Code module_global_fragment;
+global Code module_private_fragment;
+
+global Code fmt_newline;
+
+global CodeParam param_varadic;
+
+global CodePragma pragma_once;
+
+global CodePreprocessCond preprocess_else;
+global CodePreprocessCond preprocess_endif;
+
+global CodeSpecifiers spec_const;
+global CodeSpecifiers spec_consteval;
+global CodeSpecifiers spec_constexpr;
+global CodeSpecifiers spec_constinit;
+global CodeSpecifiers spec_extern_linkage;
+global CodeSpecifiers spec_final;
+global CodeSpecifiers spec_forceinline;
+global CodeSpecifiers spec_global;
+global CodeSpecifiers spec_inline;
+global CodeSpecifiers spec_internal_linkage;
+global CodeSpecifiers spec_local_persist;
+global CodeSpecifiers spec_mutable;
+global CodeSpecifiers spec_neverinline;
+global CodeSpecifiers spec_override;
+global CodeSpecifiers spec_ptr;
+global CodeSpecifiers spec_pure;
+global CodeSpecifiers spec_ref;
+global CodeSpecifiers spec_register;
+global CodeSpecifiers spec_rvalue;
+global CodeSpecifiers spec_static_member;
+global CodeSpecifiers spec_thread_local;
+global CodeSpecifiers spec_virtual;
+global CodeSpecifiers spec_volatile;
+
 global CodeType t_empty;
 global CodeType t_auto;
 global CodeType t_void;
@@ -52,39 +98,4 @@ global CodeType t_f32;
 global CodeType t_f64;
 #endif
 
-global CodeParam param_varadic;
-
-global CodeAttributes attrib_api_export;
-global CodeAttributes attrib_api_import;
-
-global Code access_public;
-global Code access_protected;
-global Code access_private;
-
-global Code module_global_fragment;
-global Code module_private_fragment;
-
-global Code pragma_once;
-
-global CodeSpecifiers spec_const;
-global CodeSpecifiers spec_consteval;
-global CodeSpecifiers spec_constexpr;
-global CodeSpecifiers spec_constinit;
-global CodeSpecifiers spec_extern_linkage;
-global CodeSpecifiers spec_final;
-global CodeSpecifiers spec_global;
-global CodeSpecifiers spec_inline;
-global CodeSpecifiers spec_internal_linkage;
-global CodeSpecifiers spec_local_persist;
-global CodeSpecifiers spec_mutable;
-global CodeSpecifiers spec_override;
-global CodeSpecifiers spec_ptr;
-global CodeSpecifiers spec_ref;
-global CodeSpecifiers spec_register;
-global CodeSpecifiers spec_rvalue;
-global CodeSpecifiers spec_static_member;
-global CodeSpecifiers spec_thread_local;
-global CodeSpecifiers spec_virtual;
-global CodeSpecifiers spec_volatile;
-
 #pragma endregion Constants

project/components/types.hpp

@@ -1,23 +1,16 @@
+#pragma once
+#include "header_start.hpp"
+
 using LogFailType = sw(*)(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 fatal, fatal will still be used for memory failures as the library is unusable when they occur.
+// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
 #ifdef GEN_DONT_USE_FATAL
-	constexpr LogFailType log_failure = log_fmt;
+	#define log_failure log_fmt
 #else
-	constexpr LogFailType log_failure = fatal;
+	#define log_failure GEN_FATAL
 #endif
 
-// Used to indicate if enum definitoin is an enum class or regular enum.
-enum class EnumT : u8
-{
-	Regular,
-	Class
-};
-
-constexpr EnumT EnumClass   = EnumT::Class;
-constexpr EnumT EnumRegular = EnumT::Regular;
-
 enum class AccessSpec : u32
 {
 	Default,
@@ -46,6 +39,16 @@ char const* to_str( AccessSpec type )
 	return lookup[ (u32)type ];
 }
 
+// Used to indicate if enum definitoin is an enum class or regular enum.
+enum class EnumT : u8
+{
+	Regular,
+	Class
+};
+
+constexpr EnumT EnumClass   = EnumT::Class;
+constexpr EnumT EnumRegular = EnumT::Regular;
+
 enum class ModuleFlag : u32
 {
 	None    = 0,
@@ -62,41 +65,15 @@ ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
 	return (ModuleFlag)( (u32)A | (u32)B );
 }
 
-/*
-	Predefined attributes
-	Used for the parser constructors to identify non-standard attributes
+enum class EPreprocessCond : u32
+{
+	If,
+	IfDef,
+	IfNotDef,
+	ElIf
+};
 
-	Override these to change the attribute to your own unique identifier convention.
-
-	The tokenizer identifies attribute defines with the GEN_DEFINE_ATTRIBUTE_TOKENS macros.
-	See the example below and the Define_TokType macro used in gen.cpp to know the format.
-	While the library can parse raw attributes, most projects use defines to wrap them for compiler
-	platform indendence. The token define allows support for them without having to modify the library.
-*/
-#if defined(GEN_SYSTEM_WINDOWS) || defined( __CYGWIN__ )
-#ifndef GEN_Attribute_Keyword
-#	define GEN_API_Export_Code   __declspec(dllexport)
-#	define GEN_API_Import_Code   __declspec(dllimport)
-#	define GEN_Attribute_Keyword __declspec
-#endif
-
-constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword);
-
-#elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 )
-#ifndef GEN_Attribute_Keyword
-#	define GEN_API_Export_Code   __attribute__ ((visibility ("default")))
-#	define GEN_API_Import_Code   __attribute__ ((visibility ("default")))
-#	define GEN_Attribute_Keyword __attribute__
-#endif
-
-constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword );
-
-#else
-#ifndef GEN_Attribute_Keyword
-#	define GEN_API_Export_Code
-#	define GEN_API_Import_Code
-#	define GEN_Attribute_Keyword
-#endif
-
-constexpr char const* Attribute_Keyword = "";
-#endif
+constexpr EPreprocessCond PreprocessCond_If       = EPreprocessCond::If;
+constexpr EPreprocessCond PreprocessCond_IfDef    = EPreprocessCond::IfDef;
+constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
+constexpr EPreprocessCond PreprocessCond_ElIf     = EPreprocessCond::ElIf;

project/dependencies/basic_types.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "macros.hpp"
+
 #pragma region Basic Types
 
 #define GEN_U8_MIN 0u
@@ -117,4 +120,4 @@ typedef s8  b8;
 typedef s16 b16;
 typedef s32 b32;
 
-#pragma region Basic Types
+#pragma endregion Basic Types

project/dependencies/containers.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "printing.hpp"
+
 #pragma region Containers
 
 template<class Type>
@@ -424,9 +427,16 @@ struct HashTable
 
 		for ( idx = 0; idx < Entries.num(); idx++ )
 		{
-			Entry* entry;
-
+			Entry*     entry;
 			FindResult find_result;
+
+			entry       = & Entries[ idx ];
+			find_result = find( entry->Key );
+
+			if ( find_result.PrevIndex < 0 )
+				Hashes[ find_result.HashIndex ] = idx;
+			else
+				Entries[ find_result.PrevIndex ].Next = idx;
 		}
 	}
 

project/dependencies/debug.cpp

@@ -1,4 +1,6 @@
-#pragma endregion Debug
+#pragma once
+
+#pragma region Debug
 
 void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... )
 {

project/dependencies/debug.hpp

@@ -1,4 +1,7 @@
-#pragma endregion Debug
+#pragma once
+#include "basic_types.hpp"
+
+#pragma region Debug
 
 #if defined( _MSC_VER )
 #	if _MSC_VER < 1300
@@ -33,4 +36,26 @@ void assert_handler( char const* condition, char const* file, s32 line, char con
 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__); \
+		GEN_PANIC(buf);                                    \
+	}                                                      \
+	while (0)
+#else
+
+#	define GEN_FATAL( ... )                  \
+	do                                       \
+	{										 \
+		str_fmt_out_err( __VA_ARGS__ );      \
+		process_exit(1);                     \
+	}             					         \
+	while (0)
+#endif
+
 #pragma endregion Debug

project/dependencies/filesystem.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "strings.cpp"
+
 #pragma region File Handling
 
 #if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
@@ -224,7 +227,7 @@ internal GEN_FILE_CLOSE_PROC( _posix_file_close )
 
 FileOperations const default_file_operations = { _posix_file_read, _posix_file_write, _posix_file_seek, _posix_file_close };
 
-GEN_NEVER_INLINE GEN_FILE_OPEN_PROC( _posix_file_open )
+neverinline GEN_FILE_OPEN_PROC( _posix_file_open )
 {
 	s32 os_mode;
 	switch ( mode & GEN_FILE_MODES )

project/dependencies/filesystem.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "strings.hpp"
+
 #pragma region File Handling
 
 typedef u32 FileMode;

project/dependencies/hashing.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "memory.cpp"
+
 #pragma region Hashing
 
 global u32 const _crc32_table[ 256 ] = {
@@ -82,4 +85,4 @@ u64 crc64( void const* data, sw len )
 	return result;
 }
 
-#pragma region Hashing
+#pragma endregion Hashing

project/dependencies/hashing.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "containers.hpp"
+
 #pragma region Hashing
 
 u32 crc32( void const* data, sw len );

project/dependencies/header_start.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region Platform Detection
 
 /* Platform architecture */
@@ -100,32 +102,25 @@
 #define GEN_DEF_INLINE  static
 #define GEN_IMPL_INLINE static inline
 
-#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
-
 #pragma endregion Platform Detection
 
 #pragma region Mandatory Includes
+
 #	include <stdarg.h>
 #	include <stddef.h>
 
 #	if defined( GEN_SYSTEM_WINDOWS )
 #		include <intrin.h>
 #	endif
+
 #pragma endregion Mandatory Includes
+
+#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

project/dependencies/macros.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "header_start.hpp"
+
 #pragma region Macros
 
 #define zpl_cast( Type ) ( Type )
@@ -8,53 +11,103 @@
 #define internal      static    // Internal linkage
 #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
 
 #define bit( Value )                             ( 1 << Value )
 #define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
 
 // 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 )
 
 // Num Arguments (Varadics)
-#if defined(__GNUC__) || defined(__clang__)
-// Supports 0-10 arguments
-#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, \
-		N, ...                                            \
+// #if defined(__GNUC__) || defined(__clang__)
+// Supports 0-50 arguments
+#define num_args_impl( _0,                                 \
+		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,   \
+		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20,  \
+		_21, _22, _23, _24, _25, _26, _27, _28, _29, _30,  \
+		_31, _32, _33, _34, _35, _36, _37, _38, _39, _40,  \
+		_41, _42, _43, _44, _45, _46, _47, _48, _49, _50,  \
+		_51, _52, _53, _54, _55, _56, _57, _58, _59, _60,  \
+		_61, _62, _63, _64, _65, _66, _67, _68, _69, _70,  \
+		_71, _72, _73, _74, _75, _76, _77, _78, _79, _80,  \
+		_81, _82, _83, _84, _85, _86, _87, _88, _89, _90,  \
+		_91, _92, _93, _94, _95, _96, _97, _98, _99, _100, \
+		N, ...                                             \
 	) N
-	// _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,
 
 	// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
-#define num_args(...)                           \
-	num_args_impl(_, ## __VA_ARGS__,            \
-		20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
-		10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
-		0                                       \
+#define num_args(...)                            \
+	num_args_impl(_, ## __VA_ARGS__,             \
+		100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
+		 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, \
+		 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, \
+		 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
+		 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
+		 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
+		 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
+		 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
+		 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
+		 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
+		 0                                       \
 	)
-	// 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,
-#else
-// Supports 1-10 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, \
-		N, ...                                            \
-	) N
 
-#define num_args(...)                           \
-	num_args_impl( __VA_ARGS__,                 \
-		20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
-		10,  9,  8,  7,  6,  5,  4,  3,  2,  1  \
-	)
-#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__
@@ -86,6 +139,9 @@
 	}                      \
 	while(0);
 
+#define labeled_scope_start if ( false ) {
+#define labeled_scope_end   }
+
 #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 ] ) ) ) ) )
 #define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
@@ -93,6 +149,12 @@
 #define min( a, b )                   ( ( a ) < ( b ) ? ( a ) : ( b ) )
 #define size_of( x )                  ( sw )( sizeof( x ) )
 
+#if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
+#	define offset_of( Type, element ) ( ( GEN_NS( gen_sw ) ) & ( ( ( Type* )0 )->element ) )
+#else
+#	define offset_of( Type, element ) __builtin_offsetof( Type, element )
+#endif
+
 template< class Type >
 void swap( Type& a, Type& b )
 {

project/dependencies/memory.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "printing.cpp"
+
 #pragma region Memory
 
 void* mem_copy( void* dest, void const* source, sw n )
@@ -221,7 +224,7 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
 				if ( arena->TotalUsed + total_size > (sw) arena->TotalSize )
 				{
 					// zpl__printf_err("%s", "Arena out of memory\n");
-					fatal("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
+					GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
 					return nullptr;
 				}
 

project/dependencies/memory.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "debug.hpp"
+
 #pragma region Memory
 
 #define kilobytes( x ) ( ( x ) * ( s64 )( 1024 ) )

project/dependencies/parsing.cpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region ADT
 
 #define _adt_fprintf( s_, fmt_, ... )                      \
@@ -799,7 +801,6 @@ ADT_Error adt_str_to_number_strict( ADT_Node* node )
 #	define GEN_CSV_ASSERT( msg )
 #endif
 
-
 u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim )
 {
 	CSV_Error error = ECSV_Error__NONE;
@@ -1104,3 +1105,4 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
 }
 
 #pragma endregion CSV
+

project/dependencies/parsing.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region ADT
 
 enum ADT_Type : u32
@@ -423,3 +425,4 @@ GEN_IMPL_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* obj )
 }
 
 #pragma endregion CSV
+

project/dependencies/printing.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "string_ops.cpp"
+
 #pragma region Printing
 
 enum
@@ -47,7 +50,8 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
 	}
 
 	if ( info && info->precision >= 0 )
-		len = str_len( str, info->precision );
+		// Made the design decision for this library that precision is the length of the string.
+		len = info->precision;
 	else
 		len = str_len( str );
 
@@ -410,6 +414,15 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
 				len = _print_string( text, remaining, &info, va_arg( va, char* ) );
 				break;
 
+			case 'S':
+			{
+				String gen_str = String { va_arg( va, char*) };
+
+				info.precision = gen_str.length();
+				len            = _print_string( text, remaining, &info, gen_str );
+			}
+			break;
+
 			case 'r' :
 				len = _print_repeated_char( text, remaining, &info, va_arg( va, int ) );
 				break;
@@ -541,6 +554,16 @@ sw str_fmt_file( struct FileInfo* f, char const* fmt, ... )
 	return res;
 }
 
+sw str_fmt( char* str, sw n, char const* fmt, ... )
+{
+	sw      res;
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_va( str, n, fmt, va );
+	va_end( va );
+	return res;
+}
+
 sw str_fmt_out_va( char const* fmt, va_list va )
 {
 	return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );

project/dependencies/printing.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "string_ops.hpp"
+
 #pragma region Printing
 
 struct FileInfo;
@@ -9,13 +12,11 @@ struct FileInfo;
 // 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 );
-
-// TODO : Move these to file handling.
-
 sw    str_fmt_file      ( FileInfo* f, char const* fmt, ... );
 sw    str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
 
@@ -35,29 +36,4 @@ sw log_fmt(char const* fmt, ...)
 	return res;
 }
 
-inline
-sw fatal(char const* fmt, ...)
-{
-	local_persist thread_local
-	char buf[GEN_PRINTF_MAXLEN] = { 0 };
-
-	va_list va;
-
-#if Build_Debug
-	va_start(va, fmt);
-	str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
-	va_end(va);
-
-	assert_crash(buf);
-	return -1;
-#else
-	va_start(va, fmt);
-	str_fmt_out_err_va( fmt, va);
-	va_end(va);
-
-	exit(1);
-	return -1;
-#endif
-}
-
 #pragma endregion Printing

project/dependencies/string.cpp

@@ -1,39 +0,0 @@
-#pragma region String
-
-String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
-{
-	va_list va;
-	va_start( va, fmt );
-	str_fmt_va( buf, buf_size, fmt, va );
-	va_end( va );
-
-	return make( allocator, buf );
-}
-
-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 );
-}
-
-#pragma endregion String

project/dependencies/string_ops.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "debug.cpp"
+
 #pragma region String Ops
 
 internal

project/dependencies/string_ops.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "memory.hpp"
+
 #pragma region String Ops
 
 GEN_DEF_INLINE const char* char_first_occurence( const char* str, char c );

project/dependencies/strings.cpp

@@ -0,0 +1,128 @@
+#pragma once
+#include "hashing.cpp"
+
+#pragma region String
+
+String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
+{
+	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 );
+
+	s32   alloc_size = header_size + length + 1;
+	void* allocation = alloc( allocator, alloc_size );
+
+	if ( allocation == nullptr )
+		return { nullptr };
+
+	Header&
+	header = * rcast(Header*, allocation);
+	header = { allocator, length, length };
+
+	String  result = { rcast( char*, allocation) + header_size };
+
+	if ( length && str )
+		mem_copy( result, str, length );
+	else
+		mem_set( result, 0, alloc_size - header_size );
+
+	result[ length ] = '\0';
+
+	return result;
+}
+
+String String::make_reserve( AllocatorInfo allocator, sw capacity )
+{
+	constexpr sw header_size = sizeof( Header );
+
+	s32   alloc_size = header_size + capacity + 1;
+	void* allocation = alloc( allocator, alloc_size );
+
+	if ( allocation == nullptr )
+		return { nullptr };
+
+	mem_set( allocation, 0, alloc_size );
+
+	Header*
+		header            = rcast(Header*, allocation);
+	header->Allocator = allocator;
+	header->Capacity  = capacity;
+	header->Length    = 0;
+
+	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/strings.hpp

@@ -1,4 +1,7 @@
-#pragma region String
+#pragma once
+#include "hashing.hpp"
+
+#pragma region Strings
 
 // Constant string with length.
 struct StrC
@@ -12,18 +15,14 @@ struct StrC
 	}
 };
 
-#define txt_StrC( text ) StrC { sizeof( text ) - 1, text }
+#define cast_to_strc( str ) * rcast( StrC*, str - sizeof(sw) )
+#define txt( text ) StrC { sizeof( text ) - 1, text }
 
-StrC to_StrC( char const* str )
+StrC to_str( char const* str )
 {
 	return { str_len( str ), str };
 }
 
-sw StrC_len( char const* str )
-{
-	return (sw) ( str - 1 );
-}
-
 // Dynamic String
 // This is directly based off the ZPL string api.
 // They used a header pattern
@@ -33,8 +32,8 @@ struct String
 	struct Header
 	{
 		AllocatorInfo Allocator;
-		sw            Length;
 		sw            Capacity;
+		sw            Length;
 	};
 
 	static
@@ -58,54 +57,10 @@ struct String
 	}
 
 	static
-	String make_reserve( AllocatorInfo allocator, sw capacity )
-	{
-		constexpr sw header_size = sizeof( Header );
-
-		s32   alloc_size = header_size + capacity + 1;
-		void* allocation = alloc( allocator, alloc_size );
-
-		if ( allocation == nullptr )
-			return { nullptr };
-
-		mem_set( allocation, 0, alloc_size );
-
-		Header*
-			header            = rcast(Header*, allocation);
-		header->Allocator = allocator;
-		header->Capacity  = capacity;
-		header->Length    = 0;
-
-		String result = { (char*)allocation + header_size };
-		return result;
-	}
+	String make_reserve( AllocatorInfo allocator, sw capacity );
 
 	static
-	String make_length( AllocatorInfo allocator, char const* str, sw length )
-	{
-		constexpr sw header_size = sizeof( Header );
-
-		s32   alloc_size = header_size + length + 1;
-		void* allocation = alloc( allocator, alloc_size );
-
-		if ( allocation == nullptr )
-			return { nullptr };
-
-		Header&
-			header = * rcast(Header*, allocation);
-		header = { allocator, length, length };
-
-		String  result = { rcast( char*, allocation) + header_size };
-
-		if ( length && str )
-			mem_copy( result, str, length );
-		else
-			mem_set( result, 0, alloc_size - header_size );
-
-		result[ length ] = '\0';
-
-		return result;
-	}
+	String make_length( AllocatorInfo allocator, char const* str, sw length );
 
 	static
 	String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
@@ -142,44 +97,7 @@ struct String
 		return true;
 	}
 
-	bool 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;
-		}
-	}
+	bool make_space_for( char const* str, sw add_len );
 
 	bool append( char const* str )
 	{
@@ -213,7 +131,7 @@ struct String
 
 	bool append( const String other )
 	{
-		return append( other.Data, other.length() );;
+		return append( other.Data, other.length() );
 	}
 
 	bool append_fmt( char const* fmt, ... );
@@ -226,6 +144,11 @@ struct String
 		return header.Capacity - header.Length;
 	}
 
+	char& back()
+	{
+		return Data[ length() - 1 ];
+	}
+
 	sw capacity() const
 	{
 		Header const&
@@ -267,6 +190,29 @@ struct String
 		return header.Length;
 	}
 
+	void skip_line()
+	{
+	#define current (*scanner)
+		char* scanner = Data;
+		while ( current != '\r' && current != '\n' )
+		{
+			++ scanner;
+		}
+
+		s32 new_length = scanner - Data;
+
+		if ( current == '\r' )
+		{
+			new_length += 1;
+		}
+
+		mem_move( Data, scanner, new_length );
+
+		Header* header = & get_header();
+		header->Length = new_length;
+	#undef current
+	}
+
 	void trim( char const* cut_set )
 	{
 		sw len = 0;
@@ -327,11 +273,7 @@ struct String
 
 	operator StrC() const
 	{
-		return
-		{
-			length(),
-			Data
-		};
+		return { length(), Data };
 	}
 
 	// Used with cached strings
@@ -358,18 +300,20 @@ struct String
 		return Data[ index ];
 	}
 
-	char* Data = nullptr;
+	char* Data;
 };
 
 struct String_POD
 {
 	char* Data;
-
-	operator String()
-	{
-		return * rcast(String*, this);
-	}
 };
 static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
 
-#pragma endregion String
+// Implements basic string interning. Data structure is based off the ZPL Hashtable.
+using StringTable = HashTable<String const>;
+
+// Represents strings cached with the string table.
+// Should never be modified, if changed string is desired, cache_string( str ) another.
+using StringCached = String const;
+
+#pragma endregion Strings

project/dependencies/timing.cpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "filesystem.cpp"
+
 #pragma region Timing
 
 #ifdef GEN_BENCHMARK

project/dependencies/timing.hpp

@@ -1,3 +1,6 @@
+#pragma once
+#include "filesystem.hpp"
+
 #pragma region Timing
 
 #ifdef GEN_BENCHMARK

project/enums/ECode.csv

@@ -1,5 +1,6 @@
 Invalid
 Untyped
+NewLine
 Comment
 Access_Private
 Access_Protected
@@ -8,6 +9,10 @@ PlatformAttributes
 Class
 Class_Fwd
 Class_Body
+Constructor
+Constructor_Fwd
+Destructor
+Destructor_Fwd
 Enum
 Enum_Fwd
 Enum_Body
@@ -32,7 +37,15 @@ Operator_Member_Fwd
 Operator_Cast
 Operator_Cast_Fwd
 Parameters
-Preprocessor_Include
+Preprocess_Define
+Preprocess_Include
+Preprocess_If
+Preprocess_IfDef
+Preprocess_IfNotDef
+Preprocess_ElIf
+Preprocess_Else
+Preprocess_EndIf
+Preprocess_Pragma
 Specifiers
 Struct
 Struct_Fwd

project/enums/ESpecifier.csv

@@ -4,11 +4,13 @@ Constexpr,        constexpr
 Constinit,        constinit
 Explicit,         explicit
 External_Linkage, extern
+ForceInline, 	  forceinline
 Global,           global
 Inline,           inline
 Internal_Linkage, internal
 Local_Persist,    local_persist
 Mutable,          mutable
+NeverInline,      neverinline
 Ptr,              *
 Ref,              &
 Register,         register
@@ -20,3 +22,4 @@ Virtual,          virtual
 Const,            const
 Final,            final
 Override,         override
+Pure,             = 0

project/enums/ETokType.csv

@@ -7,16 +7,18 @@ Access_StaticSymbol,    "::"
 Ampersand,              "&"
 Ampersand_DBL,          "&&"
 Assign_Classifer,       ":"
-Attribute_Open, 	    "[["
-Attribute_Close, 	    "]]"
+Attribute_Open,         "[["
+Attribute_Close,        "]]"
 BraceCurly_Open,        "{"
 BraceCurly_Close,       "}"
 BraceSquare_Open,       "["
 BraceSquare_Close,      "]"
 Capture_Start,          "("
 Capture_End,            ")"
-Comment,                "comemnt"
-Char,                   "character"
+Comment,                "__comemnt__"
+Comment_End,            "__comment_end__"
+Comment_Start,          "__comment_start__"
+Char,                   "__character__"
 Comma,                  ","
 Decl_Class,             "class"
 Decl_GNU_Attribute,     "__attribute__"
@@ -32,43 +34,60 @@ Decl_Template,          "template"
 Decl_Typedef,           "typedef"
 Decl_Using,             "using"
 Decl_Union,             "union"
-Identifier,             "identifier"
+Identifier,             "__identifier__"
 Module_Import,          "import"
 Module_Export,          "export"
-Number,                 "number"
-Operator,               "operator"
-Preprocess_Define,      "#define"
-Preprocess_Include,     "#include"
-Preprocess_If,          "#if"
-Preprocess_ElIF,		"#elif"
-Preprocess_Else,        "#else"
-Preprocess_EndIf,       "#endif"
+NewLine,                "__new_line__"
+Number,                 "__number__"
+Operator,               "__operator__"
+Preprocess_Hash,        "#"
+Preprocess_Define,      "define"
+Preprocess_If,          "if"
+Preprocess_IfDef,       "ifdef"
+Preprocess_IfNotDef,    "ifndef"
+Preprocess_ElIf,        "elif"
+Preprocess_Else,        "else"
+Preprocess_EndIf,       "endif"
+Preprocess_Include,     "include"
+Preprocess_Pragma,      "pragma"
+Preprocess_Content,	    "__macro_content__"
+Preprocess_Macro,       "__macro__"
+Preprocess_Unsupported, "__unsupported__"
 Spec_Alignas,           "alignas"
 Spec_Const,             "const"
 Spec_Consteval,         "consteval"
 Spec_Constexpr,         "constexpr"
 Spec_Constinit,         "constinit"
-Spec_Explicit, 		    "explicit"
+Spec_Explicit,          "explicit"
 Spec_Extern,            "extern"
-Spec_Final, 		    "final"
-Spec_Global, 		    "global"
+Spec_Final,             "final"
+Spec_ForceInline,	    "forceinline"
+Spec_Global,            "global"
 Spec_Inline,            "inline"
 Spec_Internal_Linkage,  "internal"
 Spec_LocalPersist,      "local_persist"
 Spec_Mutable,           "mutable"
+Spec_NeverInline,       "neverinline"
 Spec_Override,          "override"
 Spec_Static,            "static"
 Spec_ThreadLocal,       "thread_local"
 Spec_Volatile,          "volatile"
+Spec_Virtual,           "virtual"
 Star,                   "*"
 Statement_End,          ";"
-String,                 "string"
-Type_Unsigned, 	        "unsigned"
+StaticAssert,           "static_assert"
+String,                 "__string__"
+Type_Unsigned,          "unsigned"
 Type_Signed,            "signed"
 Type_Short,             "short"
 Type_Long,              "long"
-Type_char, 			    "char"
-Type_int, 			    "int"
-Type_double, 		    "double"
+Type_char,              "char"
+Type_int,               "int"
+Type_double,            "double"
+Type_MS_int8,           "__int8"
+Type_MS_int16,          "__int16"
+Type_MS_int32,          "__int32"
+Type_MS_int64,          "__int64"
+Type_MS_W64,            "_W64"
 Varadic_Argument,       "..."
-Attributes_Start,       "__attrib_start__"
+__Attributes_Start,     "__attrib_start__"

project/file_processors/builder.cpp

@@ -1,43 +0,0 @@
-void Builder::print( Code code )
-{
-	Buffer.append_fmt( "%s\n", code->to_string() );
-}
-
-void Builder::print_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 );
-
-	Buffer.append( buf, res );
-}
-
-bool Builder::open( char const* path )
-{
-	FileError error = file_open_mode( & File, EFileMode_WRITE, path );
-
-	if ( error != EFileError_NONE )
-	{
-		log_failure( "gen::File::open - Could not open file: %s", path);
-		return false;
-	}
-
-	Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );
-
-	return true;
-}
-
-void Builder::write()
-{
-	bool result = file_write( & File, Buffer, Buffer.length() );
-
-	if ( result == false )
-		log_failure("gen::File::write - Failed to write to file: %s", file_name( & File ) );
-
-	file_close( & File );
-	Buffer.free();
-}

project/file_processors/scanner.hpp

@@ -1,73 +0,0 @@
-#pragma once
-#include "gen.hpp"
-
-GEN_NS_BEGIN
-
-Code scan_file( char const* path )
-{
-	FileInfo file;
-
-	FileError error = file_open_mode( & file, EFileMode_READ, path );
-	if ( error != EFileError_NONE )
-	{
-		fatal( "scan_file: Could not open: %s", path );
-	}
-
-	sw fsize = file_size( & file );
-	if ( fsize <= 0 )
-	{
-		fatal("scan_file: %s is empty", path );
-	}
-
-	String str = String::make_reserve( GlobalAllocator, fsize );
-		file_read( & file, str, fsize );
-		str.get_header().Length = fsize;
-
-	file_close( & file );
-
-	return untyped_str( str );
-}
-
-struct Policy
-{
-	// Nothing for now.
-};
-
-struct SymbolInfo
-{
-	StringCached File;
-	char const*  Marker;
-	Code         Signature;
-};
-
-
-struct Scanner
-{
-	struct RequestEntry
-	{
-		SymbolInfo Info;
-	};
-
-	struct Receipt
-	{
-		StringCached File;
-		Code         Defintion;
-		bool         Result;
-	};
-
-	AllocatorInfo MemAlloc;
-
-	static void set_allocator( AllocatorInfo allocator );
-
-	Array<FileInfo>     Files;
-	String              Buffer;
-	Array<RequestEntry> Requests;
-
-	void add_files( s32 num, char const** files );
-
-	void add( SymbolInfo signature, Policy policy );
-
-	bool process_requests( Array<Receipt> out_receipts );
-};
-
-GEN_NS_END

project/gen.bootstrap.cpp

@@ -1,204 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
-#include "gen.cpp"
-#include "file_processors/scanner.hpp"
-#include "helpers/helper.hpp"
-
-using namespace gen;
-
-bool namespace_by_default = true;
-
-constexpr StrC nspace_default = txt_StrC(R"(
-#if defined(GEN_DONT_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
-#elif ! defined(GEN_NS_BEGIN)
-#  define GEN_NS_BEGIN namespace gen {
-#  define GEN_NS_END   }
-#endif
-)");
-
-constexpr StrC nspace_non_default = txt_StrC(R"(
-#if ! defined(GEN_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
-#elif ! defined(GEN_NS_BEGIN)
-#  define GEN_NS_BEGIN namespace gen {
-#  define GEN_NS_END   }
-#endif
-)");
-
-int gen_main()
-{
-	gen::init();
-
-	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 nspace_macro  = untyped_str( namespace_by_default ? nspace_default : nspace_non_default );
-		Code macros 	   = scan_file( "dependencies/macros.hpp" );
-		Code basic_types   = scan_file( "dependencies/basic_types.hpp" );
-		Code debug         = scan_file( "dependencies/debug.hpp" );
-		Code memory	       = scan_file( "dependencies/memory.hpp" );
-		Code string_ops    = scan_file( "dependencies/string_ops.hpp" );
-		Code printing      = scan_file( "dependencies/printing.hpp" );
-		Code containers    = scan_file( "dependencies/containers.hpp" );
-		Code hashing 	   = scan_file( "dependencies/hashing.hpp" );
-		Code string        = scan_file( "dependencies/string.hpp" );
-		Code parsing       = scan_file( "dependencies/parsing.hpp" );
-		Code timing        = scan_file( "dependencies/timing.hpp" );
-
-		// TOOD : Make this optional
-		Code file_handling = scan_file( "dependencies/file_handling.hpp" );
-
-		Builder
-		deps_header;
-		deps_header.open("gen/gen_dep.hpp");
-			deps_header.print_fmt("// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n\n");
-			deps_header.print_fmt("#pragma once\n\n");
-			deps_header.print( header_start );
-			deps_header.print( nspace_macro );
-			deps_header.print_fmt( "GEN_NS_BEGIN\n\n");
-
-			deps_header.print( macros );
-			deps_header.print( basic_types );
-			deps_header.print( debug );
-			deps_header.print( memory );
-			deps_header.print( string_ops );
-			deps_header.print( printing );
-			deps_header.print( containers );
-			deps_header.print( hashing );
-			deps_header.print( string );
-			deps_header.print( file_handling );
-			deps_header.print( parsing );
-			deps_header.print( timing );
-
-			deps_header.print_fmt( "GEN_NS_END\n\n");
-		deps_header.write();
-	}
-
-	// gen_dep.cpp
-	{
-		CodeInclude header     = def_include( txt_StrC("gen_dep.hpp") );
-		Code        impl_start = scan_file( "dependencies/impl_start.cpp" );
-		Code 	    debug      = scan_file( "dependencies/debug.cpp" );
-		Code 	    string_ops = scan_file( "dependencies/string_ops.cpp" );
-		Code 	    printing   = scan_file( "dependencies/printing.cpp" );
-		Code 	    memory     = scan_file( "dependencies/memory.cpp" );
-		Code        parsing    = scan_file( "dependencies/parsing.cpp" );
-		Code        hashing    = scan_file( "dependencies/hashing.cpp" );
-		Code        string     = scan_file( "dependencies/string.cpp" );
-		Code        timing     = scan_file( "dependencies/timing.cpp" );
-
-		Builder
-		deps_impl;
-		deps_impl.open("gen/gen_dep.cpp");
-			deps_impl.print_fmt("// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n\n");
-			deps_impl.print( impl_start );
-			deps_impl.print( header );
-			deps_impl.print_fmt( "\nGEN_NS_BEGIN\n");
-
-			deps_impl.print( debug );
-			deps_impl.print( string_ops );
-			deps_impl.print( printing );
-			deps_impl.print( hashing );
-			deps_impl.print( memory );
-			deps_impl.print( parsing );
-			deps_impl.print( string );
-			deps_impl.print( timing );
-
-			deps_impl.print_fmt( "GEN_NS_END\n\n");
-		deps_impl.write();
-	}
-
-	// gen.hpp
-	{
-		Code header_start = scan_file( "components/header_start.hpp" );
-		Code nspace_macro = untyped_str( namespace_by_default ? nspace_default : nspace_non_default );
-		Code types        = scan_file( "components/types.hpp" );
-		Code data_structs = scan_file( "components/data_structures.hpp" );
-		Code interface    = scan_file( "components/interface.hpp" );
-		Code header_end   = scan_file( "components/header_end.hpp" );
-
-		CodeBody ecode      = gen_ecode( "enums/ECode.csv" );
-		CodeBody eoperator  = gen_eoperator( "enums/EOperator.csv" );
-		CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" );
-
-		// TODO : Make this optional to include
-		Code builder = scan_file( "file_processors/builder.hpp" );
-
-		Builder
-		header;
-		header.open( "gen/gen.hpp" );
-			header.print_fmt("#pragma once\n\n");
-			header.print( push_ignores );
-			header.print( header_start );
-			header.print( nspace_macro );
-			header.print_fmt( "GEN_NS_BEGIN\n\n");
-
-			header.print_fmt("#pragma region Types\n\n");
-			header.print( types );
-			header.print( ecode );
-			header.print( eoperator );
-			header.print( especifier );
-			header.print_fmt("#pragma endregion Types\n\n");
-
-			header.print( data_structs );
-			header.print( interface );
-			header.print( header_end );
-
-			header.print( builder );
-
-			header.print_fmt( "GEN_NS_END\n\n");
-			header.print( pop_ignores );
-		header.write();
-	}
-
-	// gen.cpp
-	{
-		Code        impl_start      = scan_file( "components/impl_start.cpp" );
-		CodeInclude header          = def_include( txt_StrC("gen.hpp") );
-		Code        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/untyped.cpp" );
-
-		CodeBody etoktype = gen_etoktype( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-		CodeNamespace parser_nspace = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
-
-		// TODO : Make this optional to include
-		Code builder = scan_file( "file_processors/builder.cpp" );
-
-		Builder
-		impl;
-		impl.open( "gen/gen.cpp" );
-			impl.print( push_ignores );
-			impl.print( impl_start );
-			impl.print( header );
-			impl.print_fmt( "\nGEN_NS_BEGIN\n\n");
-
-			impl.print( data );
-			impl.print( ast_case_macros );
-			impl.print( ast );
-			impl.print( interface );
-			impl.print( upfront );
-			impl.print( parser_nspace );
-			impl.print( parsing );
-			impl.print( untyped );
-
-			impl.print( builder );
-			impl.print_fmt( "GEN_NS_END\n\n");
-			impl.print( pop_ignores );
-		impl.write();
-	}
-
-	gen::deinit();
-	return 0;
-}

project/gen.cpp

@@ -6,14 +6,14 @@
 #	error Gen.hpp : GEN_TIME not defined
 #endif
 
+#include "gen.hpp"
+
 //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
 //! Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
 #ifndef GEN_ROLL_OWN_DEPENDENCIES
 #	include "gen.dep.cpp"
 #endif
 
-#include "gen.hpp"
-
 GEN_NS_BEGIN
 
 #include "components/static_data.cpp"
@@ -23,11 +23,9 @@ GEN_NS_BEGIN
 
 #include "components/interface.cpp"
 #include "components/interface.upfront.cpp"
-#include "components/etoktype.cpp"
+#include "components/gen/etoktype.cpp"
 #include "components/interface.parsing.cpp"
-#include "components/untyped.cpp"
-
-#include "file_processors/builder.cpp"
+#include "components/interface.untyped.cpp"
 
 GEN_NS_END
 

project/gen.dep.cpp

@@ -1,7 +1,7 @@
 // This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)
 #include "gen.dep.hpp"
 
-#include "dependencies/impl_start.cpp"
+#include "dependencies/src_start.cpp"
 
 GEN_NS_BEGIN
 
@@ -9,11 +9,9 @@ GEN_NS_BEGIN
 #include "dependencies/string_ops.cpp"
 #include "dependencies/printing.cpp"
 #include "dependencies/memory.cpp"
-#include "dependencies/parsing.cpp"
 #include "dependencies/hashing.cpp"
-#include "dependencies/string.cpp"
+#include "dependencies/strings.cpp"
+#include "dependencies/filesystem.cpp"
 #include "dependencies/timing.cpp"
 
-#include "dependencies/file_handling.cpp"
-
 GEN_NS_END

project/gen.dep.hpp

@@ -3,14 +3,6 @@
 
 #include "dependencies/header_start.hpp"
 
-#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_NS_BEGIN
 
 #include "dependencies/macros.hpp"
@@ -21,10 +13,8 @@ GEN_NS_BEGIN
 #include "dependencies/printing.hpp"
 #include "dependencies/containers.hpp"
 #include "dependencies/hashing.hpp"
-#include "dependencies/string.hpp"
-#include "dependencies/parsing.hpp"
+#include "dependencies/strings.hpp"
+#include "dependencies/filesystem.hpp"
 #include "dependencies/timing.hpp"
 
-#include "dependencies/file_handling.hpp"
-
 GEN_NS_END

project/gen.hpp

@@ -11,25 +11,21 @@
 #include "helpers/push_ignores.inline.hpp"
 #include "components/header_start.hpp"
 
-#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_NS_BEGIN
 
 #include "components/types.hpp"
-#include "components/ecode.hpp"
-#include "components/eoperator.hpp"
-#include "components/especifier.hpp"
-#include "components/data_structures.hpp"
-#include "components/interface.hpp"
-#include "components/header_end.hpp"
+#include "components/gen/ecode.hpp"
+#include "components/gen/eoperator.hpp"
+#include "components/gen/especifier.hpp"
 
-#include "file_processors/builder.hpp"
+#include "components/ast.hpp"
+#include "components/ast_types.hpp"
+
+#include "components/interface.hpp"
+
+#include "components/inlines.hpp"
+#include "components/gen/ast_inlines.hpp"
+#include "components/header_end.hpp"
 
 GEN_NS_END
 

project/helpers/helper.hpp

@@ -2,6 +2,10 @@
 
 #include "gen.hpp"
 
+GEN_NS_BEGIN
+#include "dependencies/parsing.hpp"
+GEN_NS_END
+
 using namespace gen;
 
 CodeBody gen_ecode( char const* path )
@@ -26,13 +30,7 @@ CodeBody gen_ecode( char const* path )
 		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
 	}
 
-	CodeEnum enum_code = parse_enum( token_fmt( "entries", (StrC)enum_entries, stringize(
-		enum Type : u32
-		{
-			<entries>
-			NumTypes
-		};
-	)));
+	CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", (StrC)enum_entries, "enum Type : u32 { <entries> NumTypes };"));
 
 #pragma push_macro( "local_persist" )
 #undef local_persist
@@ -49,15 +47,15 @@ CodeBody gen_ecode( char const* path )
 	)));
 #pragma pop_macro( "local_persist" )
 
-	CodeNamespace 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) ) );
 
-	return def_global_body( args( nspace, code_t ) );
+	return def_global_body( args( nspace, code_t, fmt_newline ) );
 }
 
 CodeBody gen_eoperator( char const* path )
 {
-	char scratch_mem[kilobytes(1)];
+	char scratch_mem[kilobytes(4)];
 	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
 	file_read_contents( scratch, zero_terminate, path );
@@ -103,16 +101,16 @@ CodeBody gen_eoperator( char const* path )
 	)));
 #pragma pop_macro( "local_persist" )
 
-	CodeNamespace 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) ) );
 
-	return def_global_body( args( nspace, operator_t ) );
+	return def_global_body( args( nspace, operator_t, fmt_newline ) );
 }
 
 CodeBody gen_especifier( char const* path )
 {
-	char scratch_mem[kilobytes(1)];
+	char scratch_mem[kilobytes(4)];
 	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
 	file_read_contents( scratch, zero_terminate, path );
@@ -153,9 +151,13 @@ CodeBody gen_especifier( char const* path )
 #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 )
 		{
@@ -198,17 +200,19 @@ CodeBody gen_especifier( char const* path )
 #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" )
 
-	CodeNamespace 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) ) );
 
-	return def_global_body( args( nspace, specifier_t ) );
+	return def_global_body( args( nspace, specifier_t, fmt_newline ) );
 }
 
 CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 {
-	char  scratch_mem[kilobytes(64)];
+	char  scratch_mem[kilobytes(16)];
 	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
 
 	FileContents enum_content = file_read_contents( scratch, zero_terminate, etok_path );
@@ -226,10 +230,11 @@ 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 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++)
 	{
@@ -247,8 +252,19 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 
 		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 );
+
+		if ( idx < attribute_strs.num() - 1 )
+			attribute_define_entries.append( " \\\n");
+		else
+			attribute_define_entries.append( "\n");
 	}
 
+#pragma push_macro( "GEN_DEFINE_ATTRIBUTE_TOKENS" )
+#undef GEN_DEFINE_ATTRIBUTE_TOKENS
+	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), attribute_define_entries  );
+#pragma pop_macro( "GEN_DEFINE_ATTRIBUTE_TOKENS" )
+
 	CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, "attribute_toks", (StrC)attribute_entries, stringize(
 		enum Type : u32
 		{
@@ -308,8 +324,283 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 #pragma pop_macro( "do_once_start" )
 #pragma pop_macro( "do_once_end" )
 
-	CodeNamespace nspace     = def_namespace( name(ETokType), def_namespace_body( args( 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 ) ) );
+	CodeUsing td_toktype = def_using( name(TokType), def_type( name(ETokType::Type) ) );
 
 	return def_global_body( args( nspace, td_toktype ) );
 }
+
+CodeBody gen_ast_inlines()
+{
+#pragma push_macro("rcast")
+#pragma push_macro("log_failure")
+#undef rcast
+#undef log_failure
+	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();
+		}
+		<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), other.ast );
+			return *this;
+		}
+		bool <typename>::operator ==( Code other )
+		{
+			return (AST*) ast == other.ast;
+		}
+		bool <typename>::operator !=( Code other )
+		{
+			return (AST*) ast != other.ast;
+		}
+		<typename>::operator bool()
+		{
+			return ast != nullptr;
+		}
+	);
+
+	char const* codetype_impl_tmpl = stringize(
+		AST* Code<typename>::raw()
+		{
+			return rcast( AST*, ast );
+		}
+		Code<typename>::operator Code()
+		{
+			return *rcast( Code*, this );
+		}
+		AST_<typename>* Code<typename>::operator->()
+		{
+			if ( ast == nullptr )
+			{
+				log_failure( "Attempt to dereference a nullptr!" );
+				return nullptr;
+			}
+			return ast;
+		}
+		\n
+	);
+
+	CodeBody impl_code          = parse_global_body( token_fmt( "typename", StrC name(Code),               code_impl_tmpl ));
+	CodeBody impl_code_body     = parse_global_body( token_fmt( "typename", StrC name(CodeBody),           code_impl_tmpl ));
+	CodeBody impl_code_attr     = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes),     code_impl_tmpl ));
+	CodeBody impl_code_cmt      = parse_global_body( token_fmt( "typename", StrC name(CodeComment),        code_impl_tmpl ));
+	CodeBody impl_code_constr   = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor),    code_impl_tmpl ));
+	CodeBody impl_code_class    = parse_global_body( token_fmt( "typename", StrC name(CodeClass),          code_impl_tmpl ));
+	CodeBody impl_code_define   = parse_global_body( token_fmt( "typename", StrC name(CodeDefine),         code_impl_tmpl ));
+	CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor),     code_impl_tmpl ));
+	CodeBody impl_code_enum     = parse_global_body( token_fmt( "typename", StrC name(CodeEnum),           code_impl_tmpl ));
+	CodeBody impl_code_exec     = parse_global_body( token_fmt( "typename", StrC name(CodeExec),           code_impl_tmpl ));
+	CodeBody impl_code_extern   = parse_global_body( token_fmt( "typename", StrC name(CodeExtern),         code_impl_tmpl ));
+	CodeBody impl_code_include  = parse_global_body( token_fmt( "typename", StrC name(CodeInclude),        code_impl_tmpl ));
+	CodeBody impl_code_friend   = parse_global_body( token_fmt( "typename", StrC name(CodeFriend),         code_impl_tmpl ));
+	CodeBody impl_code_fn	    = parse_global_body( token_fmt( "typename", StrC name(CodeFn),             code_impl_tmpl ));
+	CodeBody impl_code_module   = parse_global_body( token_fmt( "typename", StrC name(CodeModule),         code_impl_tmpl ));
+	CodeBody impl_code_ns       = parse_global_body( token_fmt( "typename", StrC name(CodeNS),             code_impl_tmpl ));
+	CodeBody impl_code_op       = parse_global_body( token_fmt( "typename", StrC name(CodeOperator),       code_impl_tmpl ));
+	CodeBody impl_code_opcast   = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast),         code_impl_tmpl ));
+	CodeBody impl_code_param    = parse_global_body( token_fmt( "typename", StrC name(CodeParam),          code_impl_tmpl ));
+	CodeBody impl_code_pragma   = parse_global_body( token_fmt( "typename", StrC name(CodePragma),         code_impl_tmpl ));
+	CodeBody impl_code_precond  = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl ));
+	CodeBody impl_code_specs    = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers),     code_impl_tmpl ));
+	CodeBody impl_code_struct   = parse_global_body( token_fmt( "typename", StrC name(CodeStruct),         code_impl_tmpl ));
+	CodeBody impl_code_tmpl     = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate),       code_impl_tmpl ));
+	CodeBody impl_code_type     = parse_global_body( token_fmt( "typename", StrC name(CodeType),           code_impl_tmpl ));
+	CodeBody impl_code_typedef  = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef),        code_impl_tmpl ));
+	CodeBody impl_code_union    = parse_global_body( token_fmt( "typename", StrC name(CodeUnion),          code_impl_tmpl ));
+	CodeBody impl_code_using    = parse_global_body( token_fmt( "typename", StrC name(CodeUsing),          code_impl_tmpl ));
+	CodeBody impl_code_var      = parse_global_body( token_fmt( "typename", StrC name(CodeVar),            code_impl_tmpl ));
+
+	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 )));
+
+	char const* cast_tmpl = stringize(
+		AST::operator Code<typename>()
+		{
+			return { rcast( AST_<typename>*, this ) };
+		}
+
+		Code::operator Code<typename>() const
+		{
+			return { (AST_<typename>*) ast };
+		}
+	);
+
+	CodeBody impl_cast_body      = parse_global_body( token_fmt( "typename", StrC name(Body),           cast_tmpl ));
+	CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes),     cast_tmpl ));
+	CodeBody impl_cast_cmt       = parse_global_body( token_fmt( "typename", StrC name(Comment),        cast_tmpl ));
+	CodeBody impl_cast_constr    = parse_global_body( token_fmt( "typename", StrC name(Constructor),    cast_tmpl ));
+	CodeBody impl_cast_class     = parse_global_body( token_fmt( "typename", StrC name(Class),          cast_tmpl ));
+	CodeBody impl_cast_define    = parse_global_body( token_fmt( "typename", StrC name(Define),         cast_tmpl ));
+	CodeBody impl_cast_destruct  = parse_global_body( token_fmt( "typename", StrC name(Destructor),     cast_tmpl ));
+	CodeBody impl_cast_enum      = parse_global_body( token_fmt( "typename", StrC name(Enum),           cast_tmpl ));
+	CodeBody impl_cast_exec      = parse_global_body( token_fmt( "typename", StrC name(Exec),           cast_tmpl ));
+	CodeBody impl_cast_extern    = parse_global_body( token_fmt( "typename", StrC name(Extern),         cast_tmpl ));
+	CodeBody impl_cast_friend    = parse_global_body( token_fmt( "typename", StrC name(Friend),         cast_tmpl ));
+	CodeBody impl_cast_fn        = parse_global_body( token_fmt( "typename", StrC name(Fn),             cast_tmpl ));
+	CodeBody impl_cast_include   = parse_global_body( token_fmt( "typename", StrC name(Include),        cast_tmpl ));
+	CodeBody impl_cast_module    = parse_global_body( token_fmt( "typename", StrC name(Module),         cast_tmpl ));
+	CodeBody impl_cast_ns        = parse_global_body( token_fmt( "typename", StrC name(NS),             cast_tmpl ));
+	CodeBody impl_cast_op        = parse_global_body( token_fmt( "typename", StrC name(Operator),       cast_tmpl ));
+	CodeBody impl_cast_opcast    = parse_global_body( token_fmt( "typename", StrC name(OpCast),         cast_tmpl ));
+	CodeBody impl_cast_param     = parse_global_body( token_fmt( "typename", StrC name(Param),          cast_tmpl ));
+	CodeBody impl_cast_pragma    = parse_global_body( token_fmt( "typename", StrC name(Pragma),         cast_tmpl ));
+	CodeBody impl_cast_precond   = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl ));
+	CodeBody impl_cast_specs     = parse_global_body( token_fmt( "typename", StrC name(Specifiers),     cast_tmpl ));
+	CodeBody impl_cast_struct    = parse_global_body( token_fmt( "typename", StrC name(Struct),         cast_tmpl ));
+	CodeBody impl_cast_tmpl      = parse_global_body( token_fmt( "typename", StrC name(Template),       cast_tmpl ));
+	CodeBody impl_cast_type      = parse_global_body( token_fmt( "typename", StrC name(Type),           cast_tmpl ));
+	CodeBody impl_cast_typedef   = parse_global_body( token_fmt( "typename", StrC name(Typedef),        cast_tmpl ));
+	CodeBody impl_cast_union     = parse_global_body( token_fmt( "typename", StrC name(Union),          cast_tmpl ));
+	CodeBody impl_cast_using     = parse_global_body( token_fmt( "typename", StrC name(Using),          cast_tmpl ));
+	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", StrC name(Var),            cast_tmpl ));
+
+	CodeBody result = def_global_body( args(
+		def_pragma( txt("region generated code inline implementation")),
+		fmt_newline,
+		impl_code,
+		impl_code_body,
+		impl_code_attr,
+		impl_code_cmt,
+		impl_code_constr,
+		impl_code_class,
+		impl_code_define,
+		impl_code_destruct,
+		impl_code_enum,
+		impl_code_exec,
+		impl_code_extern,
+		impl_code_friend,
+		impl_code_fn,
+		impl_code_include,
+		impl_code_module,
+		impl_code_ns,
+		impl_code_op,
+		impl_code_opcast,
+		impl_code_param,
+		impl_code_pragma,
+		impl_code_precond,
+		impl_code_specs,
+		impl_code_struct,
+		impl_code_tmpl,
+		impl_code_type,
+		impl_code_typedef,
+		impl_code_union,
+		impl_code_using,
+		impl_code_var,
+		fmt_newline,
+		def_pragma( txt("endregion generated code inline implementation")),
+		fmt_newline,
+		def_pragma( txt("region generated AST/Code cast implementation")),
+		fmt_newline,
+		impl_cast_body,
+		impl_cast_attribute,
+		impl_cast_cmt,
+		impl_cast_constr,
+		impl_cast_class,
+		impl_cast_define,
+		impl_cast_destruct,
+		impl_cast_enum,
+		impl_cast_exec,
+		impl_cast_extern,
+		impl_cast_friend,
+		impl_cast_fn,
+		impl_cast_include,
+		impl_cast_module,
+		impl_cast_ns,
+		impl_cast_op,
+		impl_cast_opcast,
+		impl_cast_param,
+		impl_cast_pragma,
+		impl_cast_precond,
+		impl_cast_specs,
+		impl_cast_struct,
+		impl_cast_tmpl,
+		impl_cast_type,
+		impl_cast_typedef,
+		impl_cast_union,
+		impl_cast_using,
+		impl_cast_var,
+		fmt_newline,
+		def_pragma( txt("endregion generated AST/Code cast implementation")),
+		fmt_newline
+	));
+
+	return result;
+#pragma pop_macro("rcast")
+#pragma pop_macro("log_failure")
+}

project/helpers/undef.macros.hpp

@@ -64,7 +64,7 @@
 #undef stringize
 #undef stringize
 #undef stringize_va
-#undef txt_StrC
+#undef txt
 
 #undef GEN_TIME
 #undef gen_main

project/meson.build

@@ -1,18 +0,0 @@
-project( 'gencpp_bootstrap', 'c', 'cpp', default_options : ['buildtype=debug'] )
-
-includes = include_directories(
-[
-'../project',
-])
-
-sources = [ 'gen.bootstrap.cpp' ]
-
-if get_option('buildtype').startswith('debug')
-
-  add_project_arguments('-DBuild_Debug', language : ['c', 'cpp'])
-
-endif
-
-add_project_arguments('-DGEN_TIME', language : ['c', 'cpp'])
-
-executable( 'gencpp_bootstrap', sources, include_directories : includes )

scripts/.clang-format

@@ -6,16 +6,22 @@ AlignAfterOpenBracket: BlockIndent
 AlignArrayOfStructures: Left
 AlignConsecutiveAssignments:
   Enabled: true
-  AcrossEmptyLines: false
-  AcrossComments: true
+  AcrossEmptyLines: true
+  AcrossComments: false
   AlignCompound: true
   PadOperators: true
-AlignConsecutiveBitFields: AcrossComments
-AlignConsecutiveDeclarations: AcrossComments
+AlignConsecutiveBitFields:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: false
+AlignConsecutiveDeclarations:
+  Enabled: true
+  AcrossEmptyLines: false
+  AcrossComments: false
 AlignConsecutiveMacros:
   Enabled: true
   AcrossEmptyLines: true
-  AcrossComments: true
+  AcrossComments: false
 AlignEscapedNewlines: Left
 AlignOperands: DontAlign
 
@@ -62,7 +68,7 @@ BraceWrapping:
   BeforeWhile: false
 
 BreakAfterAttributes: Always
-# BreakArrays: false
+BreakArrays: true
 # BreakBeforeInlineASMColon: OnlyMultiline
 BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeBraces: Allman
@@ -73,7 +79,7 @@ BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeComma
 BreakStringLiterals: true
 
-ColumnLimit: 180
+ColumnLimit: 160
 
 CompactNamespaces: true
 
@@ -92,18 +98,17 @@ FixNamespaceComments: true
 
 IncludeBlocks: Preserve
 
-
 IndentCaseBlocks: false
-IndentCaseLabels: false
+IndentCaseLabels: true
 IndentExternBlock: AfterExternBlock
 IndentGotoLabels: true
-IndentPPDirectives: AfterHash
+IndentPPDirectives: None
 IndentRequires: true
 IndentWidth: 4
-IndentWrappedFunctionNames: false
+IndentWrappedFunctionNames: true
 
 # InsertNewlineAtEOF: true
-InsertTrailingCommas: Wrapped
+# InsertTrailingCommas: Wrapped
 
 LambdaBodyIndentation: OuterScope
 
@@ -128,7 +133,7 @@ SeparateDefinitionBlocks: Always
 ShortNamespaceLines: 40
 
 SortIncludes: false
-SortUsingDeclarations: true
+SortUsingDeclarations: false
 
 SpaceAfterCStyleCast: false
 SpaceAfterLogicalNot: true

scripts/Readme.md

@@ -8,27 +8,40 @@ Generation, testing, and cleanup scripts for the test directory are found here a
 
 Currently `refactor` only supports naive sort of *find and replace* feature set and will not be able to rename identifiers excluisvely to a specific context (such as only renaming member names of a specific struct, etc).
 
+**Note: The following macros are used with specifiers and token parsing within the library:**
+
+* global
+* internal
+* local_persist
+* forceinline
+* neverinline
+
+IF they are changed the following files would need adjustment:
+
+* `./project/enums/ESpecifier.csv`
+* `./project/enums/ETokType.csv`
+* `./project/helpers/helper.hpp`
+
 ## Build & Run Scripts
 
 **`clean.ps1`**  
 Remove any generated content from the repository.
 
-**`bootstrap.ps1`**  
-Generate a version of gencpp where components are inlined directly to `gen.<hpp/cpp>` and `gen. <hpp/cpp>`  
-Any heavily preprocessed code is not inlined and are instead generated using the code in the `helpers` directory.
+**`build.ps1`**  
+Build bootstrap, singleheader, or tests. Supports MSVC or clang, release or debug.
 
-**`singlheader.build.ps1`**  
-Generate a single-header version of the library where all code that would normally good in the usual four files (see bootstrap) are inlined into a single `gen.hpp` file.  
-As with the bootstrap, any heavily preprocessed code is not inlined and instead generated with helper code.
+```
+args:
+    bootstrap
+    singleheader
+    test
+    clang
+    msvc    : By default this project builds with clang, specifying msvc will build with MSVC.
+    debug
+    release : By default this project builds in debug mode, specifying release will build with optimizations.
+```
 
-**`test.gen.build.ps1`**  
-Build the metaprogram for generating the test code.
+**`package_release.ps1`**  
+Will build the project as fast as possible, then package the release into a zip file.
 
-**`test.gen.ps1`**  
-Build (if not already) the metaprogram for generating test code, then run it to generate code.
-
-**`test.build.ps1`**  
-Build and run metaprogram, build test program.
-
-**`test.run.ps1`**  
-Build and run metaprogram, build and run test program.
+*Note: My env is Windows 11 with MSVC 2022 and clang 16.0.6*

scripts/bootstrap.ci.ps1

@@ -1,70 +0,0 @@
-[string] $type = $null
-[string] $test = $false
-
-foreach ( $arg in $args )
-{
-	if ( $arg -eq "test" )
-	{
-		$test = $true
-	}
-	else
-	{
-		$type = $arg
-	}
-}
-
-$path_root            = git rev-parse --show-toplevel
-$path_project         = Join-Path $path_root project
-$path_project_build   = Join-Path $path_project build
-$path_project_gen     = Join-Path $path_project gen
-
-write-host "`n`nBuilding gencpp bootstrap`n"
-
-if ( -not( Test-Path $path_project_build) )
-{
-# Generate build files for meta-program
-Push-Location $path_project
-	$args_meson  = @()
-	$args_meson += "setup"
-	$args_meson += $path_project_build
-
-	& meson $args_meson
-Pop-Location
-}
-
-# Compile meta-program
-Push-Location $path_root
-	$args_ninja = @()
-	$args_ninja += "-C"
-	$args_ninja += $path_project_build
-
-	& ninja $args_ninja
-Pop-Location
-
-Push-location $path_project
-if ( -not(Test-Path($path_project_gen) )) {
-	New-Item -ItemType Directory -Path $path_project_gen
-}
-
-# Run meta-program
-$gencpp_bootstrap = Join-Path $path_project_build gencpp_bootstrap.exe
-
-Write-Host `nRunning gencpp bootstrap...
-& $gencpp_bootstrap
-
-# Format generated files
-Write-Host `nBeginning format...
-$formatParams = @(
-	'-i'          # In-place
-	'-style=file:../scripts/.clang-format'
-	'-verbose'
-)
-
-$include = @('gen.hpp', 'gen.cpp', 'gen_dep.hpp', 'gen_dep.cpp')
-$exclude = $null
-
-$targetFiles = @(Get-ChildItem -Recurse -Path $path_project_gen -Include $include -Exclude $exclude | Select-Object -ExpandProperty FullName)
-
-clang-format $formatParams $targetFiles
-Write-Host "`nFormatting complete"
-Pop-Location

scripts/bootstrap.ps1

@@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'bootstrap.ci.ps1') $args" 

scripts/build.ci.ps1

@@ -0,0 +1,472 @@
+# This build script was written to build on windows, however I did setup some generalization to allow for cross platform building.
+# 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
+
+Push-Location $path_root
+
+#region Arguments
+       $vendor       = $null
+       $release      = $null
+[bool] $bootstrap    = $false
+[bool] $singleheader = $false
+[bool] $test         = $false
+
+[array] $vendors = @( "clang", "msvc" )
+
+# This is a really lazy way of parsing the args, could use actual params down the line...
+
+if ( $args ) { $args | ForEach-Object {
+	switch ($_){
+		{ $_ -in $vendors }   { $vendor      = $_; break }
+		"release"             { $release      = $true }
+		"debug"               { $release      = $false }
+		"bootstrap"           { $bootstrap    = $true }
+		"singleheader"        { $singleheader = $true }
+		"test"                { $test         = $true }
+	}
+}}
+#endregion Arguments
+
+#region Configuration
+if ($IsWindows) {
+	# This library was really designed to only run on 64-bit systems.
+	# (Its a development tool after all)
+    & $devshell -arch amd64
+}
+
+if ( $vendor -eq $null ) {
+	write-host "No vendor specified, assuming clang available"
+	$compiler = "clang"
+}
+
+if ( $release -eq $null ) {
+	write-host "No build type specified, assuming debug"
+	$release = $false
+}
+
+if ( $bootstrap -eq $false -and $singleheader -eq $false -and $test -eq $false ) {
+	throw "No build target specified. One must be specified, this script will not assume one"
+}
+
+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
+	}
+}
+
+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_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 = '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_test         = Join-Path $path_root test
+
+if ( $bootstrap )
+{
+	$path_build    = join-path $path_project build
+	$path_gen      = join-path $path_project gen
+	$path_comp_gen = join-path $path_project components/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
+	}
+	if ( -not(Test-Path($path_comp_gen) )) {
+		New-Item -ItemType Directory -Path $path_comp_gen
+	}
+
+	$includes   = @( $path_project)
+	$unit       = join-path $path_project "bootstrap.cpp"
+	$executable = join-path $path_build   "bootstrap.exe"
+
+	build-simple $includes $unit $executable
+
+	Push-Location $path_project
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning bootstrap"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`nBootstrap completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+}
+
+if ( $singleheader )
+{
+	$path_build = join-path $path_singleheader build
+	$path_gen   = join-path $path_singleheader 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_singleheader "singleheader.cpp"
+	$executable = join-path $path_build        "singleheader.exe"
+
+	build-simple $includes $unit $executable
+
+	Push-Location $path_singleheader
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning singleheader generator"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`nSingleheader generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+}
+
+if ( $test )
+{
+	$path_gen       = join-path $path_test gen
+	$path_gen_build = join-path $path_gen  build
+	$path_build     = join-path $path_test build
+
+	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
+	}
+	if ( -not(Test-Path($path_gen_build) ))  {
+		New-Item -ItemType Directory -Path $path_gen_build
+	}
+
+	$path_bootstrap = join-path $path_project gen
+
+	$includes    = @( $path_bootstrap )
+	$unit       = join-path $path_test  "test.cpp"
+	$executable = join-path $path_build "test.exe"
+
+	build-simple $includes $unit $executable
+
+	Push-Location $path_test
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning test generator"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`nTest generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+}
+#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")) )
+{
+	$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',
+		'gen.builder.hpp', 'gen.builder.cpp'
+		'gen.scanner.hpp', 'gen.scanner.cpp'
+	)
+	$exclude  = $null
+	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")) )
+{
+	$path_gen = join-path $path_singleheader gen
+	$include  = @(
+		'gen.hpp'
+	)
+	$exclude  = $null
+	format-cpp $path_gen $include $exclude
+}
+
+if ( $test )
+{
+	$path_gen = join-path $path_test gen
+	$include  = @(
+		'*.gen.hpp'
+	)
+	$exclude  = $null
+	format-cpp $path_gen $include $exclude
+}
+#endregion Formatting
+
+Pop-Location # $path_root

scripts/build.ps1

@@ -0,0 +1,3 @@
+cls
+$build = Join-Path $PSScriptRoot 'build.ci.ps1'
+& $build @args

scripts/clean.ps1

@@ -7,9 +7,9 @@ $path_singleheader_build = Join-Path $path_singleheader build
 $path_singleheader_gen	 = Join-Path $path_singleheader gen
 $path_test               = Join-Path $path_root test
 $path_test_build         = Join-Path $path_test build
-$path_gen                = Join-Path $path_test gen
-$path_gen_build          = Join-Path $path_gen  build
+$path_test_gen           = Join-Path $path_test gen
 $path_x64				 = Join-Path $path_root x64
+$path_release			 = Join-Path $path_root release
 
 if ( Test-Path $path_project_build)
 {
@@ -36,9 +36,9 @@ if ( Test-Path $path_test_build )
 	Remove-Item $path_test_build -Recurse
 }
 
-if ( Test-Path $path_gen_build )
+if ( Test-Path $path_test_gen )
 {
-	Remove-Item $path_gen_build -Recurse
+	Remove-Item $path_test_gen -Recurse
 }
 
 if ( Test-Path $path_x64)
@@ -46,22 +46,10 @@ if ( Test-Path $path_x64)
 	Remove-Item $path_x64 -Recurse
 }
 
-# [string[]] $include = 'gen.hpp', 'gen.cpp', 'gen_dep.hpp', 'gen_dep.cpp'
-# [string[]] $exclude =
-
-# $files = Get-ChildItem -Recurse -Path $path_project_gen -Include $include -Exclude $exclude
-
-# if ( $files )
-# {
-# 	Remove-Item $files
-# }
-
-# $files = Get-ChildItem -Recurse -Path $path_singleheader_gen -Include $include -Exclude $exclude
-
-# if ( $files )
-# {
-# 	Remove-Item $files
-# }
+if ( Test-Path $path_release )
+{
+	Remove-Item $path_release -Recurse
+}
 
 $include = '*.h', '*.hpp', '*.cpp'
 $exclude =

scripts/gencpp.natvis

@@ -48,8 +48,8 @@
 				<DisplayString>{(Header*)((char*)Data - sizeof(Header))}</DisplayString>
 				<Expand>
 					<Item Name="Allocator">((Header*)((char*)Data - sizeof(Header)))->Allocator</Item>
-					<Item Name="Length">((Header*)((char*)Data - sizeof(Header)))->Length</Item>
 					<Item Name="Capacity">((Header*)((char*)Data - sizeof(Header)))->Capacity</Item>
+					<Item Name="Length">((Header*)((char*)Data - sizeof(Header)))->Length</Item>
 				</Expand>
 			</Synthetic>
 		</Expand>
@@ -213,7 +213,7 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::AST_Namespace">
+	<Type Name="gen::AST_NS">
 		<DisplayString>{Name} Type: {Type}</DisplayString>
 		<Expand>
 			<Item Name="ModuleFlags">ModuleFlags</Item>
@@ -498,7 +498,7 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::CodeNamespace">
+	<Type Name="gen::CodeNS">
 		<DisplayString Condition="ast == nullptr">Null</DisplayString>
 		<DisplayString Condition="ast != nullptr">{ast->Name} {ast->Type}</DisplayString>
 		<Expand>

scripts/gencpp.refactor

@@ -21,8 +21,8 @@
 // Gen Macro namespace
 // namespace GEN_, new_namespace_
 
-// ---------- ZPL Macros
-
+// ---------- Dependency Macros
+    // Platform
 // word GEN_ARCH_64_BIT, new_name
 // word GEN_ARCH_32_BIT, new_name
 
@@ -43,20 +43,86 @@
 // word GEN_COMPILER_MINGW, new_name
 // word GEN_COMPILER_MSVC,  new_name
 
-// word forceinline, new_name
-// word neverinline, new_name
-
+    // General
 // word zpl_cast, new_name
 
 // word global,        new_name
 // word internal,      new_name
 // word local_persist, new_name
+// word forceinline,   new_name
+// word neverinline,   new_name
 
+// word bit,               new_name
+// word bitfield_is_equal, new_name
+
+// word ccast, new_name
+// word pcast, new_name
+// word rcast, new_name
+// word scast, new_name
+
+// word num_args,      new_name
+// word num_args_impl, new_name
+
+// word stringize,    new_name
+// word stringize_va, new_name
+
+// word do_once,           new_name
+// word do_once_start,     new_name
+// word do_once_end,       new_name
+// word label_scope_start, new_name
+// word label_scope_end,   new_name
+
+// word count_of,   new_name
+// word is_between, new_name
+// word min,        new_name
+// word size_of,    new_name
+// word offset_of,  new_name
+// word swap,       new_name
+
+    // Basic Types
+// word GEN_U8_MIN, new_name
+// word GEN_U8_MAX, new_name
+// word GEN_I8_MIN, new_name
+// word GEN_I8_MAX, new_name
+
+// word GEN_U16_MIN, new_name
+// word GEN_U16_MAX, new_name
+// word GEN_I16_MIN, new_name
+// word GEN_I16_MAX, new_name
+
+// word GEN_U32_MIN, new_name
+// word GEN_U32_MAX, new_name
+// word GEN_I32_MIN, new_name
+// word GEN_I32_MAX, new_name
+
+// word GEN_U64_MIN, new_name
+// word GEN_U64_MAX, new_name
+// word GEN_I64_MIN, new_name
+// word GEN_I64_MAX, new_name
+
+// word GEN_USIZE_MIN, new_name
+// word GEN_USIZE_MAX, new_name
+// word GEN_ISIZE_MIN, new_name
+// word GEN_ISIZE_MAX, new_name
+
+// word GEN_F32_MIN, new_name
+// word GEN_F32_MAX, new_name
+// word GEN_F64_MIN, new_name
+// word GEN_F64_MAX, new_name
+
+    // Debug
 // word GEN_DEBUG_TRAP,      new_name
 // word GEN_ASSERT,          new_name
 // word GEN_ASSERT_MSG,      new_name
 // word GEN_ASSERT_NOT_NULL, new_name
 // word GEN_PANIC,           new_name
+// word GEN_FATAL,           new_name
+
+    // Memory
+// word kilobytes, new_name
+// word megabytes, new_name
+// word gigabytes, new_name
+// word terabytes, new_name
 
 // word zero_item,  new_name
 // word zero_array, new_name
@@ -67,13 +133,11 @@
 // word malloc, new_name
 // word mfree,  new_name
 
-// word count_of,   new_name
-// word is_between, new_name
-// word min,        new_name
-// word size_of,    new_name
-// word swap,       new_name
+    // Strings
+// word txt, new_name
+// word cast_to_strc, new_name
 
-// ---------- ZPL Types
+// ---------- Dependency Types
 
 // word b8,   new_name
 // word b16,  new_name
@@ -114,11 +178,11 @@
 // word FileStandardType, new_name
 // word SeekWhenceType,   new_name
 
-// ---------- ZPL Data
+// ---------- Dependency Data
 
 // word default_file_operations, new_name
 
-// ---------- ZPL Procedures
+// ---------- Dependency Procedures
 
 // word align_forward,          new_name
 // word align_fordward_i64,     new_name
@@ -158,6 +222,7 @@
 // word hex_digit_to_int,	    new_name
 // word i64_to_str,			    new_name
 // word is_power_of_two,        new_name
+// word log_fmt,                new_name
 // word mem_copy,               new_name
 // word mem_move,               new_name
 // word mem_set,                new_name
@@ -189,22 +254,10 @@
 
 // ---------- gencpp Macros
 
-// word bit,               new_name
-// word bitfield_is_equal, new_name
+// word log_failure, new_name
 
-// word ccast, new_name
-// word pcast, new_name
-// word rcast, new_name
-// word scast, new_name
-
-// word do_once,       new_name
-// word do_once_start, new_name
-// word do_once_end,   new_name
-// word num_args,      new_name
-// word num_args_impl, new_name
-// word stringize,     new_name
-// word stringize_va,  new_name
-// word txt_StrC,      new_name
+// word NoCode,      new_name
+// word CodeInvalid, new_name
 
 // ------------ gencpp common
 
@@ -215,16 +268,13 @@
 // word StrC,      new_name
 // word String,    new_name
 
-// word log_fmt,  new_name
-// word fatal,    new_name
-// word to_str,   new_name
-// word to_StrC,  new_name
-// word to_type,  new_name
+// word to_str,  new_name
+// word to_str,  new_name
+// word to_type, new_name
 
 // ------------ gencpp Types & Constants
 
 // word LogFailType, new_name
-// word log_failure, new_name
 
 // word AccessSpec,     new_name
 // word ECode,          new_name
@@ -251,7 +301,6 @@
 // word Code,         new_name
 // word Code_POD,     new_name
 // word Keyword,      new_name
-// word NoCode,       new_name
 
 // ------------ gencpp API
 
@@ -277,6 +326,9 @@
 // word def_attributes,      new_name
 // word def_comment,         new_name
 // word def_class,           new_name
+// word def_constructor,     new_name
+// word def_destructor,      new_name
+// word def_define,          new_name
 // word def_enum,            new_name
 // word def_execution,       new_name
 // word def_extern_link,     new_name
@@ -286,7 +338,10 @@
 // word def_module,          new_name
 // word def_namespace,       new_name
 // word def_operator,        new_name
+// word def_operator_cast,   new_name
 // word def_param,           new_name
+// word def_pargma,          new_name
+// word def_preprocess_cond, new_name
 // word def_specifier,       new_name
 // word def_struct,          new_name
 // word def_template,        new_name
@@ -343,22 +398,24 @@
 // word untyped_fmt,       new_name
 // word untyped_token_fmt, new_name
 
-// ------------ File Handling
+// ------------ File Ops
 
 // word Builder, new_name
 // word Editor,  new_name
 // word Scanner, new_name
 
-// ------------ gencpp macros
+// ------------ gencpp user macros
 
 // word gen_main,     new_name
 // word GEN_TIME,     new_name
 
-// word __,           new_name
-// word code,         new_name
-// word name,         new_name
-// word args,         new_name
-// word token_fmt,    new_name
+// word __,        new_name
+// word name,      new_name
+// word code,      new_name
+// word args,      new_name
+// word code_str,  new_name
+// word code_fmt,  new_name
+// word token_fmt, new_name
 
 // ------------ Type AST namespace
 // namespace t_, new_namespace_

scripts/helpers/devshell.ps1

@@ -0,0 +1,27 @@
+if ($env:VCINSTALLDIR) {
+    return
+}
+
+$ErrorActionPreference = "Stop"
+
+# Use vswhere to find the latest Visual Studio installation
+$vswhere_out = & "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath
+if ($null -eq $vswhere_out) {
+    Write-Host "ERROR: Visual Studio installation not found"
+    exit 1
+}
+
+# Find Launch-VsDevShell.ps1 in the Visual Studio installation
+$vs_path     = $vswhere_out
+$vs_devshell = Join-Path $vs_path "\Common7\Tools\Launch-VsDevShell.ps1"
+
+if ( -not (Test-Path $vs_devshell) ) {
+    Write-Host "ERROR: Launch-VsDevShell.ps1 not found in Visual Studio installation"
+    Write-Host Tested path: $vs_devshell
+    exit 1
+}
+
+# Launch the Visual Studio Developer Shell
+Push-Location
+& $vs_devshell @args
+Pop-Location

scripts/helpers/target_arch.psm1

@@ -0,0 +1,25 @@
+# target_arch.psm1
+
+function Get-TargetArchClang {
+    # Get the target architecture by querying clang itself
+    $output = & clang -v 2>&1
+    foreach ($line in $output) {
+        if ($line -like "*Target:*") {
+            $clangTarget = ($line -split ':')[1].Trim()
+            return $clangTarget
+        }
+    }
+    throw "Clang target architecture could not be determined."
+}
+
+function Get-TargetArchMSVC {
+    # Assuming you've set the Visual Studio environment variables using `vcvarsall.bat`
+    # This looks for the `VSCMD_ARG_TGT_ARCH` environment variable which Visual Studio sets to indicate the target architecture.
+    $arch = $env:VSCMD_ARG_TGT_ARCH
+    if (-not $arch) {
+        throw "MSVC target architecture could not be determined. Ensure you've initialized the Visual Studio environment."
+    }
+    return $arch
+}
+
+Export-ModuleMember -Function Get-TargetArchClang, Get-TargetArchMSVC

scripts/msvc/build_msvc.ps1

@@ -1,16 +0,0 @@
-cls
-
-if ( -not( Test-Path $path_build ) ) {
-	New-Item -ItemType Directory -Path $path_build | Out-Null
-}
-if ( -not( Test-Path $path_build_interm ) ) {
-	New-Item -ItemType Directory -Path $path_build_interm | Out-Null
-}
-
-$path_root       = git rev-parse --show-toplevel
-$path_build      = Join-Path $path_root build
-$path_gen        = Join-Path $path_test gen
-$path_gen_build  = Join-Path $path_gen  build
-$path_scripts    = Join-Path $path_root scripts
-$path_test       = Join-Path $path_root test
-$path_test_build = Join-Path $path_test build

scripts/msvc/devshell.ps1

@@ -1,26 +0,0 @@
-# This script is used to iniitate the MSVC DevShell
-$vs_devshell = @()
-@("enterprise", "professional", "community") | ForEach-Object {
-    $vs_devshell_2022 = "C:\Program Files\Microsoft Visual Studio\2022\"       + $_ + "\Common7\Tools\Launch-VsDevShell.ps1"
-    $vs_devshell_2019 = "C:\Program Files (x86)\Microsoft Visual Studio\2019\" + $_ + "\Common7\Tools\Launch-VsDevShell.ps1"
-
-    $vs_devshell += @( $vs_devshell_2022, $vs_devshell_2019 )
-}
-
-$found = $false
-foreach($path in $vs_devshell) {
-    if (Test-Path $path) {
-        write-host "Found $path"
-
-        Push-Location # Save the current path, loading the script will change it.
-        & $path
-        Pop-Location
-
-        $found = $true
-        break;
-    }
-}
-
-if (-not $found) {
-    write-host "MSVC DevShell: No valid path found"
-}

scripts/package_release.ps1

@@ -0,0 +1,48 @@
+cls
+
+$build = Join-Path $PSScriptRoot 'build.ci.ps1'
+
+if ( $IsWindows ) {
+	& $build release msvc bootstrap singleheader
+}
+else {
+	& $build release clang bootstrap singleheader
+}
+
+$path_root             = git rev-parse --show-toplevel
+$path_docs			   = Join-Path $path_root docs
+$path_project          = Join-Path $path_root project
+$path_project_gen      = Join-Path $path_project gen
+$path_singleheader	   = Join-Path $path_root singleheader
+$path_singleheader_gen = Join-Path $path_singleheader gen
+$path_release          = Join-Path $path_root release
+$path_release_content  = Join-Path $path_release content
+
+if ( -not(Test-Path $path_release) ) {
+	New-Item -ItemType Directory -Path $path_release
+}
+
+if ( -not(Test-Path $path_release_content) ) {
+	New-Item -ItemType Directory -Path $path_release_content
+}
+
+$license        = Join-Path $path_root LICENSE
+$readme_root    = Join-Path $path_root Readme.md
+$readme_docs    = Join-Path $path_docs Readme.md
+$readme_parsing = Join-Path $path_docs Parsing.md
+
+Copy-Item $license		  -Destination (Join-Path $path_release_content "LICENSE")
+Copy-Item $readme_root    -Destination (Join-Path $path_release_content "Readme.md")
+Copy-Item $readme_docs    -Destination (Join-Path $path_release_content "Readme_Docs.md")
+Copy-Item $readme_parsing -Destination (Join-Path $path_release_content "Parsing.md")
+
+# Singleheader
+Copy-Item        -Path $path_singleheader_gen\gen.hpp -Destination $path_release_content\gen.hpp
+Compress-Archive -Path $path_release_content\*        -DestinationPath $path_release\gencpp_singleheader.zip -Force
+Remove-Item      -Path $path_release_content\gen.hpp
+
+# Segmented
+Copy-Item        -Path $path_project_gen\*     -Destination $path_release_content
+Compress-Archive -Path $path_release_content\* -DestinationPath $path_release\gencpp_segmented.zip -Force
+
+Remove-Item -Path $path_release_content -Recurse

scripts/singleheader.ci.ps1

@@ -1,70 +0,0 @@
-[string] $type = $null
-[string] $test = $false
-
-foreach ( $arg in $args )
-{
-	if ( $arg -eq "test" )
-	{
-		$test = $true
-	}
-	else
-	{
-		$type = $arg
-	}
-}
-
-$path_root               = git rev-parse --show-toplevel
-$path_singleheader       = Join-Path $path_root singleheader
-$path_singleheader_build = Join-Path $path_singleheader build
-$path_singleheader_gen   = Join-Path $path_singleheader gen
-
-write-host "`n`nBuilding gencpp singleheader`n"
-
-if ( -not( Test-Path $path_singleheader_build) )
-{
-# Generate build files for meta-program
-Push-Location $path_singleheader
-	$args_meson  = @()
-	$args_meson += "setup"
-	$args_meson += $path_singleheader_build
-
-	& meson $args_meson
-Pop-Location
-}
-
-# Compile meta-program
-Push-Location $path_root
-	$args_ninja = @()
-	$args_ninja += "-C"
-	$args_ninja += $path_singleheader_build
-
-	& ninja $args_ninja
-Pop-Location
-
-Push-location $path_singleheader
-if ( -not(Test-Path($path_singleheader_gen) )) {
-	New-Item -ItemType Directory -Path $path_singleheader_gen
-}
-
-# Run meta-program
-$gencpp_singleheader = Join-Path $path_singleheader_build gencpp_singleheader.exe
-
-Write-Host `nRunning gencpp singleheader...
-& $gencpp_singleheader
-
-# Format generated files
-Write-Host `nBeginning format...
-$formatParams = @(
-	'-i'          # In-place
-	'-style=file:../scripts/.clang-format'
-	'-verbose'
-)
-
-$include = @('gen.hpp')
-$exclude = $null
-
-$targetFiles = @(Get-ChildItem -Recurse -Path $path_project -Include $include -Exclude $exclude | Select-Object -ExpandProperty FullName)
-
-clang-format $formatParams $targetFiles
-Write-Host "`nFormatting complete"
-Pop-Location

scripts/singleheader.ps1

@@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'singleheader.ci.ps1') $args" 

scripts/test.gen_build.ci.ps1

@@ -1,45 +0,0 @@
-[string] $type = $null
-[string] $test = $false
-
-foreach ( $arg in $args )
-{
-	if ( $arg -eq "test" )
-	{
-		$test = $true
-	}
-	else
-	{
-		$type = $arg
-	}
-}
-
-$path_root       = git rev-parse --show-toplevel
-$path_build      = Join-Path $path_root build
-$path_scripts    = Join-Path $path_root scripts
-$path_test       = Join-Path $path_root test
-$path_gen        = Join-Path $path_test gen
-$path_test_build = Join-Path $path_test build
-$path_gen_build  = Join-Path $path_gen  build
-
-write-host "`n`nBuilding Test`n"
-
-if ( -not( Test-Path $path_gen_build ) )
-{
-# Generate build files for meta-program
-Push-Location $path_gen
-	$args_meson  = @()
-	$args_meson += "setup"
-	$args_meson += $path_gen_build
-
-	& meson $args_meson
-Pop-Location
-}
-
-# Compile meta-program
-Push-Location $path_root
-	$args_ninja = @()
-	$args_ninja += "-C"
-	$args_ninja += $path_gen_build
-
-	& ninja $args_ninja
-Pop-Location

scripts/test.gen_build.ps1

@@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'test.gen_build.ci.ps1') $args" 

scripts/test.gen_run.ps1

@@ -1,97 +0,0 @@
-[string] $type = $null
-[string] $test = $false
-
-foreach ( $arg in $args )
-{
-	if ( $arg -eq "test" )
-	{
-		$test = $true
-	}
-	else
-	{
-		$type = $arg
-	}
-}
-
-$path_root       = git rev-parse --show-toplevel
-$path_build      = Join-Path $path_root build
-$path_scripts    = Join-Path $path_root scripts
-$path_test       = Join-Path $path_root test
-$path_gen        = Join-Path $path_test gen
-$path_test_build = Join-Path $path_test build
-$path_gen_build  = Join-Path $path_gen  build
-
-write-host "`n`nBuilding Test`n"
-
-if ( -not( Test-Path $path_gen_build ) )
-{
-# Generate build files for meta-program
-Push-Location $path_gen
-	$args_meson  = @()
-	$args_meson += "setup"
-	$args_meson += $path_gen_build
-
-	& meson $args_meson
-Pop-Location
-}
-
-# Compile meta-program
-Push-Location $path_root
-	$args_ninja = @()
-	$args_ninja += "-C"
-	$args_ninja += $path_gen_build
-
-	& ninja $args_ninja
-Pop-Location
-
-Push-location $path_gen
-# Run meta-program
-	$gencpp = Join-Path $path_gen_build gencpp.exe
-
-	Write-Host `nRunning tests...
-	& $gencpp
-
-# Format generated files
-	$path_clang_format = Join-Path $path_scripts .clang-format
-
-	Write-Host `nBeginning format...
-	$formatParams = @(
-		'-i'          # In-place
-		"-style=file:$path_clang_format" # Search for a .clang-format file in the parent directory of the source file.
-		'-verbose'
-	)
-
-	$include = @('*.gen.hpp', '*.gen.cpp')
-	$exclude = $null
-
-	$targetFiles = @(Get-ChildItem -Recurse -Path $path_gen -Include $include -Exclude $exclude | Select-Object -ExpandProperty FullName)
-
-	clang-format $formatParams $targetFiles
-	Write-Host "`nFormatting complete"
-Pop-Location
-
-# Build the program depending on generated files.
-if ( -not( Test-Path $path_test_build ) )
-{
-Push-Location $path_test
-	$args_meson = @()
-	$args_meson += "setup"
-	$args_meson += $path_test_build
-
-# 	& meson $args_meson
-Pop-Location
-}
-
-Push-Location $path_root
-	$args_ninja = @()
-	$args_ninja += "-C"
-	$args_ninja += $path_test_build
-
-	# ninja $args_ninja
-Pop-Location
-
-Push-Location $path_test
-	$testcpp = Join-Path $path_test_build testcpp.exe
-
-	# & $testcpp
-Pop-Location

singleheader/components/header_start.hpp

@@ -11,4 +11,13 @@
 */
 #if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
 #	error Gen.hpp : GEN_TIME not defined
-#endif
+#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
+

singleheader/gen.singleheader.cpp

@@ -1,212 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
-#include "gen.cpp"
-#include "file_processors/scanner.hpp"
-#include "helpers/helper.hpp"
-
-using namespace gen;
-
-bool namespace_by_default = true;
-
-constexpr StrC nspace_default = txt_StrC(R"(
-#if defined(GEN_DONT_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
-#elif ! defined(GEN_NS_BEGIN)
-#  define GEN_NS_BEGIN namespace gen {
-#  define GEN_NS_END   }
-#endif
-)");
-
-constexpr StrC nspace_non_default = txt_StrC(R"(
-#if ! defined(GEN_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
-#	define GEN_NS_BEGIN
-#	define GEN_NS_END
-#elif ! defined(GEN_NS_BEGIN)
-#  define GEN_NS_BEGIN namespace gen {
-#  define GEN_NS_END   }
-#endif
-)");
-
-constexpr StrC implementation_guard_start = txt_StrC(R"(
-#pragma region GENCPP IMPLEMENTATION GUARD
-#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
-#	define GEN_IMPLEMENTED
-)");
-
-constexpr StrC implementation_guard_end = txt_StrC(R"(
-#endif
-#pragma endregion GENCPP IMPLEMENTATION GUARD
-)");
-
-constexpr StrC roll_own_dependencies_guard_start = txt_StrC(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_StrC(R"(
-// GEN_ROLL_OWN_DEPENDENCIES
-#endif
-
-)");
-
-int gen_main()
-{
-	gen::init();
-
-#define project_dir "../project/"
-
-	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 header_start = scan_file( "components/header_start.hpp" );
-	Code nspace_macro = untyped_str( namespace_by_default ? nspace_default : nspace_non_default );
-
-	Builder
-	header;
-	header.open( "gen/gen.hpp" );
-	header.print( push_ignores );
-
-	header.print_fmt("#pragma once\n\n");
-
-	// Headers
-	{
-		header.print( header_start );
-		header.print( nspace_macro );
-
-		{
-			header.print_fmt( roll_own_dependencies_guard_start );
-
-			Code header_start  = scan_file( project_dir "dependencies/header_start.hpp" );
-			Code macros        = scan_file( project_dir "dependencies/macros.hpp" );
-			Code basic_types   = scan_file( project_dir "dependencies/basic_types.hpp" );
-			Code debug         = scan_file( project_dir "dependencies/debug.hpp" );
-			Code memory	       = scan_file( project_dir "dependencies/memory.hpp" );
-			Code string_ops    = scan_file( project_dir "dependencies/string_ops.hpp" );
-			Code printing      = scan_file( project_dir "dependencies/printing.hpp" );
-			Code containers    = scan_file( project_dir "dependencies/containers.hpp" );
-			Code hashing 	   = scan_file( project_dir "dependencies/hashing.hpp" );
-			Code string        = scan_file( project_dir "dependencies/string.hpp" );
-			Code file_handling = scan_file( project_dir "dependencies/file_handling.hpp" );
-			Code parsing       = scan_file( project_dir "dependencies/parsing.hpp" );
-			Code timing        = scan_file( project_dir "dependencies/timing.hpp" );
-
-			header.print( header_start );
-			header.print_fmt( "GEN_NS_BEGIN\n\n" );
-			header.print( macros );
-			header.print( basic_types );
-			header.print( debug );
-			header.print( memory );
-			header.print( string_ops );
-			header.print( printing );
-			header.print( containers );
-			header.print( hashing );
-			header.print( string );
-			header.print( file_handling );
-			header.print( parsing );
-			header.print( timing );
-			header.print_fmt( "GEN_NS_END\n" );
-
-			header.print_fmt( roll_own_dependencies_guard_end );
-		}
-
-		Code types        = scan_file( project_dir "components/types.hpp" );
-		Code data_structs = scan_file( project_dir "components/data_structures.hpp" );
-		Code interface    = scan_file( project_dir "components/interface.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" );
-
-		Code builder = scan_file( project_dir "file_processors/builder.hpp" );
-
-		header.print_fmt( "GEN_NS_BEGIN\n\n" );
-
-		header.print_fmt("#pragma region Types\n\n");
-		header.print( types );
-		header.print( ecode );
-		header.print( eoperator );
-		header.print( especifier );
-		header.print_fmt("#pragma endregion Types\n\n");
-
-		header.print( data_structs );
-		header.print( interface );
-		header.print( header_end );
-		header.print( builder );
-		header.print_fmt( "GEN_NS_END\n" );
-	}
-
-	// Implementation
-	{
-		header.print_fmt( "%s\n", (char const*) implementation_guard_start );
-		{
-			header.print_fmt( roll_own_dependencies_guard_start );
-
-			Code impl_start = scan_file( project_dir "dependencies/impl_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 parsing    = scan_file( project_dir "dependencies/parsing.cpp" );
-			Code hashing    = scan_file( project_dir "dependencies/hashing.cpp" );
-			Code string     = scan_file( project_dir "dependencies/string.cpp" );
-			Code timing     = scan_file( project_dir "dependencies/timing.cpp" );
-
-			Code file_handling = scan_file( project_dir "dependencies/file_handling.cpp" );
-
-			header.print_fmt( "GEN_NS_BEGIN\n\n");
-			header.print( impl_start );
-			header.print( debug );
-			header.print( string_ops );
-			header.print( printing );
-			header.print( memory );
-			header.print( parsing );
-			header.print( hashing );
-			header.print( string );
-			header.print( timing );
-
-			header.print( file_handling );
-
-			header.print_fmt( "GEN_NS_END\n");
-
-			header.print_fmt( roll_own_dependencies_guard_end );
-		}
-
-		Code 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/untyped.cpp" );
-
-		CodeBody etoktype = gen_etoktype( project_dir "enums/ETokType.csv", project_dir "enums/AttributeTokens.csv" );
-		CodeNamespace parser_nspace = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
-
-		Code builder = scan_file( project_dir "file_processors/builder.cpp" );
-
-		header.print_fmt( "GEN_NS_BEGIN\n\n");
-		header.print( data );
-		header.print( ast_case_macros );
-		header.print( ast );
-		header.print( interface );
-		header.print( upfront );
-		header.print( parser_nspace );
-		header.print( parsing );
-		header.print( untyped );
-			header.print( builder );
-		header.print_fmt( "GEN_NS_END\n");
-
-		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
-	}
-
-	header.print( pop_ignores );
-	header.write();
-
-	gen::deinit();
-	return 0;
-}