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

More formatting fixes
Formatting fixes
2025-06-15 03:01:47 -07:00 · 2023-08-22 02:17:28 -04:00 · 2023-08-22 02:09:20 -04:00 · 2023-08-22 01:51:59 -04:00 · 2023-08-22 00:40:38 -04:00 · 2023-08-21 23:49:23 -04:00
112 changed files with 5853 additions and 2417 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,6 @@
 .idea

-build/*
+**/build/*
 .vs

 **/*.gen.*
@ -30,4 +30,5 @@ bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
-[Ll]ogs/
+[Ll]ogs/
+vc140.pdb
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@ -1,7 +1,7 @@
 {
    "configurations": [
        {
-            "name": "Win32",
+            "name": "Win32 msvc",
            "includePath": [
                "${workspaceFolder}/**"
            ],
@ -9,7 +9,27 @@
                "_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",
--- a/.vscode/launch.json
+++ b/.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"
--- a/.vscode/settings.json
+++ b/.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,
--- a/Readme.md
+++ b/Readme.md
@ -6,7 +6,7 @@ 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, it should be easy to intergrate into a user's their project domain.
+its not meant to be a black box metaprogramming utility, it should be easy to intergrate into a user's project domain.

 ## Notes

--- a/docs/Parsing.md
+++ b/docs/Parsing.md
@ -30,7 +30,7 @@ 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***, and ***pragmas**.  
+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:

@ -40,7 +40,6 @@ The keywords supported for the preprocessor are:
 * ifdef
 * elif
 * endif
-* undef
 * pragma

 Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.  
@ -69,4 +68,4 @@ The lexing and parsing takes shortcuts from whats expected in the standard.
  * *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 for ast serialization.
+Empty lines used throughout the file are preserved for formatting purposes during ast serialization.
--- a/docs/Readme.md
+++ b/docs/Readme.md
@ -40,15 +40,6 @@ Otherwise the library is free of any templates.

 ### *WHAT IS NOT PROVIDED*

-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    : ^^
-
 **There is no support for validating expressions.**  
 Its difficult to parse without enough benefits (At the metaprogramming level).  

@ -70,7 +61,7 @@ Use at your own mental peril.

 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:
@ -369,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
@ -456,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
@ -471,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.
@ -495,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**

@ -504,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().  
--- a/gencpp.vcxproj
+++ b/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">
--- a/gencpp.vcxproj.filters
+++ b/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" />
--- a/project/file_processors/builder.cpp
+++ b/project/file_processors/builder.cpp
@ -1,3 +1,5 @@
+#include "builder.hpp"
+
 Builder Builder::open( char const* path )
 {
 	Builder result;
@ -12,6 +14,7 @@ Builder Builder::open( char const* path )

 	result.Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );

+	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
 	return result;
 }

@ -22,7 +25,11 @@ void Builder::pad_lines( s32 num )

 void Builder::print( Code code )
 {
-	Buffer.append( code->to_string() );
+	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, ... )
@ -35,6 +42,7 @@ void Builder::print_fmt( char const* 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 );
 }

@ -43,8 +51,9 @@ 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 ) );
+		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();
 }
--- a/project/file_processors/builder.hpp
+++ b/project/file_processors/builder.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "gen.hpp"
+
 struct Builder
 {
 	FileInfo File;
--- a/project/file_processors/editor.hpp
+++ b/project/file_processors/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
-};
--- a/project/auxillary/scanner.cpp
+++ b/project/auxillary/scanner.cpp
@ -0,0 +1 @@
+#include "scanner.hpp"
--- a/project/auxillary/scanner.hpp
+++ b/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
+
--- a/project/bootstrap.cpp
+++ b/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;
+}
--- a/project/components/ast.cpp
+++ b/project/components/ast.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "static_data.cpp"
+
 Code Code::Global;
 Code Code::Invalid;

@ -26,7 +29,7 @@ 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:
@ -40,33 +43,35 @@ String AST::to_string()

 		case Comment:
 		{
-			result.append("\n");
+			if ( Prev && Prev->Type != Comment && Prev->Type != NewLine )
+				result.append( "\n" );

-			static char line[MaxCommentLineLength];
+			static char line[ MaxCommentLineLength ];

-			s32 left  = Content.length();
-			s32 index = 0;
-			s32 curr  = 0;
+			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--;
-					index++;
 				}
-				index++;
-
-				str_copy( line, Content + curr, length );
-				result.append_fmt( "//%.*s", length, line );
-				mem_set( line, 0, MaxCommentLineLength);
-
 				length++;
-				left--;
-				curr = index;
+
+				str_copy( line, scanner, length );
+				result.append_fmt( "//%.*s", length, line );
+				mem_set( line, 0, MaxCommentLineLength );
+
+				scanner += length;
 			}
-			while ( left--, left > 0 );
+			while ( scanner <= end );
+
+			if ( result.back() != '\n' )
+				result.append( "\n" );
 		}
 		break;

@ -90,43 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -136,12 +137,12 @@ 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(";");
+				result.append(";\n");
 		}
 		break;

@ -150,14 +151,14 @@ String AST::to_string()
 			result.append( Parent->Name );

 			if ( Params )
-				result.append_fmt( "( %s )", Params->to_string() );
+				result.append_fmt( "( %S )", Params->to_string() );
 			else
 				result.append( "(void)" );

 			if ( InitializerList )
-				result.append_fmt( " : %s", InitializerList->to_string() );
+				result.append_fmt( " : %S", InitializerList->to_string() );

-			result.append_fmt( "\n{\n%s\n}", Body->to_string() );
+			result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
 		}
 		break;

@ -166,9 +167,9 @@ String AST::to_string()
 			result.append( Parent->Name );

 			if ( Params )
-				result.append_fmt( "( %s )", Params->to_string() );
+				result.append_fmt( "( %S )", Params->to_string() );
 			else
-				result.append( "(void);" );
+				result.append( "(void);\n" );
 		}
 		break;

@ -179,14 +180,14 @@ String AST::to_string()
 				CodeSpecifiers specs = Specs->cast<CodeSpecifiers>();

 				if ( specs.has( ESpecifier::Virtual ) )
-					result.append_fmt( "virtual ~%s()", Parent->Name );
+					result.append_fmt( "virtual ~%S()", Parent->Name );
 				else
-					result.append_fmt( "~%s()", Parent->Name );
+					result.append_fmt( "~%S()", Parent->Name );
 			}
 			else
-				result.append_fmt( "~%s()", Parent->Name );
+				result.append_fmt( "~%S()", Parent->Name );

-			result.append_fmt( "\n{\n%s\n}", Body->to_string() );
+			result.append_fmt( "\n{\n%S\n}\n", Body->to_string() );
 		}
 		break;

@ -197,15 +198,15 @@ String AST::to_string()
 				CodeSpecifiers specs = Specs->cast<CodeSpecifiers>();

 				if ( specs.has( ESpecifier::Virtual ) )
-					result.append_fmt( "virtual ~%s();", Parent->Name );
+					result.append_fmt( "virtual ~%S();\n", Parent->Name );
 				else
-					result.append_fmt( "~%s()", Parent->Name );
+					result.append_fmt( "~%S()", Parent->Name );

 				if ( specs.has( ESpecifier::Pure ) )
-					result.append( " = 0;" );
+					result.append( " = 0;\n" );
 			}
 			else
-				result.append_fmt( "~%s();", Parent->Name );
+				result.append_fmt( "~%S();\n", Parent->Name );
 		}
 		break;

@ -219,27 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -249,12 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -269,34 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -308,12 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -325,26 +311,23 @@ String AST::to_string()
 			s32  left = NumEntries;
 			while ( left-- )
 			{
-				result.append_fmt( "%s", 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:
@ -353,19 +336,19 @@ 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", 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)" );
@ -375,13 +358,14 @@ String AST::to_string()
 				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;

@ -391,19 +375,19 @@ 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", 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)" );
@ -413,11 +397,14 @@ String AST::to_string()
 				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;

@ -428,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\n}"
-				, Name
-				, Body->to_string()
-			);
+			result.append_fmt( "namespace %S\n{\n%S\n}\n", Name , Body->to_string() );
 		break;

 		case Operator:
@ -448,16 +432,16 @@ 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)" );
@ -467,11 +451,14 @@ String AST::to_string()
 				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()
 			);
 		}
@ -484,15 +471,15 @@ 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)" );
@ -502,11 +489,14 @@ String AST::to_string()
 				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;

@ -515,105 +505,111 @@ String AST::to_string()
 			if ( Specs )
 			{
 				if ( Name && Name.length() )
-					result.append_fmt( "%.*soperator %s()", Name.length(), Name, ValueType->to_string() );
+					result.append_fmt( "%Soperator %S()", Name, ValueType->to_string() );
 				else
-					result.append_fmt( "operator %s()", ValueType->to_string() );
+					result.append_fmt( "operator %S()", ValueType->to_string() );

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

 			if ( Name && Name.length() )
-				result.append_fmt("%.*soperator %s()\n{\n%s\n}", Name.length(), Name, ValueType->to_string(), Body->to_string() );
+				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}", ValueType->to_string(), Body->to_string() );
+				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()", ValueType->to_string() );
+				result.append_fmt( "operator %S()", ValueType->to_string() );

 				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( ";" );
 				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 );
+				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", Name, Content );
+			result.append_fmt( "#define %S %S\n", Name, Content );
 		break;

 		case Preprocess_If:
-			result.append_fmt( "#if %s", Content );
+			result.append_fmt( "#if %S\n", Content );
 		break;

 		case Preprocess_IfDef:
-			result.append_fmt( "#ifdef %s", Content );
+			result.append_fmt( "#ifdef %S\n", Content );
 		break;

 		case Preprocess_IfNotDef:
-			result.append_fmt( "#ifndef %s", Content );
+			result.append_fmt( "#ifndef %S\n", Content );
 		break;

 		case Preprocess_Include:
-			result.append_fmt( "#include \"%s\"\n", Content );
+			result.append_fmt( "#include \"%S\"\n", Content );
 		break;

 		case Preprocess_ElIf:
-			result.append_fmt( "#elif %s", Content );
+			result.append_fmt( "#elif %S\n", Content );
 		break;

 		case Preprocess_Else:
-			result.append_fmt( "\n#else" );
+			result.append_fmt( "#else\n" );
 		break;

 		case Preprocess_EndIf:
-			result.append_fmt( "#endif" );
+			result.append_fmt( "#endif\n" );
 		break;

 		case Preprocess_Pragma:
-			result.append_fmt( "#pragma %s", Content );
+			result.append_fmt( "#pragma %S\n", Content );
 		break;

 		case Specifiers:
@ -628,7 +624,8 @@ String AST::to_string()
 					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++;
 			}
 		}
@ -641,7 +638,7 @@ String AST::to_string()

 			if ( Name == nullptr)
 			{
-				result.append_fmt( "struct\n{\n%s\n};", Body->to_string() );
+				result.append_fmt( "struct\n{\n%S\n};\n", Body->to_string() );
 				break;
 			}

@ -650,44 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -697,12 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -711,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;

@ -725,15 +718,15 @@ String AST::to_string()
 			if ( IsFunction )
 				result.append( UnderlyingType->to_string() );
 			else
-				result.append_fmt( "%s %s", UnderlyingType->to_string(), Name );
+				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;
@ -743,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;
@ -766,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()
 				);
@ -778,13 +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(";");
+				result.append(";\n");
 		}
 		break;

@ -794,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:
@ -822,51 +815,38 @@ 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() );
+					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 ( BitfieldSize )
-				result.append_fmt( "%s : %s", ValueType->to_string(), BitfieldSize->to_string() );
+				result.append_fmt( "%S %S : %S;\n", ValueType->to_string(), Name, BitfieldSize->to_string() );

 			else if ( UnderlyingType->ArrExpr )
-				result.append_fmt( "%s %s[%s];", UnderlyingType->to_string(), Name, UnderlyingType->ArrExpr->to_string() );
+				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;

-#if 0
-		{
-			Code curr = Front->cast<Code>();
-			s32  left = NumEntries;
-			while ( left -- )
-			{
-				result.append_fmt( "%s", curr.to_string() );
-				++curr;
-			}
-		}
-		break;
-#endif
-
 		case Enum_Body:
 		case Class_Body:
 		case Extern_Linkage_Body:
@ -880,11 +860,7 @@ String AST::to_string()
 			s32  left = NumEntries;
 			while ( left -- )
 			{
-				result.append_fmt( "%s", curr.to_string() );
-
-				if ( curr->Type != ECode::NewLine )
-					result.append( "\n" );
-
+				result.append_fmt( "%S", curr.to_string() );
 				++curr;
 			}
 		}
--- a/project/components/ast.hpp
+++ b/project/components/ast.hpp
@ -1,3 +1,9 @@
+#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;
@ -163,10 +169,11 @@ struct AST
 	Code&       entry      ( u32 idx );
 	bool        has_entries();
 	bool        is_equal   ( AST* other );
-	String      to_string  ();
 	char const* type_str();
 	bool        validate_body();

+	neverinline String to_string();
+
 	template< class Type >
 	Type cast()
 	{
@ -214,7 +221,7 @@ struct AST
 			- sizeof(ModuleFlag)
 			- sizeof(u32)
 	)
-	/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes
+	/ sizeof(SpecifierT) - 1; // -1 for 4 extra bytes

 	union {
 		struct
@ -574,4 +581,3 @@ Define_CodeType( Var );
 #undef Using_Code

 #pragma endregion Code Types
-
--- a/project/components/ast_case_macros.cpp
+++ b/project/components/ast_case_macros.cpp
@ -76,4 +76,3 @@
 	case Specifiers: 					          \
 	case Struct_Body: 					          \
 	case Typename:
-
--- a/project/components/ast_types.hpp
+++ b/project/components/ast_types.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "ast.hpp"
+
 #pragma region AST Types
 /*
 	Show only relevant members of the AST for its type.
@ -538,5 +541,5 @@ struct AST_Var
 	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

+#pragma endregion AST Types
--- a/project/components/gen/ast_inlines.hpp
+++ b/project/components/gen/ast_inlines.hpp
--- a/project/components/gen/ecode.hpp
+++ b/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;
--- a/project/components/gen/eoperator.hpp
+++ b/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;
--- a/project/components/gen/especifier.hpp
+++ b/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;
--- a/project/components/gen/etoktype.cpp
+++ b/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
--- a/project/components/header_end.hpp
+++ b/project/components/header_end.hpp
@ -1,10 +1,14 @@
+#pragma once
+#include "inlines.hpp"
+#include "gen/ast_inlines.hpp"
+
 #pragma region Constants

 #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)
@ -22,7 +26,7 @@
 #	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)
@ -73,6 +77,7 @@ 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;
@ -139,11 +144,11 @@ extern CodeType t_typename;

 #	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

@ -168,4 +173,3 @@ extern CodeType t_typename;
 	extern AllocatorInfo Allocator_TypeTable;

 #endif
-
--- a/project/components/header_start.hpp
+++ b/project/components/header_start.hpp
@ -1,3 +1,5 @@
+#pragma once
+
 /*
 	gencpp: An attempt at "simple" staged metaprogramming for c/c++.

@ -16,11 +18,14 @@
 #	include "gen.dep.hpp"
 #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   }
+#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
-
--- a/project/components/inlines.hpp
+++ b/project/components/inlines.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "interface.hpp"
+
 void AST::append( AST* other )
 {
 	if ( other->Parent )
@ -211,4 +214,3 @@ StrC token_fmt_impl( sw num, ... )

 	return { result, buf };
 }
-
--- a/project/components/interface.cpp
+++ b/project/components/interface.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "ast.cpp"
+
 internal void init_parser();
 internal void deinit_parser();

@ -15,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();
 			}
@ -42,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();
 			}
@ -68,7 +71,7 @@ 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();
@ -76,22 +79,22 @@ void define_constants()

 	t_empty          = (CodeType) make_code();
 	t_empty->Type    = ECode::Typename;
-	t_empty->Name    = get_cached_string( txt_StrC("") );
+	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_StrC("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_StrC("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_StrC("public:") );
+	access_public->Name = get_cached_string( txt("public:") );
 	access_public.set_global();

 	attrib_api_export = def_attributes( code(GEN_API_Export_Code));
@ -102,13 +105,13 @@ void define_constants()

 	module_global_fragment          = make_code();
 	module_global_fragment->Type    = ECode::Untyped;
-	module_global_fragment->Name    = get_cached_string( txt_StrC("module;") );
+	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_StrC("module : private;") );
+	module_private_fragment->Name    = get_cached_string( txt("module : private;") );
 	module_private_fragment->Content = module_private_fragment->Name;
 	module_private_fragment.set_global();

@ -117,14 +120,14 @@ void define_constants()
 	fmt_newline.set_global();

 	pragma_once          = (CodePragma) make_code();
-	pragma_once->Type    = ECode::Untyped;
-	pragma_once->Name    = get_cached_string( txt_StrC("once") );
+	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_StrC("...") );
+	param_varadic->Name      = get_cached_string( txt("...") );
 	param_varadic->ValueType = t_empty;
 	param_varadic.set_global();

@ -170,10 +173,12 @@ void define_constants()
 #endif
 #	undef def_constant_code_type

+#	pragma push_macro( "forceinline" )
 #	pragma push_macro( "global" )
 #	pragma push_macro( "internal" )
 #	pragma push_macro( "local_persist" )
 #	pragma push_macro( "neverinline" )
+#	undef forceinline
 #	undef global
 #	undef internal
 #	undef local_persist
@ -189,6 +194,7 @@ 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 );
@ -209,6 +215,7 @@ 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" )
@ -226,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 );

@ -242,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.
@ -255,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 );

@ -264,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 );
 	}
@ -274,7 +281,7 @@ 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();
@ -362,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();
 	}
@ -397,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();
 	}
@ -443,4 +450,3 @@ void set_allocator_string_table( AllocatorInfo allocator )
 {
 	Allocator_StringArena = allocator;
 }
-
--- a/project/components/interface.hpp
+++ b/project/components/interface.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "ast_types.hpp"
+
 #pragma region Gen Interface

 // Initialize the library.
@ -175,4 +178,3 @@ Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
 #pragma endregion Untyped text

 #pragma endregion Gen Interface
-
--- a/project/components/interface.parsing.cpp
+++ b/project/components/interface.parsing.cpp
@ -1,3 +1,7 @@
+#pragma once
+#include "gen/etoktype.cpp"
+#include "interface.upfront.cpp"
+
 namespace Parser
 {
 	struct Token
@ -225,6 +229,7 @@ namespace Parser

 	global Array<Token> Tokens;

+	neverinline
 	TokArray lex( StrC content )
 	{
 	#	define current ( * scanner )
@ -250,6 +255,25 @@ namespace Parser
 			move_forward();                         \
 		}

+		#define end_line()                      \
+		do                                      \
+		{                                       \
+			while ( left && current == ' ' )    \
+			{                                   \
+				move_forward();                 \
+			}                                   \
+			if ( left && current == '\r' )      \
+			{                                   \
+				move_forward();                 \
+				move_forward();                 \
+			}                                   \
+			else if ( left && current == '\n' ) \
+			{                                   \
+				move_forward();                 \
+			}                                   \
+		}                                       \
+		while (0)
+
 		s32         left    = content.Len;
 		char const* scanner = content.Ptr;

@ -292,10 +316,11 @@ namespace Parser

 				if ( current == '\n' )
 				{
-					token.Type = TokType::NewLine;
-					token.Length ++;
 					move_forward();

+					token.Type = TokType::NewLine;
+					token.Length++;
+
 					Tokens.append( token );
 					continue;
 				}
@ -370,14 +395,14 @@ namespace Parser

 							if ( current == '\r' )
 							{
-								// move_forward();
-								// token.Length++;
+								move_forward();
+								token.Length++;
 							}

 							if ( current == '\n' )
 							{
-								// move_forward();
-								// token.Length++;
+								move_forward();
+								token.Length++;
 								break;
 							}

@ -394,6 +419,7 @@ namespace Parser
 					if ( token.Type == TokType::Preprocess_Else || token.Type == TokType::Preprocess_EndIf )
 					{
 						Tokens.append( token );
+						end_line();
 						continue;
 					}

@ -502,13 +528,13 @@ namespace Parser

 						if ( current == '\r' )
 						{
-							// move_forward();
+							move_forward();
 							// content.Length++;
 						}

 						if ( current == '\n' )
 						{
-							// move_forward();
+							move_forward();
 							// content.Length++;
 							break;
 						}
@ -599,6 +625,8 @@ namespace Parser

 					if (left)
 						move_forward();
+
+					end_line();
 					goto FoundToken;

 				case '[':
@ -702,6 +730,8 @@ namespace Parser

 					if (left)
 						move_forward();
+
+					end_line();
 					goto FoundToken;

 				case '"':
@ -875,12 +905,13 @@ namespace Parser
 						}
 						else if ( current == '*' )
 						{
-							token.Type = TokType::Comment_Start;
+							token.Type   = TokType::Comment_Start;
 							token.Length = 2;
 							Tokens.append( token );

+							Token content = { token.Text, 0, TokType::Comment, line, column, false };
 							move_forward();
-							Token content = { scanner, 1, TokType::Comment, line, column, false };
+							content.Length++;

 							bool star   = current == '*';
 							bool slash  = scanner[1] == '/';
@ -894,13 +925,15 @@ namespace Parser
 								slash  = scanner[1] == '/';
 								at_end = star && slash;
 							}
+							content.Length += 3;
 							Tokens.append( content );

 							Token end = { scanner, 2, TokType::Comment_End, line, column, false };
+							Tokens.append( end );
 							move_forward();
 							move_forward();

-							Tokens.append( end );
+							end_line();
 							continue;
 						}
 					}
@ -1044,15 +1077,13 @@ namespace Parser
 					token.Length++;
 				}

-				if ( current == '\r' )
+				if ( current == '\r' && scanner[1] == '\n' )
 				{
 					move_forward();
-					// token.Length++;
 				}
-				if ( current == '\n' )
+				else if ( current == '\n' )
 				{
 					move_forward();
-					// token.Length++;
 				}
 			}
 			else
@ -1121,7 +1152,7 @@ if ( def.Ptr == nullptr )                                                      \
 #	define check( Type_ )        ( left && currtok.Type == Type_ )

 #	define push_scope()                                                    \
-	StackNode scope { nullptr, currtok, NullToken, txt_StrC( __func__ ) }; \
+	StackNode scope { nullptr, currtok, NullToken, txt( __func__ ) }; \
 	Context.push( & scope )

 #pragma endregion Helper Macros
@ -1139,7 +1170,7 @@ internal CodeExtern      parse_exten_link      ();
 internal CodeFriend      parse_friend          ();
 internal CodeFn          parse_function        ();
 internal CodeNS          parse_namespace       ();
-internal CodeOpCast      parse_operator_cast   ();
+internal CodeOpCast      parse_operator_cast   ( CodeSpecifiers specifiers = NoCode );
 internal CodeStruct      parse_struct          ( bool inplace_def = false );
 internal CodeVar         parse_variable        ();
 internal CodeTemplate    parse_template        ();
@ -1150,7 +1181,7 @@ internal CodeUsing       parse_using           ();

 constexpr bool inplace_def = true;

-internal inline
+internal
 CodeComment parse_comment()
 {
 	using namespace Parser;
@ -1209,7 +1240,7 @@ CodeDefine parse_define()
 	return define;
 }

-internal inline
+internal
 CodePreprocessCond parse_preprocess_cond()
 {
 	using namespace Parser;
@ -1242,7 +1273,7 @@ CodePreprocessCond parse_preprocess_cond()
 	return cond;
 }

-internal inline
+internal
 CodeInclude parse_include()
 {
 	using namespace Parser;
@ -1268,7 +1299,7 @@ CodeInclude parse_include()
 	return include;
 }

-internal inline
+internal
 CodePragma parse_pragma()
 {
 	using namespace Parser;
@ -1294,7 +1325,7 @@ CodePragma parse_pragma()
 	return pragma;
 }

-internal inline
+internal
 Code parse_static_assert()
 {
 	using namespace Parser;
@ -1326,17 +1357,16 @@ Code parse_static_assert()

 	content.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)content.Text;

-	// content.Text = str_fmt_buf( "%.*s\n", content.Length, content.Text );
-	// content.Length++;
+	char const* result = str_fmt_buf( "%.*s\n", content.Length, content.Text );

-	assert->Content = get_cached_string( content );
+	assert->Content = get_cached_string( to_str( result ) );
 	assert->Name	= assert->Content;

 	Context.pop();
 	return assert;
 }

-internal inline
+internal
 Code parse_array_decl()
 {
 	using namespace Parser;
@ -1409,7 +1439,7 @@ CodeAttributes parse_attributes()
 	using namespace Parser;
 	push_scope();

-	Token start;
+	Token start = NullToken;
 	s32 len = 0;

 	if ( check(TokType::Attribute_Open) )
@ -1428,16 +1458,16 @@ CodeAttributes parse_attributes()

 	else if ( check(TokType::Decl_GNU_Attribute) )
 	{
-		eat(TokType::BraceCurly_Open);
-		eat(TokType::BraceCurly_Open);
+		eat(TokType::Capture_Start);
+		eat(TokType::Capture_Start);

-		while ( left && currtok.Type != TokType::BraceCurly_Close )
+		while ( left && currtok.Type != TokType::Capture_End )
 		{
 			eat(currtok.Type);
 		}

-		eat(TokType::BraceCurly_Close);
-		eat(TokType::BraceCurly_Close);
+		eat(TokType::Capture_End);
+		eat(TokType::Capture_End);

 		s32 len = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)start.Text;
 	}
@ -1445,14 +1475,14 @@ CodeAttributes parse_attributes()
 	else if ( check(TokType::Decl_MSVC_Attribute) )
 	{
 		eat( TokType::Decl_MSVC_Attribute );
-		eat( TokType::BraceCurly_Open);
+		eat( TokType::Capture_Start);

-		while ( left && currtok.Type != TokType::BraceCurly_Close )
+		while ( left && currtok.Type != TokType::Capture_End )
 		{
 			eat(currtok.Type);
 		}

-		eat(TokType::BraceCurly_Close);
+		eat(TokType::Capture_End);

 		s32 len = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)start.Text;
 	}
@ -1474,7 +1504,7 @@ CodeAttributes parse_attributes()
 	return { nullptr };
 }

-internal inline
+internal
 Parser::Token parse_identifier()
 {
 	using namespace Parser;
@ -1568,7 +1598,7 @@ Parser::Token parse_identifier()
 	return name;
 }

-internal
+internal inline
 CodeParam parse_params( bool use_template_capture = false )
 {
 	using namespace Parser;
@ -1832,7 +1862,7 @@ CodeFn parse_function_after_name(
 	return result;
 }

-internal inline
+internal
 CodeOperator parse_operator_after_ret_type(
 	  ModuleFlag     mflags
 	, CodeAttributes attributes
@ -2118,7 +2148,7 @@ CodeOperator parse_operator_after_ret_type(
 }

 // Variable parsing is handled in multiple places because its initial signature is shared with function parsing
-internal inline
+internal
 CodeVar parse_variable_after_name(
 	  ModuleFlag        mflags
 	, CodeAttributes    attributes
@ -2197,7 +2227,7 @@ CodeVar parse_variable_after_name(
 			eat( currtok.Type );
 		}

-		expr_tok.Length = ( (sptr)currtok.Text + currtok.Length ) - (sptr)expr_tok.Text;
+		expr_tok.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)expr_tok.Text;
 		bitfield_expr   = untyped_str( expr_tok );
 	}

@ -2259,25 +2289,40 @@ Code parse_simple_preprocess( Parser::TokType which )
 		}
 		eat( TokType::BraceCurly_Close );

+		StrC prev_proc = Context.Scope->Prev->ProcName;
+		if ( str_compare( prev_proc.Ptr, "parse_typedef", prev_proc.Len ) != 0 )
+		{
+			if ( check( TokType::Statement_End ))
+			{
+				eat( TokType::Statement_End );
+			}
+		}
+
+		tok.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)tok.Text;
+	}
+	else
+	{
+		if ( str_compare( Context.Scope->Prev->ProcName.Ptr, "parse_typedef", Context.Scope->Prev->ProcName.Len ) != 0 )
+		{
+			if ( check( TokType::Statement_End ))
+			{
+				eat( TokType::Statement_End );
+			}
+		}
+
 		tok.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)tok.Text;
 	}

-	Code result = untyped_str( tok );
-	Context.Scope->Name = tok;
+	char const* content = str_fmt_buf( "%.*s ", tok.Length, tok.Text );

-	if ( str_compare( Context.Scope->Prev->ProcName.Ptr, "parse_typedef", Context.Scope->Prev->ProcName.Len ) != 0 )
-	{
-		if ( check( TokType::Statement_End ))
-		{
-			eat( TokType::Statement_End );
-		}
-	}
+	Code result = untyped_str( to_str( content ) );
+	Context.Scope->Name = tok;

 	Context.pop();
 	return result;
 }

-internal inline
+internal
 Code parse_operator_function_or_variable( bool expects_function, CodeAttributes attributes, CodeSpecifiers specifiers )
 {
 	using namespace Parser;
@ -2399,7 +2444,7 @@ Code parse_foward_or_definition( Parser::TokType which, bool is_inplace )
 	return CodeInvalid;
 }

-internal inline
+internal
 Code parse_complicated_definition( Parser::TokType which )
 {
 	using namespace Parser;
@ -2492,7 +2537,7 @@ Code parse_complicated_definition( Parser::TokType which )
 	}
 }

-internal
+internal neverinline
 CodeBody parse_class_struct_body( Parser::TokType which, Parser::Token name = Parser::NullToken )
 {
 	using namespace Parser;
@ -2520,7 +2565,7 @@ CodeBody parse_class_struct_body( Parser::TokType which, Parser::Token name = Pa

 		Context.Scope->Start = currtok_noskip;

-		if ( currtok.Type == TokType::Preprocess_Hash )
+		if ( currtok_noskip.Type == TokType::Preprocess_Hash )
 			eat( TokType::Preprocess_Hash );

 		switch ( currtok_noskip.Type )
@ -2652,8 +2697,10 @@ CodeBody parse_class_struct_body( Parser::TokType which, Parser::Token name = Pa
 			case TokType::Spec_Consteval:
 			case TokType::Spec_Constexpr:
 			case TokType::Spec_Constinit:
+			case TokType::Spec_ForceInline:
 			case TokType::Spec_Inline:
 			case TokType::Spec_Mutable:
+			case TokType::Spec_NeverInline:
 			case TokType::Spec_Static:
 			case TokType::Spec_Volatile:
 			{
@ -2669,7 +2716,9 @@ CodeBody parse_class_struct_body( Parser::TokType which, Parser::Token name = Pa
 						case ESpecifier::Constexpr:
 						case ESpecifier::Constinit:
 						case ESpecifier::Inline:
+						case ESpecifier::ForceInline:
 						case ESpecifier::Mutable:
+						case ESpecifier::NeverInline:
 						case ESpecifier::Static:
 						case ESpecifier::Volatile:
 						break;
@ -2699,6 +2748,12 @@ CodeBody parse_class_struct_body( Parser::TokType which, Parser::Token name = Pa
 					member = parse_destructor( specifiers );
 					break;
 				}
+
+				if ( currtok.Type == TokType::Decl_Operator )
+				{
+					member = parse_operator_cast( specifiers );
+					break;
+				}
 			}
 			//! Fallthrough intentional
 			case TokType::Identifier:
@ -2880,7 +2935,7 @@ Code parse_function_body()
 	return result;
 }

-internal
+internal neverinline
 CodeBody parse_global_nspace( CodeT which )
 {
 	using namespace Parser;
@ -2906,7 +2961,7 @@ CodeBody parse_global_nspace( CodeT which )

 		Context.Scope->Start = currtok_noskip;

-		if ( currtok.Type == TokType::Preprocess_Hash )
+		if ( currtok_noskip.Type == TokType::Preprocess_Hash )
 			eat( TokType::Preprocess_Hash );

 		switch ( currtok_noskip.Type )
@ -3026,6 +3081,7 @@ CodeBody parse_global_nspace( CodeT which )
 			case TokType::Spec_Constexpr:
 			case TokType::Spec_Constinit:
 			case TokType::Spec_Extern:
+			case TokType::Spec_ForceInline:
 			case TokType::Spec_Global:
 			case TokType::Spec_Inline:
 			case TokType::Spec_Internal_Linkage:
@ -3045,6 +3101,7 @@ CodeBody parse_global_nspace( CodeT which )
 					{
 						case ESpecifier::Constexpr:
 						case ESpecifier::Constinit:
+						case ESpecifier::ForceInline:
 						case ESpecifier::Global:
 						case ESpecifier::External_Linkage:
 						case ESpecifier::Internal_Linkage:
@ -3184,7 +3241,7 @@ CodeConstructor parse_constructor()
 	{
 		eat( TokType::Assign_Classifer );

-		Token initializer_list_tok;
+		Token initializer_list_tok = NullToken;

 		s32 level = 0;
 		while ( left && ( currtok.Type != TokType::BraceCurly_Open || level > 0 ) )
@ -3694,7 +3751,9 @@ CodeFn parse_functon()
 			case ESpecifier::Consteval:
 			case ESpecifier::Constexpr:
 			case ESpecifier::External_Linkage:
+			case ESpecifier::ForceInline:
 			case ESpecifier::Inline:
+			case ESpecifier::NeverInline:
 			case ESpecifier::Static:
 			break;

@ -3838,7 +3897,9 @@ CodeOperator parse_operator()
 		{
 			case ESpecifier::Const:
 			case ESpecifier::Constexpr:
+			case ESpecifier::ForceInline:
 			case ESpecifier::Inline:
+			case ESpecifier::NeverInline:
 			case ESpecifier::Static:
 			break;

@ -3883,11 +3944,14 @@ CodeOperator parse_operator( StrC def )
 	return (CodeOperator) parse_operator();
 }

-CodeOpCast parse_operator_cast()
+CodeOpCast parse_operator_cast( CodeSpecifiers specifiers )
 {
 	using namespace Parser;
 	push_scope();

+	// Specifiers attributed to the cast
+
+	// Operator's namespace if not within same class.
 	Token name = NullToken;
 	if ( check( TokType::Identifier ) )
 	{
@ -3912,11 +3976,14 @@ CodeOpCast parse_operator_cast()
 	eat( TokType::Capture_Start );
 	eat( TokType::Capture_End );

-	CodeSpecifiers specifiers = { nullptr };
-
 	if ( check(TokType::Spec_Const))
 	{
-		specifiers = spec_const;
+		if ( specifiers.ast == nullptr )
+			specifiers = def_specifier( ESpecifier::Const );
+
+		else
+			specifiers.append( ESpecifier::Const );
+
 		eat( TokType::Spec_Const );
 	}

@ -4518,7 +4585,7 @@ CodeTypedef parse_typedef( StrC def )
 	return parse_typedef();
 }

-internal
+internal neverinline
 CodeUnion parse_union( bool inplace_def )
 {
 	using namespace Parser;
@ -4850,4 +4917,3 @@ CodeVar parse_variable( StrC def )
 #	undef left
 #	undef check
 #	undef push_scope
-
--- a/project/components/interface.untyped.cpp
+++ b/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;
@ -181,4 +184,3 @@ Code untyped_token_fmt( s32 num_tokens, ... )

 	return result;
 }
-
--- a/project/components/interface.upfront.cpp
+++ b/project/components/interface.upfront.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "interface.cpp"
+
 #pragma region Upfront

 enum class OpValidateResult : u32
@ -7,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;
@ -1059,13 +1061,17 @@ CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
 	switch (type)
 	{
 		case EPreprocessCond::If:
-			result->Type = ECode::Preprocess_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;
@ -2249,6 +2255,4 @@ CodeBody def_union_body( s32 num, CodeUnion* codes )
 #	undef def_body_start
 #	undef def_body_code_array_start

-
 #pragma endregion Upfront
-
--- a/project/components/static_data.cpp
+++ b/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.
@ -47,6 +50,7 @@ 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;
@ -95,4 +99,3 @@ global CodeType t_f64;
 #endif

 #pragma endregion Constants
-
--- a/project/components/temp/Readme.md
+++ b/project/components/temp/Readme.md
@ -1,8 +0,0 @@
-# Temporary Code
-
-These are heavy macro code used throughout the library thats intended to be replaced with codegen done with the library itself.
-
-The reason for this is to minimize macro generation to only trivial cases.  
-This makes the library more verbose but makes it easier to debug which is of higher priority.
-
-Any sort of verbosity cost will be mitigated with better docs and heavy usage of pragma regions.
--- a/project/components/temp/ast_inlines.hpp
+++ b/project/components/temp/ast_inlines.hpp
@ -1,230 +0,0 @@
-// This is the non-bootstraped version of the Common AST Implementation. This will be obsolete once bootstrap is stress tested.
-
-#pragma region AST 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;                                                  \
-}                                                                                    \
-Typename::operator bool()                                                            \
-{                                                                                    \
-	return ast != nullptr;                                                           \
-}
-
-#define Define_CodeType_Impl( Typename )                    \
-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;                                             \
-}                                                           \
-
-Define_CodeImpl( Code );
-Define_CodeImpl( CodeBody );
-Define_CodeImpl( CodeAttributes );
-Define_CodeImpl( CodeComment );
-Define_CodeImpl( CodeClass );
-Define_CodeImpl( CodeConstructor );
-Define_CodeImpl( CodeDefine );
-Define_CodeImpl( CodeDestructor );
-Define_CodeImpl( CodeEnum );
-Define_CodeImpl( CodeExec );
-Define_CodeImpl( CodeExtern );
-Define_CodeImpl( CodeInclude );
-Define_CodeImpl( CodeFriend );
-Define_CodeImpl( CodeFn );
-Define_CodeImpl( CodeModule );
-Define_CodeImpl( CodeNS );
-Define_CodeImpl( CodeOperator );
-Define_CodeImpl( CodeOpCast );
-Define_CodeImpl( CodeParam );
-Define_CodeImpl( CodePragma );
-Define_CodeImpl( CodePreprocessCond );
-Define_CodeImpl( CodeSpecifiers );
-Define_CodeImpl( CodeStruct );
-Define_CodeImpl( CodeTemplate );
-Define_CodeImpl( CodeType );
-Define_CodeImpl( CodeTypedef );
-Define_CodeImpl( CodeUnion );
-Define_CodeImpl( CodeUsing );
-Define_CodeImpl( CodeVar );
-
-Define_CodeType_Impl( Attributes );
-Define_CodeType_Impl( Comment );
-Define_CodeType_Impl( Constructor );
-Define_CodeType_Impl( Define );
-Define_CodeType_Impl( Destructor );
-Define_CodeType_Impl( Enum );
-Define_CodeType_Impl( Exec );
-Define_CodeType_Impl( Extern );
-Define_CodeType_Impl( Include );
-Define_CodeType_Impl( Friend );
-Define_CodeType_Impl( Fn );
-Define_CodeType_Impl( Module );
-Define_CodeType_Impl( NS );
-Define_CodeType_Impl( Operator );
-Define_CodeType_Impl( OpCast );
-Define_CodeType_Impl( Pragma );
-Define_CodeType_Impl( PreprocessCond );
-Define_CodeType_Impl( Template );
-Define_CodeType_Impl( Type );
-Define_CodeType_Impl( Typedef );
-Define_CodeType_Impl( Union );
-Define_CodeType_Impl( Using );
-Define_CodeType_Impl( Var );
-
-#undef Define_CodeImpl
-#undef Define_CodeType_Impl
-
-#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( Constructor );
-Define_AST_Cast( Class );
-Define_AST_Cast( Define );
-Define_AST_Cast( Destructor );
-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( NS );
-Define_AST_Cast( Operator );
-Define_AST_Cast( OpCast );
-Define_AST_Cast( Param );
-Define_AST_Cast( Pragma );
-Define_AST_Cast( PreprocessCond );
-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( Constructor );
-Define_CodeCast( Class );
-Define_CodeCast( Define );
-Define_CodeCast( Destructor );
-Define_CodeCast( Exec );
-Define_CodeCast( Enum );
-Define_CodeCast( Extern );
-Define_CodeCast( Include );
-Define_CodeCast( Friend );
-Define_CodeCast( Fn );
-Define_CodeCast( Module );
-Define_CodeCast( NS );
-Define_CodeCast( Operator );
-Define_CodeCast( OpCast );
-Define_CodeCast( Param );
-Define_CodeCast( Pragma );
-Define_CodeCast( PreprocessCond );
-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 Common
-
--- a/project/components/temp/ecode.hpp
+++ b/project/components/temp/ecode.hpp
@ -1,92 +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( NewLine )              \
-	Entry( Comment )              \
-	Entry( Access_Private )       \
-	Entry( Access_Protected )     \
-	Entry( Access_Public )        \
-	Entry( PlatformAttributes )   \
-	Entry( Class )                \
-	Entry( Class_Fwd )            \
-	Entry( Class_Body )           \
-	Entry( Constructor )          \
-	Entry( Constructor_Fwd )      \
-	Entry( Destructor )		      \
-	Entry( Destructor_Fwd )       \
-	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( Preprocess_Define )    \
-	Entry( Preprocess_If )        \
-	Entry( Preprocess_IfDef )     \
-	Entry( Preprocess_IfNotDef )  \
-	Entry( Preprocess_ElIf )      \
-	Entry( Preprocess_Else )      \
-	Entry( Preprocess_EndIf )     \
-	Entry( Preprocess_Include )   \
-	Entry( Preprocess_Pragma )    \
-	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;
-
--- a/project/components/temp/eoperator.hpp
+++ b/project/components/temp/eoperator.hpp
@ -1,76 +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
-	StrC to_str( Type op )
-	{
-		local_persist
-		StrC lookup[ Num_Ops ] = {
-		#	define Entry( Type_, Token_ ) { sizeof(stringize(Token_)), stringize(Token_) },
-			Define_Operators
-		#	undef Entry
-			txt_StrC(",")
-		};
-
-		return lookup[ op ];
-	}
-
-#	undef Define_Operators
-}
-using OperatorT = EOperator::Type;
-
--- a/project/components/temp/especifier.hpp
+++ b/project/components/temp/especifier.hpp
@ -1,110 +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( NeverInline,      neverinline )       \
-	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 )          \
-	Entry( Pure,  		     = 0 )
-
-	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" )
-		#	pragma push_macro( "neverinline" )
-		#	undef global
-		#	undef internal
-		#	undef local_persist
-		#	undef neverinline
-
-		#	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" )
-		#	pragma pop_macro( "neverinline" )
-		};
-
-		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;
-
--- a/project/components/temp/etoktype.cpp
+++ b/project/components/temp/etoktype.cpp
@ -1,170 +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( Comment_End,            "__comment_end__" )   \
-	Entry( Comment_Start,          "__comment start__" ) \
-	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( NewLine,                "__NewLine__" )       \
-	Entry( Number,                 "__number__" )        \
-	Entry( Operator,               "__operator__" )      \
-	Entry( Preprocess_Hash,        "#" )                 \
-	Entry( Preprocess_Define,      "define")             \
-	Entry( Preprocess_If,          "if")                 \
-	Entry( Preprocess_IfDef,       "ifdef")              \
-	Entry( Preprocess_IfNotDef,    "ifndef")             \
-	Entry( Preprocess_ElIf,        "elif")               \
-	Entry( Preprocess_Else,        "else")               \
-	Entry( Preprocess_EndIf,       "endif")              \
-	Entry( Preprocess_Include,     "include" )           \
-	Entry( Preprocess_Pragma,      "pragma")             \
-	Entry( Preprocess_Content,     "__macro_content__")  \
-	Entry( Preprocess_Macro,       "__macro__")          \
-	Entry( Preprocess_Unsupported, "__unsupported__" )   \
-	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_NeverInline,       "neverinline" )       \
-	Entry( Spec_Override,          "override" )          \
-	Entry( Spec_Static,            "static" )            \
-	Entry( Spec_ThreadLocal,       "thread_local" )      \
-	Entry( Spec_Virtual, 		   "virtual" )           \
-	Entry( Spec_Volatile,          "volatile")           \
-	Entry( Star,                   "*" )                 \
-	Entry( Statement_End,          ";" )                 \
-	Entry( StaticAssert,           "static_assert" )     \
-	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( Type_MS_int8,           "__int8" )            \
-	Entry( Type_MS_int16,          "__int16" )           \
-	Entry( Type_MS_int32,          "__int32" )           \
-	Entry( Type_MS_int64,          "__int64" )           \
-	Entry( Type_MS_W64,            "_W64" )              \
-	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
-		StrC to_str( Type type )
-		{
-			local_persist
-			StrC lookup[(u32)NumTokens] =
-			{
-			#	define Entry( Name_, Str_ ) { sizeof(Str_), Str_ },
-				Define_TokType
-				GEN_DEFINE_ATTRIBUTE_TOKENS
-			#	undef Entry
-			};
-
-			return lookup[(u32)type];
-		}
-	#	undef Define_TokType
-	};
-
-	using TokType = ETokType::Type;
-
-} // Parser
-
--- a/project/components/types.hpp
+++ b/project/components/types.hpp
@ -1,11 +1,14 @@
+#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
 	#define log_failure log_fmt
 #else
-	#define log_failure fatal
+	#define log_failure GEN_FATAL
 #endif

 enum class AccessSpec : u32
@ -46,7 +49,6 @@ enum class EnumT : u8
 constexpr EnumT EnumClass   = EnumT::Class;
 constexpr EnumT EnumRegular = EnumT::Regular;

-
 enum class ModuleFlag : u32
 {
 	None    = 0,
@ -75,51 +77,3 @@ constexpr EPreprocessCond PreprocessCond_If       = EPreprocessCond::If;
 constexpr EPreprocessCond PreprocessCond_IfDef    = EPreprocessCond::IfDef;
 constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
 constexpr EPreprocessCond PreprocessCond_ElIf     = EPreprocessCond::ElIf;
-
-/*
-	Predefined attributes
-	Used for the parser constructors to identify non-standard attributes
-
-	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
-
-// 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;
-
--- a/project/dependencies/basic_types.hpp
+++ b/project/dependencies/basic_types.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "macros.hpp"
+
 #pragma region Basic Types

 #define GEN_U8_MIN 0u
@ -118,4 +121,3 @@ typedef s16 b16;
 typedef s32 b32;

 #pragma endregion Basic Types
-
--- a/project/dependencies/containers.hpp
+++ b/project/dependencies/containers.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "printing.hpp"
+
 #pragma region Containers

 template<class Type>
@ -540,4 +543,3 @@ protected:
 };

 #pragma endregion Containers
-
--- a/project/dependencies/debug.cpp
+++ b/project/dependencies/debug.cpp
@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region Debug

 void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... )
@ -39,4 +41,3 @@ s32 assert_crash( char const* condition )
 #endif

 #pragma endregion Debug
-
--- a/project/dependencies/debug.hpp
+++ b/project/dependencies/debug.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "basic_types.hpp"
+
 #pragma region Debug

 #if defined( _MSC_VER )
@ -34,26 +37,25 @@ s32  assert_crash( char const* condition );
 void process_exit( u32 code );

 #if Build_Debug
-	#define fatal( fmt, ... )                              \
+	#define GEN_FATAL( ... )                               \
 	do                                                     \
 	{                                                      \
 		local_persist thread_local                         \
 		char buf[GEN_PRINTF_MAXLEN] = { 0 };               \
 													       \
-		str_fmt(buf, GEN_PRINTF_MAXLEN, fmt, __VA_ARGS__); \
+		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \
 		GEN_PANIC(buf);                                    \
 	}                                                      \
 	while (0)
 #else

-#	define fatal( fmt, ... )						 \
-	do                                               \
-	{												 \
-		str_fmt_out_err_va( fmt, __VA_ARGS__ );      \
-		process_exit(1);                             \
-	}             					                 \
+#	define GEN_FATAL( ... )                  \
+	do                                       \
+	{										 \
+		str_fmt_out_err( __VA_ARGS__ );      \
+		process_exit(1);                     \
+	}             					         \
 	while (0)
 #endif

 #pragma endregion Debug
-
--- a/project/dependencies/file_handling.cpp
+++ b/project/dependencies/file_handling.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "strings.cpp"
+
 #pragma region File Handling

 #if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
@ -634,4 +637,3 @@ internal GEN_FILE_CLOSE_PROC( _memory_file_close )
 FileOperations const memory_file_operations = { _memory_file_read, _memory_file_write, _memory_file_seek, _memory_file_close };

 #pragma endregion File Handling
-
--- a/project/dependencies/file_handling.hpp
+++ b/project/dependencies/file_handling.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "strings.hpp"
+
 #pragma region File Handling

 typedef u32 FileMode;
@ -370,4 +373,3 @@ u8* file_stream_buf( FileInfo* file, sw* size );
 extern FileOperations const memory_file_operations;

 #pragma endregion File Handling
-
--- a/project/dependencies/hashing.cpp
+++ b/project/dependencies/hashing.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "memory.cpp"
+
 #pragma region Hashing

 global u32 const _crc32_table[ 256 ] = {
@ -83,4 +86,3 @@ u64 crc64( void const* data, sw len )
 }

 #pragma endregion Hashing
-
--- a/project/dependencies/hashing.hpp
+++ b/project/dependencies/hashing.hpp
@ -1,7 +1,9 @@
+#pragma once
+#include "containers.hpp"
+
 #pragma region Hashing

 u32 crc32( void const* data, sw len );
 u64 crc64( void const* data, sw len );

 #pragma endregion Hashing
-
--- a/project/dependencies/header_start.hpp
+++ b/project/dependencies/header_start.hpp
@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region Platform Detection

 /* Platform architecture */
@ -100,25 +102,6 @@
 #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
@ -133,10 +116,11 @@
 #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
-
--- a/project/dependencies/macros.hpp
+++ b/project/dependencies/macros.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "header_start.hpp"
+
 #pragma region Macros

 #define zpl_cast( Type ) ( Type )
@ -8,6 +11,25 @@
 #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 )
@ -21,7 +43,7 @@
 #define scast( Type, Value ) static_cast< Type >( Value )

 // Num Arguments (Varadics)
-#if defined(__GNUC__) || defined(__clang__)
+// #if defined(__GNUC__) || defined(__clang__)
 // Supports 0-50 arguments
 #define num_args_impl( _0,                                 \
 		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,   \
@ -53,37 +75,39 @@
 		 0                                       \
 	)

-#else
-// 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
+// #else
+// This doesn't work on latest msvc so I had to use /Zc:preprocessor flag.

-#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
+// 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__
@ -125,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 )
 {
@ -134,4 +164,3 @@ void swap( Type& a, Type& b )
 }

 #pragma endregion Macros
-
--- a/project/dependencies/memory.cpp
+++ 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;
 				}

@ -387,4 +390,3 @@ void Pool::clear()
 }

 #pragma endregion Memory
-
--- a/project/dependencies/memory.hpp
+++ b/project/dependencies/memory.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "debug.hpp"
+
 #pragma region Memory

 #define kilobytes( x ) ( ( x ) * ( s64 )( 1024 ) )
@ -484,4 +487,3 @@ struct Pool
 };

 #pragma endregion Memory
-
--- a/project/dependencies/parsing.cpp
+++ b/project/dependencies/parsing.cpp
@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region ADT

 #define _adt_fprintf( s_, fmt_, ... )                      \
--- a/project/dependencies/parsing.hpp
+++ b/project/dependencies/parsing.hpp
@ -1,3 +1,5 @@
+#pragma once
+
 #pragma region ADT

 enum ADT_Type : u32
--- a/project/dependencies/printing.cpp
+++ b/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;
@ -572,4 +585,3 @@ sw str_fmt_out_err( char const* fmt, ... )
 }

 #pragma endregion Printing
-
--- a/project/dependencies/printing.hpp
+++ b/project/dependencies/printing.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "string_ops.hpp"
+
 #pragma region Printing

 struct FileInfo;
@ -34,4 +37,3 @@ sw log_fmt(char const* fmt, ...)
 }

 #pragma endregion Printing
-
--- a/project/dependencies/src_start.cpp
+++ b/project/dependencies/src_start.cpp
@ -78,4 +78,3 @@
 #endif

 #pragma endregion Macros and Includes
-
--- a/project/dependencies/string.cpp
+++ b/project/dependencies/string.cpp
@ -1,40 +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
-
--- a/project/dependencies/string_ops.cpp
+++ b/project/dependencies/string_ops.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "debug.cpp"
+
 #pragma region String Ops

 internal
@ -207,4 +210,3 @@ f64 str_to_f64( const char* str, char** end_ptr )
 }

 #pragma endregion String Ops
-
--- a/project/dependencies/string_ops.hpp
+++ b/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 );
@ -260,4 +263,3 @@ GEN_IMPL_INLINE void str_to_upper( char* str )
 }

 #pragma endregion String Ops
-
--- a/project/dependencies/strings.cpp
+++ b/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
--- a/project/dependencies/strings.hpp
+++ b/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,19 +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
--- a/project/dependencies/timing.cpp
+++ b/project/dependencies/timing.cpp
@ -1,3 +1,6 @@
+#pragma once
+#include "filesystem.cpp"
+
 #pragma region Timing

 #ifdef GEN_BENCHMARK
@ -160,4 +163,3 @@
 #endif

 #pragma endregion Timing
-
--- a/project/dependencies/timing.hpp
+++ b/project/dependencies/timing.hpp
@ -1,3 +1,6 @@
+#pragma once
+#include "filesystem.hpp"
+
 #pragma region Timing

 #ifdef GEN_BENCHMARK
@ -12,4 +15,3 @@ u64 time_rel_ms( void );
 #endif

 #pragma endregion Timing
-
--- a/project/enums/ESpecifier.csv
+++ b/project/enums/ESpecifier.csv
@ -4,6 +4,7 @@ Constexpr,        constexpr
 Constinit,        constinit
 Explicit,         explicit
 External_Linkage, extern
+ForceInline, 	  forceinline
 Global,           global
 Inline,           inline
 Internal_Linkage, internal
--- a/project/enums/ETokType.csv
+++ b/project/enums/ETokType.csv
@ -61,6 +61,7 @@ Spec_Constinit,         "constinit"
 Spec_Explicit,          "explicit"
 Spec_Extern,            "extern"
 Spec_Final,             "final"
+Spec_ForceInline,	    "forceinline"
 Spec_Global,            "global"
 Spec_Inline,            "inline"
 Spec_Internal_Linkage,  "internal"
--- a/project/file_processors/scanner.cpp
+++ b/project/file_processors/scanner.cpp
--- a/project/file_processors/scanner.hpp
+++ b/project/file_processors/scanner.hpp
@ -1,69 +0,0 @@
-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 );
-}
-
-#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
-
--- a/project/gen.bootstrap.cpp
+++ b/project/gen.bootstrap.cpp
@ -1,254 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
-#include "gen.cpp"
-
-#include "helpers/helper.hpp"
-
-GEN_NS_BEGIN
-#include "dependencies/parsing.cpp"
-GEN_NS_END
-
-#include "file_processors/builder.hpp"
-#include "file_processors/builder.cpp"
-#include "file_processors/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";
-
-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 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 file_handling = scan_file( "dependencies/file_handling.hpp" );
-		Code timing        = scan_file( "dependencies/timing.hpp" );
-
-		Builder
-		deps_header = Builder::open("gen/gen.dep.hpp");
-		deps_header.print_fmt( generation_notice );
-		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( header_start );
-		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( timing );
-
-		deps_header.print_fmt( "GEN_NS_END\n\n" );
-		deps_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 string        = scan_file( "dependencies/string.cpp" );
-		Code file_handling = scan_file( "dependencies/file_handling.cpp" );
-		Code timing        = scan_file( "dependencies/timing.cpp" );
-
-		Builder
-		deps_impl = Builder::open( "gen/gen.dep.cpp" );
-		deps_impl.print_fmt( generation_notice );
-		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( src_start );
-		deps_impl.print_fmt( "GEN_NS_BEGIN\n\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( string );
-		deps_impl.print( file_handling );
-		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 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( "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_fmt( "#pragma region AST\n\n" );
-		header.print( ast );
-		header.print( ast_types );
-		header.print_fmt( "#pragma endregion AST\n\n" );
-
-		header.print( interface );
-
-		header.print_fmt( "#pragma region Inlines\n\n" );
-		header.print( inlines );
-		header.print( ast_inlines );
-		header.print_fmt( "#pragma endregion Inlines\n\n" );
-
-		header.print( header_end );
-		header.print_fmt( "GEN_NS_END\n\n" );
-		header.print( pop_ignores );
-		header.write();
-	}
-
-	// gen.cpp
-	{
-		Code        src_start       = scan_file( "components/src_start.cpp" );
-		Code        static_data 	= scan_file( "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" );
-		CodeNS   parser_nspace = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
-
-		Builder
-		src = Builder::open( "gen/gen.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( push_ignores );
-		src.print( src_start );
-		src.print_fmt( "\nGEN_NS_BEGIN\n\n");
-
-		src.print( static_data );
-
-		src.print_fmt( "#pragma region AST\n\n" );
-		src.print( ast_case_macros );
-		src.print( ast );
-		src.print_fmt( "#pragma endregion AST\n\n" );
-
-		src.print_fmt( "#pragma region Interface\n\n" );
-		src.print( interface );
-		src.print( upfront );
-		src.print_fmt( "#pragma region Parsing\n\n" );
-		src.print( parser_nspace );
-		src.print( parsing );
-		src.print( untyped );
-		src.print_fmt( "#pragma endregion Parsing\n\n" );
-		src.print_fmt( "#pragma endregion Interface\n\n" );
-
-		src.print_fmt( "GEN_NS_END\n\n");
-		src.print( pop_ignores );
-		src.write();
-	}
-
-	// gen_builder.hpp
-	{
-		Code builder = scan_file( "file_processors/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_StrC("gen.hpp") ));
-		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
-		header.print( builder );
-		header.print_fmt( "\nGEN_NS_END\n\n" );
-		header.write();
-	}
-
-	// gen_builder.cpp
-	{
-		Code builder = scan_file( "file_processors/builder.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.builder.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( def_include( txt_StrC("gen.builder.hpp") ) );
-		src.print_fmt( "\nGEN_NS_BEGIN\n\n" );
-		src.print( builder );
-		src.print_fmt( "\nGEN_NS_END\n\n" );
-		src.write();
-	}
-
-	// gen_scanner.hpp
-	{
-		Code parsing = scan_file( "dependencies/parsing.hpp" );
-		Code scanner = scan_file( "file_processors/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_StrC("gen.hpp") ) );
-		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
-		header.print( parsing );
-		header.print( scanner );
-		header.print_fmt( "\nGEN_NS_END\n\n" );
-		header.write();
-	}
-
-	// gen_scanner.cpp
-	{
-		Code parsing = scan_file( "dependencies/parsing.cpp" );
-		// Code scanner = scan_file( "file_processors/scanner.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.scanner.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( def_include( txt_StrC("gen.scanner.hpp") ) );
-		src.print_fmt( "\nGEN_NS_BEGIN\n\n" );
-		src.print( parsing );
-		// src.print( scanner );
-		src.print_fmt( "\nGEN_NS_END\n\n" );
-		src.write();
-	}
-
-	gen::deinit();
-	return 0;
-}
--- a/project/gen.cpp
+++ b/project/gen.cpp
@ -23,9 +23,9 @@ GEN_NS_BEGIN

 #include "components/interface.cpp"
 #include "components/interface.upfront.cpp"
-#include "components/temp/etoktype.cpp"
+#include "components/gen/etoktype.cpp"
 #include "components/interface.parsing.cpp"
-#include "components/untyped.cpp"
+#include "components/interface.untyped.cpp"

 GEN_NS_END

--- a/project/gen.dep.cpp
+++ b/project/gen.dep.cpp
@ -6,16 +6,12 @@
 GEN_NS_BEGIN

 #include "dependencies/debug.cpp"
-
 #include "dependencies/string_ops.cpp"
 #include "dependencies/printing.cpp"
 #include "dependencies/memory.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
--- a/project/gen.dep.hpp
+++ b/project/gen.dep.hpp
@ -8,17 +8,13 @@ GEN_NS_BEGIN
 #include "dependencies/macros.hpp"
 #include "dependencies/basic_types.hpp"
 #include "dependencies/debug.hpp"
-
 #include "dependencies/memory.hpp"
 #include "dependencies/string_ops.hpp"
 #include "dependencies/printing.hpp"
-
 #include "dependencies/containers.hpp"
 #include "dependencies/hashing.hpp"
-#include "dependencies/string.hpp"
-
+#include "dependencies/strings.hpp"
+#include "dependencies/filesystem.hpp"
 #include "dependencies/timing.hpp"

-#include "dependencies/file_handling.hpp"
-
 GEN_NS_END
--- a/project/gen.hpp
+++ b/project/gen.hpp
@ -14,9 +14,9 @@
 GEN_NS_BEGIN

 #include "components/types.hpp"
-#include "components/temp/ecode.hpp"
-#include "components/temp/eoperator.hpp"
-#include "components/temp/especifier.hpp"
+#include "components/gen/ecode.hpp"
+#include "components/gen/eoperator.hpp"
+#include "components/gen/especifier.hpp"

 #include "components/ast.hpp"
 #include "components/ast_types.hpp"
@ -24,7 +24,7 @@ GEN_NS_BEGIN
 #include "components/interface.hpp"

 #include "components/inlines.hpp"
-#include "components/temp/ast_inlines.hpp"
+#include "components/gen/ast_inlines.hpp"
 #include "components/header_end.hpp"

 GEN_NS_END
--- a/project/helpers/helper.hpp
+++ b/project/helpers/helper.hpp
@ -30,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
@ -53,15 +47,15 @@ CodeBody gen_ecode( char const* path )
 	)));
 #pragma pop_macro( "local_persist" )

-	CodeNS nspace = def_namespace( name(ECode), def_namespace_body( args( enum_code, to_str ) ) );
-	CodeUsing    code_t  = def_using( name(CodeT), def_type( name(ECode::Type) ) );
+	CodeNS    nspace = def_namespace( name(ECode), def_namespace_body( args( enum_code, to_str ) ) );
+	CodeUsing code_t = def_using( name(CodeT), def_type( name(ECode::Type) ) );

-	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 );
@ -111,12 +105,12 @@ CodeBody gen_eoperator( char const* path )

 	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 );
@ -157,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 )
 		{
@ -202,12 +200,14 @@ 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" )

 	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 )
@ -324,8 +324,8 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 #pragma pop_macro( "do_once_start" )
 #pragma pop_macro( "do_once_end" )

-	CodeNS nspace     = def_namespace( name(ETokType), def_namespace_body( args( attribute_entires_def, enum_code, to_str, to_type ) ) );
-	CodeUsing     td_toktype = def_using( name(TokType), def_type( name(ETokType::Type) ) );
+	CodeNS    nspace     = def_namespace( name(ETokType), def_namespace_body( args( attribute_entires_def, enum_code, to_str, to_type ) ) );
+	CodeUsing td_toktype = def_using( name(TokType), def_type( name(ETokType::Type) ) );

 	return def_global_body( args( nspace, td_toktype ) );
 }
@ -333,7 +333,9 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 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()
@ -529,7 +531,7 @@ CodeBody gen_ast_inlines()
 	CodeBody impl_cast_var       = parse_global_body( token_fmt( "typename", StrC name(Var),            cast_tmpl ));

 	CodeBody result = def_global_body( args(
-		def_pragma( txt_StrC("region generated code inline implementation")),
+		def_pragma( txt("region generated code inline implementation")),
 		fmt_newline,
 		impl_code,
 		impl_code_body,
@ -561,9 +563,9 @@ CodeBody gen_ast_inlines()
 		impl_code_using,
 		impl_code_var,
 		fmt_newline,
-		def_pragma( txt_StrC("endregion generated code inline implementation")),
+		def_pragma( txt("endregion generated code inline implementation")),
 		fmt_newline,
-		def_pragma( txt_StrC("region generated AST/Code cast implementation")),
+		def_pragma( txt("region generated AST/Code cast implementation")),
 		fmt_newline,
 		impl_cast_body,
 		impl_cast_attribute,
@ -594,10 +596,11 @@ CodeBody gen_ast_inlines()
 		impl_cast_using,
 		impl_cast_var,
 		fmt_newline,
-		def_pragma( txt_StrC("endregion generated AST/Code cast implementation")),
+		def_pragma( txt("endregion generated AST/Code cast implementation")),
 		fmt_newline
 	));

 	return result;
 #pragma pop_macro("rcast")
+#pragma pop_macro("log_failure")
 }
--- a/project/helpers/undef.macros.hpp
+++ b/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
--- a/project/meson.build
+++ b/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 )
--- a/scripts/Readme.md
+++ b/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*
--- a/scripts/bootstrap.ci.ps1
+++ b/scripts/bootstrap.ci.ps1
@ -1,78 +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 bootstrap
-Push-Location $path_project
-	$args_meson  = @()
-	$args_meson += "setup"
-	$args_meson += $path_project_build
-
-	& meson $args_meson
-Pop-Location
-}
-
-# Compile bootstrap
-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 bootstrap
-	$gencpp_bootstrap = Join-Path $path_project_build gencpp_bootstrap.exe
-
-	Write-Host `nRunning gencpp bootstrap...
-	& $gencpp_bootstrap
-
-	# Format generated gencpp
-	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',
-		'gen.builder.hpp', 'gen.builder.cpp'
-		'gen.scanner.hpp', 'gen.scanner.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
-
-# Build and run validation
-
--- a/scripts/bootstrap.ps1
+++ b/scripts/bootstrap.ps1
@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'bootstrap.ci.ps1') $args" 
--- a/scripts/build.ci.ps1
+++ b/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
--- a/scripts/build.ps1
+++ b/scripts/build.ps1
@ -0,0 +1,3 @@
+cls
+$build = Join-Path $PSScriptRoot 'build.ci.ps1'
+& $build @args
--- a/scripts/clean.ps1
+++ b/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 =
--- a/scripts/gencpp.natvis
+++ b/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>
--- a/scripts/gencpp.refactor
+++ b/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_
--- a/scripts/helpers/devshell.ps1
+++ b/scripts/helpers/devshell.ps1
@ -1,3 +1,7 @@
+if ($env:VCINSTALLDIR) {
+    return
+}
+
 $ErrorActionPreference = "Stop"

 # Use vswhere to find the latest Visual Studio installation
--- a/scripts/helpers/target_arch.psm1
+++ b/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
--- a/scripts/msvc/build_msvc.ps1
+++ b/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
--- a/scripts/package_release.ps1
+++ b/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
--- a/scripts/singleheader.ci.ps1
+++ b/scripts/singleheader.ci.ps1
@ -1,73 +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
-
-# Build and run validation
-
--- a/scripts/singleheader.ps1
+++ b/scripts/singleheader.ps1
@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'singleheader.ci.ps1') $args" 
--- a/scripts/test.gen_build.ci.ps1
+++ b/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
--- a/scripts/test.gen_build.ps1
+++ b/scripts/test.gen_build.ps1
@ -1,2 +0,0 @@
-cls
-Invoke-Expression "& $(Join-Path $PSScriptRoot 'test.gen_build.ci.ps1') $args" 
--- a/scripts/test.gen_run.ps1
+++ b/scripts/test.gen_run.ps1
@ -1,99 +0,0 @@
-cls
-
-[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
--- a/singleheader/meson.build
+++ b/singleheader/meson.build
@ -1,18 +0,0 @@
-project( 'gencpp_singleheader', 'c', 'cpp', default_options : ['buildtype=debug'] )
-
-includes = include_directories(
-[
-'../project',
-])
-
-sources = [ 'gen.singleheader.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_singleheader', sources, include_directories : includes )
--- a/singleheader/gen.singleheader.cpp
+++ b/singleheader/gen.singleheader.cpp
@ -3,15 +3,16 @@
 #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 "file_processors/builder.hpp"
-#include "file_processors/builder.cpp"
-#include "file_processors/scanner.hpp"
+#include "auxillary/builder.hpp"
+#include "auxillary/builder.cpp"
+#include "auxillary/scanner.hpp"

 using namespace gen;

@ -19,25 +20,25 @@ constexpr char const* generation_notice =
 "// This file was generated automatially by gen.bootstrap.cpp "
 "(See: https://github.com/Ed94/gencpp)\n\n";

-constexpr StrC implementation_guard_start = txt_StrC(R"(
+constexpr StrC implementation_guard_start = txt(R"(
 #pragma region GENCPP IMPLEMENTATION GUARD
 #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
 #	define GEN_IMPLEMENTED
 )");

-constexpr StrC implementation_guard_end = txt_StrC(R"(
+constexpr StrC implementation_guard_end = txt(R"(
 #endif
 #pragma endregion GENCPP IMPLEMENTATION GUARD
 )");

-constexpr StrC roll_own_dependencies_guard_start = txt_StrC(R"(
+constexpr StrC roll_own_dependencies_guard_start = txt(R"(
 //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
 // Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
 #ifndef GEN_ROLL_OWN_DEPENDENCIES

 )");

-constexpr StrC roll_own_dependencies_guard_end = txt_StrC(R"(
+constexpr StrC roll_own_dependencies_guard_end = txt(R"(
 // GEN_ROLL_OWN_DEPENDENCIES
 #endif
 )");
@ -47,6 +48,8 @@ global bool generate_builder = true;
 global bool generate_editor  = true;
 global bool generate_scanner = true;

+constexpr bool DontSkipInitialDirectives = false;
+
 int gen_main()
 {
 #define project_dir "../project/"
@ -54,7 +57,7 @@ int gen_main()

 	Code push_ignores        = scan_file( project_dir "helpers/push_ignores.inline.hpp" );
 	Code pop_ignores         = scan_file( project_dir "helpers/pop_ignores.inline.hpp" );
-	Code single_header_start = scan_file( "components/header_start.hpp" );
+	Code single_header_start = scan_file( "components/header_start.hpp", DontSkipInitialDirectives );

 	Builder
 	header = Builder::open( "gen/gen.hpp" );
@ -68,22 +71,22 @@ int gen_main()

 		if ( generate_gen_dep )
 		{
-			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 timing        = scan_file( project_dir "dependencies/timing.hpp" );
+			Code header_start = scan_file( project_dir "dependencies/header_start.hpp", DontSkipInitialDirectives );
+			Code macros       = scan_file( project_dir "dependencies/macros.hpp" );
+			Code basic_types  = scan_file( project_dir "dependencies/basic_types.hpp" );
+			Code debug        = scan_file( project_dir "dependencies/debug.hpp" );
+			Code memory	      = scan_file( project_dir "dependencies/memory.hpp" );
+			Code string_ops   = scan_file( project_dir "dependencies/string_ops.hpp" );
+			Code printing     = scan_file( project_dir "dependencies/printing.hpp" );
+			Code containers   = scan_file( project_dir "dependencies/containers.hpp" );
+			Code hashing 	  = scan_file( project_dir "dependencies/hashing.hpp" );
+			Code strings      = scan_file( project_dir "dependencies/strings.hpp" );
+			Code filesystem   = scan_file( project_dir "dependencies/filesystem.hpp" );
+			Code timing       = scan_file( project_dir "dependencies/timing.hpp" );

 			header.print_fmt( roll_own_dependencies_guard_start );
 			header.print( header_start );
-			header.print_fmt( "GEN_NS_BEGIN\n\n" );
+			header.print_fmt( "\nGEN_NS_BEGIN\n" );

 			header.print( macros );
 			header.print( basic_types );
@ -93,19 +96,20 @@ int gen_main()
 			header.print( printing );
 			header.print( containers );
 			header.print( hashing );
-			header.print( string );
-			header.print( file_handling );
+			header.print( strings );
+			header.print( filesystem );
 			header.print( timing );

 			if ( generate_scanner )
 			{
-				header.print_fmt( "#pragma region Parsing\n\n" );
+				header.print_fmt( "\n#pragma region Parsing\n" );
 				header.print( scan_file( project_dir "dependencies/parsing.hpp" ) );
 				header.print_fmt( "#pragma endregion Parsing\n\n" );
 			}

 			header.print_fmt( "GEN_NS_END\n" );
 			header.print_fmt( roll_own_dependencies_guard_end );
+			header.print( fmt_newline );
 		}

 		Code types      = scan_file( project_dir "components/types.hpp" );
@ -122,38 +126,38 @@ int gen_main()

 		header.print_fmt( "GEN_NS_BEGIN\n\n" );

-		header.print_fmt("#pragma region Types\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\n");
+		header.print_fmt("#pragma region AST\n");
 		header.print( ast );
 		header.print( ast_types );
-		header.print_fmt("#pragma endregion AST\n\n");
+		header.print_fmt("\n#pragma endregion AST\n");

 		header.print( interface );

-		header.print_fmt( "#pragma region Inlines\n\n" );
+		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
 		header.print( ast_inlines );
-		header.print_fmt( "#pragma endregion Inlines\n\n" );
+		header.print_fmt( "#pragma endregion Inlines\n" );

 		header.print( header_end );

 		if ( generate_builder )
 		{
-			header.print_fmt( "#pragma region Builder\n\n" );
-			header.print( scan_file( project_dir "file_processors/builder.hpp" ) );
-			header.print_fmt( "#pragma endregion Builder\n\n" );
+			header.print_fmt( "\n#pragma region Builder\n" );
+			header.print( scan_file( project_dir "auxillary/builder.hpp" ) );
+			header.print_fmt( "#pragma endregion Builder\n" );
 		}

 		if ( generate_scanner )
 		{
-			header.print_fmt( "#pragma region Scanner\n\n" );
-			header.print( scan_file( project_dir "file_processors/scanner.hpp" ) );
+			header.print_fmt( "\n#pragma region Scanner\n" );
+			header.print( scan_file( project_dir "auxillary/scanner.hpp" ) );
 			header.print_fmt( "#pragma endregion Scanner\n\n" );
 		}

@ -166,15 +170,15 @@ int gen_main()

 		if ( generate_gen_dep )
 		{
-			Code impl_start    = scan_file( project_dir "dependencies/src_start.cpp" );
-			Code debug         = scan_file( project_dir "dependencies/debug.cpp" );
-			Code string_ops    = scan_file( project_dir "dependencies/string_ops.cpp" );
-			Code printing      = scan_file( project_dir "dependencies/printing.cpp" );
-			Code memory        = scan_file( project_dir "dependencies/memory.cpp" );
-			Code hashing       = scan_file( project_dir "dependencies/hashing.cpp" );
-			Code string        = scan_file( project_dir "dependencies/string.cpp" );
-			Code file_handling = scan_file( project_dir "dependencies/file_handling.cpp" );
-			Code timing        = scan_file( project_dir "dependencies/timing.cpp" );
+			Code impl_start = scan_file( project_dir "dependencies/src_start.cpp" );
+			Code debug      = scan_file( project_dir "dependencies/debug.cpp" );
+			Code string_ops = scan_file( project_dir "dependencies/string_ops.cpp" );
+			Code printing   = scan_file( project_dir "dependencies/printing.cpp" );
+			Code memory     = scan_file( project_dir "dependencies/memory.cpp" );
+			Code hashing    = scan_file( project_dir "dependencies/hashing.cpp" );
+			Code strings    = scan_file( project_dir "dependencies/strings.cpp" );
+			Code filesystem = scan_file( project_dir "dependencies/filesystem.cpp" );
+			Code timing     = scan_file( project_dir "dependencies/timing.cpp" );

 			header.print_fmt( roll_own_dependencies_guard_start );
 			header.print_fmt( "GEN_NS_BEGIN\n\n");
@ -185,14 +189,14 @@ int gen_main()
 			header.print( printing );
 			header.print( memory );
 			header.print( hashing );
-			header.print( string );
-			header.print( file_handling );
+			header.print( strings );
+			header.print( filesystem );
 			header.print( timing );

 			if ( generate_scanner )
 			{
-				header.print_fmt( "#pragma region Parsing\n\n" );
-				header.print( scan_file( project_dir "dependencies/parsing.cpp" ) );
+				header.print_fmt( "\n#pragma region Parsing\n" );
+			header.print( scan_file( project_dir "dependencies/parsing.cpp" ) );
 				header.print_fmt( "#pragma endregion Parsing\n\n" );
 			}

@ -206,12 +210,12 @@ int gen_main()
 		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" );
+		Code untyped         = scan_file( project_dir "components/interface.untyped.cpp" );

 		CodeBody      etoktype      = gen_etoktype( project_dir "enums/ETokType.csv", project_dir "enums/AttributeTokens.csv" );
 		CodeNS parser_nspace = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );

-		header.print_fmt( "GEN_NS_BEGIN\n\n");
+		header.print_fmt( "\nGEN_NS_BEGIN\n");
 		header.print( static_data );

 		header.print_fmt( "#pragma region AST\n\n" );
@ -219,28 +223,28 @@ int gen_main()
 		header.print( ast );
 		header.print_fmt( "#pragma endregion AST\n\n" );

-		header.print_fmt( "#pragma region Interface\n\n" );
+		header.print_fmt( "#pragma region Interface\n" );
 		header.print( interface );
 		header.print( upfront );
-		header.print_fmt( "#pragma region Parsing\n\n" );
+		header.print_fmt( "\n#pragma region Parsing\n\n" );
 		header.print( parser_nspace );
 		header.print( parsing );
-		header.print_fmt( "#pragma endregion Parsing\n\n" );
+		header.print_fmt( "\n#pragma endregion Parsing\n" );
 		header.print( untyped );
-		header.print_fmt( "#pragma endregion Interface\n\n");
+		header.print_fmt( "\n#pragma endregion Interface\n\n");

 		if ( generate_builder )
 		{
-			header.print_fmt( "#pragma region Builder\n\n" );
-			header.print( scan_file( project_dir "file_processors/builder.cpp" ) );
-			header.print_fmt( "#pragma endregion Builder\n\n" );
+			header.print_fmt( "#pragma region Builder\n" );
+			header.print( scan_file( project_dir "auxillary/builder.cpp"  ) );
+			header.print_fmt( "\n#pragma endregion Builder\n\n" );
 		}

 #if 0
 		if ( generate_scanner )
 		{
 			header.print_fmt( "#pragma region Scanner\n\n" );
-			header.print( scan_file( project_dir "file_processors/scanner.cpp" ) );
+			header.print( scan_file( project_dir "auxillary/scanner.cpp" ) );
 			header.print_fmt( "#pragma endregion Scanner\n\n" );
 		}
 #endif
--- a/test/SOA.cpp
+++ b/test/SOA.cpp
@ -2,8 +2,8 @@
 #define GEN_ENFORCE_STRONG_CODE_TYPES
 #define GEN_EXPOSE_BACKEND
 #define GEN_BENCHMARK
-#include "gen/gen.hpp"
-#include "gen/gen.builder.hpp"
+#include "gen.hpp"
+#include "gen.builder.hpp"
 using namespace gen;

 Code gen_SOA( CodeStruct struct_def, s32 num_entries = 0 )
@ -33,7 +33,7 @@ Code gen_SOA( CodeStruct struct_def, s32 num_entries = 0 )
 			if ( struct_mem->Type == ECode::Variable )
 			{
 				CodeType var_type        = struct_mem.cast<CodeVar>()->ValueType;
-				StrC     num_entries_str = to_StrC( str_fmt_buf( "%d", num_entries ) );
+				StrC     num_entries_str = to_str( str_fmt_buf( "%d", num_entries ) );

 				CodeVar entry_arr = { nullptr };
 				if ( ! num_entries)
@ -118,12 +118,13 @@ void check_SOA()
 {
 	log_fmt("\ncheck_SOA:");
 	gen::init();
+
 	Builder soa_test = Builder::open( "SOA.gen.hpp" );

 	soa_test.print( parse_using( code(
 		using u16 = unsigned short;
 	)));
-	soa_test.print( def_include( txt_StrC("gen.hpp")));
+	soa_test.print( def_include( txt("gen.hpp")));
 	soa_test.print( def_using_namespace( name(gen) ) );

 	soa_test.print( gen_SOA(
@ -136,6 +137,7 @@ void check_SOA()
 				u64 D;
 			};
 		))
+		, 100
 	));

 	soa_test.write();
--- a/test/gen/meson.build
+++ b/test/gen/meson.build
@ -1,27 +0,0 @@
-project( 'test', 'c', 'cpp', default_options : ['buildtype=debug'] )
-
-# add_global_arguments('-E', language : 'cpp')
-
-includes = include_directories(
-[
-	'../../project',
-	# '../../thirdparty'
-])
-
-# get_sources = files('./get_sources.ps1')
-# sources     = files(run_command('powershell', get_sources, check: true).stdout().strip().split('\n'))
-
-sources = [ '../test.cpp' ]
-
-if get_option('buildtype').startswith('debug')
-
-  add_project_arguments('-DBuild_Debug', language : ['c', 'cpp'])
-  # add_project_arguments('-E', language : ['c', 'cpp'])
-
-endif
-  # add_project_arguments('-E', language : ['c', 'cpp'])
-  # add_global_arguments( '-E', language : ['cpp'])
-
-add_project_arguments('-DGEN_TIME', language : ['c', 'cpp'])
-
-executable( 'gencpp', sources, include_directories : includes )
--- a/test/meson.build
+++ b/test/meson.build
@ -1,25 +0,0 @@
-project( 'test', 'c', 'cpp', default_options : ['buildtype=debug'] )
-
-# add_global_arguments('-E', language : 'cpp')
-
-includes = include_directories(
-  [
-    './gen',
-    '../project',
-    # '../thirdparty'
-  ])
-
-# get_sources = files('./get_sources.ps1')
-# sources     = files(run_command('powershell', get_sources, check: true).stdout().strip().split('\n'))
-
-sources = [ 'test.cpp' ]
-
-if get_option('buildtype').startswith('debug')
-
-  add_project_arguments('-DBuild_Debug', language : ['c', 'cpp'])
-
-endif
-
-add_project_arguments('-Druntime', language : ['c', 'cpp'])
-
-executable( 'testcpp', sources, include_directories : includes )
--- a/test/parsed/Array.Parsed.hpp
+++ b/test/parsed/Array.Parsed.hpp
@ -255,7 +255,7 @@ u32 gen_array_file()
 	gen_array_file;
 	gen_array_file.open( "array.Parsed.gen.hpp" );

-	Code include_gen = def_include( txt_StrC("gen.hpp") );
+	Code include_gen = def_include( txt("gen.hpp") );
 	gen_array_file.print( include_gen );

 	gen_array_file.print( def_using_namespace( name(gen)));
--- a/test/parsed/Buffer.Parsed.hpp
+++ b/test/parsed/Buffer.Parsed.hpp
@ -169,7 +169,7 @@ u32 gen_buffer_file()
 	gen_buffer_file;
 	gen_buffer_file.open( "buffer.Parsed.gen.hpp" );

-	gen_buffer_file.print( def_include( txt_StrC("gen.hpp")) );
+	gen_buffer_file.print( def_include( txt("gen.hpp")) );
 	gen_buffer_file.print( def_using_namespace( name(gen)));

 	gen_buffer_file.print( gen__buffer_base() );
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ed_	49a2cd7b2c	Uncomment formatting comments in build script (forgot to after completing fixes)	2023-08-22 02:17:28 -04:00
Ed_	a6c6574390	More formatting fixes	2023-08-22 02:09:20 -04:00
Ed_	c4846dad26	Formatting fixes	2023-08-22 01:51:59 -04:00
Ed_	a61a28b778	Fixx to bitfield variables Related to https://github.com/Ed94/gencpp/issues/25	2023-08-22 00:40:38 -04:00
Ed_	d0c995893d	Lower inital memory allocation amounts. (Lower latency iteration for running generator) I need to change it so that they all use one big arena allocation for the initial. This can be done when the global allocator is changed to a growable arena.	2023-08-21 23:49:23 -04:00
Ed_	a42e241afb	Got rid of the temp compoonent files, they are now generated via bootstrapping. This isn't the last step though everything in the main project directory that isn't md files needs to be generated only. Can't do that till testing is robust enough...	2023-08-21 23:28:39 -04:00
Ed_	6d85dd8fe8	Update vcproj	2023-08-21 23:09:40 -04:00
Ed_	db6e8b33eb	got intellisense working for the most part... VScode works withs some issues. VS2022 fails. 10xEditor works fine. JetBrains Rider fails due to it not supporting <push/pop>_macro pragmas	2023-08-21 23:07:03 -04:00
Ed_	7be3617083	Runtime fixed	2023-08-21 22:48:05 -04:00
Ed_	5c47777972	compiles agian...	2023-08-21 21:40:23 -04:00
Ed_	4a2ed6de4e	another vs code automated edit...	2023-08-21 21:40:05 -04:00
Ed_	9f64760b7a	Commenting out includes to diagnose...	2023-08-21 21:20:29 -04:00
Ed_	68f34e6fab	gitignore update for vc140.pdb will remove after I figure out how its going rogue.	2023-08-21 21:12:52 -04:00
Ed_	1f9bbddbb7	vs setting update	2023-08-21 21:12:25 -04:00
Ed_	050b00f28a	WIP - Broken Compile : Added pragma once and includes to all files + Parser fixes, and String improvements Adding the pragma once and includes the files broke compilation, still diagnosing why. - Some string functions were moved to the cpp, still need to do some more evaluation of it and the containers... - Added support for forceinline and neverinline to parsing (untested) - Added support for specifiers in operator cast such as explicit, inline/forceinline/neverinline, etc. - Before it only support const. - Still need to support volatile. - Forceinline was not supported at all for tokenization, fixed that.	2023-08-21 20:30:13 -04:00
Ed_	1241f44fd4	scan_file function can auto skips pragma once and includes Needed so that includes could be added to components so that intellisense would not fail since the parser (for most editors) doesn't properly parse the enviornment and cheats on a per-file basis.	2023-08-21 20:27:00 -04:00
Ed_	7d1c499e7b	Build script improvements Made sure devshell only loads up the msvc env once.	2023-08-20 22:39:46 -04:00
Ed_	b3f0c2734f	Merge remote-tracking branch 'origin/main' into dev	2023-08-20 18:04:51 -04:00
Ed_	eaeb8acee4	Remove Some vcproj changes, removal of the rogue vc140.pdb	2023-08-20 18:04:35 -04:00
Ed_	12bf878cb3	Merge pull request #23 from Ed94/dev dev pull - Build script updates and misc fixes	2023-08-20 17:55:35 -04:00
Ed_	52ae431ad6	Made clean script remove the gen dir now from test dir.	2023-08-20 15:51:51 -04:00
Ed_	05fa62eced	Test building & generation fixed with altest scripts	2023-08-20 15:45:06 -04:00
Ed_	2f7836b191	Fixes to buildscript	2023-08-20 13:18:09 -04:00
Ed_	f574a9ba9a	Further improvements to build script test is failing to complete properly, need to debug...	2023-08-20 13:02:50 -04:00
Ed_	a6bf60a51e	Simpilication of build script, added initial support for tests	2023-08-20 12:31:28 -04:00
Ed_	37d9782cf2	Singleheader now compiles with new build script on both clang & msvc	2023-08-20 10:17:55 -04:00
Ed_	11679ba8b4	New build script works for clang and msvc! Need to update singleheader and test to use it.	2023-08-19 21:33:01 -04:00
Ed_	8985f0a4d9	MSVC in latest script works Clang is having issues.	2023-08-19 17:08:13 -04:00
Ed_	32a910515e	More refactoring, getting rid of meson in favor of just powershell scripts	2023-08-19 12:18:48 -04:00
Ed_	aa928ff446	Scripting updates, some refactors.. Made a package release script. Did refactors based on some design considerations Still need to make some major decisions...	2023-08-09 18:47:59 -04:00
Ed_	5aff89262b	Fixes (Doc typos, pragma once worng type, non-debug fatal compile fail)	2023-08-09 09:50:12 -04:00
Ed_	b5fa864318	Fixes and improvements to serialization. There were multiple issues with comment and newline lexing. Extended printing functions to support Strings with %S flag (captial 'S'). Allows for length detection. Also made it so that precision for strings is the string length.	2023-08-08 22:14:58 -04:00
Ed_	bb35444be9	Fix for `log_failure` macro expansion in helper.hpp: `CodeBody gen_ast_inlines()`	2023-08-08 15:53:10 -04:00
Ed_	67d02c1f62	Fix for wrong tokens for GNU/MSVC attribute captures (parse_attributes) Also a fix for a typo in the readme...	2023-08-08 15:35:06 -04:00