.gitignore

@@ -1,4 +1,3 @@
-.vscode
 .idea
 
 **/build/*
@@ -28,19 +27,5 @@ release/**
 **/Unreal/*.h
 **/Unreal/*.cpp
 ! **/Unreal/validate.unreal.cpp
-project/auxiliary/vis_ast/dependencies/temp
+project/auxillary/vis_ast/dependencies/temp
 test/gen/original
-singleheader/gen/scratch.hpp
-test/gen/scratch.cpp
-gen_c_library/gen
-
-**/*.sln
-**/*.sln.DotSettings.user
-**/*.10x
-**/*.vcxproj
-**/*.vcxproj.filters
-**/*.vcxproj.user
-test/c_library/gen
-test/cpp_library/gen
-
-!scripts/helpers/refactor.exe

.vscode/bookmarks.json

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

.vscode/c_cpp_properties.json

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

.vscode/launch.json

@@ -0,0 +1,63 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "lldb",
+			"request": "launch",
+			"name": "Debug gentime lldb",
+			"program": "${workspaceFolder}/test/test.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/test/",
+			"postRunCommands": [
+			]
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug gentime vsdbg",
+			"program": "${workspaceFolder}/test/build/test.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/test/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug bootstrap vsdbg",
+			"program": "${workspaceFolder}/project/build/bootstrap.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/project/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug singleheader vsdbg",
+			"program": "${workspaceFolder}/singleheader/build/gencpp_singleheader.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/singleheader/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug raylib refactor vsdbg",
+			"program": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/raylib/build/raylib_refactor.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/temp/raylib-master/src/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug VIS AST",
+			"program": "${workspaceFolder}/project/auxillary/vis_ast/binaries/vis_ast.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/binaries/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		}
+	]
+}

.vscode/settings.json

@@ -0,0 +1,55 @@
+{
+	"files.associations": {
+		"*.rmd": "markdown",
+		"array": "cpp",
+		"compare": "cpp",
+		"type_traits": "cpp",
+		"utility": "cpp",
+		"xtr1common": "cpp",
+		"xutility": "cpp",
+		"initializer_list": "cpp",
+		"table.h": "c",
+		"iterator": "cpp",
+		"memory": "cpp",
+		"exception": "cpp",
+		"optional": "cpp",
+		"tuple": "cpp",
+		"xmemory": "cpp",
+		"algorithm": "cpp",
+		"limits": "cpp",
+		"concepts": "cpp",
+		"*.rh": "cpp",
+		"chrono": "cpp",
+		"string": "cpp",
+		"filesystem": "cpp",
+		"format": "cpp",
+		"ratio": "cpp",
+		"xstring": "cpp",
+		"functional": "cpp",
+		"vector": "cpp",
+		"list": "cpp",
+		"xhash": "cpp",
+		"glfw3.h": "c",
+		"stdbool.h": "c",
+		"objbase.h": "c",
+		"mmreg.h": "c",
+		"mmsystem.h": "c",
+		"propidl.h": "c",
+		"android_native_app_glue.h": "c",
+		"raylib.h": "c",
+		"*.m": "cpp"
+	},
+	"C_Cpp.intelliSenseEngineFallback": "disabled",
+	"mesonbuild.configureOnOpen": true,
+	"C_Cpp.errorSquiggles": "disabled", // This doesn't work well with how the headers are included.
+	"godot_tools.scene_file_config": "",
+	"C_Cpp.default.compilerPath": "cl.exe",
+	"C_Cpp.exclusionPolicy": "checkFilesAndFolders",
+	"C_Cpp.files.exclude": {
+		"**/.vscode": true,
+		"**/.vs": true,
+		"**/sanity.gen.hpp": true
+	},
+	"autoHide.autoHidePanel": false,
+	"autoHide.autoHideSideBar": false
+}

LICENSE

@@ -26,19 +26,3 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Source URL: https://github.com/Ed94/gencpp
-
-Acknowledgements
-
-* The dependencies for gencpp source are derived from the zpl library: https://github.com/zpl-c/zpl
-
-Special thanks to:
-
-* The Handmade Community.
-
-* Casey Muratori, Ginger Bill (Bill Hall), Mr. 4th (Allen Webster), Ryan Fluery: Influnced conceptually how to handle staged metaprograming.
-
-* Jonathan Blow: Jai's metaprogramming influenced the design of this library.
-
-* My friends for putting up with discord spam on this library.

Readme.md

@@ -1,54 +1,35 @@
 # gencpp
 
-An attempt at simple staged metaprogramming for C/C++. Reflect and generate code for your codebase at runtime!
+An attempt at simple staged metaprogramming for c/c++.
 
-![splash-cpp](./docs/assets/Code_-_Insiders_2024-12-15_23-04-07.gif)
-![splash-c](./docs/assets/Code_-_Insiders_2024-12-15_22-57-58.gif)
-
-The library API is a composition of code element constructors, and a non-standards-compliant single-pass C/C++ parser.  
-These build up a code AST to then serialize with a file builder, or can be traversed for staged-reflection of C/C++ code.
+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 integrate into a user's project domain.
-
-## Langauge Bindings
-
-* [gencpp-odin](https://github.com/Ed94/gencpp-odin): Bindings for the odin programming language.
-
-## Utility Libraries
-
-* [UnrealGencpp](https://github.com/Ed94/UnrealGencpp): Setup as a plugin to integrate into Unreal Engine or Unreal Projects.
-
-## Documentation
-
-* [docs - General](./docs/Readme.md): Overview and additional docs
-  * [AST_Design](./docs/AST_Design.md): Overview of ASTs
-  * [AST Types](./docs/AST_Types.md): Listing of all AST types along with their Code type interface.
-  * [Parsing](./docs/Parsing.md): Overview of the parsing interface.
-  * [Parser Algo](./docs/Parser_Algo.md): In-depth breakdown of the parser's implementation.
-* [base](./base/Readme.md): Essential (base) library.
-* [gen_c_library](./gen_c_library/): C11 library variant generation (single header and segmented).
-* [gen_segmented](./gen_segmented/): Segmented C++ (`gen.<hpp/cpp>`, `gen.dep.<hpp/cpp>`) generation
-* [gen_singleheader](./gen_singleheader/): Singlehader C++ generation `gen.hpp`
-* [gen_unreal_engine](./gen_unreal_engine/): Unreal Engine thirdparty code generation.
+Its not meant to be a black box metaprogramming utility, it should be easy to intergrate into a user's project domain.  
 
 ## Notes
 
+**On Partial Hiatus: Working on handmade hero for now. Only fixes will be pushed as I come across them until I get what I want done from the series**
+
 This project is still in development (very much an alpha state), so expect bugs and missing features.  
 See [issues](https://github.com/Ed94/gencpp/issues) for a list of known bugs or todos.
 
 The library can already be used to generate code just fine, but the parser is where the most work is needed. If your C++ isn't "down to earth" expect issues.
 
 A `natvis` and `natstepfilter` are provided in the scripts directory (its outdated, I'll update this readme when its not).
-*Minor update: I've been using [RAD Debugger](https://github.com/EpicGamesExt/raddebugger) with this and the code structures should be easy to debug even without natvis.*
+
+***The editor and scanner have not been implemented yet. The scanner will come first, then the editor.***
+
+A C variant is hosted [here](https://github.com/Ed94/genc); I will complete it when this library is feature complete, it should be easier to make than this...
 
 ## Usage
 
 A metaprogram is built to generate files before the main program is built. We'll term runtime for this program as `GEN_TIME`. The metaprogram's core implementation are within `gen.hpp` and `gen.cpp` in the project directory.
 
-`gen.cpp` \`s  `main()` is defined as `gen_main()` which the user will have to define once for their program. There they may reflect and/or generate code.
+`gen.cpp` \`s  `main()` is defined as `gen_main()` which the user will have to define once for their program. There they will dictate everything that should be generated.
 
-In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't the best to use):
+In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't required at all):
 
 Within `program.cpp` :
 
@@ -60,11 +41,7 @@ Within `program.cpp` :
 
 u32 gen_main()
 {
-    gen::Context ctx;
-    gen::init(& ctx);
     ...
-    gen::deinit(& ctx);
-    return 0;
 }
 #endif
 
@@ -75,6 +52,7 @@ u32 gen_main()
 
     // Regular runtime dependent on the generated code here.
 #endif
+
 ```
 
 The design uses a constructive builder API for the code to generate.  
@@ -87,18 +65,18 @@ Example using each construction interface:
 Validation and construction through a functional interface.
 
 ```cpp
-CodeTypename t_uw           = def_type( name(usize) );
-CodeTypename t_allocator    = def_type( name(allocator) );
-CodeTypename t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
+Code t_uw           = def_type( name(uw) );
+Code t_allocator    = def_type( name(allocator) );
+Code t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
 
-CodeStruct header;
+Code header;
 {
-    CodeVar  num       = def_variable( t_uw,        name(Num) );
-    CodeVar  cap       = def_variable( t_uw,        name(Capacity) );
-    CodeVar  mem_alloc = def_variable( t_allocator, name(Allocator) );
-    CodeBody body      = def_struct_body( args( num, cap, mem_alloc ) );
+    Code num       = def_variable( t_uw,        name(Num) );
+    Code cap       = def_variable( t_uw,        name(Capacity) );
+    Code mem_alloc = def_variable( t_allocator, name(Allocator) );
+    Code body      = def_struct_body( args( num, cap, mem_alloc ) );
 
-    header = def_struct( name(ArrayHeader), { body });
+    header = def_struct( name(ArrayHeader), __, __, body );
 }
 ```
 
@@ -107,11 +85,11 @@ CodeStruct header;
 Validation through ast construction.
 
 ```cpp
-CodeStruct header = parse_struct( code(
+Code header = parse_struct( code(
     struct ArrayHeader
     {
-        usize     Num;
-        usize     Capacity;
+        uw        Num;
+        uw        Capacity;
         allocator Allocator;
     };
 ));
@@ -126,8 +104,8 @@ No validation, just glorified text injection.
 Code header = code_str(
     struct ArrayHeader
     {
-        usize     Num;
-        usize     Capacity;
+        uw        Num;
+        uw        Capacity;
         allocator Allocator;
     };
 );
@@ -136,15 +114,15 @@ Code header = code_str(
 `name` is a helper macro for providing a string literal with its size, intended for the name parameter of functions.  
 `code` is a helper macro for providing a string literal with its size, but intended for code string parameters.  
 `args` is a helper macro for providing the number of arguments to varadic constructors.
-`code_str` is a helper macro for writing `untyped_str( code( <content> ))`
+`code_str` is a helper macro for writting `untyped_str( code( <content> ))`
 
-All three construction interfaces will generate the following C code:
+All three constrcuton interfaces will generate the following C code:
 
 ```cpp
 struct ArrayHeader
 {
-    usize     Num;
-    usize     Capacity;
+    uw        Num;
+    uw        Capacity;
     allocator Allocator;
 };
 ```
@@ -155,13 +133,3 @@ struct ArrayHeader
 ## Building
 
 See the [scripts directory](scripts/).
-
-## Gallery
-
-### Listing definitions in the Cuik Compiler
-
-https://github.com/user-attachments/assets/2302240c-01f1-4e1b-a4b5-292eb3186648
-
-### Unreal: Generating a UAttributeSet from a UDataTable
-
-https://github.com/user-attachments/assets/2a07b743-825d-4f9f-beaf-3559e8748a4d

base/Readme.md

@@ -1,212 +0,0 @@
-## Navigation
-
-# base
-
-[Top](../Readme.md)
-
-* [docs](../docs/Readme.md)
-
-The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a standard target format, or a user's desires.
-
-If using the library's provided build scripts:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> base
-```
-
-## Content Overview
-
-* **base**: Files are in granular pieces separated into four directories:
-  * **dependencies**: Originally from the c-zpl library and modified thereafter.
-  * **components**: The essential definitions of the library.
-  * **helpers**: Contains helper functionality used by base and the variant library generators.
-    * `base_codegen.hpp`: Helps with self-hosted code generation of enums, and operator overload inlines of the code types.
-    * `<push/pop>.<name>.inline.<hpp>`: macros that are meant to be injected at specific locations of the library file/s.
-    * `misc.hpp`: Misc functionality used by the library generation metaprograms.
-    * `undef.macros.h`: Undefines all macros from library.
-  * **auxiliary**: Non-essential tooling:
-    * `Builder`: Similar conceptually to Jai programming language's *builder*, just opens a file and prepares a string buffer to serialize code into (`builder_print`, `builder_print_fmt`). Then write & close the file when completed (`builder_write`).
-    * **`Scanner`**: Interface to load up `Code` from files two basic functions are currently provided.
-      * `scan_file`: Used mainly by the library format generators to directly scan files into untyped `Code` (raw string content, pre-formatted no AST parsed).
-      * `parse_file`: Used to read file and then parsed to populate a `CodeBody` AST.
-      * CSV parsing via one or two columns simplified.
-* **gen_segemetned**: Dependencies go into gen.dep.{hpp/cpp} and components into gen.{hpp/cpp}
-* **gen_singleheader**: Everything into a single file: gen.hpp
-* **gen_unreal_engine**: Like gen_segmented but the library is modified slightly to compile as a thirdparty library within an Unreal Engine plugin or module.
-* **gen_c_library**: The library is heavily modifed into C11 compliant code. A segmented and single-header set of variants are generated.
-
-Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
-
-## Dependencies
-
-The project has no external dependencies beyond:
-
-* `errno.h`
-* `stat.h`
-* `stdarg.h`
-* `stddef.h`
-* `stdio.h`
-* `copyfile.h` (Mac)
-* `types.h`    (Linux)
-* `sys/man.h`  (Linux)
-* `fcntl.h`    (POSXIX Filesystem)
-* `unistd.h`   (Linux/Mac)
-* `intrin.h`   (Windows)
-* `io.h`       (Windows with gcc)
-* `windows.h`  (Windows)
-
-Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).
-The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
-
-See the following files for any updates:
-
-* [`platform.hpp`](./dependencies/platform.hpp)
-* [`src_start.cpp`](./dependencies/src_start.cpp)
-* [`filesystem.cpp`](./dependencies/filesystem.cpp)
-* [`memory.cpp`](./dependencies/memory.cpp)
-
-## Conventions
-
-This library was written in a subset of C++ where the following are not used at all:
-
-* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
-* Language provide dynamic dispatch, RTTI
-* Object-Oriented Inheritance
-* Exceptions
-
-Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.
-The base library itself does not use anything but C-like features to allow for generating a derviative compatiable with C.
-
-Member function support or free-functions with reference object passing are wrapped in `! GEN_C_LIKE CPP` preprocess conditionals.
-
-## C++ template usage
-
-There are only 4 template definitions in the entire library (C++ versions). (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `tmpl_cast<CodeT>(CodeT code)`)
-
-Two generic templated containers are used throughout the library:
-
-* `template< class Type> struct Array`
-* `template< class Type> struct HashTable`
-
-`tmpl_cast<CodeT>(CodeT code)` is just an alternative way to explicitly cast to code. Its usage is wrapped in a macro called `cast` for the base library (needed for interoperability with C).
-
-`template< class Type> swap( Type& a, Type& b)` is used over a macro.
-
-Otherwise the library is free of any templates.
-
-## Macro usage
-
-Since this is a meta-programming library, it was desired to keep both templates and macros (especially macros) usage very limited.
-
-Most macros are defined within [macros.hpp](./dependencies/macros.hpp). 
-
-The most advanced macro usage is `num_args` which is a helper for counting the number of arguments of another macro.
-
-Any large macros used implementing the gen interface or parser are going to be phased out in favor of just forcinlined functions.  
-*(Unless there is a hot-path that requires them)*
-
-The vast majority of macros should be single-line subsitutions that either add:
-
-* Improvements to searching
-* Intentionality of keyword usage
-* A  feature that only the preprocessor has (ex: function name reflection or stringifying)
-* Compatibility of statements or expressions bewteen C & C++ that cannot be parsed by gencpp itself.
-* Masking highly verbose syntax (the latter is getting phased out).
-
-[gen_c_library](../gen_c_library/) has the most advanced set of macros for c11's generic selection.
-
-* A significant amount of explicit code geneeration is utilized to keep abuse of the preprocessor to the absolute minimum.
-* There is a heavy set of documentation inlined wth them; their naming is also highly verbose and explicit.
-* See its documentation for more information.
-
-## On base code generation
-
-There are ***five*** header files which are automatically generated using [base_codegen.hpp](./helpers/base_codegen.hpp) by [base.cpp](./base.cpp). They are all located in [components/gen](./components/gen/).
-
-* [ecodetypes.hpp](./components/gen/ecode.hpp): `CodeType` enum definition and related implementation. Generation is based off of [ECodeType.csv](./enums/ECodeTypes.csv).
-* [especifier.hpp](./components/gen/especifier.hpp): `Specifier` enum definition, etc. Generated using [ESpecifier.csv](./enums/ESpecifier.csv).
-* [eoperator.hpp](./components/gen/eoperator.hpp): `Operator` enum definition, etc. Generated using [EOperator.hpp](./enums/EOperator.csv).
-* [etoktype.cpp](./components/gen/etoktype.cpp): `TokType` enum defininition, etc. Used by the lexer and parser backend. Uses two csvs:
-  * [ETokType.csv](./enums/ETokType.csv): Provides the enum entries and their strinng ids.
-  * [AttributeTokens.csv](./enums/AttributeTokens.csv): Provides tokens entries that should be considered as attributes  by the lexer and parser. Sspecfiically macro attributes such as those use for exporting symbols.
-* [ast_inlines.hpp](./components/gen/ast_inlines.hpp): Member trivial `operator` definitions for C++ code types. Does not use a csv.
-
-[misc.hpp](./helpers/misc.hpp): Has shared functions used by the library generation meta-programs throughout this codebase.
-
-If using the library's provided build scripts:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> base
-```
-
-Will refresh those files.
-
-## On multi-threading
-
-Currently unsupported. I want the library to be *stable* and *correct*, with the addition of exhausting all basic single-threaded optimizations before I consider multi-threading.
-
-## Extending the library
-
-This library is relatively very small (for parsing C++), and can be extended without much hassle.
-
-The convention you'll see used throughout the upfront interface of the library is as follows:
-
-1. Check name or parameters to make sure they are valid for the construction requested
-2. Create a code object using `make_code`.
-3. Populate immediate fields (Name, Type, ModuleFlags, etc)
-4. Populate sub-entires using `add_entry`. If using the default serialization function `to_strbuilder`, follow the order at which entires are expected to appear (there is a strong ordering expected).
-
-Names or Content fields are interned strings and thus showed be cached using `cache_str` if its desired to preserve that behavior.
-
-`def_operator` is the most sophisticated upfront constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
-
-The parser is documented under [`docs/Parsing.md`](../docs/Parsing.md) and [`docs/Parser_Algo.md`](../docs/Parser_Algo.md). Read that and the entire library if you want to extend it.
-
-### Attributes
-
-To add additional macro attributes, all that has to be done is modifying [`AttributeTokens.csv`](./enums/AttributeTokens.csv).
-
-### Specifiers
-
-To add additional macro specifiers, the following needs to be done:
-
-1. Adjust [especifier.hpp](./components/gen/especifier.hpp)
-2. Adjust [etoktype.cpp](./components/gen/etoktype.cpp)
-3. Adjust [parser_case_macros.cpp](./components/parser_case_macros.cpp)
-
-If the specifier is a new trailing specifier on function definitions:
-
-Head into [base_codegen.hpp](./helpers/base_codegen.hpp): `gen_especifier`. There will be an `is_trailing` function that needs to be adjusted with an additional case for the user's new trailing specifier.
-
-### Code Types
-
-These require the following to be handled to the equivalent extent as the other types:
-
-1. Adjust [ECodeTypes.csv](./enums/ECodeTypes.csv) with the new types
-2. Define a new `AST_<Name>` and `Code<Name>`. See
-    * [ast.hpp](./components/ast.hpp): Initial forwards and user defined conversion for Code.
-    * [ast_types.hpp](./components/ast_types.hpp): Define the `AST_<Name>` struct.
-    * [code_types.hpp](./components/code_types.hpp): Defne the `CodeType` struct. If its needs an iterator see: `struct CodeBody` & `struct CodeParams`.
-3. [ast_case_macros.cpp](./components/ast_case_macros.cpp): Review cases here if the new code type needs to be considered.
-4. [ast.cpp](./components/ast.cpp): Need to review
-    * `code_debug_str`
-    * `code_is_equal`
-    * `code_to_strbuilder_ref`
-    * `code_validate_body`
-5. [code_serialization.cpp](./components/code_serialization.cpp): Define serialization here.
-6. [inlines.hpp](./components/inlines.hpp): Any inline definitions for the `struct Code<Name>` are defined here.
-7. [interface.cpp](./components/interface.hpp): Define the `Code<Name>` upfront and parsing interface.
-8. [interface.upfront.cpp](./components/interface.upfront.cpp): Define the upfront constructor implementation.
-9. [interface.parsing.cpp](./components/interface.parsing.cpp): Define the parsing interface implementation.
-10. [lexer.cpp](./components/lexer.cpp): Adjust the lexer as needed.
-11. [parser.cpp](./components/parser.cpp): Adjust the parser as needed.
-
-## A note on compilation and runtime generation speed
-
-The library is designed to be fast to compile and generate code at runtime as fast as possible on a debug build.
-Its recommended that your metaprogam be compiled using a single translation unit (unity build).
-
-## Whats with the expression / executions support #ifd and enums?
-
-The library is a *work in progress* and those are unfinished hypotheticals for adding the ability to manage or parse the AST of expresions or execution scope code.
-They are entirely untested and not meant to be used yet, futher there is no parsing support or an upfront interface for what CodeTypes are defined so far.

base/auxiliary/builder.cpp

@@ -1,61 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	include "builder.hpp"
-#endif
-
-#pragma region Builder
-
-Builder builder_open( char const* path )
-{
-	Builder result;
-
-	FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
-	if ( error != EFileError_NONE )
-	{
-		log_failure( "gen::File::open - Could not open file: %s", path);
-		return result;
-	}
-
-	Context* ctx = get_context();
-	GEN_ASSERT_NOT_NULL(ctx);
-	result.Buffer = strbuilder_make_reserve( ctx->Allocator_Temp, ctx->InitSize_BuilderBuffer );
-
-	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
-	return result;
-}
-
-void builder_pad_lines( Builder* builder, s32 num )
-{
-	strbuilder_append_str( & builder->Buffer, txt("\n") );
-}
-
-void builder_print( Builder* builder, Code code )
-{
-	StrBuilder   str = code_to_strbuilder(code);
-	// const ssize len = str.length();
-	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
-	strbuilder_append_string( & builder->Buffer, str );
-}
-
-void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
-{
-	ssize   res;
-	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
-
-	res = c_str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
-
-	strbuilder_append_c_str_len( (StrBuilder*) & (builder->Buffer), (char const*)buf, res);
-}
-
-void builder_write(Builder* builder)
-{
-	b32 result = file_write( & builder->File, builder->Buffer, strbuilder_length(builder->Buffer) );
-
-	if ( result == false )
-		log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) );
-
-	log_fmt( "Generated: %s\n", builder->File.filename );
-	file_close( & builder->File );
-	strbuilder_free(& builder->Buffer);
-}
-
-#pragma endregion Builder

base/auxiliary/builder.hpp

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

base/auxiliary/gen_template.hpp

@@ -1,35 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "helpers/push_ignores.inline.hpp"
-#	include "components/header_start.hpp"
-#	include "components/types.hpp"
-#	include "components/gen/ecode.hpp"
-#	include "components/gen/eoperator.hpp"
-#	include "components/gen/especifier.hpp"
-#	include "components/ast.hpp"
-#	include "components/code_types.hpp"
-#	include "components/ast_types.hpp"
-#	include "components/interface.hpp"
-#	include "components/inlines.hpp"
-#	include "components/gen/ast_inlines.hpp"
-#	include "components/header_end.hpp"
-#endif
-
-/*
-	Explicitly generates a resolved definition of a cpp template definition.
-
-	TODO(Ed): Needs implementing for the C-library variant.
-	TODO(Ed): We need a non <token> syntax subst implemtnation for Strings for this to work. It must subst keywords directly based on template parameter names.
-
-	This is only meant to be used on relatively trivial templates, where the type or numeric is mostly a 'duck' type.
-	It cannot parse complex template parameters.
-
-	The varadic args should correspond 1:1 with the type of objects the generator expects from the template's parameters.alignas.
-*/
-
-CodeOperator gen_operator_template( CodeTemplate template, ... );
-CodeFn       gen_func_template( CodeTemplate template, ...  );
-Code         gen_class_struct_template( CodeTemplate template, ... );
-
-Code gen_template( CodeTemplate template, ... );
-Code gen_template( Str template, Str instantiation );

base/auxiliary/scanner.cpp

@@ -1,148 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	include "scanner.hpp"
-#endif
-
-#pragma region Scanner
-
-Code scan_file( char const* path )
-{
-	FileInfo file;
-
-	FileError error = file_open_mode( & file, EFileMode_READ, path );
-	if ( error != EFileError_NONE )
-	{
-		GEN_FATAL( "scan_file: Could not open: %s", path );
-	}
-
-	ssize fsize = file_size( & file );
-	if ( fsize <= 0 )
-	{
-		GEN_FATAL("scan_file: %s is empty", path );
-	}
-
-	StrBuilder str = strbuilder_make_reserve( get_context()->Allocator_Temp, fsize );
-		file_read( & file, str, fsize );
-		strbuilder_get_header(str)->Length = fsize;
-
-	// Skip INTELLISENSE_DIRECTIVES preprocessor blocks
-	// Its designed so that the directive should be the first thing in the file.
-	// Anything that comes before it will also be omitted.
-	{
-	#define current (*scanner)
-	#define matched    0
-	#define move_fwd() do { ++ scanner; -- left; } while (0)
-		const Str directive_start = txt( "ifdef" );
-		const Str directive_end   = txt( "endif" );
-		const Str def_intellisense = txt("INTELLISENSE_DIRECTIVES" );
-
-		bool        found_directive = false;
-		char const* scanner         = (char const*)str;
-		s32         left            = fsize;
-		while ( left )
-		{
-			// Processing directive.
-			if ( current == '#' )
-			{
-				move_fwd();
-				while ( left && char_is_space( current ) )
-					move_fwd();
-
-				if ( ! found_directive )
-				{
-					if ( left && c_str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched )
-					{
-						scanner += directive_start.Len;
-						left    -= directive_start.Len;
-
-						while ( left && char_is_space( current ) )
-							move_fwd();
-
-						if ( left && c_str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
-						{
-							scanner += def_intellisense.Len;
-							left    -= def_intellisense.Len;
-
-							found_directive = true;
-						}
-					}
-
-					// Skip to end of line
-					while ( left && current != '\r' && current != '\n' )
-						move_fwd();
-					move_fwd();
-
-					if ( left && current == '\n' )
-						move_fwd();
-
-					continue;
-				}
-
-				if ( left && c_str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched )
-				{
-					scanner += directive_end.Len;
-					left    -= directive_end.Len;
-
-					// Skip to end of line
-					while ( left && current != '\r' && current != '\n' )
-						move_fwd();
-					move_fwd();
-
-					if ( left && current == '\n' )
-						move_fwd();
-
-					// sptr skip_size = fsize - left;
-					if ( (scanner + 2) >= ( (char const*) str + fsize ) )
-					{
-						mem_move( str, scanner, left );
-						strbuilder_get_header(str)->Length = left;
-						break;
-					}
-
-					mem_move( str, scanner, left );
-					strbuilder_get_header(str)->Length = left;
-
-					break;
-				}
-			}
-
-			move_fwd();
-		}
-	#undef move_fwd
-	#undef matched
-	#undef current
-	}
-
-	file_close( & file );
-	return untyped_str( strbuilder_to_str(str) );
-}
-
-CodeBody parse_file( const char* path ) {
-	FileContents file    = file_read_contents( get_context()->Allocator_Temp, true, path );
-	Str          content = { (char const*)file.data, file.size };
-	CodeBody     code    = parse_global_body( content );
-	log_fmt("\nParsed: %s\n", path);
-	return code;
-}
-
-CSV_Column parse_csv_one_column(AllocatorInfo allocator, char const* path) {
-	FileContents content   = file_read_contents( allocator, file_zero_terminate, path );
-	Arena        csv_arena = arena_init_from_memory(content.data, content.size);
-
-	CSV_Column result;
-	csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
-	result.Content = result.ADT.nodes[0].nodes;
-	return result;
-}
-
-CSV_Columns2 parse_csv_two_columns(AllocatorInfo allocator, char const* path) {
-	FileContents content   = file_read_contents( allocator, file_zero_terminate, path );
-	Arena        csv_arena = arena_init_from_memory(content.data, content.size);
-
-	CSV_Columns2 result;
-	csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
-	result.Col_1 = result.ADT.nodes[0].nodes;
-	result.Col_2 = result.ADT.nodes[1].nodes;
-	return result;
-}
-
-#pragma endregion Scanner

base/auxiliary/scanner.hpp

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

base/base.cpp

@@ -1,74 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_C_LIKE_CPP 1
-#include "gen.cpp"
-#include "helpers/push_ignores.inline.hpp"
-
-#include <stdlib.h>
-
-GEN_NS_BEGIN
-#include "helpers/base_codegen.hpp"
-#include "helpers/misc.hpp"
-GEN_NS_END
-
-using namespace gen;
-
-constexpr char const* path_format_style = "../scripts/.clang-format";
-constexpr char const* scratch_file      = "build/scratch.hpp";
-
-Code format( Code code ) {
-	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
-}
-
-constexpr char const* generation_notice =
-"// This file was generated automatially by gencpp's bootstrap.cpp "
-"(See: https://github.com/Ed94/gencpp)\n\n";
-
-int gen_main()
-{
-	gen::Context ctx {};
-	gen::init( & ctx);
-
-	CodeBody gen_component_header = def_global_body( args(
-		def_preprocess_cond( PreprocessCond_IfDef, txt("INTELLISENSE_DIRECTIVES") ),
-		pragma_once,
-		def_include(txt("components/types.hpp")),
-		preprocess_endif,
-		fmt_newline,
-		untyped_str( to_str_from_c_str(generation_notice) )
-	));
-
-	CodeBody ecode       = gen_ecode     ( "enums/ECodeTypes.csv" );
-	CodeBody eoperator   = gen_eoperator ( "enums/EOperator.csv" );
-	CodeBody especifier  = gen_especifier( "enums/ESpecifier.csv" );
-	CodeBody etoktype    = gen_etoktype  ( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-	CodeBody ast_inlines = gen_ast_inlines();
-
-	Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" );
-	builder_print( & header_ecode, gen_component_header );
-	builder_print( & header_ecode, format(ecode) );
-	builder_write( & header_ecode);
-
-	Builder header_eoperator = builder_open( "components/gen/eoperator.hpp" );
-	builder_print( & header_eoperator, gen_component_header );
-	builder_print( & header_eoperator, format(eoperator) );
-	builder_write( & header_eoperator );
-
-	Builder header_especifier = builder_open( "components/gen/especifier.hpp" );
-	builder_print( & header_especifier, gen_component_header );
-	builder_print( & header_especifier, format(especifier) );
-	builder_write( & header_especifier);
-	
-	Builder header_etoktype = builder_open( "components/gen/etoktype.hpp" );
-	builder_print( & header_etoktype, gen_component_header );
-	builder_print( & header_etoktype, format(etoktype) );
-	builder_write( & header_etoktype);
-
-	Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
-	builder_print( & header_ast_inlines, gen_component_header );
-	builder_print( & header_ast_inlines, format(ast_inlines) );
-	builder_write( & header_ast_inlines);
-
-	gen::deinit(& ctx);
-	return 0;
-}

base/components/ast.hpp

@@ -1,459 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "types.hpp"
-#include "gen/ecode.hpp"
-#include "gen/eoperator.hpp"
-#include "gen/especifier.hpp"
-#endif
-
-/*
-  ______   ______  ________      __    __       ______                 __
- /      \ /      \|        \    |  \  |  \     /      \               |  \
-|  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\\▓▓▓▓▓▓▓▓    | ▓▓\ | ▓▓    |  ▓▓▓▓▓▓\ ______   ____| ▓▓ ______
-| ▓▓__| ▓▓ ▓▓___\▓▓  | ▓▓       | ▓▓▓\| ▓▓    | ▓▓   \▓▓/      \ /      ▓▓/      \
-| ▓▓    ▓▓\▓▓    \   | ▓▓       | ▓▓▓▓\ ▓▓    | ▓▓     |  ▓▓▓▓▓▓\  ▓▓▓▓▓▓▓  ▓▓▓▓▓▓\
-| ▓▓▓▓▓▓▓▓_\▓▓▓▓▓▓\  | ▓▓       | ▓▓\▓▓ ▓▓    | ▓▓   __| ▓▓  | ▓▓ ▓▓  | ▓▓ ▓▓    ▓▓
-| ▓▓  | ▓▓  \__| ▓▓  | ▓▓       | ▓▓ \▓▓▓▓    | ▓▓__/  \ ▓▓__/ ▓▓ ▓▓__| ▓▓ ▓▓▓▓▓▓▓▓
-| ▓▓  | ▓▓\▓▓    ▓▓  | ▓▓       | ▓▓  \▓▓▓     \▓▓    ▓▓\▓▓    ▓▓\▓▓    ▓▓\▓▓     \
- \▓▓   \▓▓ \▓▓▓▓▓▓    \▓▓        \▓▓   \▓▓      \▓▓▓▓▓▓  \▓▓▓▓▓▓  \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
-*/
-
-struct AST;
-struct AST_Body;
-struct AST_Attributes;
-struct AST_Comment;
-struct AST_Constructor;
-// struct AST_BaseClass;
-struct AST_Class;
-struct AST_Define;
-struct AST_DefineParams;
-struct AST_Destructor;
-struct AST_Enum;
-struct AST_Exec;
-struct AST_Extern;
-struct AST_Include;
-struct AST_Friend;
-struct AST_Fn;
-struct AST_Module;
-struct AST_NS;
-struct AST_Operator;
-struct AST_OpCast;
-struct AST_Params;
-struct AST_Pragma;
-struct AST_PreprocessCond;
-struct AST_Specifiers;
-
-#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
-struct AST_Expr;
-struct AST_Expr_Assign;
-struct AST_Expr_Alignof;
-struct AST_Expr_Binary;
-struct AST_Expr_CStyleCast;
-struct AST_Expr_FunctionalCast;
-struct AST_Expr_CppCast;
-struct AST_Expr_ProcCall;
-struct AST_Expr_Decltype;
-struct AST_Expr_Comma;  // TODO(Ed) : This is a binary op not sure if it needs its own AST...
-struct AST_Expr_AMS;    // Access Member Symbol
-struct AST_Expr_Sizeof;
-struct AST_Expr_Subscript;
-struct AST_Expr_Ternary;
-struct AST_Expr_UnaryPrefix;
-struct AST_Expr_UnaryPostfix;
-struct AST_Expr_Element;
-
-struct AST_Stmt;
-struct AST_Stmt_Break;
-struct AST_Stmt_Case;
-struct AST_Stmt_Continue;
-struct AST_Stmt_Decl;
-struct AST_Stmt_Do;
-struct AST_Stmt_Expr;  // TODO(Ed) : Is this distinction needed? (Should it be a flag instead?)
-struct AST_Stmt_Else;
-struct AST_Stmt_If;
-struct AST_Stmt_For;
-struct AST_Stmt_Goto;
-struct AST_Stmt_Label;
-struct AST_Stmt_Switch;
-struct AST_Stmt_While;
-#endif
-
-struct AST_Struct;
-struct AST_Template;
-struct AST_Typename;
-struct AST_Typedef;
-struct AST_Union;
-struct AST_Using;
-struct AST_Var;
-
-#if GEN_COMPILER_C
-typedef AST* Code;
-#else
-struct Code;
-#endif
-
-#if GEN_COMPILER_C
-typedef AST_Body*           CodeBody;
-typedef AST_Attributes*     CodeAttributes;
-typedef AST_Comment*        CodeComment;
-typedef AST_Class*          CodeClass;
-typedef AST_Constructor*    CodeConstructor;
-typedef AST_Define*         CodeDefine;
-typedef AST_DefineParams*   CodeDefineParams;
-typedef AST_Destructor*     CodeDestructor;
-typedef AST_Enum*           CodeEnum;
-typedef AST_Exec*           CodeExec;
-typedef AST_Extern*         CodeExtern;
-typedef AST_Include*        CodeInclude;
-typedef AST_Friend*         CodeFriend;
-typedef AST_Fn*             CodeFn;
-typedef AST_Module*         CodeModule;
-typedef AST_NS*             CodeNS;
-typedef AST_Operator*       CodeOperator;
-typedef AST_OpCast*         CodeOpCast;
-typedef AST_Params*         CodeParams;
-typedef AST_PreprocessCond* CodePreprocessCond;
-typedef AST_Pragma*         CodePragma;
-typedef AST_Specifiers*     CodeSpecifiers;
-#else
-struct CodeBody;
-struct CodeAttributes;
-struct CodeComment;
-struct CodeClass;
-struct CodeConstructor;
-struct CodeDefine;
-struct CodeDefineParams;
-struct CodeDestructor;
-struct CodeEnum;
-struct CodeExec;
-struct CodeExtern;
-struct CodeInclude;
-struct CodeFriend;
-struct CodeFn;
-struct CodeModule;
-struct CodeNS;
-struct CodeOperator;
-struct CodeOpCast;
-struct CodeParams;
-struct CodePreprocessCond;
-struct CodePragma;
-struct CodeSpecifiers;
-#endif
-
-#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
-
-#if GEN_COMPILER_C
-typedef AST_Expr*                CodeExpr;
-typedef AST_Expr_Assign*         CodeExpr_Assign;
-typedef AST_Expr_Alignof*        CodeExpr_Alignof;
-typedef AST_Expr_Binary*         CodeExpr_Binary;
-typedef AST_Expr_CStyleCast*     CodeExpr_CStyleCast;
-typedef AST_Expr_FunctionalCast* CodeExpr_FunctionalCast;
-typedef AST_Expr_CppCast*        CodeExpr_CppCast;
-typedef AST_Expr_Element*        CodeExpr_Element;
-typedef AST_Expr_ProcCall*       CodeExpr_ProcCall;
-typedef AST_Expr_Decltype*       CodeExpr_Decltype;
-typedef AST_Expr_Comma*          CodeExpr_Comma;
-typedef AST_Expr_AMS*            CodeExpr_AMS; // Access Member Symbol
-typedef AST_Expr_Sizeof*         CodeExpr_Sizeof;
-typedef AST_Expr_Subscript*      CodeExpr_Subscript;
-typedef AST_Expr_Ternary*        CodeExpr_Ternary;
-typedef AST_Expr_UnaryPrefix*    CodeExpr_UnaryPrefix;
-typedef AST_Expr_UnaryPostfix*   CodeExpr_UnaryPostfix;
-#else
-struct CodeExpr;
-struct CodeExpr_Assign;
-struct CodeExpr_Alignof;
-struct CodeExpr_Binary;
-struct CodeExpr_CStyleCast;
-struct CodeExpr_FunctionalCast;
-struct CodeExpr_CppCast;
-struct CodeExpr_Element;
-struct CodeExpr_ProcCall;
-struct CodeExpr_Decltype;
-struct CodeExpr_Comma;
-struct CodeExpr_AMS; // Access Member Symbol
-struct CodeExpr_Sizeof;
-struct CodeExpr_Subscript;
-struct CodeExpr_Ternary;
-struct CodeExpr_UnaryPrefix;
-struct CodeExpr_UnaryPostfix;
-#endif
-
-#if GEN_COMPILER_C
-typedef AST_Stmt*          CodeStmt;
-typedef AST_Stmt_Break*    CodeStmt_Break;
-typedef AST_Stmt_Case*     CodeStmt_Case;
-typedef AST_Stmt_Continue* CodeStmt_Continue;
-typedef AST_Stmt_Decl*     CodeStmt_Decl;
-typedef AST_Stmt_Do*       CodeStmt_Do;
-typedef AST_Stmt_Expr*     CodeStmt_Expr;
-typedef AST_Stmt_Else*     CodeStmt_Else;
-typedef AST_Stmt_If*       CodeStmt_If;
-typedef AST_Stmt_For*      CodeStmt_For;
-typedef AST_Stmt_Goto*     CodeStmt_Goto;
-typedef AST_Stmt_Label*    CodeStmt_Label;
-typedef AST_Stmt_Lambda*   CodeStmt_Lambda;
-typedef AST_Stmt_Switch*   CodeStmt_Switch;
-typedef AST_Stmt_While*    CodeStmt_While;
-#else
-struct CodeStmt;
-struct CodeStmt_Break;
-struct CodeStmt_Case;
-struct CodeStmt_Continue;
-struct CodeStmt_Decl;
-struct CodeStmt_Do;
-struct CodeStmt_Expr;
-struct CodeStmt_Else;
-struct CodeStmt_If;
-struct CodeStmt_For;
-struct CodeStmt_Goto;
-struct CodeStmt_Label;
-struct CodeStmt_Lambda;
-struct CodeStmt_Switch;
-struct CodeStmt_While;
-#endif
-
-// GEN_EXECUTION_EXPRESSION_SUPPORT
-#endif
-
-#if GEN_COMPILER_C
-typedef AST_Struct*   CodeStruct;
-typedef AST_Template* CodeTemplate;
-typedef AST_Typename* CodeTypename;
-typedef AST_Typedef*  CodeTypedef;
-typedef AST_Union*    CodeUnion;
-typedef AST_Using*    CodeUsing;
-typedef AST_Var*      CodeVar;
-#else
-struct CodeStruct;
-struct CodeTemplate;
-struct CodeTypename;
-struct CodeTypedef;
-struct CodeUnion;
-struct CodeUsing;
-struct CodeVar;
-#endif
-
-#if GEN_COMPILER_CPP
-template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
-#endif
-
-#pragma region Code C-Interface
-
-        void       code_append           (Code code, Code other );
-GEN_API Str        code_debug_str        (Code code);
-GEN_API Code       code_duplicate        (Code code);
-        Code*      code_entry            (Code code, u32 idx );
-        bool       code_has_entries      (Code code);
-        bool       code_is_body          (Code code);
-GEN_API bool       code_is_equal         (Code code, Code other);
-        bool       code_is_valid         (Code code);
-        void       code_set_global       (Code code);
-GEN_API StrBuilder code_to_strbuilder    (Code self );
-GEN_API void       code_to_strbuilder_ref(Code self, StrBuilder* result );
-        Str        code_type_str         (Code self );
-GEN_API bool       code_validate_body    (Code self );
-
-#pragma endregion Code C-Interface
-
-#if GEN_COMPILER_CPP
-/*
-	AST* wrapper
-	- Not constantly have to append the '*' as this is written often..
-	- Allows for implicit conversion to any of the ASTs (raw or filtered).
-*/
-struct Code
-{
-	AST* ast;
-
-#	define Using_Code( Typename )                                                        \
-	forceinline Str  debug_str()                { return code_debug_str(* this); }       \
-	forceinline Code duplicate()                { return code_duplicate(* this); }	     \
-	forceinline bool is_equal( Code other )     { return code_is_equal(* this, other); } \
-	forceinline bool is_body()                  { return code_is_body(* this); }         \
-	forceinline bool is_valid()                 { return code_is_valid(* this); }        \
-	forceinline void set_global()               { return code_set_global(* this); }
-
-#	define Using_CodeOps( Typename )                                                                           \
-	forceinline Typename&  operator = ( Code other );                                                          \
-	forceinline bool       operator ==( Code other )                        { return (AST*)ast == other.ast; } \
-	forceinline bool       operator !=( Code other )                        { return (AST*)ast != other.ast; } \
-	forceinline bool       operator ==(std::nullptr_t) const                { return ast == nullptr; }         \
-	forceinline bool       operator !=(std::nullptr_t) const                { return ast != nullptr;  }        \
-	operator bool();
-
-#if ! GEN_C_LIKE_CPP
-	Using_Code( Code );
-	forceinline void       append(Code other)                { return code_append(* this, other); }
-	forceinline Code*      entry(u32 idx)                    { return code_entry(* this, idx); }
-	forceinline bool       has_entries()                     { return code_has_entries(* this); }
-	forceinline StrBuilder to_strbuilder()                   { return code_to_strbuilder(* this); }
-	forceinline void       to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ref(* this, & result); }
-	forceinline Str        type_str()                        { return code_type_str(* this); }
-	forceinline bool       validate_body()                   { return code_validate_body(*this); }
-#endif
-
-	Using_CodeOps( Code );
-	forceinline Code operator *() { return * this; } // Required to support for-range iteration.
-	forceinline AST* operator ->() { return ast; }
-
-	Code& operator ++();
-
-#ifdef GEN_ENFORCE_STRONG_CODE_TYPES
-#	define operator explicit operator
-#endif
-	operator CodeBody() const;
-	operator CodeAttributes() const;
-	// operator CodeBaseClass() const;
-	operator CodeComment() const;
-	operator CodeClass() const;
-	operator CodeConstructor() const;
-	operator CodeDefine() const;
-	operator CodeDefineParams() const;
-	operator CodeDestructor() const;
-	operator CodeExec() const;
-	operator CodeEnum() const;
-	operator CodeExtern() const;
-	operator CodeInclude() const;
-	operator CodeFriend() const;
-	operator CodeFn() const;
-	operator CodeModule() const;
-	operator CodeNS() const;
-	operator CodeOperator() const;
-	operator CodeOpCast() const;
-	operator CodeParams() const;
-	operator CodePragma() const;
-	operator CodePreprocessCond() const;
-	operator CodeSpecifiers() const;
-	operator CodeStruct() const;
-	operator CodeTemplate() const;
-	operator CodeTypename() const;
-	operator CodeTypedef() const;
-	operator CodeUnion() const;
-	operator CodeUsing() const;
-	operator CodeVar() const;
-	#undef operator
-};
-#endif
-
-#pragma region Statics
-// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
-GEN_API extern Code Code_Global;
-
-// Used to identify invalid generated code.
-GEN_API extern Code Code_Invalid;
-#pragma endregion Statics
-
-struct Code_POD
-{
-	AST* ast;
-};
-static_assert( sizeof(Code) == sizeof(Code_POD), "ERROR: Code is not POD" );
-
-// Desired width of the AST data structure.
-constexpr int const AST_POD_Size = 128;
-
-constexpr static
-int AST_ArrSpecs_Cap =
-(
-	AST_POD_Size
-	- sizeof(Code)
-	- sizeof(StrCached)
-	- sizeof(Code) * 2
-	- sizeof(Token*)
-	- sizeof(Code)
-	- sizeof(CodeType)
-	- sizeof(ModuleFlag)
-	- sizeof(u32)
-)
-/ sizeof(Specifier) - 1;
-
-/*
-	Simple AST POD with functionality to seralize into C++ syntax.
-	TODO(Ed): Eventually haven't a transparent AST like this will longer be viable once statements & expressions are in (most likely....)
-*/
-struct AST
-{
-	union {
-		struct
-		{
-			Code      InlineCmt;       // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
-			Code      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable // TODO(Ed): Parameters can have attributes
-			Code      Specs;           // Class, Destructor, Function, Operator, Struct, Typename, Variable
-			union {
-				Code  InitializerList; // Constructor
-				Code  ParentType;      // Class, Struct, ParentType->Next has a possible list of interfaces.
-				Code  ReturnType;      // Function, Operator, Typename
-				Code  UnderlyingType;  // Enum, Typedef
-				Code  ValueType;       // Parameter, Variable
-			};
-			union {
-				Code  Macro;               // Parameter
-				Code  BitfieldSize;        // Variable (Class/Struct Data Member)
-				Code  Params;              // Constructor, Define, Function, Operator, Template, Typename
-				Code  UnderlyingTypeMacro; // Enum
-			};
-			union {
-				Code  ArrExpr;          // Typename
-				Code  Body;             // Class, Constructor, Define, Destructor, Enum, Friend, Function, Namespace, Struct, Union
-				Code  Declaration;      // Friend, Template
-				Code  Value;            // Parameter, Variable
-			};
-			union {
-				Code  NextVar;          // Variable
-				Code  SuffixSpecs;      // Typename, Function (Thanks Unreal)
-				Code  PostNameMacro;    // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
-			};
-		};
-		StrCached  Content;          // Attributes, Comment, Execution, Include
-		struct {
-			Specifier  ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
-			Code       NextSpecs;              // Specifiers; If ArrSpecs is full, then NextSpecs is used.
-		};
-	};
-	StrCached      Name;
-	union {
-		Code Prev;
-		Code Front;
-		Code Last;
-	};
-	union {
-		Code Next;
-		Code Back;
-	};
-	Token*            Token; // Reference to starting token, only available if it was derived from parsing.
-	Code              Parent;
-	CodeType          Type;
-//	CodeFlag          CodeFlags;
-	ModuleFlag        ModuleFlags;
-	union {
-		b32           IsFunction;  // Used by typedef to not serialize the name field.
-		struct {
-			b16           IsParamPack;   // Used by typename to know if type should be considered a parameter pack.
-			ETypenameTag  TypeTag;       // Used by typename to keep track of explicitly declared tags for the identifier (enum, struct, union)
-		};
-		Operator      Op;
-		AccessSpec    ParentAccess;
-		s32           NumEntries;
-		s32           VarParenthesizedInit;  // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
-	};
-};
-static_assert( sizeof(AST) == AST_POD_Size, "ERROR: AST is not size of AST_POD_Size" );
-
-#if GEN_COMPILER_CPP
-// Uses an implicitly overloaded cast from the AST to the desired code type.
-// Necessary if the user wants GEN_ENFORCE_STRONG_CODE_TYPES
-struct  InvalidCode_ImplictCaster;
-#define InvalidCode (InvalidCode_ImplictCaster{})
-#else
-#define InvalidCode (void*){ (void*)Code_Invalid }
-#endif
-
-#if GEN_COMPILER_CPP
-struct NullCode_ImplicitCaster;
-// Used when the its desired when omission is allowed in a definition.
-#define NullCode    (NullCode_ImplicitCaster{})
-#else
-#define NullCode    nullptr
-#endif

base/components/ast_case_macros.cpp

@@ -1,80 +0,0 @@
-// These macros are used in the swtich cases within ast.cpp, inteface.upfront.cpp, parser.cpp
-
-#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES_CASES    \
-	case CT_PlatformAttributes:                  \
-	case CT_Class_Body:                          \
-	case CT_Enum_Body:                           \
-	case CT_Extern_Linkage:                      \
-	case CT_Function_Body:                       \
-	case CT_Function_Fwd:                        \
-	case CT_Global_Body:                         \
-	case CT_Namespace:                           \
-	case CT_Namespace_Body:                      \
-	case CT_Operator:                            \
-	case CT_Operator_Fwd:                        \
-	case CT_Parameters:                          \
-	case CT_Specifiers:                          \
-	case CT_Struct_Body:                         \
-	case CT_Typename
-#	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES_CASES GEN_AST_BODY_CLASS_UNALLOWED_TYPES_CASES
-
-#	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES_CASES \
-	case CT_Access_Public:                          \
-	case CT_Access_Protected:                       \
-	case CT_Access_Private:                         \
-	case CT_PlatformAttributes:                     \
-	case CT_Class_Body:                             \
-	case CT_Enum_Body:                              \
-	case CT_Extern_Linkage:                         \
-	case CT_Friend:                                 \
-	case CT_Function_Body:                          \
-	case CT_Function_Fwd:                           \
-	case CT_Global_Body:                            \
-	case CT_Namespace:                              \
-	case CT_Namespace_Body:                         \
-	case CT_Operator:                               \
-	case CT_Operator_Fwd:                           \
-	case CT_Operator_Member:                        \
-	case CT_Operator_Member_Fwd:                    \
-	case CT_Parameters:                             \
-	case CT_Specifiers:                             \
-	case CT_Struct_Body:                            \
-	case CT_Typename
-
-#	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES     \
-	case CT_Access_Public:                         \
-	case CT_Access_Protected:                      \
-	case CT_Access_Private:                        \
-	case CT_PlatformAttributes:                    \
-	case CT_Class_Body:                            \
-	case CT_Enum_Body:                             \
-	case CT_Execution:                             \
-	case CT_Friend:                                \
-	case CT_Function_Body:                         \
-	case CT_Namespace_Body:                        \
-	case CT_Operator_Member:                       \
-	case CT_Operator_Member_Fwd:                   \
-	case CT_Parameters:                            \
-	case CT_Specifiers:                            \
-	case CT_Struct_Body:                           \
-	case CT_Typename
-#	define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES_CASES         GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES
-#	define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES_CASES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES_CASES
-
-#	define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES_CASES \
-	case CT_Access_Public:                        \
-	case CT_Access_Protected:                     \
-	case CT_Access_Private:                       \
-	case CT_PlatformAttributes:                   \
-	case CT_Class_Body:                           \
-	case CT_Enum_Body:                            \
-	case CT_Execution:                            \
-	case CT_Friend:                               \
-	case CT_Function_Body:                        \
-	case CT_Namespace_Body:                       \
-	case CT_Operator_Member:                      \
-	case CT_Operator_Member_Fwd:                  \
-	case CT_Parameters:                           \
-	case CT_Specifiers:                           \
-	case CT_Struct_Body:                          \
-	case CT_Typename

base/components/constants.hpp

@@ -1,85 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "interface.hpp"
-#endif
-
-#pragma region Constants
-// Predefined typename codes. Are set to readonly and are setup during gen::init()
-
-GEN_API extern Macro enum_underlying_macro;
-
-GEN_API extern Code access_public;
-GEN_API extern Code access_protected;
-GEN_API extern Code access_private;
-
-GEN_API extern CodeAttributes attrib_api_export;
-GEN_API extern CodeAttributes attrib_api_import;
-
-GEN_API extern Code module_global_fragment;
-GEN_API extern Code module_private_fragment;
-
-GEN_API extern Code fmt_newline;
-
-GEN_API extern CodePragma pragma_once;
-
-GEN_API extern CodeParams param_varadic;
-
-GEN_API extern CodePreprocessCond preprocess_else;
-GEN_API extern CodePreprocessCond preprocess_endif;
-
-GEN_API extern CodeSpecifiers spec_const;
-GEN_API extern CodeSpecifiers spec_consteval;
-GEN_API extern CodeSpecifiers spec_constexpr;
-GEN_API extern CodeSpecifiers spec_constinit;
-GEN_API extern CodeSpecifiers spec_extern_linkage;
-GEN_API extern CodeSpecifiers spec_final;
-GEN_API extern CodeSpecifiers spec_forceinline;
-GEN_API extern CodeSpecifiers spec_global;
-GEN_API extern CodeSpecifiers spec_inline;
-GEN_API extern CodeSpecifiers spec_internal_linkage;
-GEN_API extern CodeSpecifiers spec_local_persist;
-GEN_API extern CodeSpecifiers spec_mutable;
-GEN_API extern CodeSpecifiers spec_neverinline;
-GEN_API extern CodeSpecifiers spec_noexcept;
-GEN_API extern CodeSpecifiers spec_override;
-GEN_API extern CodeSpecifiers spec_ptr;
-GEN_API extern CodeSpecifiers spec_pure;
-GEN_API extern CodeSpecifiers spec_ref;
-GEN_API extern CodeSpecifiers spec_register;
-GEN_API extern CodeSpecifiers spec_rvalue;
-GEN_API extern CodeSpecifiers spec_static_member;
-GEN_API extern CodeSpecifiers spec_thread_local;
-GEN_API extern CodeSpecifiers spec_virtual;
-GEN_API extern CodeSpecifiers spec_volatile;
-
-GEN_API extern CodeTypename t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
-GEN_API extern CodeTypename t_auto;
-GEN_API extern CodeTypename t_void;
-GEN_API extern CodeTypename t_int;
-GEN_API extern CodeTypename t_bool;
-GEN_API extern CodeTypename t_char;
-GEN_API extern CodeTypename t_wchar_t;
-GEN_API extern CodeTypename t_class;
-GEN_API extern CodeTypename t_typename;
-
-#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-	GEN_API extern CodeTypename t_b32;
-
-	GEN_API extern CodeTypename t_s8;
-	GEN_API extern CodeTypename t_s16;
-	GEN_API extern CodeTypename t_s32;
-	GEN_API extern CodeTypename t_s64;
-
-	GEN_API extern CodeTypename t_u8;
-	GEN_API extern CodeTypename t_u16;
-	GEN_API extern CodeTypename t_u32;
-	GEN_API extern CodeTypename t_u64;
-
-	GEN_API extern CodeTypename t_ssize;
-	GEN_API extern CodeTypename t_usize;
-
-	GEN_API extern CodeTypename t_f32;
-	GEN_API extern CodeTypename t_f64;
-#endif
-
-#pragma endregion Constants

base/components/gen/ast_inlines.hpp

@@ -1,986 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "components/types.hpp"
-#endif
-
-// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
-
-#pragma region generated code inline implementation
-
-inline Code& Code::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline Code::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeBody& CodeBody::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeBody::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeAttributes& CodeAttributes::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeAttributes::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeAttributes::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Attributes* CodeAttributes::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeComment& CodeComment::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeComment::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeComment::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Comment* CodeComment::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeConstructor& CodeConstructor::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeConstructor::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeConstructor::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Constructor* CodeConstructor::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeClass& CodeClass::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeClass::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeDefine& CodeDefine::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeDefine::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeDefine::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Define* CodeDefine::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeDefineParams& CodeDefineParams::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeDefineParams::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeDestructor& CodeDestructor::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeDestructor::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeDestructor::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Destructor* CodeDestructor::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeEnum& CodeEnum::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeEnum::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeEnum::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Enum* CodeEnum::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeExec& CodeExec::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeExec::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeExec::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Exec* CodeExec::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeExtern& CodeExtern::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeExtern::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeExtern::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Extern* CodeExtern::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeFriend& CodeFriend::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeFriend::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeFriend::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Friend* CodeFriend::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeFn& CodeFn::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeFn::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeFn::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Fn* CodeFn::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeInclude& CodeInclude::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeInclude::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeInclude::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Include* CodeInclude::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeModule& CodeModule::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeModule::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeModule::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Module* CodeModule::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeNS& CodeNS::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeNS::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeNS::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_NS* CodeNS::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeOperator& CodeOperator::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeOperator::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeOperator::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Operator* CodeOperator::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeOpCast& CodeOpCast::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeOpCast::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeOpCast::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_OpCast* CodeOpCast::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeParams& CodeParams::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeParams::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodePragma& CodePragma::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodePragma::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodePragma::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Pragma* CodePragma::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodePreprocessCond& CodePreprocessCond::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodePreprocessCond::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodePreprocessCond::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_PreprocessCond* CodePreprocessCond::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeSpecifiers& CodeSpecifiers::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeSpecifiers::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeStruct& CodeStruct::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeStruct::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeTemplate& CodeTemplate::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeTemplate::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeTemplate::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Template* CodeTemplate::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeTypename& CodeTypename::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeTypename::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeTypename::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Typename* CodeTypename::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeTypedef& CodeTypedef::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeTypedef::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeTypedef::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Typedef* CodeTypedef::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeUnion& CodeUnion::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeUnion::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeUnion::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Union* CodeUnion::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeUsing& CodeUsing::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeUsing::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeUsing::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Using* CodeUsing::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-inline CodeVar& CodeVar::operator=(Code other)
-{
-	if (other.ast != nullptr && other->Parent != nullptr)
-	{
-		ast         = rcast(decltype(ast), code_duplicate(other).ast);
-		ast->Parent = { nullptr };
-	}
-	ast = rcast(decltype(ast), other.ast);
-	return *this;
-}
-
-inline CodeVar::operator bool()
-{
-	return ast != nullptr;
-}
-
-inline CodeVar::operator Code()
-{
-	return *rcast(Code*, this);
-}
-
-inline AST_Var* CodeVar::operator->()
-{
-	if (ast == nullptr)
-	{
-		log_failure("Attempt to dereference a nullptr!\n");
-		return nullptr;
-	}
-	return ast;
-}
-
-#pragma endregion generated code inline implementation
-
-#pragma region generated AST/Code cast implementation
-GEN_OPTIMIZE_MAPPINGS_BEGIN
-
-forceinline Code::operator CodeBody() const
-{
-	return { (AST_Body*)ast };
-}
-
-forceinline Code::operator CodeAttributes() const
-{
-	return { (AST_Attributes*)ast };
-}
-
-forceinline Code::operator CodeComment() const
-{
-	return { (AST_Comment*)ast };
-}
-
-forceinline Code::operator CodeConstructor() const
-{
-	return { (AST_Constructor*)ast };
-}
-
-forceinline Code::operator CodeClass() const
-{
-	return { (AST_Class*)ast };
-}
-
-forceinline Code::operator CodeDefine() const
-{
-	return { (AST_Define*)ast };
-}
-
-forceinline Code::operator CodeDefineParams() const
-{
-	return { (AST_DefineParams*)ast };
-}
-
-forceinline Code::operator CodeDestructor() const
-{
-	return { (AST_Destructor*)ast };
-}
-
-forceinline Code::operator CodeEnum() const
-{
-	return { (AST_Enum*)ast };
-}
-
-forceinline Code::operator CodeExec() const
-{
-	return { (AST_Exec*)ast };
-}
-
-forceinline Code::operator CodeExtern() const
-{
-	return { (AST_Extern*)ast };
-}
-
-forceinline Code::operator CodeFriend() const
-{
-	return { (AST_Friend*)ast };
-}
-
-forceinline Code::operator CodeFn() const
-{
-	return { (AST_Fn*)ast };
-}
-
-forceinline Code::operator CodeInclude() const
-{
-	return { (AST_Include*)ast };
-}
-
-forceinline Code::operator CodeModule() const
-{
-	return { (AST_Module*)ast };
-}
-
-forceinline Code::operator CodeNS() const
-{
-	return { (AST_NS*)ast };
-}
-
-forceinline Code::operator CodeOperator() const
-{
-	return { (AST_Operator*)ast };
-}
-
-forceinline Code::operator CodeOpCast() const
-{
-	return { (AST_OpCast*)ast };
-}
-
-forceinline Code::operator CodeParams() const
-{
-	return { (AST_Params*)ast };
-}
-
-forceinline Code::operator CodePragma() const
-{
-	return { (AST_Pragma*)ast };
-}
-
-forceinline Code::operator CodePreprocessCond() const
-{
-	return { (AST_PreprocessCond*)ast };
-}
-
-forceinline Code::operator CodeSpecifiers() const
-{
-	return { (AST_Specifiers*)ast };
-}
-
-forceinline Code::operator CodeStruct() const
-{
-	return { (AST_Struct*)ast };
-}
-
-forceinline Code::operator CodeTemplate() const
-{
-	return { (AST_Template*)ast };
-}
-
-forceinline Code::operator CodeTypename() const
-{
-	return { (AST_Typename*)ast };
-}
-
-forceinline Code::operator CodeTypedef() const
-{
-	return { (AST_Typedef*)ast };
-}
-
-forceinline Code::operator CodeUnion() const
-{
-	return { (AST_Union*)ast };
-}
-
-forceinline Code::operator CodeUsing() const
-{
-	return { (AST_Using*)ast };
-}
-
-forceinline Code::operator CodeVar() const
-{
-	return { (AST_Var*)ast };
-}
-
-GEN_OPITMIZE_MAPPINGS_END
-#pragma endregion generated AST / Code cast implementation

base/components/gen/ecodetypes.hpp

@@ -1,222 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "components/types.hpp"
-#endif
-
-// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
-
-enum CodeType : u32
-{
-	CT_Invalid,
-	CT_Untyped,
-	CT_NewLine,
-	CT_Comment,
-	CT_Access_Private,
-	CT_Access_Protected,
-	CT_Access_Public,
-	CT_PlatformAttributes,
-	CT_Class,
-	CT_Class_Fwd,
-	CT_Class_Body,
-	CT_Constructor,
-	CT_Constructor_Fwd,
-	CT_Destructor,
-	CT_Destructor_Fwd,
-	CT_Enum,
-	CT_Enum_Fwd,
-	CT_Enum_Body,
-	CT_Enum_Class,
-	CT_Enum_Class_Fwd,
-	CT_Execution,
-	CT_Export_Body,
-	CT_Extern_Linkage,
-	CT_Extern_Linkage_Body,
-	CT_Friend,
-	CT_Function,
-	CT_Function_Fwd,
-	CT_Function_Body,
-	CT_Global_Body,
-	CT_Module,
-	CT_Namespace,
-	CT_Namespace_Body,
-	CT_Operator,
-	CT_Operator_Fwd,
-	CT_Operator_Member,
-	CT_Operator_Member_Fwd,
-	CT_Operator_Cast,
-	CT_Operator_Cast_Fwd,
-	CT_Parameters,
-	CT_Parameters_Define,
-	CT_Preprocess_Define,
-	CT_Preprocess_Include,
-	CT_Preprocess_If,
-	CT_Preprocess_IfDef,
-	CT_Preprocess_IfNotDef,
-	CT_Preprocess_ElIf,
-	CT_Preprocess_Else,
-	CT_Preprocess_EndIf,
-	CT_Preprocess_Pragma,
-	CT_Specifiers,
-	CT_Struct,
-	CT_Struct_Fwd,
-	CT_Struct_Body,
-	CT_Template,
-	CT_Typedef,
-	CT_Typename,
-	CT_Union,
-	CT_Union_Fwd,
-	CT_Union_Body,
-	CT_Using,
-	CT_Using_Namespace,
-	CT_Variable,
-	CT_NumTypes,
-	CT_UnderlyingType = GEN_U32_MAX
-};
-
-inline Str codetype_to_str(CodeType type)
-{
-	local_persist Str lookup[] = {
-		{ "Invalid",             sizeof("Invalid") - 1             },
-		{ "Untyped",             sizeof("Untyped") - 1             },
-		{ "NewLine",             sizeof("NewLine") - 1             },
-		{ "Comment",             sizeof("Comment") - 1             },
-		{ "Access_Private",      sizeof("Access_Private") - 1      },
-		{ "Access_Protected",    sizeof("Access_Protected") - 1    },
-		{ "Access_Public",       sizeof("Access_Public") - 1       },
-		{ "PlatformAttributes",  sizeof("PlatformAttributes") - 1  },
-		{ "Class",               sizeof("Class") - 1               },
-		{ "Class_Fwd",           sizeof("Class_Fwd") - 1           },
-		{ "Class_Body",          sizeof("Class_Body") - 1          },
-		{ "Constructor",         sizeof("Constructor") - 1         },
-		{ "Constructor_Fwd",     sizeof("Constructor_Fwd") - 1     },
-		{ "Destructor",          sizeof("Destructor") - 1          },
-		{ "Destructor_Fwd",      sizeof("Destructor_Fwd") - 1      },
-		{ "Enum",                sizeof("Enum") - 1                },
-		{ "Enum_Fwd",            sizeof("Enum_Fwd") - 1            },
-		{ "Enum_Body",           sizeof("Enum_Body") - 1           },
-		{ "Enum_Class",          sizeof("Enum_Class") - 1          },
-		{ "Enum_Class_Fwd",      sizeof("Enum_Class_Fwd") - 1      },
-		{ "Execution",           sizeof("Execution") - 1           },
-		{ "Export_Body",         sizeof("Export_Body") - 1         },
-		{ "Extern_Linkage",      sizeof("Extern_Linkage") - 1      },
-		{ "Extern_Linkage_Body", sizeof("Extern_Linkage_Body") - 1 },
-		{ "Friend",              sizeof("Friend") - 1              },
-		{ "Function",            sizeof("Function") - 1            },
-		{ "Function_Fwd",        sizeof("Function_Fwd") - 1        },
-		{ "Function_Body",       sizeof("Function_Body") - 1       },
-		{ "Global_Body",         sizeof("Global_Body") - 1         },
-		{ "Module",              sizeof("Module") - 1              },
-		{ "Namespace",           sizeof("Namespace") - 1           },
-		{ "Namespace_Body",      sizeof("Namespace_Body") - 1      },
-		{ "Operator",            sizeof("Operator") - 1            },
-		{ "Operator_Fwd",        sizeof("Operator_Fwd") - 1        },
-		{ "Operator_Member",     sizeof("Operator_Member") - 1     },
-		{ "Operator_Member_Fwd", sizeof("Operator_Member_Fwd") - 1 },
-		{ "Operator_Cast",       sizeof("Operator_Cast") - 1       },
-		{ "Operator_Cast_Fwd",   sizeof("Operator_Cast_Fwd") - 1   },
-		{ "Parameters",          sizeof("Parameters") - 1          },
-		{ "Parameters_Define",   sizeof("Parameters_Define") - 1   },
-		{ "Preprocess_Define",   sizeof("Preprocess_Define") - 1   },
-		{ "Preprocess_Include",  sizeof("Preprocess_Include") - 1  },
-		{ "Preprocess_If",       sizeof("Preprocess_If") - 1       },
-		{ "Preprocess_IfDef",    sizeof("Preprocess_IfDef") - 1    },
-		{ "Preprocess_IfNotDef", sizeof("Preprocess_IfNotDef") - 1 },
-		{ "Preprocess_ElIf",     sizeof("Preprocess_ElIf") - 1     },
-		{ "Preprocess_Else",     sizeof("Preprocess_Else") - 1     },
-		{ "Preprocess_EndIf",    sizeof("Preprocess_EndIf") - 1    },
-		{ "Preprocess_Pragma",   sizeof("Preprocess_Pragma") - 1   },
-		{ "Specifiers",          sizeof("Specifiers") - 1          },
-		{ "Struct",              sizeof("Struct") - 1              },
-		{ "Struct_Fwd",          sizeof("Struct_Fwd") - 1          },
-		{ "Struct_Body",         sizeof("Struct_Body") - 1         },
-		{ "Template",            sizeof("Template") - 1            },
-		{ "Typedef",             sizeof("Typedef") - 1             },
-		{ "Typename",            sizeof("Typename") - 1            },
-		{ "Union",               sizeof("Union") - 1               },
-		{ "Union_Fwd",           sizeof("Union_Fwd") - 1           },
-		{ "Union_Body",          sizeof("Union_Body") - 1          },
-		{ "Using",               sizeof("Using") - 1               },
-		{ "Using_Namespace",     sizeof("Using_Namespace") - 1     },
-		{ "Variable",            sizeof("Variable") - 1            },
-	};
-	return lookup[type];
-}
-
-inline Str codetype_to_keyword_str(CodeType type)
-{
-	local_persist Str lookup[] = {
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "//",              sizeof("//") - 1              },
-		{ "private",         sizeof("private") - 1         },
-		{ "protected",       sizeof("protected") - 1       },
-		{ "public",          sizeof("public") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "class",           sizeof("class") - 1           },
-		{ "clsss",           sizeof("clsss") - 1           },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "enum",            sizeof("enum") - 1            },
-		{ "enum",            sizeof("enum") - 1            },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "enum class",      sizeof("enum class") - 1      },
-		{ "enum class",      sizeof("enum class") - 1      },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "extern",          sizeof("extern") - 1          },
-		{ "extern",          sizeof("extern") - 1          },
-		{ "friend",          sizeof("friend") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "module",          sizeof("module") - 1          },
-		{ "namespace",       sizeof("namespace") - 1       },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "operator",        sizeof("operator") - 1        },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "define",          sizeof("define") - 1          },
-		{ "include",         sizeof("include") - 1         },
-		{ "if",              sizeof("if") - 1              },
-		{ "ifdef",           sizeof("ifdef") - 1           },
-		{ "ifndef",          sizeof("ifndef") - 1          },
-		{ "elif",            sizeof("elif") - 1            },
-		{ "else",            sizeof("else") - 1            },
-		{ "endif",           sizeof("endif") - 1           },
-		{ "pragma",          sizeof("pragma") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "struct",          sizeof("struct") - 1          },
-		{ "struct",          sizeof("struct") - 1          },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "template",        sizeof("template") - 1        },
-		{ "typedef",         sizeof("typedef") - 1         },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "union",           sizeof("union") - 1           },
-		{ "union",           sizeof("union") - 1           },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-		{ "using",           sizeof("using") - 1           },
-		{ "using namespace", sizeof("using namespace") - 1 },
-		{ "__NA__",          sizeof("__NA__") - 1          },
-	};
-	return lookup[type];
-}
-
-forceinline Str to_str(CodeType type)
-{
-	return codetype_to_str(type);
-}
-
-forceinline Str to_keyword_str(CodeType type)
-{
-	return codetype_to_keyword_str(type);
-}

base/components/gen/eoperator.hpp

@@ -1,118 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "components/types.hpp"
-#endif
-
-// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
-
-enum Operator : u32
-{
-	Op_Invalid,
-	Op_Assign,
-	Op_Assign_Add,
-	Op_Assign_Subtract,
-	Op_Assign_Multiply,
-	Op_Assign_Divide,
-	Op_Assign_Modulo,
-	Op_Assign_BAnd,
-	Op_Assign_BOr,
-	Op_Assign_BXOr,
-	Op_Assign_LShift,
-	Op_Assign_RShift,
-	Op_Increment,
-	Op_Decrement,
-	Op_Unary_Plus,
-	Op_Unary_Minus,
-	Op_UnaryNot,
-	Op_Add,
-	Op_Subtract,
-	Op_Multiply,
-	Op_Divide,
-	Op_Modulo,
-	Op_BNot,
-	Op_BAnd,
-	Op_BOr,
-	Op_BXOr,
-	Op_LShift,
-	Op_RShift,
-	Op_LAnd,
-	Op_LOr,
-	Op_LEqual,
-	Op_LNot,
-	Op_Lesser,
-	Op_Greater,
-	Op_LesserEqual,
-	Op_GreaterEqual,
-	Op_Subscript,
-	Op_Indirection,
-	Op_AddressOf,
-	Op_MemberOfPointer,
-	Op_PtrToMemOfPtr,
-	Op_FunctionCall,
-	Op_Comma,
-	Op_New,
-	Op_NewArray,
-	Op_Delete,
-	Op_DeleteArray,
-	Op_NumOps,
-	Op_UnderlyingType = 0xffffffffu
-};
-
-inline Str operator_to_str(Operator op)
-{
-	local_persist Str lookup[] = {
-		{ "INVALID",  sizeof("INVALID") - 1  },
-		{ "=",        sizeof("=") - 1        },
-		{ "+=",       sizeof("+=") - 1       },
-		{ "-=",       sizeof("-=") - 1       },
-		{ "*=",       sizeof("*=") - 1       },
-		{ "/=",       sizeof("/=") - 1       },
-		{ "%=",       sizeof("%=") - 1       },
-		{ "&=",       sizeof("&=") - 1       },
-		{ "|=",       sizeof("|=") - 1       },
-		{ "^=",       sizeof("^=") - 1       },
-		{ "<<=",      sizeof("<<=") - 1      },
-		{ ">>=",      sizeof(">>=") - 1      },
-		{ "++",       sizeof("++") - 1       },
-		{ "--",       sizeof("--") - 1       },
-		{ "+",        sizeof("+") - 1        },
-		{ "-",        sizeof("-") - 1        },
-		{ "!",        sizeof("!") - 1        },
-		{ "+",        sizeof("+") - 1        },
-		{ "-",        sizeof("-") - 1        },
-		{ "*",        sizeof("*") - 1        },
-		{ "/",        sizeof("/") - 1        },
-		{ "%",        sizeof("%") - 1        },
-		{ "~",        sizeof("~") - 1        },
-		{ "&",        sizeof("&") - 1        },
-		{ "|",        sizeof("|") - 1        },
-		{ "^",        sizeof("^") - 1        },
-		{ "<<",       sizeof("<<") - 1       },
-		{ ">>",       sizeof(">>") - 1       },
-		{ "&&",       sizeof("&&") - 1       },
-		{ "||",       sizeof("||") - 1       },
-		{ "==",       sizeof("==") - 1       },
-		{ "!=",       sizeof("!=") - 1       },
-		{ "<",        sizeof("<") - 1        },
-		{ ">",        sizeof(">") - 1        },
-		{ "<=",       sizeof("<=") - 1       },
-		{ ">=",       sizeof(">=") - 1       },
-		{ "[]",       sizeof("[]") - 1       },
-		{ "*",        sizeof("*") - 1        },
-		{ "&",        sizeof("&") - 1        },
-		{ "->",       sizeof("->") - 1       },
-		{ "->*",      sizeof("->*") - 1      },
-		{ "()",       sizeof("()") - 1       },
-		{ ",",        sizeof(",") - 1        },
-		{ "new",      sizeof("new") - 1      },
-		{ "new[]",    sizeof("new[]") - 1    },
-		{ "delete",   sizeof("delete") - 1   },
-		{ "delete[]", sizeof("delete[]") - 1 },
-	};
-	return lookup[op];
-}
-
-forceinline Str to_str(Operator op)
-{
-	return operator_to_str(op);
-}

base/components/gen/especifier.hpp

@@ -1,124 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "components/types.hpp"
-#endif
-
-// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
-
-enum Specifier : u32
-{
-	Spec_Invalid,
-	Spec_Consteval,
-	Spec_Constexpr,
-	Spec_Constinit,
-	Spec_Explicit,
-	Spec_External_Linkage,
-	Spec_ForceInline,
-	Spec_Global,
-	Spec_Inline,
-	Spec_Internal_Linkage,
-	Spec_Local_Persist,
-	Spec_Mutable,
-	Spec_NeverInline,
-	Spec_Ptr,
-	Spec_Ref,
-	Spec_Register,
-	Spec_Restrict,
-	Spec_RValue,
-	Spec_Static,
-	Spec_Thread_Local,
-	Spec_Virtual,
-	Spec_Const,
-	Spec_Final,
-	Spec_NoExceptions,
-	Spec_Override,
-	Spec_Pure,
-	Spec_Delete,
-	Spec_Volatile,
-	Spec_NumSpecifiers,
-	Spec_UnderlyingType = 0xffffffffu
-};
-
-inline Str spec_to_str(Specifier type)
-{
-	local_persist Str lookup[] = {
-		{ "INVALID",       sizeof("INVALID") - 1       },
-		{ "consteval",     sizeof("consteval") - 1     },
-		{ "constexpr",     sizeof("constexpr") - 1     },
-		{ "constinit",     sizeof("constinit") - 1     },
-		{ "explicit",      sizeof("explicit") - 1      },
-		{ "extern",        sizeof("extern") - 1        },
-		{ "forceinline",   sizeof("forceinline") - 1   },
-		{ "global",        sizeof("global") - 1        },
-		{ "inline",        sizeof("inline") - 1        },
-		{ "internal",      sizeof("internal") - 1      },
-		{ "local_persist", sizeof("local_persist") - 1 },
-		{ "mutable",       sizeof("mutable") - 1       },
-		{ "neverinline",   sizeof("neverinline") - 1   },
-		{ "*",             sizeof("*") - 1             },
-		{ "&",             sizeof("&") - 1             },
-		{ "register",      sizeof("register") - 1      },
-		{ "restrict",      sizeof("restrict") - 1      },
-		{ "&&",            sizeof("&&") - 1            },
-		{ "static",        sizeof("static") - 1        },
-		{ "thread_local",  sizeof("thread_local") - 1  },
-		{ "virtual",       sizeof("virtual") - 1       },
-		{ "const",         sizeof("const") - 1         },
-		{ "final",         sizeof("final") - 1         },
-		{ "noexcept",      sizeof("noexcept") - 1      },
-		{ "override",      sizeof("override") - 1      },
-		{ "= 0",           sizeof("= 0") - 1           },
-		{ "= delete",      sizeof("= delete") - 1      },
-		{ "volatile",      sizeof("volatile") - 1      },
-	};
-	return lookup[type];
-}
-
-inline bool spec_is_trailing(Specifier specifier)
-{
-	switch (specifier)
-	{
-		case Spec_Const:
-		case Spec_Final:
-		case Spec_NoExceptions:
-		case Spec_Override:
-		case Spec_Pure:
-		case Spec_Delete:
-		case Spec_Volatile:
-			return true;
-		default:
-			return false;
-	}
-}
-
-inline Specifier str_to_specifier(Str str)
-{
-	local_persist u32 keymap[Spec_NumSpecifiers];
-	do_once_start for (u32 index = 0; index < Spec_NumSpecifiers; index++)
-	{
-		Str enum_str  = spec_to_str((Specifier)index);
-		keymap[index] = crc32(enum_str.Ptr, enum_str.Len);
-	}
-	do_once_end u32 hash = crc32(str.Ptr, str.Len);
-	for (u32 index = 0; index < Spec_NumSpecifiers; index++)
-	{
-		if (keymap[index] == hash)
-			return (Specifier)index;
-	}
-	return Spec_Invalid;
-}
-
-forceinline Str to_str(Specifier spec)
-{
-	return spec_to_str(spec);
-}
-
-forceinline Specifier to_type(Str str)
-{
-	return str_to_specifier(str);
-}
-
-forceinline bool is_trailing(Specifier specifier)
-{
-	return spec_is_trailing(specifier);
-}

base/components/gen/etoktype.hpp

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

base/components/header_start.hpp

@@ -1,32 +0,0 @@
-#pragma once
-
-/*
-	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
-
-	See Readme.md for more information from the project repository.
-
-	Public Address:
-	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
-	|   _____                               _____ _                       _                        |
-	|  / ____)                             / ____} |                     | |                       |
-	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
-	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
-	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
-	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
-	|                        | |   | |                      __} |                                  |
-	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.25-Alpha |
-	! ============================================================================================ |
-	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
-	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
-	! ============================================================================================ /
-*/
-#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
-#	error Gen.hpp : GEN_TIME not defined
-#endif
-
-//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
-// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
-#ifndef GEN_ROLL_OWN_DEPENDENCIES
-#	include "gen.dep.hpp"
-#endif

base/components/inlines.hpp

@@ -1,753 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "interface.hpp"
-#endif
-
-#pragma region Serialization
-inline
-StrBuilder attributes_to_strbuilder(CodeAttributes attributes) {
-	GEN_ASSERT(attributes);
-	char* raw = ccast(char*, str_duplicate( attributes->Content, get_context()->Allocator_Temp ).Ptr);
-	StrBuilder result = { raw };
-	return result;
-}
-
-inline
-void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result) {
-	GEN_ASSERT(attributes);
-	GEN_ASSERT(result);
-	strbuilder_append_str(result, attributes->Content);
-}
-
-inline
-StrBuilder comment_to_strbuilder(CodeComment comment) {
-	GEN_ASSERT(comment);
-	char* raw = ccast(char*, str_duplicate( comment->Content, get_context()->Allocator_Temp ).Ptr);
-	StrBuilder result = { raw };
-	return result;
-}
-
-inline
-void body_to_strbuilder_ref( CodeBody body, StrBuilder* result )
-{
-	GEN_ASSERT(body   != nullptr);
-	GEN_ASSERT(result != nullptr);
-	Code curr = body->Front;
-	s32  left = body->NumEntries;
-	while ( left -- )
-	{
-		code_to_strbuilder_ref(curr, result);
-		// strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) );
-		++curr;
-	}
-}
-
-inline
-void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result) {
-	GEN_ASSERT(comment);
-	GEN_ASSERT(result);
-	strbuilder_append_str(result, comment->Content);
-}
-
-inline
-StrBuilder define_to_strbuilder(CodeDefine define)
-{
-	GEN_ASSERT(define);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 );
-	define_to_strbuilder_ref(define, & result);
-	return result;
-}
-
-inline
-StrBuilder define_params_to_strbuilder(CodeDefineParams params)
-{
-	GEN_ASSERT(params);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 );
-	define_params_to_strbuilder_ref( params, & result );
-	return result;
-}
-
-inline
-StrBuilder exec_to_strbuilder(CodeExec exec)
-{
-	GEN_ASSERT(exec);
-	char* raw = ccast(char*, str_duplicate( exec->Content, _ctx->Allocator_Temp ).Ptr);
-	StrBuilder result = { raw };
-	return result;
-}
-
-inline
-void exec_to_strbuilder_ref(CodeExec exec, StrBuilder* result) {
-	GEN_ASSERT(exec);
-	GEN_ASSERT(result);
-	strbuilder_append_str(result, exec->Content);
-}
-
-inline
-void extern_to_strbuilder(CodeExtern self, StrBuilder* result )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(result);
-	if ( self->Body )
-		strbuilder_append_fmt( result, "extern \"%S\"\n{\n%SB\n}\n", self->Name, body_to_strbuilder(self->Body) );
-	else
-		strbuilder_append_fmt( result, "extern \"%S\"\n{}\n", self->Name );
-}
-
-inline
-StrBuilder friend_to_strbuilder(CodeFriend self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 );
-	friend_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "friend %SB", code_to_strbuilder(self->Declaration) );
-
-	if ( self->Declaration->Type != CT_Function && self->Declaration->Type != CT_Operator && (* result)[ strbuilder_length(* result) - 1 ] != ';' )
-	{
-		strbuilder_append_str( result, txt(";") );
-	}
-
-	if ( self->InlineCmt )
-		strbuilder_append_fmt( result, "  %S", self->InlineCmt->Content );
-	else
-		strbuilder_append_str( result, txt("\n"));
-}
-
-inline
-StrBuilder include_to_strbuilder(CodeInclude include)
-{
-	GEN_ASSERT(include);
-	return strbuilder_fmt_buf( _ctx->Allocator_Temp, "#include %S\n", include->Content );
-}
-
-inline
-void include_to_strbuilder_ref( CodeInclude include, StrBuilder* result )
-{
-	GEN_ASSERT(include);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#include %S\n", include->Content );
-}
-
-inline
-StrBuilder module_to_strbuilder(CodeModule self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 );
-	module_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder namespace_to_strbuilder(CodeNS self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 );
-	namespace_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(result);
-	if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export ))
-		strbuilder_append_str( result, txt("export ") );
-
-	strbuilder_append_fmt( result, "namespace %S\n{\n%SB\n}\n", self->Name, body_to_strbuilder(self->Body) );
-}
-
-inline
-StrBuilder params_to_strbuilder(CodeParams self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 );
-	params_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder pragma_to_strbuilder(CodePragma self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 );
-	pragma_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#pragma %S\n", self->Content );
-}
-
-inline
-void preprocess_to_strbuilder_if(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#if %S", cond->Content );
-}
-
-inline
-void preprocess_to_strbuilder_ifdef(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#ifdef %S\n", cond->Content );
-}
-
-inline
-void preprocess_to_strbuilder_ifndef(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#ifndef %S", cond->Content );
-}
-
-inline
-void preprocess_to_strbuilder_elif(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_fmt( result, "#elif %S\n", cond->Content );
-}
-
-inline
-void preprocess_to_strbuilder_else(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_str( result, txt("#else\n") );
-}
-
-inline
-void preprocess_to_strbuilder_endif(CodePreprocessCond cond, StrBuilder* result )
-{
-	GEN_ASSERT(cond);
-	GEN_ASSERT(result);
-	strbuilder_append_str( result, txt("#endif\n") );
-}
-
-inline
-StrBuilder specifiers_to_strbuilder(CodeSpecifiers self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 );
-	specifiers_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder template_to_strbuilder(CodeTemplate self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 1024 );
-	template_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder typedef_to_strbuilder(CodeTypedef self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 );
-	typedef_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder typename_to_strbuilder(CodeTypename self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_str( _ctx->Allocator_Temp, txt("") );
-	typename_to_strbuilder_ref( self, & result );
-	return result;
-}
-
-inline
-StrBuilder using_to_strbuilder(CodeUsing self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 );
-	switch ( self->Type )
-	{
-		case CT_Using:
-			using_to_strbuilder_ref( self, & result );
-		break;
-		case CT_Using_Namespace:
-			using_to_strbuilder_ns( self, & result );
-		break;
-	}
-	return result;
-}
-
-inline
-void using_to_strbuilder_ns(CodeUsing self, StrBuilder* result )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(result);
-	if ( self->InlineCmt )
-		strbuilder_append_fmt( result, "using namespace $S;  %S", self->Name, self->InlineCmt->Content );
-	else
-		strbuilder_append_fmt( result, "using namespace %S;\n", self->Name );
-}
-
-inline
-StrBuilder var_to_strbuilder(CodeVar self)
-{
-	GEN_ASSERT(self);
-	StrBuilder result = strbuilder_make_reserve( get_context()->Allocator_Temp, 256 );
-	var_to_strbuilder_ref( self, & result );
-	return result;
-}
-#pragma endregion Serialization
-
-#pragma region Code
-inline
-void code_append( Code self, Code other )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(other);
-	GEN_ASSERT_MSG(self != other, "Attempted to recursively append Code AST to itself.");
-
-	if ( other->Parent != nullptr )
-		other = code_duplicate(other);
-
-	other->Parent = self;
-
-	if ( self->Front == nullptr )
-	{
-		self->Front = other;
-		self->Back  = other;
-
-		self->NumEntries++;
-		return;
-	}
-
-	Code
-	Current       = self->Back;
-	Current->Next = other;
-	other->Prev   = Current;
-	self->Back    = other;
-	self->NumEntries++;
-}
-inline
-bool code_is_body(Code self)
-{
-	GEN_ASSERT(self);
-	switch (self->Type)
-	{
-		case CT_Enum_Body:
-		case CT_Class_Body:
-		case CT_Union_Body:
-		case CT_Export_Body:
-		case CT_Global_Body:
-		case CT_Struct_Body:
-		case CT_Function_Body:
-		case CT_Namespace_Body:
-		case CT_Extern_Linkage_Body:
-			return true;
-	}
-	return false;
-}
-inline
-Code* code_entry( Code self, u32 idx )
-{
-	GEN_ASSERT(self != nullptr);
-	Code* current = & self->Front;
-	while ( idx >= 0 && current != nullptr )
-	{
-		if ( idx == 0 )
-			return rcast( Code*, current);
-
-		current = & ( * current )->Next;
-		idx--;
-	}
-
-	return rcast( Code*, current);
-}
-forceinline
-bool code_is_valid(Code self)
-{
-	GEN_ASSERT(self);
-	return self != nullptr && self->Type != CT_Invalid;
-}
-forceinline
-bool code_has_entries(Code self)
-{
-	GEN_ASSERT(self);
-	return self->NumEntries > 0;
-}
-forceinline
-void code_set_global(Code self)
-{
-	if ( self == nullptr )
-	{
-		log_failure("Code::set_global: Cannot set code as global, AST is null!");
-		return;
-	}
-
-	self->Parent = Code_Global;
-}
-#if GEN_COMPILER_CPP
-forceinline
-Code& Code::operator ++()
-{
-	if ( ast )
-		ast = ast->Next.ast;
-
-	return * this;
-}
-#endif
-forceinline
-Str code_type_str(Code self)
-{
-	GEN_ASSERT(self != nullptr);
-	return codetype_to_str( self->Type );
-}
-#pragma endregion Code
-
-#pragma region CodeBody
-inline
-void body_append( CodeBody self, Code other )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(other);
-
-	if (code_is_body(other)) {
-		body_append_body( self, cast(CodeBody, other) );
-		return;
-	}
-
-	code_append( cast(Code, self), other );
-}
-inline
-void body_append_body( CodeBody self, CodeBody body )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(body);
-	GEN_ASSERT_MSG(self != body, "Attempted to append body to itself.");
-
-	for ( Code entry = begin_CodeBody(body); entry != end_CodeBody(body); entry = next_CodeBody(body, entry) ) {
-		body_append( self, entry );
-	}
-}
-inline
-Code begin_CodeBody( CodeBody body) {
-	GEN_ASSERT(body);
-	if ( body != nullptr )
-		return body->Front;
-
-	return NullCode;
-}
-forceinline
-Code end_CodeBody(CodeBody body ){
-	GEN_ASSERT(body);
-	return body->Back->Next;
-}
-inline
-Code next_CodeBody(CodeBody body, Code entry) {
-	GEN_ASSERT(body);
-	GEN_ASSERT(entry);
-	return entry->Next;
-}
-#pragma endregion CodeBody
-
-#pragma region CodeClass
-inline
-void class_add_interface( CodeClass self, CodeTypename type )
-{
-	GEN_ASSERT(self);
-	GEN_ASSERT(type);
-	CodeTypename possible_slot = self->ParentType;
-	if ( possible_slot != nullptr )
-	{
-		// Were adding an interface to parent type, so we need to make sure the parent type is public.
-		self->ParentAccess = AccessSpec_Public;
-		// If your planning on adding a proper parent,
-		// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
-	}
-
-	while ( possible_slot->Next != nullptr )
-	{
-		possible_slot = cast(CodeTypename, possible_slot->Next);
-	}
-
-	possible_slot->Next = cast(Code, type);
-}
-#pragma endregion CodeClass
-
-#pragma region CodeParams
-inline
-void params_append( CodeParams appendee, CodeParams other )
-{
-	GEN_ASSERT(appendee);
-	GEN_ASSERT(other);
-	GEN_ASSERT_MSG(appendee != other, "Attempted to append parameter to itself.");
-	Code self  = cast(Code, appendee);
-	Code entry = cast(Code, other);
-
-	if ( entry->Parent != nullptr )
-		entry = code_duplicate( entry );
-
-	entry->Parent = self;
-
-	if ( self->Last == nullptr )
-	{
-		self->Last = entry;
-		self->Next = entry;
-		self->NumEntries++;
-		return;
-	}
-
-	self->Last->Next = entry;
-	self->Last       = entry;
-	self->NumEntries++;
-}
-inline
-CodeParams params_get(CodeParams self, s32 idx )
-{
-	GEN_ASSERT(self);
-	CodeParams param = self;
-	do
-	{
-		if ( ++ param != nullptr )
-			return NullCode;
-
-		param = cast(CodeParams, cast(Code, param)->Next);
-	}
-	while ( --idx );
-
-	return param;
-}
-forceinline
-bool params_has_entries(CodeParams self)
-{
-	GEN_ASSERT(self);
-	return self->NumEntries > 0;
-}
-#if GEN_COMPILER_CPP
-forceinline
-CodeParams& CodeParams::operator ++()
-{
-	* this = ast->Next;
-	return * this;
-}
-#endif
-forceinline
-CodeParams begin_CodeParams(CodeParams params)
-{
-	if ( params != nullptr )
-		return params;
-
-	return NullCode;
-}
-forceinline
-CodeParams end_CodeParams(CodeParams params)
-{
-	// return { (AST_Params*) rcast( AST*, ast)->Last };
-	return NullCode;
-}
-forceinline
-CodeParams next_CodeParams(CodeParams params, CodeParams param_iter)
-{
-	GEN_ASSERT(param_iter);
-	return param_iter->Next;
-}
-#pragma endregion CodeParams
-
-#pragma region CodeDefineParams
-forceinline void             define_params_append     (CodeDefineParams appendee, CodeDefineParams other ) { params_append( cast(CodeParams, appendee), cast(CodeParams, other) ); }
-forceinline CodeDefineParams define_params_get        (CodeDefineParams self, s32 idx )                    { return (CodeDefineParams) (Code) params_get( cast(CodeParams, self), idx); }
-forceinline bool             define_params_has_entries(CodeDefineParams self)                              { return params_has_entries( cast(CodeParams, self)); }
-
-forceinline CodeDefineParams begin_CodeDefineParams(CodeDefineParams params)                              { return (CodeDefineParams) (Code) begin_CodeParams( cast(CodeParams, (Code)params)); }
-forceinline CodeDefineParams end_CodeDefineParams  (CodeDefineParams params)                              { return (CodeDefineParams) (Code) end_CodeParams  ( cast(CodeParams, (Code)params)); }
-forceinline CodeDefineParams next_CodeDefineParams (CodeDefineParams params, CodeDefineParams entry_iter) { return (CodeDefineParams) (Code) next_CodeParams ( cast(CodeParams, (Code)params), cast(CodeParams, (Code)entry_iter)); }
-
-#if GEN_COMPILER_CPP
-forceinline
-CodeDefineParams& CodeDefineParams::operator ++()
-{
-	* this = ast->Next;
-	return * this;
-}
-#endif
-#pragma endregion CodeDefineParams
-
-#pragma region CodeSpecifiers
-inline
-bool specifiers_append(CodeSpecifiers self, Specifier spec )
-{
-	if ( self == nullptr )
-	{
-		log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
-		return false;
-	}
-	if ( self->NumEntries == AST_ArrSpecs_Cap )
-	{
-		log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
-		return false;
-	}
-
-	self->ArrSpecs[ self->NumEntries ] = spec;
-	self->NumEntries++;
-	return true;
-}
-inline
-bool specifiers_has(CodeSpecifiers self, Specifier spec)
-{
-	GEN_ASSERT(self != nullptr);
-	for ( s32 idx = 0; idx < self->NumEntries; idx++ ) {
-		if ( self->ArrSpecs[ idx ] == spec )
-			return true;
-	}
-	return false;
-}
-inline
-s32 specifiers_index_of(CodeSpecifiers self, Specifier spec)
-{
-	GEN_ASSERT(self != nullptr);
-	for ( s32 idx = 0; idx < self->NumEntries; idx++ ) {
-		if ( self->ArrSpecs[ idx ] == spec )
-			return idx;
-	}
-	return -1;
-}
-inline
-s32 specifiers_remove( CodeSpecifiers self, Specifier to_remove )
-{
-	if ( self == nullptr )
-	{
-		log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
-		return -1;
-	}
-	if ( self->NumEntries == AST_ArrSpecs_Cap )
-	{
-		log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
-		return -1;
-	}
-
-	s32 result = -1;
-
-	s32 curr = 0;
-	s32 next = 0;
-	for(; next < self->NumEntries; ++ curr, ++ next)
-	{
-		Specifier spec = self->ArrSpecs[next];
-		if (spec == to_remove)
-		{
-			result = next;
-
-			next ++;
-			if (next >= self->NumEntries)
-				break;
-
-			spec = self->ArrSpecs[next];
-		}
-
-		self->ArrSpecs[ curr ] = spec;
-	}
-
-	if (result > -1) {
-		self->NumEntries --;
-	}
-	return result;
-}
-forceinline
-Specifier* begin_CodeSpecifiers(CodeSpecifiers self)
-{
-	if ( self != nullptr )
-		return & self->ArrSpecs[0];
-
-	return nullptr;
-}
-forceinline
-Specifier* end_CodeSpecifiers(CodeSpecifiers self)
-{
-	return self->ArrSpecs + self->NumEntries;
-}
-forceinline
-Specifier* next_CodeSpecifiers(CodeSpecifiers self, Specifier* spec_iter)
-{
-	return spec_iter + 1;
-}
-#pragma endregion CodeSpecifiers
-
-#pragma region CodeStruct
-inline
-void struct_add_interface(CodeStruct self, CodeTypename type )
-{
-	CodeTypename possible_slot = self->ParentType;
-	if ( possible_slot != nullptr )
-	{
-		// Were adding an interface to parent type, so we need to make sure the parent type is public.
-		self->ParentAccess = AccessSpec_Public;
-		// If your planning on adding a proper parent,
-		// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
-	}
-
-	while ( possible_slot->Next != nullptr )
-	{
-		possible_slot = cast(CodeTypename, possible_slot->Next);
-	}
-
-	possible_slot->Next = cast(Code, type);
-}
-#pragma endregion Code
-
-#pragma region Interface
-inline
-CodeBody def_body( CodeType type )
-{
-	switch ( type )
-	{
-		case CT_Class_Body:
-		case CT_Enum_Body:
-		case CT_Export_Body:
-		case CT_Extern_Linkage:
-		case CT_Function_Body:
-		case CT_Global_Body:
-		case CT_Namespace_Body:
-		case CT_Struct_Body:
-		case CT_Union_Body:
-			break;
-
-		default:
-			log_failure( "def_body: Invalid type %s", codetype_to_str(type).Ptr );
-			return (CodeBody)Code_Invalid;
-	}
-
-	Code
-	result       = make_code();
-	result->Type = type;
-	return (CodeBody)result;
-}
-
-inline
-Str token_fmt_impl( ssize num, ... )
-{
-	local_persist thread_local
-	char buf[GEN_PRINTF_MAXLEN] = { 0 };
-	mem_set( buf, 0, GEN_PRINTF_MAXLEN );
-
-	va_list va;
-	va_start(va, num );
-	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
-	va_end(va);
-
-	Str str = { buf, result };
-	return str;
-}
-#pragma endregion Interface

base/components/interface.cpp

@@ -1,521 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "code_serialization.cpp"
-#endif
-
-internal void parser_init();
-internal void parser_deinit();
-
-internal
-void* fallback_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
-{
-	GEN_ASSERT(_ctx);
-	GEN_ASSERT(_ctx->Fallback_AllocatorBuckets);
-	Arena* last = array_back(_ctx->Fallback_AllocatorBuckets);
-
-	switch ( type )
-	{
-		case EAllocation_ALLOC:
-		{
-			if ( ( last->TotalUsed + size ) > last->TotalSize )
-			{
-				Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
-
-				if ( bucket.PhysicalStart == nullptr )
-					GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
-
-				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
-					GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
-
-				last = array_back(_ctx->Fallback_AllocatorBuckets);
-			}
-
-			return alloc_align( arena_allocator_info(last), size, alignment );
-		}
-		case EAllocation_FREE:
-		{
-			// Doesn't recycle.
-		}
-		break;
-		case EAllocation_FREE_ALL:
-		{
-			// Memory::cleanup instead.
-		}
-		break;
-		case EAllocation_RESIZE:
-		{
-			if ( last->TotalUsed + size > last->TotalSize )
-			{
-				Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
-
-				if ( bucket.PhysicalStart == nullptr )
-					GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
-
-				if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
-					GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
-
-				last = array_back( _ctx->Fallback_AllocatorBuckets);
-			}
-
-			void* result = alloc_align( last->Backing, size, alignment );
-
-			if ( result != nullptr && old_memory != nullptr )
-			{
-				mem_copy( result, old_memory, old_size );
-			}
-
-			return result;
-		}
-	}
-
-	return nullptr;
-}
-
-internal
-void define_constants()
-{
-	// We only initalize these if there is no base context.
-	if ( context_counter > 0 )
-		return;
-
-	Code_Global          = make_code();
-	Code_Global->Name    = cache_str( txt("Global Code") );
-	Code_Global->Content = Code_Global->Name;
-
-	Code_Invalid = make_code();
-	code_set_global(Code_Invalid);
-
-	t_empty       = (CodeTypename) make_code();
-	t_empty->Type = CT_Typename;
-	t_empty->Name = cache_str( txt("") );
-	code_set_global(cast(Code, t_empty));
-
-	access_private       = make_code();
-	access_private->Type = CT_Access_Private;
-	access_private->Name = cache_str( txt("private:\n") );
-	code_set_global(cast(Code, access_private));
-
-	access_protected       = make_code();
-	access_protected->Type = CT_Access_Protected;
-	access_protected->Name = cache_str( txt("protected:\n") );
-	code_set_global(access_protected);
-
-	access_public       = make_code();
-	access_public->Type = CT_Access_Public;
-	access_public->Name = cache_str( txt("public:\n") );
-	code_set_global(access_public);
-
-	Str api_export_str = code(GEN_API_Export_Code);
-	attrib_api_export = def_attributes( api_export_str );
-	code_set_global(cast(Code, attrib_api_export));
-
-	Str api_import_str = code(GEN_API_Import_Code);
-	attrib_api_import = def_attributes( api_import_str );
-	code_set_global(cast(Code, attrib_api_import));
-
-	module_global_fragment          = make_code();
-	module_global_fragment->Type    = CT_Untyped;
-	module_global_fragment->Name    = cache_str( txt("module;") );
-	module_global_fragment->Content = module_global_fragment->Name;
-	code_set_global(cast(Code, module_global_fragment));
-
-	module_private_fragment          = make_code();
-	module_private_fragment->Type    = CT_Untyped;
-	module_private_fragment->Name    = cache_str( txt("module : private;") );
-	module_private_fragment->Content = module_private_fragment->Name;
-	code_set_global(cast(Code, module_private_fragment));
-
-	fmt_newline = make_code();
-	fmt_newline->Type = CT_NewLine;
-	code_set_global((Code)fmt_newline);
-
-	pragma_once          = (CodePragma) make_code();
-	pragma_once->Type    = CT_Preprocess_Pragma;
-	pragma_once->Name    = cache_str( txt("once") );
-	pragma_once->Content = pragma_once->Name;
-	code_set_global((Code)pragma_once);
-
-	param_varadic            = (CodeParams) make_code();
-	param_varadic->Type      = CT_Parameters;
-	param_varadic->Name      = cache_str( txt("...") );
-	param_varadic->ValueType = t_empty;
-	code_set_global((Code)param_varadic);
-
-	preprocess_else = (CodePreprocessCond) make_code();
-	preprocess_else->Type = CT_Preprocess_Else;
-	code_set_global((Code)preprocess_else);
-
-	preprocess_endif = (CodePreprocessCond) make_code();
-	preprocess_endif->Type = CT_Preprocess_EndIf;
-	code_set_global((Code)preprocess_endif);
-
-	Str auto_str     = txt("auto");     t_auto     = def_type( auto_str );     code_set_global( t_auto );
-	Str void_str     = txt("void");     t_void     = def_type( void_str );     code_set_global( t_void );
-	Str int_str      = txt("int");      t_int      = def_type( int_str );      code_set_global( t_int  );
-	Str bool_str     = txt("bool");     t_bool     = def_type( bool_str );     code_set_global( t_bool );
-	Str char_str     = txt("char");     t_char     = def_type( char_str );     code_set_global( t_char );
-	Str wchar_str    = txt("wchar_t");  t_wchar_t  = def_type( wchar_str );    code_set_global( t_wchar_t );
-	Str class_str    = txt("class");    t_class    = def_type( class_str );    code_set_global( t_class );
-	Str typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename );
-
-#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-	t_b32 = def_type( name(b32) ); code_set_global( t_b32 );
-
-	Str s8_str  = txt("s8");  t_s8  = def_type( s8_str ); code_set_global( t_s8 );
-	Str s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
-	Str s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
-	Str s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
-
-	Str u8_str  = txt("u8");  t_u8  = def_type( u8_str );  code_set_global( t_u8 );
-	Str u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
-	Str u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
-	Str u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
-
-	Str ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
-	Str usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
-
-	Str f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
-	Str f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
-#endif
-
-	spec_const            = def_specifier( Spec_Const);            code_set_global( cast(Code, spec_const ));
-	spec_consteval        = def_specifier( Spec_Consteval);        code_set_global( cast(Code, spec_consteval ));
-	spec_constexpr        = def_specifier( Spec_Constexpr);        code_set_global( cast(Code, spec_constexpr ));
-	spec_constinit        = def_specifier( Spec_Constinit);        code_set_global( cast(Code, spec_constinit ));
-	spec_extern_linkage   = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));
-	spec_final            = def_specifier( Spec_Final);            code_set_global( cast(Code, spec_final ));
-	spec_forceinline      = def_specifier( Spec_ForceInline);      code_set_global( cast(Code, spec_forceinline ));
-	spec_global           = def_specifier( Spec_Global);           code_set_global( cast(Code, spec_global ));
-	spec_inline           = def_specifier( Spec_Inline);           code_set_global( cast(Code, spec_inline ));
-	spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));
-	spec_local_persist    = def_specifier( Spec_Local_Persist);    code_set_global( cast(Code, spec_local_persist ));
-	spec_mutable          = def_specifier( Spec_Mutable);          code_set_global( cast(Code, spec_mutable ));
-	spec_neverinline      = def_specifier( Spec_NeverInline);      code_set_global( cast(Code, spec_neverinline ));
-	spec_noexcept         = def_specifier( Spec_NoExceptions);     code_set_global( cast(Code, spec_noexcept ));
-	spec_override         = def_specifier( Spec_Override);         code_set_global( cast(Code, spec_override ));
-	spec_ptr              = def_specifier( Spec_Ptr);              code_set_global( cast(Code, spec_ptr ));
-	spec_pure             = def_specifier( Spec_Pure);             code_set_global( cast(Code, spec_pure ));
-	spec_ref              = def_specifier( Spec_Ref);              code_set_global( cast(Code, spec_ref ));
-	spec_register         = def_specifier( Spec_Register);         code_set_global( cast(Code, spec_register ));
-	spec_rvalue           = def_specifier( Spec_RValue);           code_set_global( cast(Code, spec_rvalue ));
-	spec_static_member    = def_specifier( Spec_Static);           code_set_global( cast(Code, spec_static_member ));
-	spec_thread_local     = def_specifier( Spec_Thread_Local);     code_set_global( cast(Code, spec_thread_local ));
-	spec_virtual          = def_specifier( Spec_Virtual);          code_set_global( cast(Code, spec_virtual ));
-	spec_volatile         = def_specifier( Spec_Volatile);         code_set_global( cast(Code, spec_volatile ));
-
-	spec_local_persist = def_specifiers( 1, Spec_Local_Persist );
-	code_set_global(cast(Code, spec_local_persist));
-
-	if (enum_underlying_macro.Name.Len == 0) {
-		enum_underlying_macro.Name  = txt("enum_underlying");
-		enum_underlying_macro.Type  = MT_Expression;
-		enum_underlying_macro.Flags = MF_Functional;
-	}
-	register_macro(enum_underlying_macro);
-}
-
-void init(Context* ctx)
-{
-	do_once() {
-		context_counter = 0;
-	}
-	AllocatorInfo fallback_allocator = { & fallback_allocator_proc, nullptr };
-	
-	b32 using_fallback_allocator = false;
-	if (ctx->Allocator_DyanmicContainers.Proc == nullptr) {
-		ctx->Allocator_DyanmicContainers = fallback_allocator;
-		using_fallback_allocator = true;
-	}
-	if (ctx->Allocator_Pool.Proc == nullptr ) {
-		ctx->Allocator_Pool = fallback_allocator;
-		using_fallback_allocator = true;
-	}
-	if (ctx->Allocator_StrCache.Proc == nullptr) {
-		ctx->Allocator_StrCache = fallback_allocator;
-		using_fallback_allocator = true;
-	}
-	if (ctx->Allocator_Temp.Proc == nullptr) {
-		ctx->Allocator_Temp = fallback_allocator;
-		using_fallback_allocator = true;
-	}
-	// Setup fallback allocator
-	if (using_fallback_allocator)
-	{
-		ctx->Fallback_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
-		if ( ctx->Fallback_AllocatorBuckets == nullptr )
-			GEN_FATAL( "Failed to reserve memory for Fallback_AllocatorBuckets");
-
-		Arena bucket = arena_init_from_allocator( heap(), ctx->InitSize_Fallback_Allocator_Bucket_Size );
-		if ( bucket.PhysicalStart == nullptr )
-			GEN_FATAL( "Failed to create first bucket for Fallback_AllocatorBuckets");
-
-		array_append( ctx->Fallback_AllocatorBuckets, bucket );
-	}
-
-	if (ctx->Max_CommentLineLength == 0) {
-		ctx->Max_CommentLineLength = 1024;
-	}
-	if (ctx->Max_StrCacheLength == 0) {
-		ctx->Max_StrCacheLength = kilobytes(512);
-	}
-
-	if (ctx->InitSize_BuilderBuffer == 0) {
-		ctx->InitSize_BuilderBuffer = megabytes(2);
-	}
-	if (ctx->InitSize_CodePoolsArray == 0) { 
-		ctx->InitSize_CodePoolsArray = 16; 
-	}
-	if (ctx->InitSize_StringArenasArray == 0) {
-		ctx->InitSize_StringArenasArray = 16; 
-	}
-	if (ctx->CodePool_NumBlocks == 0) {
-		ctx->CodePool_NumBlocks = kilobytes(16);
-	}
-
-	if (ctx->InitSize_LexerTokens == 0 ) {
-		ctx->InitSize_LexerTokens = kilobytes(64);
-	}
-	if (ctx->SizePer_StringArena == 0) {
-		ctx->SizePer_StringArena = megabytes(1);
-	}
-
-	if (ctx->InitSize_Fallback_Allocator_Bucket_Size == 0) { 
-		ctx->InitSize_Fallback_Allocator_Bucket_Size = megabytes(8);
-	}
-
-	// Override the current context (user has to put it back if unwanted).
-	_ctx = ctx;
-
-	// Setup the arrays
-	{
-		ctx->CodePools = array_init_reserve(Pool, ctx->Allocator_DyanmicContainers, ctx->InitSize_CodePoolsArray );
-		if ( ctx->CodePools == nullptr )
-			GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
-
-		ctx->StringArenas = array_init_reserve(Arena, ctx->Allocator_DyanmicContainers, ctx->InitSize_StringArenasArray );
-		if ( ctx->StringArenas == nullptr )
-			GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
-	}
-	// Setup the code pool and code entries arena.
-	{
-		Pool code_pool = pool_init( ctx->Allocator_Pool, ctx->CodePool_NumBlocks, sizeof(AST) );
-		if ( code_pool.PhysicalStart == nullptr )
-			GEN_FATAL( "gen::init: Failed to initialize the code pool" );
-		array_append( ctx->CodePools, code_pool );
-
-		// TODO(Ed): Eventually the string arenas needs to be phased out for a dedicated string slab allocator
-		Arena strbuilder_arena = arena_init_from_allocator( ctx->Allocator_StrCache, ctx->SizePer_StringArena );
-		if ( strbuilder_arena.PhysicalStart == nullptr )
-			GEN_FATAL( "gen::init: Failed to initialize the string arena" );
-		array_append( ctx->StringArenas, strbuilder_arena );
-	}
-	// Setup the hash tables
-	{
-		ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
-		if ( ctx->StrCache.Entries == nullptr )
-			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
-
-		ctx->Macros = hashtable_init(Macro, ctx->Allocator_DyanmicContainers);
-		if (ctx->Macros.Hashes == nullptr || ctx->Macros.Entries == nullptr) {
-			GEN_FATAL( "gen::init: Failed to initialize the PreprocessMacros table" );
-		}
-	}
-
-	define_constants();
-	parser_init();
-
-	++ context_counter;
-}
-
-void deinit(Context* ctx)
-{
-	GEN_ASSERT(context_counter);
-	GEN_ASSERT_MSG(context_counter > 0, "Attempted to deinit a context that for some reason wan't accounted for!");
-	usize index = 0;
-	usize left  = array_num(ctx->CodePools);
-	do
-	{
-		Pool* code_pool = & ctx->CodePools[index];
-		pool_free(code_pool);
-		index++;
-	}
-	while ( left--, left );
-
-	index = 0;
-	left  = array_num(ctx->StringArenas);
-	do
-	{
-		Arena* strbuilder_arena = & ctx->StringArenas[index];
-		arena_free(strbuilder_arena);
-		index++;
-	}
-	while ( left--, left );
-
-	hashtable_destroy(ctx->StrCache);
-
-	array_free( ctx->CodePools);
-	array_free( ctx->StringArenas);
-
-	hashtable_destroy(ctx->Macros);
-
-	left  = array_num( ctx->Fallback_AllocatorBuckets);
-	if (left)
-	{
-		index = 0;
-		do
-		{
-			Arena* bucket = & ctx->Fallback_AllocatorBuckets[ index ];
-			arena_free(bucket);
-			index++;
-		}
-		while ( left--, left );
-		array_free( ctx->Fallback_AllocatorBuckets);
-	}
-	parser_deinit();
-
-	if (_ctx == ctx) 
-		_ctx = nullptr;
-	-- context_counter;
-
-	Context wipe = {};
-	* ctx = wipe;
-}
-
-Context* get_context() { 
-	return _ctx;
-}
-
-void reset(Context* ctx)
-{
-	s32 index = 0;
-	s32 left  = array_num(ctx->CodePools);
-	do
-	{
-		Pool* code_pool = & ctx->CodePools[index];
-		pool_clear(code_pool);
-		index++;
-	}
-	while ( left--, left );
-
-	index = 0;
-	left  = array_num(ctx->StringArenas);
-	do
-	{
-		Arena* strbuilder_arena = & ctx->StringArenas[index];
-		strbuilder_arena->TotalUsed = 0;;
-		index++;
-	}
-	while ( left--, left );
-
-	hashtable_clear(ctx->StrCache);
-	hashtable_clear(ctx->Macros);
-	define_constants();
-}
-
-void set_context(Context* new_ctx) {
-	GEN_ASSERT(new_ctx);
-	_ctx = new_ctx;
-}
-
-AllocatorInfo get_cached_str_allocator( s32 str_length )
-{
-	Arena* last     = array_back(_ctx->StringArenas);
-	usize  size_req = str_length + sizeof(StrBuilderHeader) + sizeof(char*);
-	if ( last->TotalUsed + scast(ssize, size_req) > last->TotalSize )
-	{
-		Arena new_arena = arena_init_from_allocator( _ctx->Allocator_StrCache, _ctx->SizePer_StringArena );
-		if ( ! array_append( _ctx->StringArenas, new_arena ) )
-			GEN_FATAL( "gen::get_cached_str_allocator: Failed to allocate a new string arena" );
-
-		last = array_back( _ctx->StringArenas);
-	}
-	return arena_allocator_info(last);
-}
-
-// Will either make or retrive a code string.
-StrCached cache_str( Str str )
-{
-	if (str.Len > _ctx->Max_StrCacheLength) {
-		// Do not cache the string, just shove into the arena and and return it.
-		Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
-		return result;
-	}
-	u64 key = crc32( str.Ptr, str.Len ); {
-		StrCached* result = hashtable_get( _ctx->StrCache, key );
-		if ( result )
-			return * result;
-	}
-	Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
-	hashtable_set( _ctx->StrCache, key, result );
-	return result;
-}
-
-// Used internally to retireve a Code object form the CodePool.
-Code make_code()
-{
-	Pool* allocator = array_back( _ctx->CodePools);
-	if ( allocator->FreeList == nullptr )
-	{
-		Pool code_pool = pool_init( _ctx->Allocator_Pool, _ctx->CodePool_NumBlocks, sizeof(AST) );
-
-		if ( code_pool.PhysicalStart == nullptr )
-			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
-
-		if ( ! array_append( _ctx->CodePools, code_pool ) )
-			GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
-
-		allocator = array_back( _ctx->CodePools);
-	}
-	Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) };
-	mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) );
-	return result;
-}
-
-Macro* lookup_macro( Str name ) {
-	u32 key = crc32( name.Ptr, name.Len );
-	return hashtable_get( _ctx->Macros, key );
-}
-
-void register_macro( Macro macro ) {
-	GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
-	GEN_ASSERT(macro.Name.Len > 0);
-	u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
-	macro.Name = cache_str(macro.Name);
-	hashtable_set( _ctx->Macros, key, macro );
-}
-
-void register_macros( s32 num, ... )
-{
-	GEN_ASSERT(num > 0);
-	va_list va;
-	va_start(va, num);
-	do
-	{
-		Macro macro = va_arg(va, Macro);
-		GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
-		GEN_ASSERT(macro.Name.Len > 0);
-		macro.Name = cache_str(macro.Name);
-
-		u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
-		hashtable_set( _ctx->Macros, key, macro );
-	}
-	while (num--, num > 0);
-	va_end(va);
-}
-
-void register_macros_arr( s32 num,  Macro* macros )
-{
-	GEN_ASSERT(num > 0);
-	do
-	{
-		Macro macro = * macros;
-		GEN_ASSERT_NOT_NULL(macro.Name.Ptr);
-		GEN_ASSERT(macro.Name.Len > 0);
-		macro.Name = cache_str(macro.Name);
-
-		u32 key = crc32( macro.Name.Ptr, macro.Name.Len );
-		hashtable_set( _ctx->Macros, key, macro );
-		++ macros;
-	}
-	while (num--, num > 0);
-}

base/components/interface.hpp

@@ -1,476 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "ast_types.hpp"
-#endif
-
-#pragma region Gen Interface
-/*
- /      \                       |      \          |  \                      /      \
-|  ▓▓▓▓▓▓\ ______  _______       \▓▓▓▓▓▓_______  _| ▓▓_    ______   ______ |  ▓▓▓▓▓▓\ ______   _______  ______
-| ▓▓ __\▓▓/      \|       \       | ▓▓ |       \|   ▓▓ \  /      \ /      \| ▓▓_  \▓▓|      \ /       \/      \
-| ▓▓|    \  ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓\      | ▓▓ | ▓▓▓▓▓▓▓\\▓▓▓▓▓▓ |  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\ ▓▓ \     \▓▓▓▓▓▓\  ▓▓▓▓▓▓▓  ▓▓▓▓▓▓\
-| ▓▓ \▓▓▓▓ ▓▓    ▓▓ ▓▓  | ▓▓      | ▓▓ | ▓▓  | ▓▓ | ▓▓ __| ▓▓    ▓▓ ▓▓   \▓▓ ▓▓▓▓    /      ▓▓ ▓▓     | ▓▓    ▓▓
-| ▓▓__| ▓▓ ▓▓▓▓▓▓▓▓ ▓▓  | ▓▓     _| ▓▓_| ▓▓  | ▓▓ | ▓▓|  \ ▓▓▓▓▓▓▓▓ ▓▓     | ▓▓     |  ▓▓▓▓▓▓▓ ▓▓_____| ▓▓▓▓▓▓▓▓
- \▓▓    ▓▓\▓▓     \ ▓▓  | ▓▓    |   ▓▓ \ ▓▓  | ▓▓  \▓▓  ▓▓\▓▓     \ ▓▓     | ▓▓      \▓▓    ▓▓\▓▓     \\▓▓     \
-  \▓▓▓▓▓▓  \▓▓▓▓▓▓▓\▓▓   \▓▓     \▓▓▓▓▓▓\▓▓   \▓▓   \▓▓▓▓  \▓▓▓▓▓▓▓\▓▓      \▓▓       \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
-*/
-
-#if 0
-enum LogLevel : u32
-{
-	Info,
-	Warning,
-	Panic,
-};
-
-struct LogEntry
-{
-	Str   msg;
-	u32   line_num;
-	void* data;
-};
-
-typedef void LoggerCallback(LogEntry entry);
-#endif
-
-// Note(Ed): This is subject to heavily change 
-// with upcoming changes to the library's fallback (default) allocations strategy;
-// and major changes to lexer/parser context usage.
-struct Context
-{
-// User Configuration
-
-// Persistent Data Allocation
-	AllocatorInfo Allocator_DyanmicContainers; // By default will use a genral slab allocator (TODO(Ed): Currently does not)
-	AllocatorInfo Allocator_Pool;              // By default will use the growing vmem reserve (TODO(Ed): Currently does not)
-	AllocatorInfo Allocator_StrCache;          // By default will use a dedicated slab allocator (TODO(Ed): Currently does not)
-
-// Temporary Allocation
-	AllocatorInfo Allocator_Temp;
-
-	// LoggerCallaback* log_callback; // TODO(Ed): Impl user logger callback as an option.
-
-// Initalization config
-	u32 Max_CommentLineLength; // Used by def_comment
-	u32 Max_StrCacheLength;    // Any cached string longer than this is always allocated again.
-
-	u32 InitSize_BuilderBuffer;
-	u32 InitSize_CodePoolsArray;
-	u32 InitSize_StringArenasArray;
-
-	u32 CodePool_NumBlocks;
-
-	// TODO(Ed): Review these... (No longer needed if using the proper allocation strategy)
-	u32 InitSize_LexerTokens;
-	u32 SizePer_StringArena;
-
-// TODO(Ed): Symbol Table
-	// Keep track of all resolved symbols (naemspaced identifiers)
-
-// Parser
-
-	// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
-	// Populate with strings via gen::cache_str.
-	// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
-	MacroTable Macros;
-
-// Backend
-
-	// The fallback allocator is utilized if any fo the three above allocators is not specified by the user.
-	u32 InitSize_Fallback_Allocator_Bucket_Size;
-	Array(Arena) Fallback_AllocatorBuckets;
-
-	StringTable token_fmt_map;
-
-	// Array(Token) LexerTokens;
-
-	Array(Pool)  CodePools;
-	Array(Arena) StringArenas;
-
-	StringTable StrCache;
-
-	// TODO(Ed): This needs to be just handled by a parser context
-	Array(Token) Lexer_Tokens;
-
-	// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
-	ParseContext parser;
-
-	// TODO(Ed): Formatting - This will eventually be in a separate struct when in the process of serialization of the builder.
-	s32 temp_serialize_indent;
-};
-
-// TODO(Ed): Eventually this library should opt out of an implicit context for baseline implementation
-// This would automatically make it viable for multi-threaded purposes among other things
-// An implicit context interface will be provided instead as wrapper procedures as convience.
-GEN_API extern Context* _ctx;
-
-// Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that
-GEN_API void init(Context* ctx);
-
-// Currently manually free's the arenas, code for checking for leaks.
-// However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
-GEN_API void deinit(Context* ctx);
-
-// Retrieves the active context (not usually needed, but here in case...)
-GEN_API Context* get_context();
-
-// Clears the allocations, but doesn't free the memoery, then calls init() again.
-// Ease of use.
-GEN_API void reset(Context* ctx);
-
-GEN_API void set_context(Context* ctx);
-
-// Mostly intended for the parser
-GEN_API Macro* lookup_macro( Str Name );
-
-// Alternative way to add a preprocess define entry for the lexer & parser to utilize 
-// if the user doesn't want to use def_define
-// Macros are tracked by name so if the name already exists the entry will be overwritten.
-GEN_API void register_macro( Macro macro );
-
-// Ease of use batch registration
-GEN_API void register_macros( s32 num, ... );
-GEN_API void register_macros_arr( s32 num, Macro* macros );
-
-#if GEN_COMPILER_CPP
-forceinline void register_macros( s32 num, Macro* macros ) { return register_macros_arr(num, macros); }
-#endif
-
-// Used internally to retrive or make string allocations.
-// Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
-GEN_API StrCached cache_str( Str str );
-
-/*
-	This provides a fresh Code AST.
-	The gen interface use this as their method from getting a new AST object from the CodePool.
-	Use this if you want to make your own API for formatting the supported Code Types.
-*/
-GEN_API Code make_code();
-
-// Set these before calling gen's init() procedure.
-
-#pragma region Upfront
-
-GEN_API CodeAttributes def_attributes( Str content );
-GEN_API CodeComment    def_comment   ( Str content );
-
-struct Opts_def_struct {
-	CodeBody       body;
-	CodeTypename   parent;
-	AccessSpec     parent_access;
-	CodeAttributes attributes;
-	CodeTypename*  interfaces;
-	s32            num_interfaces;
-	CodeSpecifiers specifiers; // Only used for final specifier for now.
-	ModuleFlag     mflags;
-};
-GEN_API CodeClass def_class( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_constructor {
-	CodeParams params;
-	Code      initializer_list;
-	Code      body;
-};
-GEN_API CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_define {
-	CodeDefineParams params;
-	Str              content;
-	MacroFlags       flags;
-	b32              dont_register_to_preprocess_macros;
-};
-GEN_API CodeDefine def_define( Str name, MacroType type, Opts_def_define opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_destructor {
-	Code           body;
-	CodeSpecifiers specifiers;
-};
-GEN_API CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_enum {
-	CodeBody       body;
-	CodeTypename   type;
-	EnumT          specifier;
-	CodeAttributes attributes;
-	ModuleFlag     mflags;
-	Code           type_macro;
-};
-GEN_API CodeEnum def_enum( Str name, Opts_def_enum opts GEN_PARAM_DEFAULT );
-
-GEN_API CodeExec   def_execution  ( Str content );
-GEN_API CodeExtern def_extern_link( Str name, CodeBody body );
-GEN_API CodeFriend def_friend     ( Code code );
-
-struct Opts_def_function {
-	CodeParams      params;
-	CodeTypename    ret_type;
-	CodeBody        body;
-	CodeSpecifiers  specs;
-	CodeAttributes  attrs;
-	ModuleFlag      mflags;
-};
-GEN_API CodeFn def_function( Str name, Opts_def_function opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_include   { b32        foreign; };
-struct Opts_def_module    { ModuleFlag mflags;  };
-struct Opts_def_namespace { ModuleFlag mflags;  };
-GEN_API CodeInclude def_include  ( Str content,             Opts_def_include   opts GEN_PARAM_DEFAULT );
-GEN_API CodeModule  def_module   ( Str name,                Opts_def_module    opts GEN_PARAM_DEFAULT );
-GEN_API CodeNS      def_namespace( Str name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_operator {
-	CodeParams      params;
-	CodeTypename    ret_type;
-	CodeBody        body;
-	CodeSpecifiers  specifiers;
-	CodeAttributes  attributes;
-	ModuleFlag      mflags;
-};
-GEN_API CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_operator_cast {
-	CodeBody       body;
-	CodeSpecifiers specs;
-};
-GEN_API CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_param { Code value; };
-GEN_API CodeParams def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
-GEN_API CodePragma def_pragma( Str directive );
-
-GEN_API CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str content );
-
-GEN_API CodeSpecifiers def_specifier( Specifier specifier );
-
-GEN_API CodeStruct def_struct( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_template { ModuleFlag mflags; };
-GEN_API CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_type {
-	ETypenameTag   type_tag;
-	Code           array_expr;
-	CodeSpecifiers specifiers;
-	CodeAttributes attributes;
-};
-GEN_API CodeTypename def_type( Str name, Opts_def_type opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_typedef {
-	CodeAttributes attributes;
-	ModuleFlag     mflags;
-};
-GEN_API CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_union {
-	CodeAttributes attributes;
-	ModuleFlag     mflags;
-};
-GEN_API CodeUnion def_union( Str name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT );
-
-struct Opts_def_using {
-	CodeAttributes attributes;
-	ModuleFlag     mflags;
-};
-GEN_API CodeUsing def_using( Str name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
-
-GEN_API CodeUsing def_using_namespace( Str name );
-
-struct Opts_def_variable
-{
-	Code           value;
-	CodeSpecifiers specifiers;
-	CodeAttributes attributes;
-	ModuleFlag     mflags;
-};
-GEN_API CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable opts GEN_PARAM_DEFAULT );
-
-// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
-CodeBody def_body( CodeType type );
-
-// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
-/// or provide as an array of Code objects.
-
-GEN_API CodeBody         def_class_body           ( s32 num, ... );
-GEN_API CodeBody         def_class_body_arr       ( s32 num, Code* codes );
-GEN_API CodeDefineParams def_define_params        ( s32 num, ... );
-GEN_API CodeDefineParams def_define_params_arr    ( s32 num, CodeDefineParams* codes );
-GEN_API CodeBody         def_enum_body            ( s32 num, ... );
-GEN_API CodeBody         def_enum_body_arr        ( s32 num, Code* codes );
-GEN_API CodeBody         def_export_body          ( s32 num, ... );
-GEN_API CodeBody         def_export_body_arr      ( s32 num, Code* codes);
-GEN_API CodeBody         def_extern_link_body     ( s32 num, ... );
-GEN_API CodeBody         def_extern_link_body_arr ( s32 num, Code* codes );
-GEN_API CodeBody         def_function_body        ( s32 num, ... );
-GEN_API CodeBody         def_function_body_arr    ( s32 num, Code* codes );
-GEN_API CodeBody         def_global_body          ( s32 num, ... );
-GEN_API CodeBody         def_global_body_arr      ( s32 num, Code* codes );
-GEN_API CodeBody         def_namespace_body       ( s32 num, ... );
-GEN_API CodeBody         def_namespace_body_arr   ( s32 num, Code* codes );
-GEN_API CodeParams       def_params               ( s32 num, ... );
-GEN_API CodeParams       def_params_arr           ( s32 num, CodeParams* params );
-GEN_API CodeSpecifiers   def_specifiers           ( s32 num, ... );
-GEN_API CodeSpecifiers   def_specifiers_arr       ( s32 num, Specifier* specs );
-GEN_API CodeBody         def_struct_body          ( s32 num, ... );
-GEN_API CodeBody         def_struct_body_arr      ( s32 num, Code* codes );
-GEN_API CodeBody         def_union_body           ( s32 num, ... );
-GEN_API CodeBody         def_union_body_arr       ( s32 num, Code* codes );
-
-#if GEN_COMPILER_CPP
-forceinline CodeBody         def_class_body      ( s32 num, Code* codes )             { return def_class_body_arr(num, codes); }
-forceinline CodeDefineParams def_define_params   ( s32 num, CodeDefineParams* codes ) { return def_define_params_arr(num, codes); }
-forceinline CodeBody         def_enum_body       ( s32 num, Code* codes )             { return def_enum_body_arr(num, codes); }
-forceinline CodeBody         def_export_body     ( s32 num, Code* codes)              { return def_export_body_arr(num, codes); }
-forceinline CodeBody         def_extern_link_body( s32 num, Code* codes )             { return def_extern_link_body_arr(num, codes); }
-forceinline CodeBody         def_function_body   ( s32 num, Code* codes )             { return def_function_body_arr(num, codes); }
-forceinline CodeBody         def_global_body     ( s32 num, Code* codes )             { return def_global_body_arr(num, codes); }
-forceinline CodeBody         def_namespace_body  ( s32 num, Code* codes )             { return def_namespace_body_arr(num, codes); }
-forceinline CodeParams       def_params          ( s32 num, CodeParams* params )      { return def_params_arr(num, params); }
-forceinline CodeSpecifiers   def_specifiers      ( s32 num, Specifier* specs )        { return def_specifiers_arr(num, specs); }
-forceinline CodeBody         def_struct_body     ( s32 num, Code* codes )             { return def_struct_body_arr(num, codes); }
-forceinline CodeBody         def_union_body      ( s32 num, Code* codes )             { return def_union_body_arr(num, codes); }
-#endif
-
-#pragma endregion Upfront
-
-#pragma region Parsing
-
-#if 0
-struct StackNode
-{
-	StackNode* Prev;
-
-	Token Start;
-	Token Name;       // The name of the AST node (if parsed)
-	Str  FailedProc; // The name of the procedure that failed
-};
-// Stack nodes are allocated the error's allocator
-
-struct Error
-{
-	StrBuilder     message;
-	StackNode* context_stack;
-};
-
-struct ParseInfo
-{
-	Arena FileMem;
-	Arena TokMem;
-	Arena CodeMem;
-
-	FileContents FileContent;
-	Array<Token> Tokens;
-	Array<Error> Errors;
-	// Errors are allocated to a dedicated general arena.
-};
-
-CodeBody parse_file( Str path );
-#endif
-
-GEN_API CodeClass       parse_class        ( Str class_def       );
-GEN_API CodeConstructor parse_constructor  ( Str constructor_def );
-GEN_API CodeDefine      parse_define       ( Str define_def      );
-GEN_API CodeDestructor  parse_destructor   ( Str destructor_def  );
-GEN_API CodeEnum        parse_enum         ( Str enum_def        );
-GEN_API CodeBody        parse_export_body  ( Str export_def      );
-GEN_API CodeExtern      parse_extern_link  ( Str exten_link_def  );
-GEN_API CodeFriend      parse_friend       ( Str friend_def      );
-GEN_API CodeFn          parse_function     ( Str fn_def          );
-GEN_API CodeBody        parse_global_body  ( Str body_def        );
-GEN_API CodeNS          parse_namespace    ( Str namespace_def   );
-GEN_API CodeOperator    parse_operator     ( Str operator_def    );
-GEN_API CodeOpCast      parse_operator_cast( Str operator_def    );
-GEN_API CodeStruct      parse_struct       ( Str struct_def      );
-GEN_API CodeTemplate    parse_template     ( Str template_def    );
-GEN_API CodeTypename    parse_type         ( Str type_def        );
-GEN_API CodeTypedef     parse_typedef      ( Str typedef_def     );
-GEN_API CodeUnion       parse_union        ( Str union_def       );
-GEN_API CodeUsing       parse_using        ( Str using_def       );
-GEN_API CodeVar         parse_variable     ( Str var_def         );
-
-#pragma endregion Parsing
-
-#pragma region Untyped text
-
-GEN_API ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
-//! Do not use directly. Use the token_fmt macro instead.
-Str   token_fmt_impl( ssize, ... );
-
-GEN_API Code untyped_str( Str content);
-GEN_API Code untyped_fmt      ( char const* fmt, ... );
-GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
-
-#pragma endregion Untyped text
-
-#pragma region Macros
-
-#ifndef gen_main
-#define gen_main main
-#endif
-
-#ifndef name
-//	Convienence for defining any name used with the gen api.
-//  Lets you provide the length and string literal to the functions without the need for the DSL.
-#	if GEN_COMPILER_C
-#		define name( Id_ ) (Str){ stringize(Id_), sizeof(stringize( Id_ )) - 1 }
-#	else
-#		define name( Id_ )  Str { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
-#	endif
-#endif
-
-#ifndef code
-//  Same as name just used to indicate intention of literal for code instead of names.
-#	if GEN_COMPILER_C
-#		define code( ... ) (Str){ stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
-#	else
-#		define code( ... )  Str { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
-#	endif
-#endif
-
-#ifndef args
-// Provides the number of arguments while passing args inplace.
-#define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
-#endif
-
-#ifndef code_str
-// Just wrappers over common untyped code definition constructions.
-#define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
-#endif
-
-#ifndef code_fmt
-#define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
-#endif
-
-#ifndef parse_fmt
-#define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
-#endif
-
-#ifndef token_fmt
-/*
-Takes a format string (char const*) and a list of tokens (Str) and returns a Str of the formatted string.
-Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
----------------------------------------------------------
-	Example - A string with:
-		typedef <type> <name> <name>;
-	Will have a token_fmt arguments populated with:
-		"type", str_for_type,
-		"name", str_for_name,
-	and:
-		stringize( typedef <type> <name> <name>; )
------------------------------------------------------------
-So the full call for this example would be:
-	token_fmt(
-		"type", str_for_type
-	,	"name", str_for_name
-	,	stringize(
-		typedef <type> <name> <name>
-	));
-!----------------------------------------------------------
-! Note: token_fmt_va is whitespace sensitive for the tokens.
-! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
-*/
-#define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
-#endif
-
-#pragma endregion Macros
-
-#pragma endregion Gen Interface

base/components/interface.parsing.cpp

@@ -1,341 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "gen/etoktype.cpp"
-#include "interface.upfront.cpp"
-#include "lexer.cpp"
-#include "parser.cpp"
-#endif
-
-// Publically Exposed Interface
-
-CodeClass parse_class( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	push_scope();
-	CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
-	parser_pop(& _ctx->parser);
-	return result;
-}
-
-CodeConstructor parse_constructor( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	// TODO(Ed): Constructors can have prefix attributes
-
-	CodeSpecifiers specifiers = NullCode;
-	Specifier      specs_found[ 16 ] = { Spec_NumSpecifiers };
-	s32            NumSpecifiers = 0;
-
-	while ( left && tok_is_specifier(currtok) )
-	{
-		Specifier spec = str_to_specifier( currtok.Text );
-
-		b32 ignore_spec = false;
-
-		switch ( spec )
-		{
-			case Spec_Constexpr :
-			case Spec_Explicit:
-			case Spec_Inline :
-			case Spec_ForceInline :
-			case Spec_NeverInline :
-				break;
-
-			case Spec_Const :
-				ignore_spec = true;
-				break;
-
-			default :
-				log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
-				parser_pop(& _ctx->parser);
-				return InvalidCode;
-		}
-
-		// Every specifier after would be considered part of the type type signature
-		if (ignore_spec)
-			break;
-
-		specs_found[ NumSpecifiers ] = spec;
-		NumSpecifiers++;
-		eat( currtok.Type );
-	}
-
-	if ( NumSpecifiers )
-	{
-		specifiers = def_specifiers_arr( NumSpecifiers, specs_found );
-		// <specifiers> ...
-	}
-
-	_ctx->parser.Tokens         = toks;
-	CodeConstructor result = parser_parse_constructor( specifiers );
-	return result;
-}
-
-CodeDefine parse_define( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	push_scope();
-	CodeDefine result = parser_parse_define();
-	parser_pop(& _ctx->parser);
-	return result;
-}
-
-CodeDestructor parse_destructor( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	// TODO(Ed): Destructors can have prefix attributes
-	// TODO(Ed): Destructors can have virtual
-
-	_ctx->parser.Tokens        = toks;
-	CodeDestructor result = parser_parse_destructor(NullCode);
-	return result;
-}
-
-CodeEnum parse_enum( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-	{
-		parser_pop(& _ctx->parser);
-		return InvalidCode;
-	}
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_enum( parser_not_inplace_def);
-}
-
-CodeBody parse_export_body( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_export_body();
-}
-
-CodeExtern parse_extern_link( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_extern_link();
-}
-
-CodeFriend parse_friend( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_friend();
-}
-
-CodeFn parse_function( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return (CodeFn) parser_parse_function();
-}
-
-CodeBody parse_global_body( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	push_scope();
-	CodeBody result = parse_global_nspace( CT_Global_Body );
-	parser_pop(& _ctx->parser);
-	return result;
-}
-
-CodeNS parse_namespace( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_namespace();
-}
-
-CodeOperator parse_operator( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return (CodeOperator) parser_parse_operator();
-}
-
-CodeOpCast parse_operator_cast( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_operator_cast(NullCode);
-}
-
-CodeStruct parse_struct( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	push_scope();
-	CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
-	parser_pop(& _ctx->parser);
-	return result;
-}
-
-CodeTemplate parse_template( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_template();
-}
-
-CodeTypename parse_type( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_type( parser_not_from_template, nullptr);
-}
-
-CodeTypedef parse_typedef( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_typedef();
-}
-
-CodeUnion parse_union( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_union( parser_not_inplace_def);
-}
-
-CodeUsing parse_using( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_using();
-}
-
-CodeVar parse_variable( Str def )
-{
-	check_parse_args( def );
-
-	TokArray toks = lex( def );
-	if ( toks.Arr == nullptr )
-		return InvalidCode;
-
-	_ctx->parser.Tokens = toks;
-	return parser_parse_variable();
-}
-
-// Undef helper macros
-#undef check_parse_args
-#undef currtok_noskip
-#undef currtok
-#undef peektok
-#undef prevtok
-#undef nexttok
-#undef nexttok_noskip
-#undef eat
-#undef left
-#undef check
-#undef push_scope
-#undef def_assign
-
-// Here for C Variant
-#undef lex_dont_skip_formatting
-#undef lex_skip_formatting
-
-#undef parser_inplace_def
-#undef parser_not_inplace_def
-#undef parser_dont_consume_braces
-#undef parser_consume_braces
-#undef parser_not_from_template
-#undef parser_use_parenthesis
-#undef parser_strip_formatting_dont_preserve_newlines

base/components/parser_case_macros.cpp

@@ -1,112 +0,0 @@
-// These macros are used in the swtich cases within parser.cpp
-
-#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
-case Tok_Spec_Consteval:   \
-case Tok_Spec_Constexpr:   \
-case Tok_Spec_Constinit:   \
-case Tok_Spec_Explicit:    \
-case Tok_Spec_ForceInline: \
-case Tok_Spec_Inline:      \
-case Tok_Spec_Mutable:     \
-case Tok_Spec_NeverInline: \
-case Tok_Spec_Static:      \
-case Tok_Spec_Volatile:    \
-case Tok_Spec_Virtual
-
-#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_SPECIFIER_CASES \
-case Spec_Constexpr:   \
-case Spec_Constinit:   \
-case Spec_Explicit:    \
-case Spec_Inline:      \
-case Spec_ForceInline: \
-case Spec_Mutable:     \
-case Spec_NeverInline: \
-case Spec_Static:      \
-case Spec_Volatile:    \
-case Spec_Virtual
-
-#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
-case Tok_Spec_Consteval:        \
-case Tok_Spec_Constexpr:        \
-case Tok_Spec_Constinit:        \
-case Tok_Spec_Extern:           \
-case Tok_Spec_ForceInline:      \
-case Tok_Spec_Global:           \
-case Tok_Spec_Inline:           \
-case Tok_Spec_Internal_Linkage: \
-case Tok_Spec_NeverInline:      \
-case Tok_Spec_Static
-
-#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \
-case Spec_Constexpr:        \
-case Spec_Constinit:        \
-case Spec_ForceInline:      \
-case Spec_Global:           \
-case Spec_External_Linkage: \
-case Spec_Internal_Linkage: \
-case Spec_Inline:           \
-case Spec_Mutable:          \
-case Spec_NeverInline:      \
-case Spec_Static:           \
-case Spec_Volatile
-
-#define GEN_PARSER_FRIEND_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:       \
-case Spec_Inline:      \
-case Spec_ForceInline
-
-#define GEN_PARSER_FUNCTION_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:            \
-case Spec_Consteval:        \
-case Spec_Constexpr:        \
-case Spec_External_Linkage: \
-case Spec_Internal_Linkage: \
-case Spec_ForceInline:      \
-case Spec_Inline:           \
-case Spec_NeverInline:      \
-case Spec_Static
-
-#define GEN_PARSER_OPERATOR_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:       \
-case Spec_Constexpr:   \
-case Spec_ForceInline: \
-case Spec_Inline:      \
-case Spec_NeverInline: \
-case Spec_Static
-
-#define GEN_PARSER_TEMPLATE_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:            \
-case Spec_Constexpr:        \
-case Spec_Constinit:        \
-case Spec_External_Linkage: \
-case Spec_Global:           \
-case Spec_Inline:           \
-case Spec_ForceInline:      \
-case Spec_Local_Persist:    \
-case Spec_Mutable:          \
-case Spec_Static:           \
-case Spec_Thread_Local:     \
-case Spec_Volatile
-
-#define GEN_PARSER_VARIABLE_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:            \
-case Spec_Constexpr:        \
-case Spec_Constinit:        \
-case Spec_External_Linkage: \
-case Spec_Global:           \
-case Spec_Inline:           \
-case Spec_Local_Persist:    \
-case Spec_Mutable:          \
-case Spec_Restrict:         \
-case Spec_Static:           \
-case Spec_Thread_Local:     \
-case Spec_Volatile
-
-#define GEN_PARSER_TYPENAME_ALLOWED_SUFFIX_SPECIFIER_CASES \
-case Spec_Const:    \
-case Spec_Ptr:      \
-case Spec_Restrict: \
-case Spec_Ref:      \
-case Spec_RValue
-
-

base/components/parser_types.hpp

@@ -1,219 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "types.hpp"
-#include "gen/ecode.hpp"
-#include "gen/eoperator.hpp"
-#include "gen/especifier.hpp"
-#include "gen/etoktype.hpp"
-#endif
-
-enum TokFlags : u32
-{
-	TF_Operator              = bit(0),
-	TF_Assign                = bit(1),
-	TF_Identifier            = bit(2),
-	TF_Preprocess            = bit(3),
-	TF_Preprocess_Cond       = bit(4),
-	TF_Attribute             = bit(5),
-	TF_AccessOperator        = bit(6),
-	TF_AccessSpecifier       = bit(7),
-	TF_Specifier             = bit(8),
-	TF_EndDefinition         = bit(9),    // Either ; or }
-	TF_Formatting            = bit(10),
-	TF_Literal               = bit(11),
-	TF_Macro_Functional      = bit(12),
-	TF_Macro_Expects_Body    = bit(13),
-
-	TF_Null = 0,
-	TF_UnderlyingType = GEN_U32_MAX,
-};
-
-struct Token
-{
-	Str     Text;
-	TokType Type;
-	s32     Line;
-	s32     Column;
-	u32     Flags;
-};
-
-constexpr Token NullToken { {}, Tok_Invalid, 0, 0, TF_Null };
-
-forceinline
-AccessSpec tok_to_access_specifier(Token tok) {
-	return scast(AccessSpec, tok.Type);
-}
-
-forceinline
-bool tok_is_valid( Token tok ) {
-	return tok.Text.Ptr && tok.Text.Len && tok.Type != Tok_Invalid;
-}
-
-forceinline
-bool tok_is_access_operator(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_AccessOperator );
-}
-
-forceinline
-bool tok_is_access_specifier(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_AccessSpecifier );
-}
-
-forceinline
-bool tok_is_attribute(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_Attribute );
-}
-
-forceinline
-bool tok_is_operator(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_Operator );
-}
-
-forceinline
-bool tok_is_preprocessor(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_Preprocess );
-}
-
-forceinline
-bool tok_is_preprocess_cond(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_Preprocess_Cond );
-}
-
-forceinline
-bool tok_is_specifier(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_Specifier );
-}
-
-forceinline
-bool tok_is_end_definition(Token tok) {
-	return bitfield_is_set( u32, tok.Flags, TF_EndDefinition );
-}
-
-StrBuilder tok_to_strbuilder(Token tok);
-
-struct TokArray 
-{
-	Array(Token) Arr;
-	s32          Idx;
-};
-
-struct LexContext
-{
-	Str             content;
-	s32             left;
-	char const*     scanner;
-	s32             line;
-	s32             column;
-	// StringTable     defines;
-	Token           token;
-};
-
-struct StackNode
-{
-	StackNode* Prev;
-
-	Token* Start;
-	Str    Name;          // The name of the AST node (if parsed)
-	Str    ProcName;    // The name of the procedure
-};
-
-struct ParseContext
-{
-	TokArray   Tokens;
-	StackNode* Scope;
-};
-
-enum MacroType : u16
-{
-	MT_Expression,     // A macro is assumed to be a expression if not resolved.
-	MT_Statement,      
-	MT_Typename,
-	MT_Block_Start,    // Not Supported yet
-	MT_Block_End,      // Not Supported yet
-	MT_Case_Statement, // Not Supported yet
-
-	MT_UnderlyingType = GEN_U16_MAX,
-};
-
-forceinline
-TokType macrotype_to_toktype( MacroType type ) {
-	switch ( type ) {
-		case MT_Statement  : return Tok_Preprocess_Macro_Stmt;
-		case MT_Expression : return Tok_Preprocess_Macro_Expr;
-		case MT_Typename   : return Tok_Preprocess_Macro_Typename;
-	}
-	// All others unsupported for now.
-	return Tok_Invalid;
-}
-
-inline
-Str macrotype_to_str( MacroType type )
-{
-	local_persist
-	Str lookup[] = {
-		{ "Statement",        sizeof("Statement")        - 1 },
-		{ "Expression",       sizeof("Expression")       - 1 },
-		{ "Typename",         sizeof("Typename")         - 1 },
-		{ "Block_Start",      sizeof("Block_Start")      - 1 },
-		{ "Block_End",        sizeof("Block_End")        - 1 },
-		{ "Case_Statement",   sizeof("Case_Statement")   - 1 },
-	};
-	local_persist
-	Str invalid = { "Invalid", sizeof("Invalid") };
-	if ( type > MT_Case_Statement )
-		return invalid;
-
-	return lookup[ type ];
-}
-
-enum EMacroFlags : u16
-{
-	MF_Functional          = bit(0), // Macro has parameters (args expected to be passed)
-	MF_Expects_Body        = bit(1), // Expects to assign a braced scope to its body.
-
-	// lex__eat wil treat this macro as an identifier if the parser attempts to consume it as one.
-	//  ^^^ This is a kludge because we don't support push/pop macro pragmas rn.
-	MF_Allow_As_Identifier = bit(2), 
-
-	// lex__eat wil treat this macro as an attribute if the parser attempts to consume it as one.
-	//  ^^^ This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc)
-	// TODO(Ed): We can keep the MF_Allow_As_Attribute flag for macros, however, we need to add the ability of AST_Attributes to chain themselves.
-	// Its thats already a thing in the standard language anyway
-	// & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/variable definition
-	MF_Allow_As_Attribute  = bit(3),
-
-	// When a macro is encountered after attributes and specifiers while parsing a function, or variable:
-	// It will consume the macro and treat it as resolving the definition. (Yes this is for Unreal Engine)
-	// (MUST BE OF MT_Statement TYPE)
-	MF_Allow_As_Definition = bit(4),
-
-	MF_Allow_As_Specifier = bit(5), // Created for Unreal's PURE_VIRTUAL
-
-	MF_Null           = 0,
-	MF_UnderlyingType = GEN_U16_MAX,
-};
-typedef u16 MacroFlags;
-
-struct Macro
-{
-	StrCached  Name;
-	MacroType  Type;
-	MacroFlags Flags;
-};
-
-forceinline
-b32 macro_is_functional( Macro macro ) {
-	return bitfield_is_set( b16, macro.Flags, MF_Functional );
-}
-
-forceinline
-b32 macro_expects_body( Macro macro ) {
-	return bitfield_is_set( b16, macro.Flags, MF_Expects_Body );
-}
-
-#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-forceinline b32 is_functional( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Functional ); }
-forceinline b32 expects_body ( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Expects_Body ); }
-#endif
-
-typedef HashTable(Macro) MacroTable;

base/components/static_data.cpp

@@ -1,92 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#include "../gen.hpp"
-#endif
-
-#pragma region StaticData
-GEN_API global Context* _ctx;
-GEN_API global u32      context_counter;
-
-#pragma region Constants
-GEN_API global Macro enum_underlying_macro;
-
-GEN_API global Code Code_Global;
-GEN_API global Code Code_Invalid;
-
-GEN_API global Code access_public;
-GEN_API global Code access_protected;
-GEN_API global Code access_private;
-
-GEN_API global CodeAttributes attrib_api_export;
-GEN_API global CodeAttributes attrib_api_import;
-
-GEN_API global Code module_global_fragment;
-GEN_API global Code module_private_fragment;
-
-GEN_API global Code fmt_newline;
-
-GEN_API global CodeParams param_varadic;
-
-GEN_API global CodePragma pragma_once;
-
-GEN_API global CodePreprocessCond preprocess_else;
-GEN_API global CodePreprocessCond preprocess_endif;
-
-GEN_API global CodeSpecifiers spec_const;
-GEN_API global CodeSpecifiers spec_consteval;
-GEN_API global CodeSpecifiers spec_constexpr;
-GEN_API global CodeSpecifiers spec_constinit;
-GEN_API global CodeSpecifiers spec_extern_linkage;
-GEN_API global CodeSpecifiers spec_final;
-GEN_API global CodeSpecifiers spec_forceinline;
-GEN_API global CodeSpecifiers spec_global;
-GEN_API global CodeSpecifiers spec_inline;
-GEN_API global CodeSpecifiers spec_internal_linkage;
-GEN_API global CodeSpecifiers spec_local_persist;
-GEN_API global CodeSpecifiers spec_mutable;
-GEN_API global CodeSpecifiers spec_noexcept;
-GEN_API global CodeSpecifiers spec_neverinline;
-GEN_API global CodeSpecifiers spec_override;
-GEN_API global CodeSpecifiers spec_ptr;
-GEN_API global CodeSpecifiers spec_pure;
-GEN_API global CodeSpecifiers spec_ref;
-GEN_API global CodeSpecifiers spec_register;
-GEN_API global CodeSpecifiers spec_rvalue;
-GEN_API global CodeSpecifiers spec_static_member;
-GEN_API global CodeSpecifiers spec_thread_local;
-GEN_API global CodeSpecifiers spec_virtual;
-GEN_API global CodeSpecifiers spec_volatile;
-
-GEN_API global CodeTypename t_empty;
-GEN_API global CodeTypename t_auto;
-GEN_API global CodeTypename t_void;
-GEN_API global CodeTypename t_int;
-GEN_API global CodeTypename t_bool;
-GEN_API global CodeTypename t_char;
-GEN_API global CodeTypename t_wchar_t;
-GEN_API global CodeTypename t_class;
-GEN_API global CodeTypename t_typename;
-
-#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-GEN_API global CodeTypename t_b32;
-
-GEN_API global CodeTypename t_s8;
-GEN_API global CodeTypename t_s16;
-GEN_API global CodeTypename t_s32;
-GEN_API global CodeTypename t_s64;
-
-GEN_API global CodeTypename t_u8;
-GEN_API global CodeTypename t_u16;
-GEN_API global CodeTypename t_u32;
-GEN_API global CodeTypename t_u64;
-
-GEN_API global CodeTypename t_ssize;
-GEN_API global CodeTypename t_usize;
-
-GEN_API global CodeTypename t_f32;
-GEN_API global CodeTypename t_f64;
-#endif
-
-#pragma endregion Constants
-
-#pragma endregion StaticData

base/components/types.hpp

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

base/dependencies/containers.hpp

@@ -1,795 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "printing.hpp"
-#endif
-
-#pragma region Containers
-
-template<class TType>             struct RemoveConst                    { typedef TType Type;       };
-template<class TType>             struct RemoveConst<const TType>       { typedef TType Type;       };
-template<class TType>             struct RemoveConst<const TType[]>     { typedef TType Type[];     };
-template<class TType, usize Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
-
-template<class TType> using TRemoveConst = typename RemoveConst<TType>::Type;
-
-template <class TType> struct RemovePtr         { typedef TType Type; };
-template <class TType> struct RemovePtr<TType*> { typedef TType Type; };
-
-template <class TType> using TRemovePtr = typename RemovePtr<TType>::Type;
-
-
-#pragma region Array
-#define Array(Type) Array<Type>
-
-// #define array_init(Type, ...)         array_init        <Type>(__VA_ARGS__)
-// #define array_init_reserve(Type, ...) array_init_reserve<Type>(__VA_ARGS__)
-
-struct ArrayHeader;
-
-#if GEN_COMPILER_CPP
-	template<class Type> struct Array;
-#	define get_array_underlying_type(array) typename TRemovePtr<typeof(array)>:: DataType
-#endif
-
-usize array_grow_formula(ssize value);
-
-template<class Type> Array<Type>  array_init           (AllocatorInfo allocator);
-template<class Type> Array<Type>  array_init_reserve   (AllocatorInfo allocator, ssize capacity);
-template<class Type> bool         array_append_array   (Array<Type>* array, Array<Type> other);
-template<class Type> bool         array_append         (Array<Type>* array, Type value);
-template<class Type> bool         array_append_items   (Array<Type>* array, Type* items, usize item_num);
-template<class Type> bool         array_append_at      (Array<Type>* array, Type item, usize idx);
-template<class Type> bool         array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx);
-template<class Type> Type*        array_back           (Array<Type>  array);
-template<class Type> void         array_clear          (Array<Type>  array);
-template<class Type> bool         array_fill           (Array<Type>  array, usize begin, usize end, Type value);
-template<class Type> void         array_free           (Array<Type>* array);
-template<class Type> bool         arary_grow           (Array<Type>* array, usize min_capacity);
-template<class Type> usize        array_num            (Array<Type>  array);
-template<class Type> void         arary_pop            (Array<Type>  array);
-template<class Type> void         arary_remove_at      (Array<Type>  array, usize idx);
-template<class Type> bool         arary_reserve        (Array<Type>* array, usize new_capacity);
-template<class Type> bool         arary_resize         (Array<Type>* array, usize num);
-template<class Type> bool         arary_set_capacity   (Array<Type>* array, usize new_capacity);
-template<class Type> ArrayHeader* arary_get_header     (Array<Type>  array);
-
-struct ArrayHeader {
-	AllocatorInfo Allocator;
-	usize         Capacity;
-	usize         Num;
-};
-
-#if GEN_COMPILER_CPP
-template<class Type>
-struct Array
-{
-	Type* Data;
-
-#pragma region Member Mapping
-	forceinline static Array  init(AllocatorInfo allocator)                         { return array_init<Type>(allocator); }
-	forceinline static Array  init_reserve(AllocatorInfo allocator, ssize capacity) { return array_init_reserve<Type>(allocator, capacity); }
-	forceinline static usize  grow_formula(ssize value)                             { return array_grow_formula<Type>(value); }
-
-	forceinline bool         append(Array other)                               { return array_append_array<Type>(this, other); }
-	forceinline bool         append(Type value)                                { return array_append<Type>(this, value); }
-	forceinline bool         append(Type* items, usize item_num)               { return array_append_items<Type>(this, items, item_num); }
-	forceinline bool         append_at(Type item, usize idx)                   { return array_append_at<Type>(this, item, idx); }
-	forceinline bool         append_at(Type* items, usize item_num, usize idx) { return array_append_items_at<Type>(this, items, item_num, idx); }
-	forceinline Type*        back()                                            { return array_back<Type>(* this); }
-	forceinline void         clear()                                           {        array_clear<Type>(* this); }
-	forceinline bool         fill(usize begin, usize end, Type value)          { return array_fill<Type>(* this, begin, end, value); }
-	forceinline void         free()                                            {        array_free<Type>(this); }
-	forceinline ArrayHeader* get_header()                                      { return array_get_header<Type>(* this); }
-	forceinline bool         grow(usize min_capacity)                          { return array_grow<Type>(this, min_capacity); }
-	forceinline usize        num()                                             { return array_num<Type>(*this); }
-	forceinline void         pop()                                             {        array_pop<Type>(* this); }
-	forceinline void         remove_at(usize idx)                              {        array_remove_at<Type>(* this, idx); }
-	forceinline bool         reserve(usize new_capacity)                       { return array_reserve<Type>(this, new_capacity); }
-	forceinline bool         resize(usize num)                                 { return array_resize<Type>(this, num); }
-	forceinline bool         set_capacity(usize new_capacity)                  { return array_set_capacity<Type>(this, new_capacity); }
-#pragma endregion Member Mapping
-
-	forceinline operator Type*()             { return Data; }
-	forceinline operator Type const*() const { return Data; }
-	forceinline Type* begin()                { return Data; }
-	forceinline Type* end()                  { return Data + get_header()->Num; }
-
-	forceinline Type&       operator[](ssize index)       { return Data[index]; }
-	forceinline Type const& operator[](ssize index) const { return Data[index]; }
-
-	using DataType = Type;
-};
-#endif
-
-#if GEN_COMPILER_CPP && 0
-template<class Type> bool append(Array<Type>& array, Array<Type> other)                         { return append( & array, other ); }
-template<class Type> bool append(Array<Type>& array, Type value)                                { return append( & array, value ); }
-template<class Type> bool append(Array<Type>& array, Type* items, usize item_num)               { return append( & array, items, item_num ); }
-template<class Type> bool append_at(Array<Type>& array, Type item, usize idx)                   { return append_at( & array, item, idx ); }
-template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
-template<class Type> void free(Array<Type>& array)                                              { return free( & array ); }
-template<class Type> bool grow(Array<Type>& array, usize min_capacity)                          { return grow( & array, min_capacity); }
-template<class Type> bool reserve(Array<Type>& array, usize new_capacity)                       { return reserve( & array, new_capacity); }
-template<class Type> bool resize(Array<Type>& array, usize num)                                 { return resize( & array, num); }
-template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity)                  { return set_capacity( & array, new_capacity); }
-
-template<class Type> forceinline Type* begin(Array<Type>& array)             { return array;      }
-template<class Type> forceinline Type* end(Array<Type>& array)               { return array + array_get_header(array)->Num; }
-template<class Type> forceinline Type* next(Array<Type>& array, Type* entry) { return entry + 1; }
-#endif
-
-template<class Type> forceinline Type* array_begin(Array<Type> array)             { return array;      }
-template<class Type> forceinline Type* array_end(Array<Type> array)               { return array + array_get_header(array)->Num; }
-template<class Type> forceinline Type* array_next(Array<Type> array, Type* entry) { return ++ entry; }
-
-template<class Type> inline
-Array<Type> array_init(AllocatorInfo allocator) {
-	return array_init_reserve<Type>(allocator, array_grow_formula(0));
-}
-
-template<class Type> inline
-Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity)
-{
-	GEN_ASSERT(capacity > 0);
-	ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(Type) * capacity));
-
-	if (header == nullptr)
-		return {nullptr};
-
-	header->Allocator = allocator;
-	header->Capacity  = capacity;
-	header->Num       = 0;
-
-	return {rcast(Type*, header + 1)};
-}
-
-forceinline
-usize array_grow_formula(ssize value) {
-	return 2 * value + 8;
-}
-
-template<class Type> inline
-bool array_append_array(Array<Type>* array, Array<Type> other) {
-	return array_append_items(array, (Type*)other, array_num(other));
-}
-
-template<class Type> inline
-bool array_append(Array<Type>* array, Type value)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(* array);
-
-	if (header->Num == header->Capacity)
-	{
-		if ( ! array_grow(array, header->Capacity))
-			return false;
-		header = array_get_header(* array);
-	}
-
-	(*array)[ header->Num] = value;
-	header->Num++;
-
-	return true;
-}
-
-template<class Type> inline
-bool array_append_items(Array<Type>* array, Type* items, usize item_num)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	GEN_ASSERT(items != nullptr);
-	GEN_ASSERT(item_num > 0);
-	ArrayHeader* header = array_get_header(* array);
-
-	if (header->Num + item_num > header->Capacity)
-	{
-		if ( ! array_grow(array, header->Capacity + item_num))
-			return false;
-		header = array_get_header(* array);
-	}
-
-	mem_copy((Type*)array + header->Num, items, item_num * sizeof(Type));
-	header->Num += item_num;
-
-	return true;
-}
-
-template<class Type> inline
-bool array_append_at(Array<Type>* array, Type item, usize idx)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(* array);
-
-	ssize slot = idx;
-	if (slot >= (ssize)(header->Num))
-		slot = header->Num - 1;
-
-	if (slot < 0)
-		slot = 0;
-
-	if (header->Capacity < header->Num + 1)
-	{
-		if ( ! array_grow(array, header->Capacity + 1))
-			return false;
-
-		header = array_get_header(* array);
-	}
-
-	Type* target = &(*array)[slot];
-
-	mem_move(target + 1, target, (header->Num - slot) * sizeof(Type));
-	header->Num++;
-
-	return true;
-}
-
-template<class Type> inline
-bool array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = get_header(array);
-
-	if (idx >= header->Num)
-	{
-		return array_append_items(array, items, item_num);
-	}
-
-	if (item_num > header->Capacity)
-	{
-		if (! grow(array, header->Capacity + item_num))
-			return false;
-
-		header = get_header(array);
-	}
-
-	Type* target = array.Data + idx + item_num;
-	Type* src    = array.Data + idx;
-
-	mem_move(target, src, (header->Num - idx) * sizeof(Type));
-	mem_copy(src, items, item_num * sizeof(Type));
-	header->Num += item_num;
-
-	return true;
-}
-
-template<class Type> inline
-Type* array_back(Array<Type> array)
-{
-	GEN_ASSERT(array != nullptr);
-
-	ArrayHeader* header = array_get_header(array);
-	if (header->Num <= 0)
-		return nullptr;
-
-	return & (array)[header->Num - 1];
-}
-
-template<class Type> inline
-void array_clear(Array<Type> array) {
-	GEN_ASSERT(array != nullptr);
-	ArrayHeader* header = array_get_header(array);
-	header->Num = 0;
-}
-
-template<class Type> inline
-bool array_fill(Array<Type> array, usize begin, usize end, Type value)
-{
-	GEN_ASSERT(array != nullptr);
-	GEN_ASSERT(begin <= end);
-	ArrayHeader* header = array_get_header(array);
-
-	if (begin < 0 || end > header->Num)
-		return false;
-
-	for (ssize idx = ssize(begin); idx < ssize(end); idx++) {
-		array[idx] = value;
-	}
-
-	return true;
-}
-
-template<class Type> forceinline
-void array_free(Array<Type>* array) {
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(* array);
-	allocator_free(header->Allocator, header);
-	Type** Data = (Type**)array;
-	*Data = nullptr;
-}
-
-template<class Type> forceinline
-ArrayHeader* array_get_header(Array<Type> array) {
-	GEN_ASSERT(array != nullptr);
-    Type* Data = array;
-
-	using NonConstType = TRemoveConst<Type>;
-    return rcast(ArrayHeader*, const_cast<NonConstType*>(Data)) - 1;
-}
-
-template<class Type> forceinline
-bool array_grow(Array<Type>* array, usize min_capacity)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	GEN_ASSERT( min_capacity > 0 );
-	ArrayHeader* header       = array_get_header(* array);
-	usize        new_capacity = array_grow_formula(header->Capacity);
-
-	if (new_capacity < min_capacity)
-		new_capacity = min_capacity;
-
-	return array_set_capacity(array, new_capacity);
-}
-
-template<class Type> forceinline
-usize array_num(Array<Type> array) {
-	GEN_ASSERT(array != nullptr);
-	return array_get_header(array)->Num;
-}
-
-template<class Type> forceinline
-void array_pop(Array<Type> array) {
-	GEN_ASSERT(array != nullptr);
-	ArrayHeader* header = array_get_header(array);
-	GEN_ASSERT(header->Num > 0);
-	header->Num--;
-}
-
-template<class Type> inline
-void array_remove_at(Array<Type> array, usize idx)
-{
-	GEN_ASSERT(array != nullptr);
-	ArrayHeader* header = array_get_header(array);
-	GEN_ASSERT(idx < header->Num);
-
-	mem_move(array + idx, array + idx + 1, sizeof(Type) * (header->Num - idx - 1));
-	header->Num--;
-}
-
-template<class Type> inline
-bool array_reserve(Array<Type>* array, usize new_capacity)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(array);
-
-	if (header->Capacity < new_capacity)
-		return set_capacity(array, new_capacity);
-
-	return true;
-}
-
-template<class Type> inline
-bool array_resize(Array<Type>* array, usize num)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(* array);
-
-	if (header->Capacity < num) {
-		if (! array_grow( array, num))
-			return false;
-		header = array_get_header(* array);
-	}
-
-	header->Num = num;
-	return true;
-}
-
-template<class Type> inline
-bool array_set_capacity(Array<Type>* array, usize new_capacity)
-{
-	GEN_ASSERT(  array != nullptr);
-	GEN_ASSERT(* array != nullptr);
-	ArrayHeader* header = array_get_header(* array);
-
-	if (new_capacity == header->Capacity)
-		return true;
-
-	if (new_capacity < header->Num)
-	{
-		header->Num = new_capacity;
-		return true;
-	}
-
-	ssize        size       = sizeof(ArrayHeader) + sizeof(Type) * new_capacity;
-	ArrayHeader* new_header = rcast(ArrayHeader*, alloc(header->Allocator, size));
-
-	if (new_header == nullptr)
-		return false;
-
-	mem_move(new_header, header, sizeof(ArrayHeader) + sizeof(Type) * header->Num);
-
-	new_header->Capacity = new_capacity;
-
-	allocator_free(header->Allocator, header);
-
-	Type** Data = (Type**)array;
-	* Data = rcast(Type*, new_header + 1);
-	return true;
-}
-
-// These are intended for use in the base library of gencpp and the C-variant of the library
-// It provides a interoperability between the C++ and C implementation of arrays. (not letting these do any crazy substiution though)
-// They are undefined in gen.hpp and gen.cpp at the end of the files.
-// The cpp library expects the user to use the regular calls as they can resolve the type fine.
-
-#define array_init(type, allocator)                        array_init           <type>                               (allocator )
-#define array_init_reserve(type, allocator, cap)           array_init_reserve   <type>                               (allocator, cap)
-#define array_append_array(array, other)                   array_append_array   < get_array_underlying_type(array) > (& array, other )
-#define array_append(array, value)                         array_append         < get_array_underlying_type(array) > (& array, value )
-#define array_append_items(array, items, item_num)         array_append_items   < get_array_underlying_type(array) > (& array, items, item_num )
-#define array_append_at(array, item, idx )                 array_append_at      < get_array_underlying_type(array) > (& array, item, idx )
-#define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
-#define array_back(array)                                  array_back           < get_array_underlying_type(array) > (array )
-#define array_clear(array)                                 array_clear          < get_array_underlying_type(array) > (array )
-#define array_fill(array, begin, end, value)               array_fill           < get_array_underlying_type(array) > (array, begin, end, value )
-#define array_free(array)                                  array_free           < get_array_underlying_type(array) > (& array )
-#define arary_grow(array, min_capacity)                    arary_grow           < get_array_underlying_type(array) > (& array, min_capacity)
-#define array_num(array)                                   array_num            < get_array_underlying_type(array) > (array )
-#define arary_pop(array)                                   arary_pop            < get_array_underlying_type(array) > (array )
-#define arary_remove_at(array, idx)                        arary_remove_at      < get_array_underlying_type(array) > (idx)
-#define arary_reserve(array, new_capacity)                 arary_reserve        < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_resize(array, num)                           arary_resize         < get_array_underlying_type(array) > (& array, num)
-#define arary_set_capacity(new_capacity)                   arary_set_capacity   < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_get_header(array)                            arary_get_header     < get_array_underlying_type(array) > (array )
-
-#pragma endregion Array
-
-#pragma region HashTable
-#define HashTable(Type) HashTable<Type>
-
-template<class Type> struct HashTable;
-
-#ifndef get_hashtable_underlying_type
-#define get_hashtable_underlying_type(table) typename TRemovePtr<typeof(table)>:: DataType
-#endif
-
-struct HashTableFindResult {
-	ssize HashIndex;
-	ssize PrevIndex;
-	ssize EntryIndex;
-};
-
-template<class Type>
-struct HashTableEntry {
-	u64   Key;
-	ssize Next;
-	Type  Value;
-};
-
-#define HashTableEntry(Type) HashTableEntry<Type>
-
-template<class Type> HashTable<Type>       hashtable_init        (AllocatorInfo allocator);
-template<class Type> HashTable<Type>       hashtable_init_reserve(AllocatorInfo allocator, usize num);
-template<class Type> void                  hashtable_clear       (HashTable<Type>  table);
-template<class Type> void                  hashtable_destroy     (HashTable<Type>* table);
-template<class Type> Type*                 hashtable_get         (HashTable<Type>  table, u64 key);
-template<class Type> void                  hashtable_grow        (HashTable<Type>* table);
-template<class Type> void                  hashtable_rehash      (HashTable<Type>* table, ssize new_num);
-template<class Type> void                  hashtable_rehash_fast (HashTable<Type>  table);
-template<class Type> void                  hashtable_remove      (HashTable<Type>  table, u64 key);
-template<class Type> void                  hashtable_remove_entry(HashTable<Type>  table, ssize idx);
-template<class Type> void                  hashtable_set         (HashTable<Type>* table, u64 key, Type value);
-template<class Type> ssize                 hashtable_slot        (HashTable<Type>  table, u64 key);
-template<class Type> void                  hashtable_map         (HashTable<Type>  table, void (*map_proc)(u64 key, Type value));
-template<class Type> void                  hashtable_map_mut     (HashTable<Type>  table, void (*map_proc)(u64 key, Type* value));
-
-template<class Type> ssize                 hashtable__add_entry  (HashTable<Type>* table, u64 key);
-template<class Type> HashTableFindResult   hashtable__find       (HashTable<Type>  table, u64 key);
-template<class Type> bool                  hashtable__full       (HashTable<Type>  table);
-
-static constexpr f32 HashTable_CriticalLoadScale = 0.7f;
-
-template<typename Type>
-struct HashTable
-{
-	Array<ssize>                Hashes;
-	Array<HashTableEntry<Type>> Entries;
-
-#if ! GEN_C_LIKE_CPP
-#pragma region Member Mapping
-	forceinline static HashTable init(AllocatorInfo allocator)                    { return	hashtable_init<Type>(allocator); }
-	forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return	hashtable_init_reserve<Type>(allocator, num); }
-
-	forceinline void  clear()                           {        clear<Type>(*this); }
-	forceinline void  destroy()                         {        destroy<Type>(*this); }
-	forceinline Type* get(u64 key)                      { return get<Type>(*this, key); }
-	forceinline void  grow()                            {        grow<Type>(*this); }
-	forceinline void  rehash(ssize new_num)             {        rehash<Type>(*this, new_num); }
-	forceinline void  rehash_fast()                     {        rehash_fast<Type>(*this); }
-	forceinline void  remove(u64 key)                   {        remove<Type>(*this, key); }
-	forceinline void  remove_entry(ssize idx)           {        remove_entry<Type>(*this, idx); }
-	forceinline void  set(u64 key, Type value)          {        set<Type>(*this, key, value); }
-	forceinline ssize slot(u64 key)                     { return slot<Type>(*this, key); }
-	forceinline void  map(void (*proc)(u64, Type))      {        map<Type>(*this, proc); }
-	forceinline void  map_mut(void (*proc)(u64, Type*)) {        map_mut<Type>(*this, proc); }
-#pragma endregion Member Mapping
-#endif
-
-	using DataType = Type;
-};
-
-#if GEN_SUPPORT_CPP_REFERENCES
-template<class Type> void  destroy  (HashTable<Type>& table)                      { destroy(& table); }
-template<class Type> void  grow     (HashTable<Type>& table)                      { grow(& table); }
-template<class Type> void  rehash   (HashTable<Type>& table, ssize new_num)       { rehash(& table, new_num); }
-template<class Type> void  set      (HashTable<Type>& table, u64 key, Type value) { set(& table, key, value); }
-template<class Type> ssize add_entry(HashTable<Type>& table, u64 key)             { add_entry(& table, key); }
-#endif
-
-template<typename Type> inline
-HashTable<Type> hashtable_init(AllocatorInfo allocator) {
-	HashTable<Type> result = hashtable_init_reserve<Type>(allocator, 8);
-	return result;
-}
-
-template<typename Type> inline
-HashTable<Type> hashtable_init_reserve(AllocatorInfo allocator, usize num)
-{
-	HashTable<Type> result = { { nullptr }, { nullptr } };
-
-	result.Hashes = array_init_reserve<ssize>(allocator, num);
-	array_get_header(result.Hashes)->Num = num;
-	array_resize(& result.Hashes, num);
-	array_fill(result.Hashes, 0, num, (ssize)-1);
-
-	result.Entries = array_init_reserve<HashTableEntry<Type>>(allocator, num);
-	return result;
-}
-
-template<typename Type> forceinline
-void hashtable_clear(HashTable<Type> table) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	array_clear(table.Entries);
-	array_fill(table.Hashes, 0, array_num(table.Hashes), (ssize)-1);
-}
-
-template<typename Type> forceinline
-void hashtable_destroy(HashTable<Type>* table) {
-	GEN_ASSERT_NOT_NULL(table->Hashes);
-	GEN_ASSERT_NOT_NULL(table->Entries);
-	if (table->Hashes && array_get_header(table->Hashes)->Capacity) {
-		array_free(table->Hashes);
-		array_free(table->Entries);
-	}
-}
-
-template<typename Type> forceinline
-Type* hashtable_get(HashTable<Type> table, u64 key) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	ssize idx = hashtable__find(table, key).EntryIndex;
-	if (idx >= 0)
-		return & table.Entries[idx].Value;
-
-	return nullptr;
-}
-
-template<typename Type> forceinline
-void hashtable_map(HashTable<Type> table, void (*map_proc)(u64 key, Type value)) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	GEN_ASSERT_NOT_NULL(map_proc);
-
-	for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
-		map_proc(table.Entries[idx].Key, table.Entries[idx].Value);
-	}
-}
-
-template<typename Type> forceinline
-void hashtable_map_mut(HashTable<Type> table, void (*map_proc)(u64 key, Type* value)) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	GEN_ASSERT_NOT_NULL(map_proc);
-
-	for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
-		map_proc(table.Entries[idx].Key, & table.Entries[idx].Value);
-	}
-}
-
-template<typename Type> forceinline
-void hashtable_grow(HashTable<Type>* table) {
-	GEN_ASSERT_NOT_NULL(table);
-	GEN_ASSERT_NOT_NULL(table->Hashes);
-	GEN_ASSERT_NOT_NULL(table->Entries);
-	ssize new_num = array_grow_formula( array_num(table->Entries));
-	hashtable_rehash(table, new_num);
-}
-
-template<typename Type> inline
-void hashtable_rehash(HashTable<Type>* table, ssize new_num)
-{
-	GEN_ASSERT_NOT_NULL(table);
-	GEN_ASSERT_NOT_NULL(table->Hashes);
-	GEN_ASSERT_NOT_NULL(table->Entries);
-	ssize last_added_index;
-	HashTable<Type> new_ht = hashtable_init_reserve<Type>( array_get_header(table->Hashes)->Allocator, new_num);
-
-	for (ssize idx = 0; idx < ssize( array_num(table->Entries)); ++idx)
-	{
-		HashTableFindResult find_result;
-		HashTableEntry<Type>& entry = table->Entries[idx];
-
-		find_result = hashtable__find(new_ht, entry.Key);
-		last_added_index = hashtable__add_entry(& new_ht, entry.Key);
-
-		if (find_result.PrevIndex < 0)
-			new_ht.Hashes[find_result.HashIndex] = last_added_index;
-		else
-			new_ht.Entries[find_result.PrevIndex].Next = last_added_index;
-
-		new_ht.Entries[last_added_index].Next = find_result.EntryIndex;
-		new_ht.Entries[last_added_index].Value = entry.Value;
-	}
-
-	hashtable_destroy(table);
-	* table = new_ht;
-}
-
-template<typename Type> inline
-void hashtable_rehash_fast(HashTable<Type> table)
-{
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	ssize idx;
-
-	for (idx = 0; idx < ssize(num(table.Entries)); idx++)
-		table.Entries[idx].Next = -1;
-
-	for (idx = 0; idx < ssize(num(table.Hashes)); idx++)
-		table.Hashes[idx] = -1;
-
-	for (idx = 0; idx < ssize(num(table.Entries)); idx++)
-	{
-		HashTableEntry<Type>* entry;
-		HashTableFindResult find_result;
-
-		entry = &table.Entries[idx];
-		find_result = find(table, entry->Key);
-
-		if (find_result.PrevIndex < 0)
-			table.Hashes[find_result.HashIndex] = idx;
-		else
-			table.Entries[find_result.PrevIndex].Next = idx;
-	}
-}
-
-template<typename Type> forceinline
-void hashtable_remove(HashTable<Type> table, u64 key) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	HashTableFindResult find_result = find(table, key);
-
-	if (find_result.EntryIndex >= 0) {
-		remove_at(table.Entries, find_result.EntryIndex);
-		rehash_fast(table);
-	}
-}
-
-template<typename Type> forceinline
-void hashtable_remove_entry(HashTable<Type> table, ssize idx) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	remove_at(table.Entries, idx);
-}
-
-template<typename Type> inline
-void hashtable_set(HashTable<Type>* table, u64 key, Type value)
-{
-	GEN_ASSERT_NOT_NULL(table);
-	GEN_ASSERT_NOT_NULL(table->Hashes);
-	GEN_ASSERT_NOT_NULL(table->Entries);
-	ssize idx;
-	HashTableFindResult find_result;
-
-	if (hashtable_full(* table))
-		hashtable_grow(table);
-
-	find_result = hashtable__find(* table, key);
-	if (find_result.EntryIndex >= 0) {
-		idx = find_result.EntryIndex;
-	}
-	else
-	{
-		idx = hashtable__add_entry(table, key);
-
-		if (find_result.PrevIndex >= 0) {
-			table->Entries[find_result.PrevIndex].Next = idx;
-		}
-		else {
-			table->Hashes[find_result.HashIndex] = idx;
-		}
-	}
-
-	table->Entries[idx].Value = value;
-
-	if (hashtable_full(* table))
-		hashtable_grow(table);
-}
-
-template<typename Type> forceinline
-ssize hashtable_slot(HashTable<Type> table, u64 key) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	for (ssize idx = 0; idx < ssize(num(table.Hashes)); ++idx)
-		if (table.Hashes[idx] == key)
-			return idx;
-
-	return -1;
-}
-
-template<typename Type> forceinline
-ssize hashtable__add_entry(HashTable<Type>* table, u64 key) {
-	GEN_ASSERT_NOT_NULL(table);
-	GEN_ASSERT_NOT_NULL(table->Hashes);
-	GEN_ASSERT_NOT_NULL(table->Entries);
-	ssize idx;
-	HashTableEntry<Type> entry = { key, -1 };
-
-	idx = array_num(table->Entries);
-	array_append( table->Entries, entry);
-	return idx;
-}
-
-template<typename Type> inline
-HashTableFindResult hashtable__find(HashTable<Type> table, u64 key)
-{
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	HashTableFindResult result = { -1, -1, -1 };
-
-	if (array_num(table.Hashes) > 0)
-	{
-		result.HashIndex = key % array_num(table.Hashes);
-		result.EntryIndex = table.Hashes[result.HashIndex];
-
-		while (result.EntryIndex >= 0)
-		{
-			if (table.Entries[result.EntryIndex].Key == key)
-				break;
-
-			result.PrevIndex  = result.EntryIndex;
-			result.EntryIndex = table.Entries[result.EntryIndex].Next;
-		}
-	}
-
-	return result;
-}
-
-template<typename Type> forceinline
-b32 hashtable_full(HashTable<Type> table) {
-	GEN_ASSERT_NOT_NULL(table.Hashes);
-	GEN_ASSERT_NOT_NULL(table.Entries);
-	usize critical_load = usize(HashTable_CriticalLoadScale * f32(array_num(table.Hashes)));
-	b32 result = array_num(table.Entries) > critical_load;
-	return result;
-}
-
-#define hashtable_init(type, allocator)              hashtable_init        <type              >(allocator)
-#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type              >(allocator, num)
-#define hashtable_clear(table)                       hashtable_clear       < get_hashtable_underlying_type(table) >(table)
-#define hashtable_destroy(table)                     hashtable_destroy     < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_get(table, key)                    hashtable_get         < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_grow(table)                        hashtable_grow        < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_rehash(table, new_num)             hashtable_rehash      < get_hashtable_underlying_type(table) >(& table, new_num)
-#define hashtable_rehash_fast(table)                 hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
-#define hashtable_remove(table, key)                 hashtable_remove      < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_remove_entry(table, idx)           hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
-#define hashtable_set(table, key, value)             hashtable_set         < get_hashtable_underlying_type(table) >(& table, key, value)
-#define hashtable_slot(table, key)                   hashtable_slot        < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_map(table, map_proc)               hashtable_map         < get_hashtable_underlying_type(table) >(table, map_proc)
-#define hashtable_map_mut(table, map_proc)           hashtable_map_mut     < get_hashtable_underlying_type(table) >(table, map_proc)
-
-//#define hashtable_add_entry(table, key)              hashtable_add_entry   < get_hashtable_underlying_type(table) >(& table, key)
-//#define hashtable_find(table, key)                   hashtable_find        < get_hashtable_underlying_type(table) >(table, key)
-//#define hashtable_full(table)                        hashtable_full        < get_hashtable_underlying_type(table) >(table)
-
-#pragma endregion HashTable
-
-#pragma endregion Containers

base/dependencies/hashing.hpp

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

base/dependencies/macros.hpp

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

base/dependencies/memory.hpp

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

base/dependencies/printing.hpp

@@ -1,42 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "strbuilder_ops.hpp"
-#endif
-
-#pragma region Printing
-
-typedef struct FileInfo FileInfo;
-
-#ifndef GEN_PRINTF_MAXLEN
-#	define GEN_PRINTF_MAXLEN kilobytes(128)
-#endif
-typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN];
-
-// NOTE: A locally persisting buffer is used internally
-GEN_API char*  c_str_fmt_buf       ( char const* fmt, ... );
-GEN_API char*  c_str_fmt_buf_va    ( char const* fmt, va_list va );
-GEN_API ssize  c_str_fmt           ( char* str, ssize n, char const* fmt, ... );
-GEN_API ssize  c_str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
-GEN_API ssize  c_str_fmt_out_va    ( char const* fmt, va_list va );
-GEN_API ssize  c_str_fmt_out_err   ( char const* fmt, ... );
-GEN_API ssize  c_str_fmt_out_err_va( char const* fmt, va_list va );
-GEN_API ssize  c_str_fmt_file      ( FileInfo* f, char const* fmt, ... );
-GEN_API ssize  c_str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
-
-constexpr
-char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
-
-inline
-ssize log_fmt(char const* fmt, ...)
-{
-	ssize res;
-	va_list va;
-
-	va_start(va, fmt);
-	res = c_str_fmt_out_va(fmt, va);
-	va_end(va);
-
-	return res;
-}
-
-#pragma endregion Printing

base/dependencies/string_ops.hpp

@@ -1,287 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "memory.hpp"
-#endif
-
-#pragma region String Ops
-
-const char* char_first_occurence( const char* str, char c );
-
-b32   char_is_alpha( char c );
-b32   char_is_alphanumeric( char c );
-b32   char_is_digit( char c );
-b32   char_is_hex_digit( char c );
-b32   char_is_space( char c );
-char  char_to_lower( char c );
-char  char_to_upper( char c );
-
-s32  digit_to_int( char c );
-s32  hex_digit_to_int( char c );
-
-s32         c_str_compare( const char* s1, const char* s2 );
-s32         c_str_compare_len( const char* s1, const char* s2, ssize len );
-char*       c_str_copy( char* dest, const char* source, ssize len );
-ssize       c_str_copy_nulpad( char* dest, const char* source, ssize len );
-ssize       c_str_len( const char* str );
-ssize       c_str_len_capped( const char* str, ssize max_len );
-char*       c_str_reverse( char* str );    // NOTE: ASCII only
-char const* c_str_skip( char const* str, char c );
-char const* c_str_skip_any( char const* str, char const* char_list );
-char const* c_str_trim( char const* str, b32 catch_newline );
-
-// NOTE: ASCII only
-void c_str_to_lower( char* str );
-void c_str_to_upper( char* str );
-
-GEN_API s64  c_str_to_i64( const char* str, char** end_ptr, s32 base );
-GEN_API void i64_to_str( s64 value, char* string, s32 base );
-GEN_API void u64_to_str( u64 value, char* string, s32 base );
-GEN_API f64  c_str_to_f64( const char* str, char** end_ptr );
-
-inline
-const char* char_first_occurence( const char* s, char c )
-{
-	char ch = c;
-	for ( ; *s != ch; s++ )
-	{
-		if ( *s == '\0' )
-			return NULL;
-	}
-	return s;
-}
-
-inline
-b32 char_is_alpha( char c )
-{
-	if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
-		return true;
-	return false;
-}
-
-inline
-b32 char_is_alphanumeric( char c )
-{
-	return char_is_alpha( c ) || char_is_digit( c );
-}
-
-inline
-b32 char_is_digit( char c )
-{
-	if ( c >= '0' && c <= '9' )
-		return true;
-	return false;
-}
-
-inline
-b32 char_is_hex_digit( char c )
-{
-	if ( char_is_digit( c ) || ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) )
-		return true;
-	return false;
-}
-
-inline
-b32 char_is_space( char c )
-{
-	if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
-		return true;
-	return false;
-}
-
-inline
-char char_to_lower( char c )
-{
-	if ( c >= 'A' && c <= 'Z' )
-		return 'a' + ( c - 'A' );
-	return c;
-}
-
-inline char char_to_upper( char c )
-{
-	if ( c >= 'a' && c <= 'z' )
-		return 'A' + ( c - 'a' );
-	return c;
-}
-
-inline
-s32 digit_to_int( char c )
-{
-	return char_is_digit( c ) ? c - '0' : c - 'W';
-}
-
-inline
-s32 hex_digit_to_int( char c )
-{
-	if ( char_is_digit( c ) )
-		return digit_to_int( c );
-	else if ( is_between( c, 'a', 'f' ) )
-		return c - 'a' + 10;
-	else if ( is_between( c, 'A', 'F' ) )
-		return c - 'A' + 10;
-	return -1;
-}
-
-inline
-s32 c_str_compare( const char* s1, const char* s2 )
-{
-	while ( *s1 && ( *s1 == *s2 ) )
-	{
-		s1++, s2++;
-	}
-	return *( u8* )s1 - *( u8* )s2;
-}
-
-inline
-s32 c_str_compare_len( const char* s1, const char* s2, ssize len )
-{
-	for ( ; len > 0; s1++, s2++, len-- )
-	{
-		if ( *s1 != *s2 )
-			return ( ( s1 < s2 ) ? -1 : +1 );
-		else if ( *s1 == '\0' )
-			return 0;
-	}
-	return 0;
-}
-
-inline
-char* c_str_copy( char* dest, const char* source, ssize len )
-{
-	GEN_ASSERT_NOT_NULL( dest );
-	if ( source )
-	{
-		char* str = dest;
-		while ( len > 0 && *source )
-		{
-			*str++ = *source++;
-			len--;
-		}
-		while ( len > 0 )
-		{
-			*str++ = '\0';
-			len--;
-		}
-	}
-	return dest;
-}
-
-inline
-ssize c_str_copy_nulpad( char* dest, const char* source, ssize len )
-{
-	ssize result = 0;
-	GEN_ASSERT_NOT_NULL( dest );
-	if ( source )
-	{
-		const char* source_start = source;
-		char*       str          = dest;
-		while ( len > 0 && *source )
-		{
-			*str++ = *source++;
-			len--;
-		}
-		while ( len > 0 )
-		{
-			*str++ = '\0';
-			len--;
-		}
-
-		result = source - source_start;
-	}
-	return result;
-}
-
-inline
-ssize c_str_len( const char* str )
-{
-	if ( str == NULL )
-	{
-		return 0;
-	}
-	const char* p = str;
-	while ( *str )
-		str++;
-	return str - p;
-}
-
-inline
-ssize c_str_len_capped( const char* str, ssize max_len )
-{
-	const char* end = rcast(const char*, mem_find( str, 0, max_len ));
-	if ( end )
-		return end - str;
-	return max_len;
-}
-
-inline
-char* c_str_reverse( char* str )
-{
-	ssize    len  = c_str_len( str );
-	char* a    = str + 0;
-	char* b    = str + len - 1;
-	len       /= 2;
-	while ( len-- )
-	{
-		swap( *a, *b );
-		a++, b--;
-	}
-	return str;
-}
-
-inline
-char const* c_str_skip( char const* str, char c )
-{
-	while ( *str && *str != c )
-	{
-		++str;
-	}
-	return str;
-}
-
-inline
-char const* c_str_skip_any( char const* str, char const* char_list )
-{
-	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), c_str_len( str ) ));
-	ssize       char_list_count = c_str_len( char_list );
-	for ( ssize i = 0; i < char_list_count; i++ )
-	{
-		char const* p = c_str_skip( str, char_list[ i ] );
-		closest_ptr   = min( closest_ptr, p );
-	}
-	return closest_ptr;
-}
-
-inline
-char const* c_str_trim( char const* str, b32 catch_newline )
-{
-	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
-	{
-		++str;
-	}
-	return str;
-}
-
-inline
-void c_str_to_lower( char* str )
-{
-	if ( ! str )
-		return;
-	while ( *str )
-	{
-		*str = char_to_lower( *str );
-		str++;
-	}
-}
-
-inline
-void c_str_to_upper( char* str )
-{
-	if ( ! str )
-		return;
-	while ( *str )
-	{
-		*str = char_to_upper( *str );
-		str++;
-	}
-}
-
-#pragma endregion String Ops

base/dependencies/strings.cpp

@@ -1,177 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "hashing.cpp"
-#endif
-
-#pragma region StrBuilder
-
-StrBuilder strbuilder_make_length( AllocatorInfo allocator, char const* str, ssize length )
-{
-	ssize const header_size = sizeof( StrBuilderHeader );
-
-	s32   alloc_size = header_size + length + 1;
-	void* allocation = alloc( allocator, alloc_size );
-
-	if ( allocation == nullptr ) {
-		StrBuilder null_string = {nullptr};
-		return null_string;
-	}
-
-	StrBuilderHeader*
-	header = rcast(StrBuilderHeader*, allocation);
-	header->Allocator = allocator;
-	header->Capacity  = length;
-	header->Length    = length;
-
-	StrBuilder  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;
-}
-
-StrBuilder strbuilder_make_reserve( AllocatorInfo allocator, ssize capacity )
-{
-	ssize const header_size = sizeof( StrBuilderHeader );
-
-	s32   alloc_size = header_size + capacity + 1;
-	void* allocation = alloc( allocator, alloc_size );
-
-	if ( allocation == nullptr ) {
-		StrBuilder null_string = {nullptr};
-		return null_string;
-	}
-	mem_set( allocation, 0, alloc_size );
-
-	StrBuilderHeader*
-	header            = rcast(StrBuilderHeader*, allocation);
-	header->Allocator = allocator;
-	header->Capacity  = capacity;
-	header->Length    = 0;
-
-	StrBuilder result = { rcast(char*, allocation) + header_size };
-	return result;
-}
-
-bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len)
-{
-	ssize available = strbuilder_avail_space(* str);
-
-	if (available >= add_len) {
-		return true;
-	}
-	else
-	{
-		ssize new_len, old_size, new_size;
-		void* ptr;
-		void* new_ptr;
-
-		AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator;
-		StrBuilderHeader* header    = nullptr;
-
-		new_len  = strbuilder_grow_formula(strbuilder_length(* str) + add_len);
-		ptr      = strbuilder_get_header(* str);
-		old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 1;
-		new_size = size_of(StrBuilderHeader) + new_len + 1;
-
-		new_ptr = resize(allocator, ptr, old_size, new_size);
-
-		if (new_ptr == nullptr)
-			return false;
-
-		header = rcast(StrBuilderHeader*, new_ptr);
-		header->Allocator = allocator;
-		header->Capacity  = new_len;
-
-		char** Data = rcast(char**, str);
-		* Data = rcast(char*, header + 1);
-
-		return true;
-	}
-}
-
-bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length)
-{
-	GEN_ASSERT(str != nullptr);
-	if ( rcast(sptr, c_str_to_append) > 0)
-	{
-		ssize curr_len = strbuilder_length(* str);
-
-		if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length))
-			return false;
-
-		StrBuilderHeader* header = strbuilder_get_header(* str);
-
-		char* Data = * str;
-		mem_copy( Data + curr_len, c_str_to_append, append_length);
-
-		Data[curr_len + append_length] = '\0';
-
-		header->Length = curr_len + append_length;
-	}
-	return c_str_to_append != nullptr;
-}
-
-void strbuilder_trim(StrBuilder str, char const* cut_set)
-{
-	ssize len = 0;
-
-	char* start_pos = str;
-	char* end_pos   = scast(char*, str) + strbuilder_length(str) - 1;
-
-	while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos))
-	start_pos++;
-
-	while (end_pos > start_pos && char_first_occurence(cut_set, *end_pos))
-	end_pos--;
-
-	len = scast(ssize, (start_pos > end_pos) ? 0 : ((end_pos - start_pos) + 1));
-
-	if (str != start_pos)
-		mem_move(str, start_pos, len);
-
-	str[len] = '\0';
-
-	strbuilder_get_header(str)->Length = len;
-}
-
-StrBuilder strbuilder_visualize_whitespace(StrBuilder const str)
-{
-	StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader));
-	StrBuilder        result = strbuilder_make_reserve(header->Allocator, strbuilder_length(str) * 2); // Assume worst case for space requirements.
-
-	for (char const* c = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c))
-	switch ( * c )
-	{
-		case ' ':
-			strbuilder_append_str(& result, txt("·"));
-		break;
-		case '\t':
-			strbuilder_append_str(& result, txt("→"));
-		break;
-		case '\n':
-			strbuilder_append_str(& result, txt("↵"));
-		break;
-		case '\r':
-			strbuilder_append_str(& result, txt("⏎"));
-		break;
-		case '\v':
-			strbuilder_append_str(& result, txt("⇕"));
-		break;
-		case '\f':
-			strbuilder_append_str(& result, txt("⌂"));
-		break;
-		default:
-			strbuilder_append_char(& result, * c);
-		break;
-	}
-
-	return result;
-}
-
-#pragma endregion StrBuilder

base/dependencies/strings.hpp

@@ -1,627 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "hashing.hpp"
-#endif
-
-#pragma region Strings
-
-struct Str;
-
-Str         to_str_from_c_str       (char const* bad_string);
-bool        str_are_equal           (Str lhs, Str rhs);
-char const* str_back                (Str str);
-bool        str_contains            (Str str, Str substring);
-Str         str_duplicate           (Str str, AllocatorInfo allocator);
-b32         str_starts_with         (Str str, Str substring);
-Str         str_visualize_whitespace(Str str, AllocatorInfo allocator);
-
-// Constant string with length.
-struct Str
-{
-	char const* Ptr;
-	ssize       Len;
-
-#if GEN_COMPILER_CPP
-	forceinline operator char const* ()               const { return Ptr; }
-	forceinline char const& operator[]( ssize index ) const { return Ptr[index]; }
-
-#if ! GEN_C_LIKE_CPP
-	forceinline bool        is_equal            (Str rhs)                 const { return str_are_equal(* this, rhs); }
-	forceinline char const* back                ()                        const { return str_back(* this); }
-	forceinline bool        contains            (Str substring)           const { return str_contains(* this, substring); }
-	forceinline Str         duplicate           (AllocatorInfo allocator) const { return str_duplicate(* this, allocator); }
-	forceinline b32         starts_with         (Str substring)           const { return str_starts_with(* this, substring); }
-	forceinline Str         visualize_whitespace(AllocatorInfo allocator) const { return str_visualize_whitespace(* this, allocator); }
-#endif
-#endif
-};
-
-#define cast_to_str( str ) * rcast( Str*, (str) - sizeof(ssize) )
-
-#ifndef txt
-#	if GEN_COMPILER_CPP
-#		define txt( text )          GEN_NS Str { ( text ), sizeof( text ) - 1 }
-#	else
-#		define txt( text )         (GEN_NS Str){ ( text ), sizeof( text ) - 1 }
-#	endif
-#endif
-
-GEN_API_C_BEGIN
-forceinline char const* str_begin(Str str)                   { return str.Ptr; }
-forceinline char const* str_end  (Str str)                   { return str.Ptr + str.Len; }
-forceinline char const* str_next (Str str, char const* iter) { return iter + 1; }
-GEN_API_C_END
-
-#if GEN_COMPILER_CPP
-forceinline char const* begin(Str str)                   { return str.Ptr; }
-forceinline char const* end  (Str str)                   { return str.Ptr + str.Len; }
-forceinline char const* next (Str str, char const* iter) { return iter + 1; }
-#endif
-
-inline
-bool str_are_equal(Str lhs, Str rhs)
-{
-	if (lhs.Len != rhs.Len)
-		return false;
-
-	for (ssize idx = 0; idx < lhs.Len; ++idx)
-		if (lhs.Ptr[idx] != rhs.Ptr[idx])
-			return false;
-
-	return true;
-}
-
-inline
-char const* str_back(Str str) {
-	return & str.Ptr[str.Len - 1];
-}
-
-inline
-bool str_contains(Str str, Str substring)
-{
-	if (substring.Len > str.Len)
-		return false;
-
-	ssize main_len = str.Len;
-	ssize sub_len  = substring.Len;
-	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
-	{
-		if (c_str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
-			return true;
-	}
-	return false;
-}
-
-inline
-b32 str_starts_with(Str str, Str substring) {
-	if (substring.Len > str.Len)
-		return false;
-
-	b32 result = c_str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
-		return result;
-}
-
-inline
-Str to_str_from_c_str( char const* bad_str ) {
-	Str result = { bad_str, c_str_len( bad_str ) };
-	return result;
-}
-
-// Dynamic StrBuilder
-// This is directly based off the ZPL string api.
-// They used a header pattern
-// I kept it for simplicty of porting but its not necessary to keep it that way.
-#pragma region StrBuilder
-struct StrBuilderHeader;
-
-#if GEN_COMPILER_C
-typedef char* StrBuilder;
-#else
-struct StrBuilder;
-#endif
-
-forceinline usize strbuilder_grow_formula(usize value);
-
-GEN_API StrBuilder        strbuilder_make_reserve        (AllocatorInfo allocator, ssize        capacity);
-GEN_API StrBuilder        strbuilder_make_length         (AllocatorInfo allocator, char const*  str,   ssize length);
-GEN_API bool              strbuilder_make_space_for      (StrBuilder* str, char const* to_append,       ssize add_len);
-GEN_API bool              strbuilder_append_c_str_len    (StrBuilder* str, char const* c_str_to_append, ssize length);
-GEN_API void              strbuilder_trim                (StrBuilder  str, char const* cut_set);
-GEN_API StrBuilder        strbuilder_visualize_whitespace(StrBuilder const str);
-
-StrBuilder        strbuilder_make_c_str          (AllocatorInfo allocator, char const*  str);
-StrBuilder        strbuilder_make_str            (AllocatorInfo allocator, Str         str);
-StrBuilder        strbuilder_fmt                 (AllocatorInfo allocator, char*        buf,   ssize buf_size,  char const* fmt, ...);
-StrBuilder        strbuilder_fmt_buf             (AllocatorInfo allocator, char const*  fmt, ...);
-StrBuilder        strbuilder_join                (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
-bool              strbuilder_are_equal           (StrBuilder const lhs, StrBuilder const rhs);
-bool              strbuilder_are_equal_str       (StrBuilder const lhs, Str rhs);
-bool              strbuilder_append_char         (StrBuilder*      str, char         c);
-bool              strbuilder_append_c_str        (StrBuilder*      str, char const*  c_str_to_append);
-bool              strbuilder_append_str          (StrBuilder*      str, Str         c_str_to_append);
-bool              strbuilder_append_string       (StrBuilder*      str, StrBuilder const other);
-bool              strbuilder_append_fmt          (StrBuilder*      str, char const*  fmt, ...);
-ssize             strbuilder_avail_space         (StrBuilder const str);
-char*             strbuilder_back                (StrBuilder       str);
-bool              strbuilder_contains_str        (StrBuilder const str, Str         substring);
-bool              strbuilder_contains_string     (StrBuilder const str, StrBuilder const substring);
-ssize             strbuilder_capacity            (StrBuilder const str);
-void              strbuilder_clear               (StrBuilder       str);
-StrBuilder        strbuilder_duplicate           (StrBuilder const str, AllocatorInfo allocator);
-void              strbuilder_free                (StrBuilder*      str);
-StrBuilderHeader* strbuilder_get_header          (StrBuilder       str);
-ssize             strbuilder_length              (StrBuilder const str);
-b32               strbuilder_starts_with_str     (StrBuilder const str, Str   substring);
-b32               strbuilder_starts_with_string  (StrBuilder const str, StrBuilder substring);
-void              strbuilder_skip_line           (StrBuilder       str);
-void              strbuilder_strip_space         (StrBuilder       str);
-Str               strbuilder_to_str              (StrBuilder       str);
-void              strbuilder_trim_space          (StrBuilder       str);
-
-struct StrBuilderHeader {
-	AllocatorInfo Allocator;
-	ssize         Capacity;
-	ssize         Length;
-};
-
-#if GEN_COMPILER_CPP
-struct StrBuilder
-{
-	char* Data;
-
-	forceinline operator char*()             { return Data; }
-	forceinline operator char const*() const { return Data; }
-	forceinline operator Str()         const { return { Data, strbuilder_length(* this) }; }
-
-	StrBuilder const& operator=(StrBuilder const& other) const {
-		if (this == &other)
-			return *this;
-
-		StrBuilder* this_ = ccast(StrBuilder*, this);
-		this_->Data = other.Data;
-
-		return *this;
-	}
-
-	forceinline char&       operator[](ssize index)       { return Data[index]; }
-	forceinline char const& operator[](ssize index) const { return Data[index]; }
-
-	       forceinline bool operator==(std::nullptr_t) const                 { return     Data == nullptr; }
-	       forceinline bool operator!=(std::nullptr_t) const                 { return     Data != nullptr; }
-	friend forceinline bool operator==(std::nullptr_t, const StrBuilder str) { return str.Data == nullptr; }
-	friend forceinline bool operator!=(std::nullptr_t, const StrBuilder str) { return str.Data != nullptr; }
-
-#if ! GEN_C_LIKE_CPP
-	forceinline char* begin() const { return Data; }
-	forceinline char* end()   const { return Data + strbuilder_length(* this); }
-
-#pragma region Member Mapping
-	forceinline static StrBuilder make(AllocatorInfo allocator, char const* str)                { return strbuilder_make_c_str(allocator, str); }
-	forceinline static StrBuilder make(AllocatorInfo allocator, Str str)                        { return strbuilder_make_str(allocator, str); }
-	forceinline static StrBuilder make_reserve(AllocatorInfo allocator, ssize cap)              { return strbuilder_make_reserve(allocator, cap); }
-	forceinline static StrBuilder make_length(AllocatorInfo a, char const* s, ssize l)          { return strbuilder_make_length(a, s, l); }
-	forceinline static StrBuilder join(AllocatorInfo a, char const** p, ssize n, char const* g) { return strbuilder_join(a, p, n, g); }
-	forceinline static usize      grow_formula(usize value)                                     { return strbuilder_grow_formula(value); }
-
-	static
-	StrBuilder fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
-		va_list va;
-		va_start(va, fmt);
-		ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
-		va_end(va);
-		return strbuilder_make_length(allocator, buf, res);
-	}
-
-	static
-	StrBuilder fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
-		local_persist thread_local
-		char buf[GEN_PRINTF_MAXLEN] = { 0 };
-		va_list va;
-		va_start(va, fmt);
-		ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
-		va_end(va);
-		return strbuilder_make_length(allocator, buf, res);
-	}
-
-	forceinline bool              make_space_for(char const* str, ssize add_len) { return strbuilder_make_space_for(this, str, add_len); }
-	forceinline bool              append(char c)                                 { return strbuilder_append_char(this, c); }
-	forceinline bool              append(char const* str)                        { return strbuilder_append_c_str(this, str); }
-	forceinline bool              append(char const* str, ssize length)          { return strbuilder_append_c_str_len(this, str, length); }
-	forceinline bool              append(Str str)                                { return strbuilder_append_str(this, str); }
-	forceinline bool              append(const StrBuilder other)                 { return strbuilder_append_string(this, other); }
-	forceinline ssize             avail_space() const                            { return strbuilder_avail_space(* this); }
-	forceinline char*             back()                                         { return strbuilder_back(* this); }
-	forceinline bool              contains(Str substring) const                  { return strbuilder_contains_str(* this, substring); }
-	forceinline bool              contains(StrBuilder const& substring) const    { return strbuilder_contains_string(* this, substring); }
-	forceinline ssize             capacity() const                               { return strbuilder_capacity(* this); }
-	forceinline void              clear()                                        {        strbuilder_clear(* this); }
-	forceinline StrBuilder        duplicate(AllocatorInfo allocator) const       { return strbuilder_duplicate(* this, allocator); }
-	forceinline void              free()                                         {        strbuilder_free(this); }
-	forceinline bool              is_equal(StrBuilder const& other) const        { return strbuilder_are_equal(* this, other); }
-	forceinline bool              is_equal(Str other) const                      { return strbuilder_are_equal_str(* this, other); }
-	forceinline ssize             length() const                                 { return strbuilder_length(* this); }
-	forceinline b32               starts_with(Str substring) const               { return strbuilder_starts_with_str(* this, substring); }
-	forceinline b32               starts_with(StrBuilder substring) const        { return strbuilder_starts_with_string(* this, substring); }
-	forceinline void              skip_line()                                    {        strbuilder_skip_line(* this); }
-	forceinline void              strip_space()                                  {        strbuilder_strip_space(* this); }
-	forceinline Str               to_str()                                       { return { Data, strbuilder_length(*this) }; }
-	forceinline void              trim(char const* cut_set)                      {        strbuilder_trim(* this, cut_set); }
-	forceinline void              trim_space()                                   {        strbuilder_trim_space(* this); }
-	forceinline StrBuilder        visualize_whitespace() const                   { return strbuilder_visualize_whitespace(* this); }
-	forceinline StrBuilderHeader& get_header()                                   { return * strbuilder_get_header(* this); }
-
-	bool append_fmt(char const* fmt, ...) {
-		ssize res;
-		char buf[GEN_PRINTF_MAXLEN] = { 0 };
-
-		va_list va;
-		va_start(va, fmt);
-		res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
-		va_end(va);
-
-		return strbuilder_append_c_str_len(this, buf, res);
-	}
-#pragma endregion Member Mapping
-#endif
-};
-#endif
-
-forceinline char* strbuilder_begin(StrBuilder str)                   { return ((char*) str); }
-forceinline char* strbuilder_end  (StrBuilder str)                   { return ((char*) str + strbuilder_length(str)); }
-forceinline char* strbuilder_next (StrBuilder str, char const* iter) { return ((char*) iter + 1); }
-
-#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-forceinline char* begin(StrBuilder str)             { return ((char*) str); }
-forceinline char* end  (StrBuilder str)             { return ((char*) str + strbuilder_length(str)); }
-forceinline char* next (StrBuilder str, char* iter) { return ((char*) iter + 1); }
-#endif
-
-#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
-forceinline bool  make_space_for(StrBuilder& str, char const* to_append, ssize add_len);
-forceinline bool  append(StrBuilder& str, char c);
-forceinline bool  append(StrBuilder& str, char const* c_str_to_append);
-forceinline bool  append(StrBuilder& str, char const* c_str_to_append, ssize length);
-forceinline bool  append(StrBuilder& str, Str c_str_to_append);
-forceinline bool  append(StrBuilder& str, const StrBuilder other);
-forceinline bool  append_fmt(StrBuilder& str, char const* fmt, ...);
-forceinline char& back(StrBuilder& str);
-forceinline void  clear(StrBuilder& str);
-forceinline void  free(StrBuilder& str);
-#endif
-
-forceinline
-usize strbuilder_grow_formula(usize value) {
-	// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
-	return 4 * value + 8;
-}
-
-forceinline
-StrBuilder strbuilder_make_c_str(AllocatorInfo allocator, char const* str) {
-	ssize length = str ? c_str_len(str) : 0;
-	return strbuilder_make_length(allocator, str, length);
-}
-
-forceinline
-StrBuilder strbuilder_make_str(AllocatorInfo allocator, Str str) {
-	return strbuilder_make_length(allocator, str.Ptr, str.Len);
-}
-
-inline
-StrBuilder strbuilder_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
-	va_list va;
-	va_start(va, fmt);
-	ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
-	va_end(va);
-
-	return strbuilder_make_length(allocator, buf, res);
-}
-
-inline
-StrBuilder strbuilder_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
-{
-	local_persist thread_local
-	PrintF_Buffer buf = struct_init(PrintF_Buffer, {0});
-
-	va_list va;
-	va_start(va, fmt);
-	ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
-	va_end(va);
-
-	return strbuilder_make_length(allocator, buf, res);
-}
-
-inline
-StrBuilder strbuilder_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
-{
-	StrBuilder result = strbuilder_make_c_str(allocator, "");
-
-	for (ssize idx = 0; idx < num_parts; ++idx)
-	{
-		strbuilder_append_c_str(& result, parts[idx]);
-
-		if (idx < num_parts - 1)
-			strbuilder_append_c_str(& result, glue);
-	}
-
-	return result;
-}
-
-forceinline
-bool strbuilder_append_char(StrBuilder* str, char c) {
-	GEN_ASSERT(str != nullptr);
-	return strbuilder_append_c_str_len( str, (char const*)& c, (ssize)1);
-}
-
-forceinline
-bool strbuilder_append_c_str(StrBuilder* str, char const* c_str_to_append) {
-	GEN_ASSERT(str != nullptr);
-	return strbuilder_append_c_str_len(str, c_str_to_append, c_str_len(c_str_to_append));
-}
-
-forceinline
-bool strbuilder_append_str(StrBuilder* str, Str c_str_to_append) {
-	GEN_ASSERT(str != nullptr);
-	return strbuilder_append_c_str_len(str, c_str_to_append.Ptr, c_str_to_append.Len);
-}
-
-forceinline
-bool strbuilder_append_string(StrBuilder* str, StrBuilder const other) {
-	GEN_ASSERT(str != nullptr);
-	return strbuilder_append_c_str_len(str, (char const*)other, strbuilder_length(other));
-}
-
-inline
-bool strbuilder_append_fmt(StrBuilder* str, char const* fmt, ...) {
-	GEN_ASSERT(str != nullptr);
-	ssize res;
-	char buf[GEN_PRINTF_MAXLEN] = { 0 };
-
-	va_list va;
-	va_start(va, fmt);
-	res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
-	va_end(va);
-
-	return strbuilder_append_c_str_len(str, (char const*)buf, res);
-}
-
-inline
-bool strbuilder_are_equal_string(StrBuilder const lhs, StrBuilder const rhs)
-{
-	if (strbuilder_length(lhs) != strbuilder_length(rhs))
-		return false;
-
-	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
-		if (lhs[idx] != rhs[idx])
-			return false;
-
-	return true;
-}
-
-inline
-bool strbuilder_are_equal_str(StrBuilder const lhs, Str rhs)
-{
-	if (strbuilder_length(lhs) != (rhs.Len))
-		return false;
-
-	for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
-		if (lhs[idx] != rhs.Ptr[idx])
-			return false;
-
-	return true;
-}
-
-forceinline
-ssize strbuilder_avail_space(StrBuilder const str) {
-	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
-	return header->Capacity - header->Length;
-}
-
-forceinline
-char* strbuilder_back(StrBuilder str) {
-	return & (str)[strbuilder_length(str) - 1];
-}
-
-inline
-bool strbuilder_contains_StrC(StrBuilder const str, Str substring)
-{
-	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
-
-	if (substring.Len > header->Length)
-		return false;
-
-	ssize main_len = header->Length;
-	ssize sub_len  = substring.Len;
-
-	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
-	{
-		if (c_str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
-			return true;
-	}
-
-	return false;
-}
-
-inline
-bool strbuilder_contains_string(StrBuilder const str, StrBuilder const substring)
-{
-	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
-
-	if (strbuilder_length(substring) > header->Length)
-		return false;
-
-	ssize main_len = header->Length;
-	ssize sub_len  = strbuilder_length(substring);
-
-	for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
-	{
-		if (c_str_compare_len(str + idx, substring, sub_len) == 0)
-			return true;
-	}
-
-	return false;
-}
-
-forceinline
-ssize strbuilder_capacity(StrBuilder const str) {
-	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
-	return header->Capacity;
-}
-
-forceinline
-void strbuilder_clear(StrBuilder str) {
-	strbuilder_get_header(str)->Length = 0;
-}
-
-forceinline
-StrBuilder strbuilder_duplicate(StrBuilder const str, AllocatorInfo allocator) {
-	return strbuilder_make_length(allocator, str, strbuilder_length(str));
-}
-
-forceinline
-void strbuilder_free(StrBuilder* str) {
-	GEN_ASSERT(str != nullptr);
-	if (! (* str))
-		return;
-
-	StrBuilderHeader* header = strbuilder_get_header(* str);
-	allocator_free(header->Allocator, header);
-}
-
-forceinline
-StrBuilderHeader* strbuilder_get_header(StrBuilder str) {
-	return (StrBuilderHeader*)(scast(char*, str) - sizeof(StrBuilderHeader));
-}
-
-forceinline
-ssize strbuilder_length(StrBuilder const str)
-{
-	StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
-	return header->Length;
-}
-
-forceinline
-b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) {
-	if (substring.Len > strbuilder_length(str))
-	return false;
-
-	b32 result = c_str_compare_len(str, substring.Ptr, substring.Len) == 0;
-	return result;
-}
-
-forceinline
-b32 strbuilder_starts_with_string(StrBuilder const str, StrBuilder substring) {
-	if (strbuilder_length(substring) > strbuilder_length(str))
-		return false;
-
-	b32 result = c_str_compare_len(str, substring, strbuilder_length(substring) - 1) == 0;
-	return result;
-}
-
-inline
-void strbuilder_skip_line(StrBuilder str)
-{
-#define current (*scanner)
-	char* scanner = str;
-	while (current != '\r' && current != '\n') {
-		++scanner;
-	}
-
-	s32 new_length = scanner - str;
-
-	if (current == '\r') {
-		new_length += 1;
-	}
-
-	mem_move((char*)str, scanner, new_length);
-
-	StrBuilderHeader* header = strbuilder_get_header(str);
-	header->Length = new_length;
-#undef current
-}
-
-inline
-void strbuilder_strip_space(StrBuilder str)
-{
-	char* write_pos = str;
-	char* read_pos  = str;
-
-	while (* read_pos)
-	{
-		if (! char_is_space(* read_pos))
-		{
-   			* write_pos = * read_pos;
-			write_pos++;
-		}
-		read_pos++;
-	}
-   write_pos[0] = '\0';  // Null-terminate the modified string
-
-	// Update the length if needed
-	strbuilder_get_header(str)->Length = write_pos - str;
-}
-
-forceinline
-Str strbuilder_to_str(StrBuilder str) {
-	Str result = { (char const*)str, strbuilder_length(str) };
-	return result;
-}
-
-forceinline
-void strbuilder_trim_space(StrBuilder str) {
-	strbuilder_trim(str, " \t\r\n\v\f");
-}
-
-#pragma endregion StrBuilder
-
-#if GEN_COMPILER_CPP
-struct StrBuilder_POD {
-	char* Data;
-};
-static_assert( sizeof( StrBuilder_POD ) == sizeof( StrBuilder ), "StrBuilder is not a POD" );
-#endif
-
-forceinline
-Str str_duplicate(Str str, AllocatorInfo allocator) {
-	Str result = strbuilder_to_str( strbuilder_make_length(allocator, str.Ptr, str.Len));
-	return result;
-}
-
-inline
-Str str_visualize_whitespace(Str str, AllocatorInfo allocator)
-{
-	StrBuilder result = strbuilder_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
-	for (char const* c = str_begin(str); c != str_end(str); c = str_next(str, c))
-	switch ( * c )
-	{
-		case ' ':
-			strbuilder_append_str(& result, txt("·"));
-		break;
-		case '\t':
-			strbuilder_append_str(& result, txt("→"));
-		break;
-		case '\n':
-			strbuilder_append_str(& result, txt("↵"));
-		break;
-		case '\r':
-			strbuilder_append_str(& result, txt("⏎"));
-		break;
-		case '\v':
-			strbuilder_append_str(& result, txt("⇕"));
-		break;
-		case '\f':
-			strbuilder_append_str(& result, txt("⌂"));
-		break;
-		default:
-			strbuilder_append_char(& result, * c);
-		break;
-}
-	return strbuilder_to_str(result);
-}
-
-// Represents strings cached with the string table.
-// Should never be modified, if changed string is desired, cache_string( str ) another.
-typedef Str StrCached;
-
-// Implements basic string interning. Data structure is based off the ZPL Hashtable.
-typedef HashTable(StrCached) StringTable;
-#pragma endregion Strings

base/enums/AttributeTokens.csv

@@ -1 +0,0 @@
-GEN_API,    GEN_API

base/enums/ECodeTypes.csv

@@ -1,62 +0,0 @@
-Invalid,             "__NA__"
-Untyped,             "__NA__"
-NewLine,             "__NA__"
-Comment,             "//"
-Access_Private,      "private"
-Access_Protected,    "protected"
-Access_Public,       "public"
-PlatformAttributes,  "__NA__"
-Class,               "class"
-Class_Fwd,           "clsss"
-Class_Body,          "__NA__"
-Constructor,         "__NA__"
-Constructor_Fwd,     "__NA__"
-Destructor,          "__NA__"
-Destructor_Fwd,      "__NA__"
-Enum,                "enum"
-Enum_Fwd,            "enum"
-Enum_Body,           "__NA__"
-Enum_Class,          "enum class"
-Enum_Class_Fwd,      "enum class"
-Execution,           "__NA__"
-Export_Body,         "__NA__"
-Extern_Linkage,      "extern"
-Extern_Linkage_Body, "extern"
-Friend,              "friend"
-Function,            "__NA__"
-Function_Fwd,        "__NA__"
-Function_Body,       "__NA__"
-Global_Body,         "__NA__"
-Module,              "module"
-Namespace,           "namespace"
-Namespace_Body,      "__NA__"
-Operator,            "operator"
-Operator_Fwd,        "operator"
-Operator_Member,     "operator"
-Operator_Member_Fwd, "operator"
-Operator_Cast,       "operator"
-Operator_Cast_Fwd,   "operator"
-Parameters,          "__NA__"
-Parameters_Define,   "__NA__"
-Preprocess_Define,   "define"
-Preprocess_Include,  "include"
-Preprocess_If,       "if"
-Preprocess_IfDef,    "ifdef"
-Preprocess_IfNotDef, "ifndef"
-Preprocess_ElIf,     "elif"
-Preprocess_Else,     "else"
-Preprocess_EndIf,    "endif"
-Preprocess_Pragma,   "pragma"
-Specifiers,          "__NA__"
-Struct,              "struct"
-Struct_Fwd,          "struct"
-Struct_Body,         "__NA__"
-Template,            "template"
-Typedef,             "typedef"
-Typename,            "__NA__"
-Union,               "union"
-Union_Fwd,           "union"
-Union_Body,          "__NA__"
-Using,               "using"
-Using_Namespace,     "using namespace"
-Variable,            "__NA__"

base/enums/ETokType.csv

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

base/helpers/base_codegen.hpp

@@ -1,686 +0,0 @@
-#pragma once
-
-#if INTELLISENSE_DIRECTIVES
-#	include "../gen.hpp"
-#	include "misc.hpp"
-
-using namespace gen;
-#endif
-
-CodeBody gen_ecode( char const* path, bool use_c_definition = false )
-{
-	CSV_Columns2 csv_enum                 = parse_csv_two_columns( _ctx->Allocator_Temp, path );
-	StrBuilder   enum_entries             = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-	StrBuilder   to_c_str_entries         = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-	StrBuilder   to_keyword_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-
-	for ( ssize idx = 0; idx < array_num(csv_enum.Col_1); ++ idx ) 	{
-		char const* code    = csv_enum.Col_1[idx].string;
-		char const* keyword = csv_enum.Col_2[idx].string;
-		// TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
-		strbuilder_append_fmt( & enum_entries,             "CT_%s,\n", code );
-		strbuilder_append_fmt( & to_c_str_entries,         "{ \"%s\",  sizeof(\"%s\") - 1 },\n", code,    code );
-		strbuilder_append_fmt( & to_keyword_c_str_entries, "{  \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
-	}
-
-	CodeEnum enum_code;
-	if (use_c_definition) {
-		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
-			"enum CodeType enum_underlying(u32) { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
-		));
-	}
-	else {
-		enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
-			"enum CodeType : u32 { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
-		));
-	}
-
-#pragma push_macro("local_persist")
-#undef local_persist
-	Str      lookup_size  = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
-	CodeBody to_c_str_fns = parse_global_body( token_fmt(
-		"entries",  strbuilder_to_str(to_c_str_entries)
-	,	"keywords", strbuilder_to_str(to_keyword_c_str_entries)
-	,	"num",      lookup_size
-	, stringize(
-		inline
-		Str codetype_to_str( CodeType type )
-		{
-			local_persist
-			Str lookup[] = {
-				<entries>
-			};
-			return lookup[ type ];
-		}
-
-		inline
-		Str codetype_to_keyword_str( CodeType type )
-		{
-			local_persist
-			Str lookup[] = {
-				<keywords>
-			};
-			return lookup[ type ];
-		}
-	)));
-#pragma pop_macro("local_persist")
-
-	CodeBody result = def_body(CT_Global_Body);
-	body_append(result, enum_code);
-
-	if (use_c_definition) {
-		CodeTypedef code_t = parse_typedef(code(typedef enum CodeType CodeType; ));
-		body_append(result, code_t);
-	}
-
-	body_append(result, to_c_str_fns);
-
-	if (! use_c_definition) {
-		#pragma push_macro("forceinline")
-		#undef forceinline
-		CodeBody alias_mappings = parse_global_body(code(
-			forceinline Str to_str        (CodeType type) { return codetype_to_str(type);         }
-			forceinline Str to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
-		));
-		#pragma pop_macro("forceinline")
-		body_append(result, alias_mappings);
-	}
-	return result;
-}
-
-CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
-{
-	CSV_Columns2 csv_enum       = parse_csv_two_columns( _ctx->Allocator_Temp, path );
-	StrBuilder enum_entries     = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
-	StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
-
-	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) {
-		char const* enum_str     = csv_enum.Col_1[idx].string;
-		char const* entry_to_str = csv_enum.Col_2[idx].string;
-		strbuilder_append_fmt( & enum_entries,     "Op_%s,\n", enum_str );
-		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-	}
-
-	CodeEnum  enum_code;
-	if (use_c_definition)
-	{
-	#pragma push_macro("enum_underlying")
-	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
-			enum Operator enum_underlying(u32)
-			{
-				<entries>
-				Op_NumOps,
-				Op_UnderlyingType = GEN_U32_MAX
-			};
-		)));
-	#pragma pop_macro("enum_underlying")
-	}
-	else
-	{
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
-			enum Operator : u32
-			{
-				<entries>
-				Op_NumOps,
-				Op_UnderlyingType = GEN_U32_MAX
-			};
-		)));
-	}
-
-#pragma push_macro("local_persist")
-#undef local_persist
-	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
-	CodeFn to_str   = parse_function(token_fmt(
-		"entries", strbuilder_to_str(to_c_str_entries)
-	,	"num",     lookup_size
-	, stringize(
-		inline
-		Str operator_to_str( Operator op )
-		{
-			local_persist
-			Str lookup[] = {
-				<entries>
-			};
-
-			return lookup[ op ];
-		}
-	)));
-#pragma pop_macro("local_persist")
-
-	CodeBody result = def_body(CT_Global_Body);
-	body_append(result, enum_code);
-	if ( use_c_definition ) {
-		CodeTypedef operator_t = parse_typedef(code( typedef enum Operator Operator; ));
-		body_append(result, operator_t);
-	}
-
-	body_append(result, to_str);
-
-	if (! use_c_definition)
-	{
-	#pragma push_macro("forceinline")
-	#undef forceinline
-		CodeBody alias_mappings = parse_global_body(code(
-			forceinline Str to_str(Operator op) { return operator_to_str(op); }
-		));
-	#pragma pop_macro("forceinline")
-		body_append(result, alias_mappings);
-	}
-	return result;
-}
-
-CodeBody gen_especifier( char const* path, bool use_c_definition = false )
-{
-	CSV_Columns2 csv_enum       = parse_csv_two_columns( _ctx->Allocator_Temp, path );
-	StrBuilder enum_entries     = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-	StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
-
-	for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++)
-	{
-		char const* enum_str     = csv_enum.Col_1[idx].string;
-		char const* entry_to_str = csv_enum.Col_2[idx].string;
-		strbuilder_append_fmt( & enum_entries,     "Spec_%s,\n", enum_str );
-		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-	}
-
-	CodeEnum enum_code;
-	if (use_c_definition)
-	{
-	#pragma push_macro("enum_underlying")
-	#undef enum_underlying
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
-			enum Specifier enum_underlying(u32)
-			{
-				<entries>
-				Spec_NumSpecifiers,
-				Spec_UnderlyingType = GEN_U32_MAX
-			};
-		)));
-	#pragma pop_macro("enum_underlying")
-	}
-	else
-	{
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
-			enum Specifier : u32
-			{
-				<entries>
-				Spec_NumSpecifiers,
-				Spec_UnderlyingType = GEN_U32_MAX
-			};
-		)));
-	}
-	CodeFn is_trailing = parse_function(token_fmt("specifier", strbuilder_to_str(to_c_str_entries), stringize(
-		inline
-		bool spec_is_trailing( Specifier specifier )
-		{
-			switch (specifier) {
-				case Spec_Const:
-				case Spec_Final:
-				case Spec_NoExceptions:
-				case Spec_Override:
-				case Spec_Pure:
-				case Spec_Delete:
-				case Spec_Volatile:
-					return true;
-		
-				default:
-					return false;
-			}
-		}
-	)));
-
-#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
-	Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
-	CodeFn to_str   = parse_function(token_fmt(
-		"entries", strbuilder_to_str(to_c_str_entries)
-	,	"num",     lookup_size
-	, stringize(
-		inline
-		Str spec_to_str( Specifier type )
-		{
-			local_persist
-			Str lookup[] = {
-				<entries>
-			};
-
-			return lookup[ type ];
-		}
-	)));
-
-	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
-		inline
-		Specifier str_to_specifier( Str str )
-		{
-			local_persist
-			u32 keymap[ Spec_NumSpecifiers ];
-			do_once_start
-				for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
-				{
-					Str enum_str = spec_to_str( (Specifier)index );
-
-					// 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  );
-				}
-			do_once_end
-
-			u32 hash = crc32( str.Ptr, str.Len );
-
-			for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
-			{
-				if ( keymap[index] == hash )
-					return (Specifier)index;
-			}
-
-			return Spec_Invalid;
-		}
-	)));
-#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")
-
-	CodeBody result = def_body(CT_Global_Body);
-	body_append(result, enum_code);
-	if (use_c_definition)
-	{
-		CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier Specifier; ));
-		body_append(result, specifier_t);
-	}
-
-	body_append(result, to_str);
-	body_append(result, is_trailing);
-	body_append(result, to_type);
-
-	if (! use_c_definition)
-	{
-	#pragma push_macro("forceinline")
-	#undef forceinline
-		CodeBody alias_mappings = parse_global_body(code(
-			forceinline Str      to_str (Specifier spec)            { return spec_to_str(spec); }
-			forceinline Specifier to_type( Str str )                { return str_to_specifier(str); }
-			forceinline bool      is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
-		));
-	#pragma pop_macro("forceinline")
-		body_append(result, alias_mappings);
-	}
-	return result;
-}
-
-CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false )
-{
-	FileContents enum_content = file_read_contents( _ctx->Allocator_Temp, file_zero_terminate, etok_path );
-	CSV_Object csv_enum_nodes;
-	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), _ctx->Allocator_Temp, false );
-
-	FileContents attrib_content = file_read_contents( _ctx->Allocator_Temp, file_zero_terminate, attr_path );
-	CSV_Object csv_attr_nodes;
-	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), _ctx->Allocator_Temp, false );
-
-	Array<ADT_Node> enum_strs            = csv_enum_nodes.nodes[0].nodes;
-	Array<ADT_Node> enum_c_str_strs      = csv_enum_nodes.nodes[1].nodes;
-	Array<ADT_Node> attribute_strs       = csv_attr_nodes.nodes[0].nodes;
-	Array<ADT_Node> attribute_c_str_strs = csv_attr_nodes.nodes[1].nodes;
-
-	StrBuilder enum_entries             = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(2) );
-	StrBuilder to_c_str_entries         = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
-	StrBuilder attribute_entries        = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(2) );
-	StrBuilder to_c_str_attributes      = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
-	StrBuilder attribute_define_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
-
-	for (usize idx = 0; idx < array_num(enum_strs); idx++)
-	{
-		char const* enum_str     = enum_strs[idx].string;
-		char const* entry_to_str = enum_c_str_strs [idx].string;
-
-		strbuilder_append_fmt( & enum_entries,     "Tok_%s,\n",                         enum_str );
-		strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-	}
-
-	for ( usize idx = 0; idx < array_num(attribute_strs); idx++ )
-	{
-		char const* attribute_str = attribute_strs[idx].string;
-		char const* entry_to_str  = attribute_c_str_strs [idx].string;
-
-		strbuilder_append_fmt( & attribute_entries,        "Tok_Attribute_%s,\n",               attribute_str );
-		strbuilder_append_fmt( & to_c_str_attributes,      "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
-		strbuilder_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
-
-		if ( idx < array_num(attribute_strs) - 1 )
-			strbuilder_append_str( & attribute_define_entries, txt(" \\\n"));
-		else
-			strbuilder_append_str( & attribute_define_entries, txt("\n"));
-	}
-
-#pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
-#undef GEN_DEFINE_ATTRIBUTE_TOKENS
-	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), MT_Statement, { {}, strbuilder_to_str(attribute_define_entries) }  );
-#pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
-
-	// We cannot parse this enum, it has Attribute names as enums
-	CodeEnum enum_code;
-	if (use_c_definition)
-	{
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
-			enum TokType
-			{
-				<entries>
-				<attribute_toks>
-				Tok_NumTokens,
-				Tok_UnderlyingType = GEN_U32_MAX
-			};
-		)));
-	}
-	else
-	{
-		enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
-			enum TokType : u32
-			{
-				<entries>
-				<attribute_toks>
-				Tok_NumTokens
-			};
-		)));
-	}
-
-#pragma push_macro("local_persist")
-#pragma push_macro("do_once_start")
-#pragma push_macro("do_once_end")
-#undef local_persist
-#undef do_once_start
-#undef do_once_end
-	CodeFn to_str = parse_function(token_fmt("entries", strbuilder_to_str(to_c_str_entries), "attribute_toks", strbuilder_to_str(to_c_str_attributes), stringize(
-		inline
-		Str toktype_to_str( TokType type )
-		{
-			local_persist
-			Str lookup[] = {
-				<entries>
-				<attribute_toks>
-			};
-
-			return lookup[ type ];
-		}
-	)));
-
-	CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
-		inline
-		TokType str_to_toktype( Str str )
-		{
-			local_persist
-			u32 keymap[ Tok_NumTokens ];
-			do_once_start
-				for ( u32 index = 0; index < Tok_NumTokens; index++ )
-				{
-					Str enum_str = toktype_to_str( (TokType)index );
-
-					// 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);
-				}
-			do_once_end
-
-			u32 hash = crc32( str.Ptr, str.Len );
-
-			for ( u32 index = 0; index < Tok_NumTokens; index++ )
-			{
-				if ( keymap[index] == hash )
-					return (TokType)index;
-			}
-
-			return Tok_Invalid;
-		}
-	)));
-#pragma pop_macro("local_persist")
-#pragma pop_macro("do_once_start")
-#pragma pop_macro("do_once_end")
-
-	CodeBody result = def_body(CT_Global_Body);
-	body_append(result, attribute_entires_def);
-	body_append(result, enum_code);
-	if (use_c_definition)
-	{
-		CodeTypedef td_toktype = parse_typedef( code( typedef enum TokType TokType; ));
-		body_append(result, td_toktype);
-	}
-	body_append(result, to_str);
-	body_append(result, to_type);
-	return result;
-}
-
-CodeBody gen_ast_inlines()
-{
-#pragma push_macro("GEN_NS")
-#pragma push_macro("rcast")
-#pragma push_macro("log_failure")
-#pragma push_macro("CodeInvalid")
-#undef GEN_NS
-#undef rcast
-#undef log_failure
-#undef CodeInvalid
-	char const* code_impl_tmpl = stringize(
-		\n
-		inline
-		<typename>& <typename>::operator =( Code other )
-		{
-			if ( other.ast != nullptr && other->Parent != nullptr )
-			{
-				ast         = rcast( decltype(ast), code_duplicate(other).ast);
-				ast->Parent = { nullptr };
-			}
-
-			ast = rcast( decltype( ast ), other.ast );
-			return * this;
-		}
-		inline
-		<typename>::operator bool()
-		{
-			return ast != nullptr;
-		}
-	);
-
-	char const* codetype_impl_tmpl = stringize(
-		inline
-		Code<typename>::operator Code()
-		{
-			return *rcast( Code*, this );
-		}
-		inline
-		AST_<typename>* Code<typename>::operator->()
-		{
-			if ( ast == nullptr )
-			{
-				log_failure( "Attempt to dereference a nullptr!\n" );
-				return nullptr;
-			}
-			return ast;
-		}
-		\n
-	);
-#pragma pop_macro("GEN_NS")
-#pragma pop_macro("CodeInvalid")
-
-	CodeBody impl_code               = parse_global_body( token_fmt( "typename", name(Code),               code_impl_tmpl ));
-	CodeBody impl_code_body          = parse_global_body( token_fmt( "typename", name(CodeBody),           code_impl_tmpl ));
-	CodeBody impl_code_attr          = parse_global_body( token_fmt( "typename", name(CodeAttributes),     code_impl_tmpl ));
-	CodeBody impl_code_cmt           = parse_global_body( token_fmt( "typename", name(CodeComment),        code_impl_tmpl ));
-	CodeBody impl_code_constr        = parse_global_body( token_fmt( "typename", name(CodeConstructor),    code_impl_tmpl ));
-	CodeBody impl_code_class         = parse_global_body( token_fmt( "typename", name(CodeClass),          code_impl_tmpl ));
-	CodeBody impl_code_define        = parse_global_body( token_fmt( "typename", name(CodeDefine),         code_impl_tmpl ));
-	CodeBody impl_code_define_params = parse_global_body( token_fmt( "typename", name(CodeDefineParams),   code_impl_tmpl ));
-	CodeBody impl_code_destruct      = parse_global_body( token_fmt( "typename", name(CodeDestructor),     code_impl_tmpl ));
-	CodeBody impl_code_enum          = parse_global_body( token_fmt( "typename", name(CodeEnum),           code_impl_tmpl ));
-	CodeBody impl_code_exec          = parse_global_body( token_fmt( "typename", name(CodeExec),           code_impl_tmpl ));
-	CodeBody impl_code_extern        = parse_global_body( token_fmt( "typename", name(CodeExtern),         code_impl_tmpl ));
-	CodeBody impl_code_include       = parse_global_body( token_fmt( "typename", name(CodeInclude),        code_impl_tmpl ));
-	CodeBody impl_code_friend        = parse_global_body( token_fmt( "typename", name(CodeFriend),         code_impl_tmpl ));
-	CodeBody impl_code_fn	         = parse_global_body( token_fmt( "typename", name(CodeFn),             code_impl_tmpl ));
-	CodeBody impl_code_module        = parse_global_body( token_fmt( "typename", name(CodeModule),         code_impl_tmpl ));
-	CodeBody impl_code_ns            = parse_global_body( token_fmt( "typename", name(CodeNS),             code_impl_tmpl ));
-	CodeBody impl_code_op            = parse_global_body( token_fmt( "typename", name(CodeOperator),       code_impl_tmpl ));
-	CodeBody impl_code_opcast        = parse_global_body( token_fmt( "typename", name(CodeOpCast),         code_impl_tmpl ));
-	CodeBody impl_code_params        = parse_global_body( token_fmt( "typename", name(CodeParams),         code_impl_tmpl ));
-	CodeBody impl_code_pragma        = parse_global_body( token_fmt( "typename", name(CodePragma),         code_impl_tmpl ));
-	CodeBody impl_code_precond       = parse_global_body( token_fmt( "typename", name(CodePreprocessCond), code_impl_tmpl ));
-	CodeBody impl_code_specs         = parse_global_body( token_fmt( "typename", name(CodeSpecifiers),     code_impl_tmpl ));
-	CodeBody impl_code_struct        = parse_global_body( token_fmt( "typename", name(CodeStruct),         code_impl_tmpl ));
-	CodeBody impl_code_tmpl          = parse_global_body( token_fmt( "typename", name(CodeTemplate),       code_impl_tmpl ));
-	CodeBody impl_code_type          = parse_global_body( token_fmt( "typename", name(CodeTypename),       code_impl_tmpl ));
-	CodeBody impl_code_typedef       = parse_global_body( token_fmt( "typename", name(CodeTypedef),        code_impl_tmpl ));
-	CodeBody impl_code_union         = parse_global_body( token_fmt( "typename", name(CodeUnion),          code_impl_tmpl ));
-	CodeBody impl_code_using         = parse_global_body( token_fmt( "typename", name(CodeUsing),          code_impl_tmpl ));
-	CodeBody impl_code_var           = parse_global_body( token_fmt( "typename", name(CodeVar),            code_impl_tmpl ));
-
-	body_append(impl_code_attr,     parse_global_body( token_fmt( "typename", name(Attributes),     codetype_impl_tmpl )));
-	body_append(impl_code_cmt,      parse_global_body( token_fmt( "typename", name(Comment),        codetype_impl_tmpl )));
-	body_append(impl_code_constr,   parse_global_body( token_fmt( "typename", name(Constructor),    codetype_impl_tmpl )));
-	body_append(impl_code_define,   parse_global_body( token_fmt( "typename", name(Define),         codetype_impl_tmpl )));
-	body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", name(Destructor),     codetype_impl_tmpl )));
-	body_append(impl_code_enum,     parse_global_body( token_fmt( "typename", name(Enum),           codetype_impl_tmpl )));
-	body_append(impl_code_exec,     parse_global_body( token_fmt( "typename", name(Exec),           codetype_impl_tmpl )));
-	body_append(impl_code_extern,   parse_global_body( token_fmt( "typename", name(Extern),         codetype_impl_tmpl )));
-	body_append(impl_code_include,  parse_global_body( token_fmt( "typename", name(Include),        codetype_impl_tmpl )));
-	body_append(impl_code_friend,   parse_global_body( token_fmt( "typename", name(Friend),         codetype_impl_tmpl )));
-	body_append(impl_code_fn,       parse_global_body( token_fmt( "typename", name(Fn),             codetype_impl_tmpl )));
-	body_append(impl_code_module,   parse_global_body( token_fmt( "typename", name(Module),         codetype_impl_tmpl )));
-	body_append(impl_code_ns,       parse_global_body( token_fmt( "typename", name(NS),             codetype_impl_tmpl )));
-	body_append(impl_code_op,       parse_global_body( token_fmt( "typename", name(Operator),       codetype_impl_tmpl )));
-	body_append(impl_code_opcast,   parse_global_body( token_fmt( "typename", name(OpCast),         codetype_impl_tmpl )));
-	body_append(impl_code_pragma,   parse_global_body( token_fmt( "typename", name(Pragma),         codetype_impl_tmpl )));
-	body_append(impl_code_precond,  parse_global_body( token_fmt( "typename", name(PreprocessCond), codetype_impl_tmpl )));
-	body_append(impl_code_tmpl,     parse_global_body( token_fmt( "typename", name(Template),       codetype_impl_tmpl )));
-	body_append(impl_code_type,     parse_global_body( token_fmt( "typename", name(Typename),       codetype_impl_tmpl )));
-	body_append(impl_code_typedef,  parse_global_body( token_fmt( "typename", name(Typedef),        codetype_impl_tmpl )));
-	body_append(impl_code_union,    parse_global_body( token_fmt( "typename", name(Union),          codetype_impl_tmpl )));
-	body_append(impl_code_using,    parse_global_body( token_fmt( "typename", name(Using),          codetype_impl_tmpl )));
-	body_append(impl_code_var,      parse_global_body( token_fmt( "typename", name(Var),            codetype_impl_tmpl )));
-
-	#pragma push_macro("forceinline")
-	#undef forceinline
-	char const* cast_tmpl = stringize(
-		forceinline Code::operator Code<typename>() const
-		{
-			return { (AST_<typename>*) ast };
-		}
-	);
-	#pragma pop_macro("forceinline")
-
-	CodeBody impl_cast_body          = parse_global_body( token_fmt( "typename", name(Body),           cast_tmpl ));
-	CodeBody impl_cast_attribute     = parse_global_body( token_fmt( "typename", name(Attributes),     cast_tmpl ));
-	CodeBody impl_cast_cmt           = parse_global_body( token_fmt( "typename", name(Comment),        cast_tmpl ));
-	CodeBody impl_cast_constr        = parse_global_body( token_fmt( "typename", name(Constructor),    cast_tmpl ));
-	CodeBody impl_cast_class         = parse_global_body( token_fmt( "typename", name(Class),          cast_tmpl ));
-	CodeBody impl_cast_define        = parse_global_body( token_fmt( "typename", name(Define),         cast_tmpl ));
-	CodeBody impl_cast_define_params = parse_global_body( token_fmt( "typename", name(DefineParams),   cast_tmpl ));
-	CodeBody impl_cast_destruct      = parse_global_body( token_fmt( "typename", name(Destructor),     cast_tmpl ));
-	CodeBody impl_cast_enum          = parse_global_body( token_fmt( "typename", name(Enum),           cast_tmpl ));
-	CodeBody impl_cast_exec          = parse_global_body( token_fmt( "typename", name(Exec),           cast_tmpl ));
-	CodeBody impl_cast_extern        = parse_global_body( token_fmt( "typename", name(Extern),         cast_tmpl ));
-	CodeBody impl_cast_friend        = parse_global_body( token_fmt( "typename", name(Friend),         cast_tmpl ));
-	CodeBody impl_cast_fn            = parse_global_body( token_fmt( "typename", name(Fn),             cast_tmpl ));
-	CodeBody impl_cast_include       = parse_global_body( token_fmt( "typename", name(Include),        cast_tmpl ));
-	CodeBody impl_cast_module        = parse_global_body( token_fmt( "typename", name(Module),         cast_tmpl ));
-	CodeBody impl_cast_ns            = parse_global_body( token_fmt( "typename", name(NS),             cast_tmpl ));
-	CodeBody impl_cast_op            = parse_global_body( token_fmt( "typename", name(Operator),       cast_tmpl ));
-	CodeBody impl_cast_opcast        = parse_global_body( token_fmt( "typename", name(OpCast),         cast_tmpl ));
-	CodeBody impl_cast_params        = parse_global_body( token_fmt( "typename", name(Params),         cast_tmpl ));
-	CodeBody impl_cast_pragma        = parse_global_body( token_fmt( "typename", name(Pragma),         cast_tmpl ));
-	CodeBody impl_cast_precond       = parse_global_body( token_fmt( "typename", name(PreprocessCond), cast_tmpl ));
-	CodeBody impl_cast_specs         = parse_global_body( token_fmt( "typename", name(Specifiers),     cast_tmpl ));
-	CodeBody impl_cast_struct        = parse_global_body( token_fmt( "typename", name(Struct),         cast_tmpl ));
-	CodeBody impl_cast_tmpl          = parse_global_body( token_fmt( "typename", name(Template),       cast_tmpl ));
-	CodeBody impl_cast_type          = parse_global_body( token_fmt( "typename", name(Typename),       cast_tmpl ));
-	CodeBody impl_cast_typedef       = parse_global_body( token_fmt( "typename", name(Typedef),        cast_tmpl ));
-	CodeBody impl_cast_union         = parse_global_body( token_fmt( "typename", name(Union),          cast_tmpl ));
-	CodeBody impl_cast_using         = parse_global_body( token_fmt( "typename", name(Using),          cast_tmpl ));
-	CodeBody impl_cast_var           = parse_global_body( token_fmt( "typename", name(Var),            cast_tmpl ));
-
-	CodeBody result = def_global_body( args(
-		def_pragma( txt("region generated code inline implementation")),
-		fmt_newline,
-		impl_code,
-		impl_code_body,
-		impl_code_attr,
-		impl_code_cmt,
-		impl_code_constr,
-		impl_code_class,
-		impl_code_define,
-		impl_code_define_params,
-		impl_code_destruct,
-		impl_code_enum,
-		impl_code_exec,
-		impl_code_extern,
-		impl_code_friend,
-		impl_code_fn,
-		impl_code_include,
-		impl_code_module,
-		impl_code_ns,
-		impl_code_op,
-		impl_code_opcast,
-		impl_code_params,
-		impl_code_pragma,
-		impl_code_precond,
-		impl_code_specs,
-		impl_code_struct,
-		impl_code_tmpl,
-		impl_code_type,
-		impl_code_typedef,
-		impl_code_union,
-		impl_code_using,
-		impl_code_var,
-		fmt_newline,
-		def_pragma( txt("endregion generated code inline implementation")),
-		fmt_newline,
-		def_pragma( txt("region generated AST/Code cast implementation")),
-		untyped_str(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN\n")),
-		fmt_newline,
-		impl_cast_body,
-		impl_cast_attribute,
-		impl_cast_cmt,
-		impl_cast_constr,
-		impl_cast_class,
-		impl_cast_define,
-		impl_cast_define_params,
-		impl_cast_destruct,
-		impl_cast_enum,
-		impl_cast_exec,
-		impl_cast_extern,
-		impl_cast_friend,
-		impl_cast_fn,
-		impl_cast_include,
-		impl_cast_module,
-		impl_cast_ns,
-		impl_cast_op,
-		impl_cast_opcast,
-		impl_cast_params,
-		impl_cast_pragma,
-		impl_cast_precond,
-		impl_cast_specs,
-		impl_cast_struct,
-		impl_cast_tmpl,
-		impl_cast_type,
-		impl_cast_typedef,
-		impl_cast_union,
-		impl_cast_using,
-		impl_cast_var,
-		fmt_newline,
-		untyped_str(txt("GEN_OPITMIZE_MAPPINGS_END\n")),
-		def_pragma( txt("endregion generated AST/Code cast implementation")),
-		fmt_newline
-	));
-
-	return result;
-#pragma pop_macro("rcast")
-#pragma pop_macro("log_failure")
-}

base/helpers/misc.hpp

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

base/helpers/pop_container_defines.inline.hpp

@@ -1,39 +0,0 @@
-
-#undef array_init
-#undef array_init_reserve
-#undef array_append_array
-#undef array_append
-#undef array_append_items
-#undef array_append_at
-#undef array_append_items_at
-#undef array_back
-#undef array_clear
-#undef array_fill
-#undef array_free
-#undef arary_grow
-#undef array_num
-#undef arary_pop
-#undef arary_remove_at
-#undef arary_reserve
-#undef arary_resize
-#undef arary_set_capacity
-#undef arary_get_header
-
-#undef hashtable_init
-#undef hashtable_init_reserve
-#undef hashtable_clear
-#undef hashtable_destroy
-#undef hashtable_get
-#undef hashtable_grow
-#undef hashtable_rehash
-#undef hashtable_rehash_fast
-#undef hashtable_remove
-#undef hashtable_remove_entry
-#undef hashtable_set
-#undef hashtable_slot
-#undef hashtable_map
-#undef hashtable_map_mut
-
-//#undef hashtable_add_entry
-//#undef hashtable_find
-//#undef hashtable_full

base/helpers/push_container_defines.inline.hpp

@@ -1,39 +0,0 @@
-
-#define array_init(type, allocator)                        array_init           <type>                               (allocator )
-#define array_init_reserve(type, allocator, cap)           array_init_reserve   <type>                               (allocator, cap)
-#define array_append_array(array, other)                   array_append_array   < get_array_underlying_type(array) > (& array, other )
-#define array_append(array, value)                         array_append         < get_array_underlying_type(array) > (& array, value )
-#define array_append_items(array, items, item_num)         array_append_items   < get_array_underlying_type(array) > (& array, items, item_num )
-#define array_append_at(array, item, idx )                 array_append_at      < get_array_underlying_type(array) > (& array, item, idx )
-#define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
-#define array_back(array)                                  array_back           < get_array_underlying_type(array) > (array )
-#define array_clear(array)                                 array_clear          < get_array_underlying_type(array) > (array )
-#define array_fill(array, begin, end, value)               array_fill           < get_array_underlying_type(array) > (array, begin, end, value )
-#define array_free(array)                                  array_free           < get_array_underlying_type(array) > (& array )
-#define arary_grow(array, min_capacity)                    arary_grow           < get_array_underlying_type(array) > (& array, min_capacity)
-#define array_num(array)                                   array_num            < get_array_underlying_type(array) > (array )
-#define arary_pop(array)                                   arary_pop            < get_array_underlying_type(array) > (array )
-#define arary_remove_at(array, idx)                        arary_remove_at      < get_array_underlying_type(array) > (idx)
-#define arary_reserve(array, new_capacity)                 arary_reserve        < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_resize(array, num)                           arary_resize         < get_array_underlying_type(array) > (& array, num)
-#define arary_set_capacity(new_capacity)                   arary_set_capacity   < get_array_underlying_type(array) > (& array, new_capacity )
-#define arary_get_header(array)                            arary_get_header     < get_array_underlying_type(array) > (array )
-
-#define hashtable_init(type, allocator)              hashtable_init        <type              >(allocator)
-#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type              >(allocator, num)
-#define hashtable_clear(table)                       hashtable_clear       < get_hashtable_underlying_type(table) >(table)
-#define hashtable_destroy(table)                     hashtable_destroy     < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_get(table, key)                    hashtable_get         < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_grow(table)                        hashtable_grow        < get_hashtable_underlying_type(table) >(& table)
-#define hashtable_rehash(table, new_num)             hashtable_rehash      < get_hashtable_underlying_type(table) >(& table, new_num)
-#define hashtable_rehash_fast(table)                 hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
-#define hashtable_remove(table, key)                 hashtable_remove      < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_remove_entry(table, idx)           hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
-#define hashtable_set(table, key, value)             hashtable_set         < get_hashtable_underlying_type(table) >(& table, key, value)
-#define hashtable_slot(table, key)                   hashtable_slot        < get_hashtable_underlying_type(table) >(table, key)
-#define hashtable_map(table, map_proc)               hashtable_map         < get_hashtable_underlying_type(table) >(table, map_proc)
-#define hashtable_map_mut(table, map_proc)           hashtable_map_mut     < get_hashtable_underlying_type(table) >(table, map_proc)
-
-//#define hashtable_add_entry(table, key)              hashtable_add_entry   < get_hashtable_underlying_type(table) >(& table, key)
-//#define hashtable_find(table, key)                   hashtable_find        < get_hashtable_underlying_type(table) >(table, key)
-//#define hashtable_full(table)                        hashtable_full        < get_hashtable_underlying_type(table) >(table)

base/helpers/undef.macros.h

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

docs/AST_Design.md

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

docs/AST_Types.md

@@ -1,16 +1,10 @@
-## Navigation
-
-[Top](../Readme.md)
-
-<- [docs - General](Readme.md)
-
 # AST Types Documentation
 
-While the Readme for docs covers the data layout per AST, this will focus on the AST types available, and their nuances.
+While the Readme for docs covers the data layout per AST, this will focus on the AST types avaialble, and their nuances.
 
 ## Body
 
-These are containers representing a scope body of a definition that can be of the following `CodeType` type:
+These are containers representing a scope body of a definition that can be of the following `ECode` type:
 
 * Class_Body
 * Enum_Body
@@ -25,27 +19,26 @@ These are containers representing a scope body of a definition that can be of th
 Fields:
 
 ```cpp
-StrCached Name;
-Code      Front;
-Code      Back;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
-s32       NumEntries;
+Code           Front;
+Code           Back;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
 ```
 
 The `Front` member represents the start of the link list and `Back` the end.
 NumEntries is the number of entries in the body.
 
-Parent should have a compatible CodeType type for the type of definition used.
+Parent should have a compatible ECode type for the type of defintion used.
 
 Serialization:
 
 Will output only the entries, the braces are handled by the parent.
 
 ```cpp
-<Front>
-...
+<Front>...
 <Back>
 ```
 
@@ -56,13 +49,13 @@ Represent standard or vendor specific C/C++ attributes.
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -80,13 +73,13 @@ Stores a comment.
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -95,7 +88,7 @@ Serialization:
 <Content>
 ```
 
-The parser will preserve comments found if residing with a body or in accepted inline-to-definition locations.
+The parser will perserve comments found if residing with a body or in accepted inline-to-definition locations.
 Otherwise they will be skipped by the TokArray::__eat and TokArray::current( skip foramtting enabled ) functions.
 
 The upfront constructor: `def_comment` expects to recieve a comment without the `//` or `/* */` parts. It will add them during construction.
@@ -109,12 +102,12 @@ CodeComment    InlineCmt;  // Only supported by forward declarations
 CodeAttributes Attributes;
 CodeType       ParentType;
 CodeBody       Body;
-StrCached      Name;
-CodeType       Prev;
-CodeType       Next;
-Token*         Tok;
+CodeType       Prev;       // Used to store references to interfaces
+CodeType       Next;       // Used to store references to interfaces
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 AccessSpec     ParentAccess;
 ```
@@ -132,23 +125,23 @@ Serialization:
 };
 ```
 
-You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest are assumed to be interfaces and are given public acess specifiers.
+You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest must be done through interfaces.
 
 ## Constructor
 
 Fields:
 
 ```cpp
-CodeComment InlineCmt;  // Only supported by forward declarations
-Code        InitializerList;
-CodeParams  Params;
-Code        Body;
-StrCached   Name;
-Code        Prev;
-Code        Next;
-Token*      Tok;
-Code        Parent;
-CodeType    Type;
+CodeComment    InlineCmt;  // Only supported by forward declarations
+Code           InitializerList;
+CodeParam      Params;
+Code           Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -178,14 +171,13 @@ Represents a preprocessor define
 Fields:
 
 ```cpp
-CodeDefineParams Params;
-Code             Body;
-StrCached        Name;
-Code             Prev;
-Code             Next;
-Token*           Tok;
-Code             Parent;
-CodeType         Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -194,28 +186,6 @@ Serialization:
 #define <Name> <Content>
 ```
 
-## DefineParams
-
-Preprocessor define's parameters.
-
-Fields:
-
-```cpp
-StrCached Name;
-Code      Last;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
-s32       NumEntries;
-```
-
-Serialization:
-
-```cpp
-<Name>, <Next> ...
-```
-
 ## Destructor
 
 Fields:
@@ -224,12 +194,12 @@ Fields:
 CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 Code           Body;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -259,28 +229,24 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
-Code           UnderlyingTypeMacro;
 CodeBody       Body;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-StrCached      Name;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
-UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment.  
-The `enum_underlying_sig` is a `Str` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro.
-
 Serialization:
 
 ```cpp
 // Enum_Fwd
-<ModuleFlags> enum class <Name> : <UnderlyingType> or <UnderlyingTypeMacro> ; <InlineCmt>
+<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>
 
 // Enum
-<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType> or <UnderlyingTypeMacro>
+<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>
 {
     <Body>
 };
@@ -289,18 +255,18 @@ Serialization:
 ## Execution
 
 Just represents an execution body. Equivalent to an untyped body.
-Will be obsolete when function body parsing is implemented.
+Will be obsolute when function body parsing is implemented.
 
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -309,18 +275,18 @@ Serialization:
 <Content>
 ```
 
-## External Linkage (Extern)
+## External Linkage
 
 Fields:
 
 ```cpp
-CodeBody  Body;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -337,13 +303,13 @@ extern "<Name>"
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Code      Parent;
-Token*    Tok;
-CodeType  Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+Code           Parent;
+parser::Token* Tok;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -359,14 +325,14 @@ This library (until its necessary become some third-party library to do otherwis
 Fields:
 
 ```cpp
-CodeComment InlineCmt;
-Code        Declaration;
-StrCached   Name;
-Code        Prev;
-Code        Next;
-Token*      Tok;
-Code        Parent;
-CodeType    Type;
+CodeComment    InlineCmt;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -384,14 +350,14 @@ CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeType       ReturnType;
-CodeParams     Params;
+CodeParam      Params;
 CodeBody       Body;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -413,13 +379,13 @@ Serialization:
 Fields:
 
 ```cpp
-StrCached  Name;
-Code       Prev;
-Code       Next;
-Token*     Tok;
-Code       Parent;
-CodeType   Type;
-ModuleFlag ModuleFlags;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -433,14 +399,14 @@ Serialization:
 Fields:
 
 ```cpp
-CodeBody   Body;
-StrCached  Name;
-Code       Prev;
-Code       Next;
-Token*     Tok;
-Code       Parent;
-CodeType   Type;
-ModuleFlag ModuleFlags;
+CodeBody       Body;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -452,7 +418,7 @@ Serialization:
 }
 ```
 
-## Operator Overload (Operator)
+## Operator Overload
 
 Fields:
 
@@ -461,14 +427,14 @@ CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeType       ReturnType;
-CodeParams     Params;
+CodeParam      Params;
 CodeBody       Body;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 OperatorT      Op;
 ```
@@ -486,7 +452,7 @@ Serialization:
 }
 ```
 
-## Operator Cast Overload ( User-Defined Type Conversion, OpCast )
+## Operator Cast Overload ( User-Defined Type Conversion )
 
 Fields:
 
@@ -495,12 +461,12 @@ CodeComment    InlineCmt;
 CodeSpecifiers Specs;
 CodeType       ValueType;
 CodeBody       Body;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -516,22 +482,21 @@ Serialization:
 }
 ```
 
-## Parameters (AST_Params)
+## Parameters (AST_Param)
 
 Fields:
 
 ```cpp
-CodeType   ValueType;
-Code       Macro;
-Code       Value;
-Code       PostNameMacro;
-StrCached  Name;
-CodeParams Last;
-CodeParams Next;
-Token*     Tok;
-Code       Parent;
-CodeType   Type;
-s32        NumEntries;
+CodeType       ValueType;
+Code           Macro;
+Code           Value;
+CodeParam      Last;
+CodeParam      Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+s32            NumEntries;
 ```
 
 Serialization:
@@ -539,7 +504,7 @@ Serialization:
 ```cpp
 <Macro>, <Next> ... <Last>
 
-<Macro> <ValueType> <Name> <PostNameMacro> = <Value>, <Next>... <Last>
+<Macro> <ValueType> <Name>, <Next>... <Last>
 ```
 
 ## Pragma
@@ -547,13 +512,13 @@ Serialization:
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+StringCached   Content;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
 ```
 
 Serialization:
@@ -567,13 +532,13 @@ Serialization:
 Fields:
 
 ```cpp
-StrCached Content;
-StrCached Name;
-Code      Prev;
-Code      Next;
-Token*    Tok;
-Code      Parent;
-CodeType  Type;
+StringCached  Content;
+Code          Prev;
+Code          Next;
+paser::Token* Tok;
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
 ```
 
 Serialization:
@@ -587,14 +552,14 @@ Serialization:
 Fields:
 
 ```cpp
-SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
+SpecifierT     ArrSpecs[ AST::ArrSpecs_Cap ];
 CodeSpecifiers NextSpecs;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 s32            NumEntries;
 ```
 
@@ -609,15 +574,15 @@ Serialization:
 Fields:
 
 ```cpp
-CodeParams  Params;
-Code        Declaration;
-StrCached   Name;
-Code        Prev;
-Code        Next;
-Token*      Tok;
-Code        Parent;
-CodeType    Type;
-ModuleFlag  ModuleFlags;
+CodeParam      Params;
+Code           Declaration;
+Code           Prev;
+Code           Next;
+parser::Token* Tok;
+Code           Parent;
+StringCached   Name;
+CodeT          Type;
+ModuleFlag     ModuleFlags;
 ```
 
 Serialization:
@@ -638,30 +603,23 @@ Fields:
 CodeAttributes Attributes;
 CodeSpecifiers Specs;
 CodeReturnType ReturnType;
-CodeParams     Params;
+CodeParam      Params;
 Code           ArrExpr;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-StrCached      Name;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 b32            IsParamPack;
-ETypenameTag   TypeTag;
 ```
 
 Serialization:
 
 ```cpp
-<Attributes> <TypeTag> <Name> <Specs> <IsParamPack ?: ...> 
-// Function
-<Attributes> <ReturnType> <Name> <Params> <Specs>
+<Attributes> <Name> <Specs> <IsParamPack ?: ...>
 ```
 
-`<Name>` currently has the full serialization of anything with
-
-*Note: ArrExpr is not used in serialization by `typename_to_strbuilder_ref` its instead handled by a parent AST's serailization (variable, typedef, using).*
-
 ## Typedef
 
 Behave as usual except function or macro typedefs.  
@@ -670,32 +628,27 @@ Those (macros) don't use the underlying type field as everything was serialized
 Fields:
 
 ```cpp
-CodeComment InlineCmt;
-Code        UnderlyingType;
-StrCached   Name;
-Code        Prev;
-Code        Next;
-Token*      Tok
-Code        Parent;
-CodeType    Type;
-ModuleFlag  ModuleFlags;
-b32         IsFunction;
+CodeComment   InlineCmt;
+Code          UnderlyingType;
+Code          Prev;
+Code          Next;
+parse::Token* Tok
+Code          Parent;
+StringCached  Name;
+CodeT         Type;
+ModuleFlag    ModuleFlags;
+b32           IsFunction;
 ```
 
 Serialization:
 
 ```cpp
 // Regular
-<ModuleFlags> typedef <UnderlyingType> <Name> <UnderlyingType-ArrExpr>; <InlineCmt>
+<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>
 
 // Functions
-
-// Currently:
-<ModuleFlags> typedef <UnderlyingType (Serialized expression)>; <InlineCmt>
-
-// Desired: Not handled yet
-<ModuleFlags> typedef <UnderlyingType->ReturnType> UnderlyingType->Name> <UnderlyingType-ArrExpr> ( <UnderlyingType->Parameters> ); <InlineCmt>
-<ModuleFlags> typedef <UnderlyingType->ReturnType> ( <Name->Namespace> for<Specs->has(Spec_Ptr) ?: *> <UnderlyingType->Name> <UnderlyingType-ArrExpr> ) ( <UnderlyingType->Parameters> ); <InlineCmt>
+<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
+<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
 ```
 
 ## Union
@@ -705,12 +658,12 @@ Fields:
 ```cpp
 CodeAttributes Attributes;
 CodeBody       Body;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -731,12 +684,12 @@ Fields:
 CodeComment    InlineCmt;
 CodeAttributes Attributes;
 CodeType       UnderlyingType;
-StrCached      Name;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -763,15 +716,14 @@ CodeSpecifiers Specs;
 CodeType       ValueType;
 Code           BitfieldSize;
 Code           Value;
-StrCached      Name;
 CodeVar        NextVar;
 Code           Prev;
 Code           Next;
-Token*         Tok;
+parser::Token* Tok;
 Code           Parent;
-CodeType       Type;
+StringCached   Name;
+CodeT          Type;
 ModuleFlag     ModuleFlags;
-s32            VarParenthesizedInit;
 ```
 
 Serialization:
@@ -782,7 +734,4 @@ Serialization:
 
 // Bitfield
 <ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
-
-// VarParenthesizedInit
-<Attributes> <Specs> <ValueType> <Name>( <Value>, NextVar ... ); <InlineCmt>
 ```

docs/Parsing.md

@@ -1,40 +1,33 @@
-## Navigation
-
-[Top](../Readme.md)
-
-<- [docs - General](Readme.md)
-
 # Parsing
 
-The library features a naive single-pass parser, tailored for only what the library needs; for construction of C++ code into gencpp's AST for *"front-end"* meta-programming purposes.
+The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.
 
-This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~7000 loc. I hope to keep it under 10-15k loc worst case.
+This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~5600 loc. I hope to keep it under 10k loc worst case.
 
-You can think of this parser as *frontend parser* vs a *semantic parser*. Its intuitively similar to WYSIWYG. What you ***perceive*** as the syntax from the user-side before the compiler gets a hold of it, is what you get.
+You can think of this parser of a frontend parser vs a semantic parser. Its intuitively similar to WYSIWYG. What you precerive as the syntax from the user-side before the compiler gets a hold of it, is what you get.
 
 User exposed interface:
 
 ```cpp
-CodeClass       parse_class        ( Str class_def       );
-CodeConstructor parse_constructor  ( Str constructor_def );
-CodeDefine      parse_define       ( Str define_def      );
-CodeDestructor  parse_destructor   ( Str destructor_def  );
-CodeEnum        parse_enum         ( Str enum_def        );
-CodeBody        parse_export_body  ( Str export_def      );
-CodeExtern      parse_extern_link  ( Str exten_link_def  );
-CodeFriend      parse_friend       ( Str friend_def      );
-CodeFn          parse_function     ( Str fn_def          );
-CodeBody        parse_global_body  ( Str body_def        );
-CodeNS          parse_namespace    ( Str namespace_def   );
-CodeOperator    parse_operator     ( Str operator_def    );
-CodeOpCast      parse_operator_cast( Str operator_def    );
-CodeStruct      parse_struct       ( Str struct_def      );
-CodeTemplate    parse_template     ( Str template_def    );
-CodeType        parse_type         ( Str type_def        );
-CodeTypedef     parse_typedef      ( Str typedef_def     );
-CodeUnion       parse_union        ( Str union_def       );
-CodeUsing       parse_using        ( Str using_def       );
-CodeVar         parse_variable     ( Str var_def         );
+CodeClass       parse_class        ( StrC class_def       );
+CodeConstructor parse_constructor  ( StrC constructor_def );
+CodeDestructor  parse_destructor   ( StrC destructor_def  );
+CodeEnum        parse_enum         ( StrC enum_def        );
+CodeBody        parse_export_body  ( StrC export_def      );
+CodeExtern      parse_extern_link  ( StrC exten_link_def  );
+CodeFriend      parse_friend       ( StrC friend_def      );
+CodeFn          parse_function     ( StrC fn_def          );
+CodeBody        parse_global_body  ( StrC body_def        );
+CodeNS          parse_namespace    ( StrC namespace_def   );
+CodeOperator    parse_operator     ( StrC operator_def    );
+CodeOpCast      parse_operator_cast( StrC operator_def    );
+CodeStruct      parse_struct       ( StrC struct_def      );
+CodeTemplate    parse_template     ( StrC template_def    );
+CodeType        parse_type         ( StrC type_def        );
+CodeTypedef     parse_typedef      ( StrC typedef_def     );
+CodeUnion       parse_union        ( StrC union_def       );
+CodeUsing       parse_using        ( StrC using_def       );
+CodeVar         parse_variable     ( StrC var_def         );
 ```
 
 To parse file buffers, use the `parse_global_body` function.
@@ -54,106 +47,35 @@ The keywords supported for the preprocessor are:
 * endif
 * pragma
 
-Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST node.
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.  
 If a directive is used with an unsupported keyword its will be processed as an untyped AST.
 
-The preprocessor lines are stored as members of their associated scope they are parsed within ( Global, Namespace, Class/Struct ).
-***Again: These ASTs will be considered members or entries of braced scope they reside within***
+The preprocessor lines are stored as members of their associated scope they are parsed within. ( Global, Namespace, Class/Struct )
 
 Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).  
 Exceptions:
 
-* variable definitions are allowed for a preprocessed macro `extern MACRO();`
-* function definitions are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
+* function signatures are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES`
 * typedefs allow for a preprocessed macro: `typedef MACRO();`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_TYPEDEF`
-* Macros can behave as typenames
-* There is some macro support in parameters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
 
 *(Exceptions are added on an on-demand basis)*
 *(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
 
 Adding your own exceptions is possible by simply modifying the parser to allow for the syntax you need.
 
-*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase contains some egregious preprocessor abuse.*
+*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase some some egregious preprocessor abuse.*
 
-Macros used within a file should be registered by the user before parsing. This can be done two ways:
+The lexing and parsing takes shortcuts from whats expected in the standard.
 
-1. The register macro interface within [interface.hpp](../base/components/interface.hpp).
-2. Using `def_define` to create a CodeDefine and making sure to not set `opts.dont_register_to_preprocess_macros` to `true`.
-
-## Registering macros
-
-While the registeration of macros in the meta-program's side for parsing can be considered tedius, its necessary for the parser to accurately resolve the macros intent in one pass (and it provides some hygenics by verifying that they are used as intended).
-
-The following can be used to register a macro:
-
-```c
-GEN_API void register_macro( Macro macro );
-GEN_API void register_macros( s32 num, ... );
-GEN_API void register_macros_arr( s32 num, Macro* macros );
-```
-
-The Macro typename is defined with the following in [parser_types.hpp](../base/components/parser_types.hpp):
-
-```c
-struct Macro
-{
-    StrCached  Name;
-    MacroType  Type;
-    MacroFlags Flags;
-};
-```
-
-The macro can be designated one of the following types:
-
-* `MT_Expression`: Intended to resolve to an expression expansion.
-* `MT_Statement`: Intended to resolve an statement expansion.
-* `MT_Typename`: Intended to resolve to a typename.
-
-Additioonally tthe following flags may be set:
-
-* `MF_Functional`: The macro intended to be passed arguments are at least have the calling `()` as part of its usage.
-* `MF_Expects_Body`: The parser should expect a braced-body `{ ... }` after the macro signature `<name> <params>`
-* `MF_Allow_As_Identifier`: Will allow the macro to be an acceptable token/s when an `Tok_Identifier` is expected.
-* `MF_Allow_As_Attribute`: Will allow the macro to be an acceptable token/s when an attribute token/s is expected.
-* `MF_Allow_As_Definition`: Will allow the macro be an acceptable token/s when the parser expects a declartion or definition to resolve after attributes or specifiers have been identified beforehand.
-  * This flag requires that the macro is of type `MT_Statement` to make any sense of usage.
-
-If a macro is not defined the following warning will be issued if `GEN_BUILD_DEBUG=1` during lexing within [lexer.cpp](../base/components/lexer.cpp) - `lex_preprocessor_define`:
-
-```c
-log_fmt("Warning: '%S' was not registered before the lexer processed its #define directive, it will be registered as a expression macro\n"
-    , name.Text 
-);
-```
-
-Further within the same scope, the lexer will issue a warning if it detects a macro was not flagged as function but has an open parenthesis `(` token right after is name with no whitespace:
-
-```c
-log_fmt("Warning: %S registered macro is not flagged as functional yet the definition detects opening parenthesis '(' for arguments\n"
-    , name.Text
-);
-```
-
-Macros are tracked using a `MacroTable Macros;` defined as a member of the library's `Context`.
-
-```c
-typedef HashTable(Macro) MacroTable;
-```
-
-## Notes
-
-* Empty lines used throughout the file are preserved for formatting purposes during ast serialization (they have a dedicated Token: `Tok_NewLine`).
 * Numeric literals are not checked for validity.
-* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs. (There is a [todo](https://github.com/Ed94/gencpp/issues/49) to add support)
+* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
   * *This includes the assignment of variables.*
 * Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
   * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function or right afterthe return type.
   * Or in the usual spot for class, structs, (*right after the declaration keyword*)
   * typedefs have attributes with the type (`parse_type`)
 * Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
-  * This is useful for example: parsing Unreal `Module_API` macros.
 
-**The lexer & parser do not gracefully attempt to continue when it comes across incorrect code, and doesn't properly track errors into a listing (yet).**
+Empty lines used throughout the file are preserved for formatting purposes during ast serialization.

docs/Readme.md

@@ -1,18 +1,48 @@
-# General Docs
+## Documentation
 
-[Top](../Readme.md)
+The project has no external dependencies beyond:
 
-Contains:
+* `errno.h`
+* `stat.h`
+* `stdarg.h`
+* `stddef.h`
+* `stdio.h`
+* `copyfile.h` (Mac)
+* `types.h`    (Linux)
+* `unistd.h`   (Linux/Mac)
+* `intrin.h`   (Windows)
+* `io.h`       (Windows with gcc)
+* `windows.h`  (Windows)
 
-* [AST_Design](./AST_Design.md): Overview of ASTs
-* [AST Types](./AST_Types.md): Listing of all AST types along with their Code type interface.
-* [Parsing](./Parsing.md): Overview of the parsing interface.
-* [Parser Algo](./Parser_Algo.md): In-depth breakdown of the parser's implementation.
+Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).  
+The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
 
-### *CURRENTLY UNSUPPORTED*
+This library was written in a subset of C++ where the following are not used at all:
+
+* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
+* Language provide dynamic dispatch, RTTI
+* Object-Oriented Inheritance
+* Exceptions
+
+Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.  
+There are only 4 template definitions in the entire library. (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `AST/Code::cast<Type>`)
+
+Two generic templated containers are used throughout the library:
+
+* `template< class Type> struct Array`
+* `template< class Type> struct HashTable`
+
+Both Code and AST definitions have a `template< class Type> Code/AST :: cast()`. Its just an alternative way to explicitly cast to each other.
+
+`template< class Type> swap( Type& a, Type& b)` is used over a macro.
+
+Otherwise the library is free of any templates.
+
+### *WHAT IS NOT PROVIDED*
 
 **There is no support for validating expressions.**  
-Its a [todo](https://github.com/Ed94/gencpp/issues/49)
+Its difficult to parse without enough benefits (At the metaprogramming level).  
+I plan to add this only at the tail of the project parsing milestone.
 
 **Only trivial template support is provided.**  
 The intention is for only simple, non-recursive substitution.  
@@ -23,107 +53,144 @@ This means that the typename entry for the parameter AST would be either:
 * `typename`
 * A fundamental type, function, or pointer type.
 
-***Concepts and Constraints are not supported***  
-Its a [todo](https://github.com/Ed94/gencpp/issues/21)
+Anything beyond this usage is not supported by parse_template for arguments (at least not intentionally).  
+Use at your own mental peril.
 
-### Feature Macros
-
-* `GEN_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing.
-  * This can be generated using base.cpp.
-* `GEN_DEFINE_LIBRARY_CORE_CONSTANTS` : Optional typename codes as they are non-standard to C/C++ and not necessary to library usage
-* `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
-* `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
-* `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
-* `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
-* `GEN_DONT_ALLOW_INVALID_CODE` (Not implemented yet) : Will fail when an invalid code is constructed, parsed, or serialized.
-* `GEN_C_LIKE_CPP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
+*Concepts and Constraints are not supported, its usage is non-trivial substitution.*
 
 ### The Data & Interface
 
-The library's persistent state is managed tracked by a context struct: `global Context* _ctx;` defined within [static_data.cpp](../base/components/static_data.cpp)
-
-https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/interface.hpp#L39-L97
-
-The interface for the context:
-
-* `init`: Initializtion
-* `deinit`: De-initialization.
-* `reset`: Clears the allocations, but doesn't free the memoery, then calls `init()` on `_ctx` again.
-* `get_context`: Retreive the currently tracked context.
-* `set_context`: Swap out the current tracked context.
-
-
-#### Allocato usage
-
-* `Allocator_DyanmicContainers`: Growing arrays, hash tables. (Unbounded sized containers)
-* `Allocator_Pool`: Fixed-sized object allocations (ASTs, etc)
-* `Allocator_StrCache`: StrCached allocations
-* `Allocator_Temp`: Temporary alloations mostly intended for StrBuilder usage. Manually cleared by the user by their own discretion.
-
-The allocator definitions used are exposed to the user incase they want to dictate memory usage
-
-* Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
-* Most of the work is just defining the allocation procedure:
-
-```cpp
-    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
-```
-
-For any allocator above that the user does not define before `init`, a fallback allocator will be assigned that utiizes the `fallback_allocator_proc` wtihin [interface.cpp](../base/components/interface.cpp).
-
 As mentioned in root readme, the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
 
 The AST is managed by the library and provided to the user via its interface.  
 However, the user may specifiy memory configuration.
 
-[Data layout of AST struct (Subject to heavily change with upcoming todos)](../base/components/ast.hpp#L396-461)  
+Data layout of AST struct (Subject to heavily change with upcoming redesign):
 
-https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/ast.hpp#L369-L435
+```cpp
+union {
+    struct
+    {
+        AST*      InlineCmt;       // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
+        AST*      Attributes;      // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+        AST*      Specs;           // Destructor, Function, Operator, Typename, Variable
+        union {
+            AST*  InitializerList; // Constructor
+            AST*  ParentType;      // Class, Struct, ParentType->Next has a possible list of interfaces.
+            AST*  ReturnType;      // Function, Operator, Typename
+            AST*  UnderlyingType;  // Enum, Typedef
+            AST*  ValueType;       // Parameter, Variable
+        };
+        union {
+            AST*  Macro;           // Parameters
+            AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
+            AST*  Params;          // Constructor, Function, Operator, Template, Typename
+        };
+        union {
+            AST*  ArrExpr;          // Typename
+            AST*  Body;             // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+            AST*  Declaration;      // Friend, Template
+            AST*  Value;            // Parameter, Variable
+        };
+        union {
+            AST*  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
+            AST*  SpecsFuncSuffix;  // Only used with typenames, to store the function suffix if typename is function signature.
+        };
+    };
+    StringCached  Content;          // Attributes, Comment, Execution, Include
+    struct {
+        SpecifierT ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
+        AST*       NextSpecs;                   // Specifiers
+    };
+};
+union {
+    AST* Prev;
+    AST* Front;
+    AST* Last;
+};
+union {
+    AST* Next;
+    AST* Back;
+};
+AST*              Parent;
+StringCached      Name;
+CodeT             Type;
+ModuleFlag        ModuleFlags;
+union {
+    b32           IsFunction;  // Used by typedef to not serialize the name field.
+    b32           IsParamPack; // Used by typename to know if type should be considered a parameter pack.
+    OperatorT     Op;
+    AccessSpec    ParentAccess;
+    s32           NumEntries;
+};
+s32               Token;       // Handle to the token, stored in the CodeFile (Otherwise unretrivable)
+```
 
-*`StringCahced` is a typedef for `Str` (a string slice), to denote it is an interned string*  
-*`CodeType` is enum taggin the type of code. Has an underlying type of `u32`*  
+*`CodeT` is a typedef for `ECode::Type` which has an underlying type of `u32`*  
 *`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*  
-*`StrBuilder` is the dynamically allocating string builder type for the library*  
+*`StringCahced` is a typedef for `String const`, to denote it is an interned string*  
+*`String` is the dynamically allocated string type for the library*
 
-AST widths are setup to be AST_POD_Size (128 bytes by default).
+AST widths are setup to be AST_POD_Size.
 The width dictates how much the static array can hold before it must give way to using an allocated array:
 
 ```cpp
 constexpr static
-int AST_ArrSpecs_Cap =
+uw ArrSpecs_Cap =
 (
     AST_POD_Size
-    - sizeof(Code)
-    - sizeof(StrCached)
-    - sizeof(Code) * 2
-    - sizeof(Token*)
-    - sizeof(Code)
-    - sizeof(CodeType)
+    - sizeof(AST*) * 3
+    - sizeof(StringCached)
+    - sizeof(CodeT)
     - sizeof(ModuleFlag)
     - sizeof(u32)
 )
-/ sizeof(Specifier) - 1;
+/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
 ```
+
+*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
+
 Data Notes:
 
+* The allocator definitions used are exposed to the user incase they want to dictate memory usage
+  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
+  * Allocators are defined with the `AllocatorInfo` structure found in `dependencies\memory.hpp`
+  * Most of the work is just defining the allocation procedure:
+
+```cpp
+    void* ( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+```
+
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
-* Code types have member symbols but their data layout is enforced to be POD types.
+* Both AST and Code have member symbols but their data layout is enforced to be POD types.
 * This library treats memory failures as fatal.
 * Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
+  * `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
 * Strings used for serialization and file buffers are not contained by those used for cached strings.
-  * `_ctx->Allocator_Temp` is used.
+  * They are currently using `GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
+  * Memory within the buckets is not reused, so its inherently wasteful.
+  * I will be augmenting the single arena with a simple slag allocator.
+* Linked lists used children nodes on bodies, and parameters.
 * Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
-  * Any modifcations to an existing AST should be to just construct another with the modifications done on-demand while traversing the AST (non-destructive).
+* Allocations can be tuned by defining the folloiwng macros:
+  * `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
+  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
+  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
+  * `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
+  * `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
+  * `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
+  * `GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE` : token_fmt_va uses local_persit memory of this size for the hashtable.
+  * `GEN_LEX_ALLOCATOR_SIZE`
+  * `GEN_BUILDER_STR_BUFFER_RESERVE`
 
 The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
 
-* CodeBody : Has support for `for : range` iterating across Code objects.
+* CodeBody : Has support for `for-range` iterating across Code objects.
 * CodeAttributes
 * CodeComment
 * CodeClass
 * CodeConstructor
 * CodeDefine
-* CodeDefineParams
 * CodeDestructor
 * CodeEnum
 * CodeExec
@@ -134,28 +201,24 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeModule
 * CodeNS
 * CodeOperator
-* CodeOpCast : User defined member operator conversion
-* CodeParams : Has support for `for : range` iterating across parameters.
+* CodeOpCast
+* CodeParam : Has support for `for-range` iterating across parameters.
 * CodePreprocessCond
 * CodePragma
-* CodeSpecifiers : Has support for `for : range` iterating across specifiers.
+* CodeSpecifiers : Has support for `for-range` iterating across specifiers.
 * CodeStruct
 * CodeTemplate
-* CodeTypename
+* CodeType
 * CodeTypedef
 * CodeUnion
 * CodeUsing
 * CodeVar
 
-Each `struct Code<Name>` has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
+Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
 Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
+Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
 
-For the interface related to these code types see:
-
-* [ast.hpp](../base/components/ast.hpp): Under the region pragma `Code C-Interface`
-* [code_types.hpp](../base/components/code_types.hpp): Under the region pragma `Code C-Interface`. Additional functionlity for c++ will be within the struct definitions or at the end of the file.
-
-## There are three categories of interfaces for Code AST generation & reflection
+## There are three sets of interfaces for Code AST generation the library provides
 
 * Upfront
 * Parsing
@@ -175,7 +238,6 @@ Interface :``
 * def_class
 * def_constructor
 * def_define
-* def_define_params
 * def_destructor
 * def_enum
 * def_execution
@@ -230,29 +292,7 @@ Code <name>
 
 ```
 
-All optional parmeters are defined within `struct Opts_def_<functon name>`. This was done to setup a [macro trick](https://x.com/vkrajacic/status/1749816169736073295) for default optional parameers in the C library:
-
-```cpp
-struct gen_Opts_def_struct
-{
-	gen_CodeBody       body;
-	gen_CodeTypename   parent;
-	gen_AccessSpec     parent_access;
-	gen_CodeAttributes attributes;
-	gen_CodeTypename*  interfaces;
-	gen_s32            num_interfaces;
-	gen_ModuleFlag     mflags;
-};
-typedef struct gen_Opts_def_struct gen_Opts_def_struct;
-
-GEN_API gen_CodeClass gen_def__struct( gen_Str name, gen_Opts_def_struct opts GEN_PARAM_DEFAULT );
-#define gen_def_struct( name, ... ) gen_def__struct( name, ( gen_Opts_def_struct ) { __VA_ARGS__ } )
-```
-
-In the C++ library, the `def_<funtion name>` is not wrapped in a macro.
-
 When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
-
 ```cpp
 def_global_body( args( ht_entry, array_ht_entry, hashtable ));
 
@@ -260,8 +300,8 @@ def_global_body( args( ht_entry, array_ht_entry, hashtable ));
 def_global_body( 3, ht_entry, array_ht_entry, hashtable );
 ```
 
-If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty bodyss
-When the members have been populated use: `code_validate_body` to verify that the members are valid entires for that type.
+If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.  
+When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
 
 ### Parse construction
 
@@ -271,12 +311,12 @@ Interface :
 
 * parse_class
 * parse_constructor
-* parse_define
 * parse_destructor
 * parse_enum
 * parse_export_body
 * parse_extern_link
 * parse_friend
+  * Purposefully are only support forward declares with this constructor.
 * parse_function
 * parse_global_body
 * parse_namespace
@@ -333,7 +373,6 @@ Code <name> = untyped_str( code(
 ```
 
 Optionally, `code_str`, and `code_fmt` macros can be used so that the code macro doesn't have to be used:
-
 ```cpp
 Code <name> = code_str( <some code without "" quotes > )
 ```
@@ -341,7 +380,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
-Str value = txt("Something");
+StrC value = txt("Something");
 
 char const* template_str = txt(
     Code with <key> to replace with token_values
@@ -355,7 +394,6 @@ Code        <name>       = parse_<function name>( gen_code_str );
 
 The following are provided predefined by the library as they are commonly used:
 
-* `enum_underlying_macro`
 * `access_public`
 * `access_protected`
 * `access_private`
@@ -364,8 +402,8 @@ The following are provided predefined by the library as they are commonly used:
 * `module_global_fragment`
 * `module_private_fragment`
 * `fmt_newline`
-* `pragma_once`
 * `param_varaidc` (Used for varadic definitions)
+* `pragma_once`
 * `preprocess_else`
 * `preprocess_endif`
 * `spec_const`
@@ -381,7 +419,6 @@ The following are provided predefined by the library as they are commonly used:
 * `spec_local_persist` (local_persist macro)
 * `spec_mutable`
 * `spec_neverinline`
-* `spec_noexcept`
 * `spec_override`
 * `spec_ptr`
 * `spec_pure`
@@ -413,8 +450,8 @@ Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` i
 * `t_u16`
 * `t_u32`
 * `t_u64`
-* `t_ssize` (ssize_t)
-* `t_usize` (size_t)
+* `t_sw` (ssize_t)
+* `t_uw` (size_t)
 * `t_f32`
 * `t_f64`
 
@@ -432,22 +469,21 @@ and have the desired specifiers assigned to them beforehand.
 
 ## Code generation and modification
 
-There are two provided auxiliary interfaces:
+There are three provided auxillary interfaces:
 
 * Builder
+* Editor
 * Scanner
 
-### Builder is a similar object to the jai language's strbuilder_builder
+Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FEATURE_SCANNER` to enable them.
+
+### Builder is a similar object to the jai language's string_builder
 
 * The purpose of it is to generate a file.
 * A file is specified and opened for writing using the open( file_path) function.
 * The code is provided via print( code ) function  will be serialized to its buffer.
 * When all serialization is finished, use the write() command to write the buffer to the file.
 
-### Scanner
+### Scanner Auxillary Interface
 
-* The purpose is to scan or parse files
-* Some with two basic functions to convert a fil to code: `scan_file` and `parse_file`
-  * `scan_file`: Merely grabs the file and stores it in an untyped Code.
-  * `parse_file`: Will parse the file using `parse_global_body` and return a `CodeBody`.
-* Two basic functions for grabbing columns from a CSV: `parse_csv_one_column` and `parse_csv_two_columns`
+Provides *(eventually)* `scan_file` to automatically populate a CodeFile which contains a parsed AST (`Code`) of the file, with any contextual failures that are reported from the parser.

gen_c_library/.editorconfig

@@ -1,8 +0,0 @@
-[*.c]
-indent_style = tab
-indent_size  = 4
-
-[*.cpp]
-indent_style = tab
-indent_size  = 2
-

gen_c_library/Readme.md

@@ -1,147 +0,0 @@
-## Navigation
-
-[Top](../Readme.md)
-
-* [docs](../docs/Readme.md)
-
-# C Library Generation
-
-`c_library.cpp` generates both *segemnted* and *singleheader* variants of the library compliant with C11.
-
-The output will be in the `gen_segmented/gen` directory (if the directory does not exist, it will create it).
-
-If using the library's provided build scripts:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> c_lib
-```
-
-To generate a static or dynamic library:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> c_lib_static c_lib_dyn
-```
-.
-All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying [c_library.refactor](./c_library.refactor).
-
-**If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.**
-
-## Generation structure
-
-1. Files are scanned in or parsed.
-    * If they are parsed, its due to requiring some changes to either naming, or adding additonal definitions (container generation, typedefs, etc).
-2. All scanned or parsed code is refactored (identifiers substs) and/or formatted.
-3. Singleheader generated.
-4. Segmented headers and source generated.
-
-## Templated container generation
-
-The array and hashtable containers used across this library are generated using the following implementatioon:
-
-* [containers.array.hpp](./components/containers.array.hpp)
-* [containers.hashtable.hpp](./components/containers.hashtable.hpp)
-
-These are functionally (and interface wise) equivalent to the library's `Array<Type>` `HashTable<Type>` within [containers.hpp](../base/dependencies/containers.hpp)
-
-Both files follow the same pattern of providing three procedures:
-
-* `gen_<container>_base` : Intended to be called once, defines universal "base" definitions.
-* `gen_<container>` : Called per instatiation of the container for a given set of dependent args.
-* `gen_<container>_generic_selection_interface` : Intended to be called once after all of the instantiated containers have finished generating. It will generate a set of generic selection macros as described by Macro Usage section below.
-
-A simple `<container>_DefinitionCounter` is used to know how many instantiations of the template have occured. This is used to determine how to define `GENERIC_SLOT_<ID>_<functionID>` for the generic interface along with how many slots the `_Generic` macro will need to have generated.
-
-## Macro Usage
-
-For the most part macros are kept minimal with exception to `_Generic`...  
-
-The `_Generic` macro plays a key role in reducing direct need of the user to wrangle with mangled definition identifiers of 'templated' containers or for type coercion to map distinct data types to a common code path.
-
-Many C11 libraries don't use it.. and, of those that do. they usually end up obfuscate it with excessive preprocessor abuse; Effort was put into minimizing how much of these macros are handled by the preprocessor vs gencpp itself.
-
-*(I will be explaining this thing for the rest of this seciton along with gencpp c library's usage of it)*
-
-
-The usual presentation (done bare) is the following:
-
-```c
-#define macro_that_selects_typeof_arg(arg, y) \
-_Generic( (arg),                              \
-    int            : some expression,         \
-    double         : some other expression,   \
-    struct Whatnot : something else again,    \
-    default        : fallback expression      \
-)
-```
-
-Where `_Generic` can be considered the follwoing (psuedo-C):
-
-```c
-#define type_expr_pair(type, expr) type: expr
-
-C_Expression _Generic( selector_arg, a_type_expr_pair, ... ) {
-    switch( typeof(selector_arg)) {
-        case a_type_expr_pair:
-            return a_type_expr_pari.expr;
-        ...
-        default:
-            return default.expr;
-    }
-}
-```
-
-The first `arg` of _Generic behaves as the "controlling expression" or the expression that resolves to a type which will dictate which of the following expressions provided after to `_Generic` will be resolved as the one used inline for the implemenation.
-
-
-For this library's purposes we'll be using the functional macro equivalent *(if there is an exception I'll link it at the end of this section)*:
-
-```c
-#define macro_that_uses_selector_arg_for_resolving_a_fucntion( selecting_exp) \
-_Generic( (selecting_exp),                                                    \
-    int            : func_use_int,                                            \
-    double         : func_use_double,                                         \
-    struct Whatnot : func_use_Whatnot,                                        \
-    default        : struct SIGNALS_FAILURE                                   \
-) (selecting_exp)
-```
-
-In this case, we directly added `(selecting_exp)` to the end there.. as we want to directly have the macro resolve to calling a resolved procedure. A default has been set to a struct as that leads to a neat compiler message that would otherwise be impossible beause static_assert is a statement and thus cannot be used within a slot.
-
-Now, even with gencpp generating this type-expression table, we still need wrapper macros to achieve function 'overloading' for the templated containers as _Generic has a [significant drawback](https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/c11-generic/):  
-
-> Discarded expressions still have to be semantically valid.
-
-The only way to absolve this issue [(without resorting to nasty preprocessor hacks)](https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md) is with wrapping expressions in 'slot' resolving macros that do not expand if the slot is not defined:
-
-```c
-GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig )
-```
-
-`GENERIC_SLOT_1__function_sig` is our warpper of a "`int, func_use_int`" pair. The `GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT` is a verbse named macro to indicate that that pair will be expanded ***ONLY IF*** its defined.
-
-So for any given templated container interface. Expect the follwoing (taken straight from generation, and just cleaned up formatting):
-
-```c
-#define gen_array_append( selector_arg, ... ) _Generic(                         \
-(selector_arg ),                                                                \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_1__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_2__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_3__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_4__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_5__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_6__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_7__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_8__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_9__array_append )  \
-    GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GEN_GENERIC_SLOT_10__array_append ) \
-    default: gen_generic_selection_fail                                         \
-) GEN_RESOLVED_FUNCTION_CALL( &selector_arg, __VA_ARGS__ )
-
-```
-
-*Note(Ed): Unfortunately I cannot get clang-format to output these macros sanely like the above..*  
-*Eventually I'll add some basic builtin formatting but if the user has suggestions for something better I'm open ears...*
-
-`GEN_RESOLVED_FUNCTION_CALL` is an empty define, its just to indicate that its intended to expand to a function call.
-
-To see the the actual macro definitions used - see: [generic_macros.h](./components/generic_macros.h). They'll be injected right after the usual macros in the generated header file.

gen_c_library/c_library.refactor

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

gen_c_library/components/containers.array.hpp

@@ -1,434 +0,0 @@
-#pragma once
-#include "gen.hpp"
-
-using namespace gen;
-
-// Used to know what slot the array will be for generic selection
-global s32 Array_DefinitionCounter = 0;
-
-CodeBody gen_array_base()
-{
-	CodeTypedef td_header = parse_typedef( code( typedef struct ArrayHeader ArrayHeader; ));
-	CodeStruct  header    = parse_struct( code(
-		struct ArrayHeader
-		{
-			AllocatorInfo Allocator;
-			usize         Capacity;
-			usize         Num;
-		};
-	));
-
-	Code grow_formula = untyped_str( txt( "#define array_grow_formula( value ) ( 2 * value + 8 )\n" ));
-	Code get_header   = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" ));
-	Code type_define  = untyped_str( txt( "#define Array(Type) gen_Array_##Type\n"));
-
-	Code array_begin = def_define(txt("array_begin(array)"),       MT_Expression, { {}, code( (array) ) } );
-	Code array_end   = def_define(txt("array_end(array)"),         MT_Expression, { {}, code( (array + array_get_header(array)->Num ) ) } );
-	Code array_next  = def_define(txt("array_next(array, entry)"), MT_Expression, { {}, code( (entry + 1) ) } );
-
-	return def_global_body( args(
-		fmt_newline,
-		td_header,
-		header,
-		type_define,
-		grow_formula,
-		get_header,
-		array_begin,
-		array_end,
-		array_next,
-		fmt_newline
-	));
-};
-
-CodeBody gen_array( Str type, Str array_name )
-{
-	StrBuilder array_type = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
-	StrBuilder fn         = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
-	// c_str_to_lower(fn.Data);
-
-#pragma push_macro( "GEN_ASSERT" )
-#pragma push_macro( "rcast" )
-#pragma push_macro( "cast" )
-#pragma push_macro( "typeof" )
-#pragma push_macro( "forceinline" )
-#undef GEN_ASSERT
-#undef rcast
-#undef cast
-#undef typeof
-#undef forceinline
-	CodeBody result = parse_global_body( token_fmt( "array_type", (Str)array_type, "fn", (Str)fn, "type", (Str)type
-	, stringize(
-		typedef <type>* <array_type>;
-
-		<array_type> <fn>_init           ( AllocatorInfo allocator );
-		<array_type> <fn>_init_reserve   ( AllocatorInfo allocator, usize capacity );
-		bool         <fn>_append_array   ( <array_type>*  self, <array_type> other );
-		bool         <fn>_append         ( <array_type>*  self, <type> value );
-		bool         <fn>_append_items   ( <array_type>*  self, <type>* items, usize item_num );
-		bool         <fn>_append_at      ( <array_type>*  self, <type> item, usize idx );
-		bool         <fn>_append_items_at( <array_type>*  self, <type>* items, usize item_num, usize idx );
-		<type>*      <fn>_back           ( <array_type>   self );
-		void         <fn>_clear          ( <array_type>   self );
-		bool         <fn>_fill		     ( <array_type>   self, usize begin, usize end, <type> value );
-		void         <fn>_free           ( <array_type>*  self );
-		bool         <fn>_grow           ( <array_type>*  self, usize min_capacity );
-		usize        <fn>_num            ( <array_type>   self );
-		<type>       <fn>_pop 	         ( <array_type>   self );
-		void         <fn>_remove_at      ( <array_type>   self, usize idx );
-		bool         <fn>_reserve        ( <array_type>*  self, usize new_capacity );
-		bool         <fn>_resize         ( <array_type>*  self, usize num );
-		bool         <fn>_set_capacity   ( <array_type>*  self, usize new_capacity );
-
-		forceinline
-		<array_type> <fn>_init( AllocatorInfo allocator )
-		{
-			size_t initial_size = array_grow_formula(0);
-			return array_init_reserve( <type>, allocator, initial_size );
-		}
-
-		inline
-		<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
-		{
-			GEN_ASSERT(capacity > 0);
-			ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity));
-
-			if (header == nullptr)
-				return nullptr;
-
-			header->Allocator = allocator;
-			header->Capacity  = capacity;
-			header->Num       = 0;
-
-			return rcast(<type>*, header + 1);
-		}
-
-		forceinline
-		bool <fn>_append_array( <array_type>* self, <array_type> other )
-		{
-			return array_append_items( * self, (<array_type>)other, <fn>_num(other));
-		}
-
-		inline
-		bool <fn>_append( <array_type>* self, <type> value )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( header->Num == header->Capacity )
-			{
-				if ( ! array_grow( self, header->Capacity))
-					return false;
-
-				header = array_get_header( * self );
-			}
-
-			(* self)[ header->Num ] = value;
-			header->Num++;
-
-			return true;
-		}
-
-		inline
-		bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			GEN_ASSERT(items != nullptr);
-			GEN_ASSERT(item_num > 0);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( header->Num + item_num > header->Capacity )
-			{
-				if ( ! array_grow( self, header->Capacity + item_num ))
-					return false;
-
-				header = array_get_header( * self );
-			}
-
-			mem_copy( (* self) + header->Num, items, sizeof(<type>) * item_num );
-			header->Num += item_num;
-
-			return true;
-		}
-
-		inline
-		bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( idx >= header->Num )
-				idx = header->Num - 1;
-
-			if ( idx < 0 )
-				idx = 0;
-
-			if ( header->Capacity < header->Num + 1 )
-			{
-				if ( ! array_grow( self, header->Capacity + 1 ) )
-					return false;
-
-				header = array_get_header( * self );
-			}
-
-			<array_type> target = (* self) + idx;
-
-			mem_move( target + 1, target, (header->Num - idx) * sizeof(<type>) );
-			header->Num++;
-
-			return true;
-		}
-
-		inline
-		bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( idx >= header->Num )
-			{
-				return array_append_items( * self, items, item_num );
-			}
-
-			if ( item_num > header->Capacity )
-			{
-				if ( ! array_grow( self, item_num + header->Capacity ) )
-					return false;
-
-				header = array_get_header( * self );
-			}
-
-			<type>* target = (* self) + idx + item_num;
-			<type>* src    = (* self) + idx;
-
-			mem_move( target, src, (header->Num - idx) * sizeof(<type>) );
-			mem_copy( src, items, item_num * sizeof(<type>) );
-			header->Num += item_num;
-
-			return true;
-		}
-
-		inline
-		<type>* <fn>_back( <array_type> self )
-		{
-			GEN_ASSERT(self != nullptr);
-			ArrayHeader* header = array_get_header( self );
-
-			if ( header->Num == 0 )
-				return NULL;
-
-			return self + header->Num - 1;
-		}
-
-		inline
-		void <fn>_clear( <array_type> self )
-		{
-			GEN_ASSERT(self != nullptr);
-			ArrayHeader* header = array_get_header( self );
-			header->Num = 0;
-		}
-
-		inline
-		bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
-		{
-			GEN_ASSERT(self != nullptr);
-			GEN_ASSERT(begin <= end);
-			ArrayHeader* header = array_get_header( self );
-
-			if ( begin < 0 || end > header->Num )
-				return false;
-
-			for ( ssize idx = (ssize)begin; idx < (ssize)end; idx ++ )
-				self[ idx ] = value;
-
-			return true;
-		}
-
-		inline
-		void <fn>_free( <array_type>* self )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			ArrayHeader* header = array_get_header( * self );
-			allocator_free( header->Allocator, header );
-			self = NULL;
-		}
-
-		inline
-		bool <fn>_grow( <array_type>* self, usize min_capacity )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			GEN_ASSERT( min_capacity > 0 );
-			ArrayHeader* header       = array_get_header( *self );
-			usize        new_capacity = array_grow_formula( header->Capacity );
-
-			if ( new_capacity < min_capacity )
-				new_capacity = min_capacity;
-
-			return array_set_capacity( self, new_capacity );
-		}
-
-		forceinline
-		usize <fn>_num( <array_type> self )
-		{
-			GEN_ASSERT(  self != nullptr);
-			return array_get_header(self)->Num;
-		}
-
-		inline
-		<type> <fn>_pop( <array_type> self )
-		{
-			GEN_ASSERT(  self != nullptr);
-			ArrayHeader* header = array_get_header( self );
-			GEN_ASSERT( header->Num > 0 );
-
-			<type> result = self[ header->Num - 1 ];
-			header->Num--;
-			return result;
-		}
-
-		forceinline
-		void <fn>_remove_at( <array_type> self, usize idx )
-		{
-			GEN_ASSERT(  self != nullptr);
-			ArrayHeader* header = array_get_header( self );
-			GEN_ASSERT( idx < header->Num );
-
-			mem_move( self + idx, self + idx + 1, sizeof( <type> ) * ( header->Num - idx - 1 ) );
-			header->Num--;
-		}
-
-		inline
-		bool <fn>_reserve( <array_type>* self, usize new_capacity )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			GEN_ASSERT(new_capacity > 0);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( header->Capacity < new_capacity )
-				return array_set_capacity( self, new_capacity );
-
-			return true;
-		}
-
-		inline
-		bool <fn>_resize( <array_type>* self, usize num )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			GEN_ASSERT(num > 0);
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( header->Capacity < num )
-			{
-				if ( ! array_grow( self, num ) )
-					return false;
-
-				header = array_get_header( * self );
-			}
-
-			header->Num = num;
-			return true;
-		}
-
-		inline
-		bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
-		{
-			GEN_ASSERT(  self != nullptr);
-			GEN_ASSERT(* self != nullptr);
-			GEN_ASSERT( new_capacity > 0 );
-			ArrayHeader* header = array_get_header( * self );
-
-			if ( new_capacity == header->Capacity )
-				return true;
-
-			if ( new_capacity < header->Num )
-			{
-				header->Num = new_capacity;
-				return true;
-			}
-
-			usize        size       = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity;
-			ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size ));
-
-			if ( new_header == NULL )
-				return false;
-
-			mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
-			new_header->Capacity = new_capacity;
-
-			allocator_free( header->Allocator, & header );
-
-			* self = cast( <type>*, new_header + 1 );
-			return true;
-		}
-	)));
-#pragma pop_macro( "GEN_ASSERT" )
-#pragma pop_macro( "rcast" )
-#pragma pop_macro( "cast" )
-#pragma pop_macro( "typeof" )
-#pragma pop_macro( "forceinline" )
-
-	++ Array_DefinitionCounter;
-	Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", Array_DefinitionCounter).to_str();
-
-	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (Str)array_type, "slot", (Str)slot_str,
-R"(#define GENERIC_SLOT_<slot>__array_init         <type>,        <array_type>_init
-#define GENERIC_SLOT_<slot>__array_init_reserve    <type>,        <array_type>_init_reserve
-#define GENERIC_SLOT_<slot>__array_append          <array_type>,  <array_type>_append
-#define GENERIC_SLOT_<slot>__array_append_items    <array_type>,  <array_type>_append_items
-#define GENERIC_SLOT_<slot>__array_append_at       <array_type>,  <array_type>_append_at
-#define GENERIC_SLOT_<slot>__array_append_items_at <array_type>,  <array_type>_append_items_at
-#define GENERIC_SLOT_<slot>__array_back            <array_type>,  <array_type>_back
-#define GENERIC_SLOT_<slot>__array_clear           <array_type>,  <array_type>_clear
-#define GENERIC_SLOT_<slot>__array_fill            <array_type>,  <array_type>_fill
-#define GENERIC_SLOT_<slot>__array_free            <array_type>,  <array_type>_free
-#define GENERIC_SLOT_<slot>__array_grow            <array_type>*, <array_type>_grow
-#define GENERIC_SLOT_<slot>__array_num             <array_type>,  <array_type>_num
-#define GENERIC_SLOT_<slot>__array_pop             <array_type>,  <array_type>_pop
-#define GENERIC_SLOT_<slot>__array_remove_at       <array_type>,  <array_type>_remove_at
-#define GENERIC_SLOT_<slot>__array_reserve         <array_type>,  <array_type>_reserve
-#define GENERIC_SLOT_<slot>__array_resize          <array_type>,  <array_type>_resize
-#define GENERIC_SLOT_<slot>__array_set_capacity    <array_type>*, <array_type>_set_capacity
-)"
-	));
-
-	return def_global_body( args(
-		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", array_type ))),
-		fmt_newline,
-		generic_interface_slot,
-		fmt_newline,
-		result,
-		fmt_newline,
-		def_pragma( strbuilder_to_str(strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", array_type ))),
-		fmt_newline
-	));
-};
-
-CodeBody gen_array_generic_selection_interface()
-{
-	CodeBody interface_defines = def_body(CT_Global_Body);
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_init"), GenericSel_Direct_Type ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_init_reserve"), GenericSel_Direct_Type ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append"), GenericSel_By_Ref ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_at"), GenericSel_By_Ref ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_items"), GenericSel_By_Ref ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_items_at"), GenericSel_By_Ref ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_back"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_clear"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_fill")) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_free"), GenericSel_By_Ref, GenericSel_One_Arg ) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_grow")) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_num"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_pop"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_remove_at")) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_reserve"), GenericSel_By_Ref) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_resize"), GenericSel_By_Ref) );
-	interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_set_capacity")) );
-	return interface_defines;
-}

gen_c_library/components/containers.hashtable.hpp

@@ -1,433 +0,0 @@
-#pragma once
-#include "gen.hpp"
-#include "containers.array.hpp"
-
-using namespace gen;
-
-global s32 HashTable_DefinitionCounter = 0;
-
-CodeBody gen_hashtable_base()
-{
-	CodeBody struct_def = parse_global_body( code(
-		typedef struct HT_FindResult_Def HT_FindResult;
-		struct HT_FindResult_Def
-		{
-			ssize HashIndex;
-			ssize PrevIndex;
-			ssize EntryIndex;
-		};
-	));
-
-	Code define_type = untyped_str(txt(
-R"(#define HashTable(_type) struct gen_HashTable_##_type
-)"
-	));
-
-	Code define_critical_load_scale = untyped_str(txt("#define HashTable_CriticalLoadScale 0.7f\n"));
-	return def_global_body(args(struct_def, define_type, define_critical_load_scale));
-}
-
-CodeBody gen_hashtable( Str type, Str hashtable_name )
-{
-
-	StrBuilder tbl_type = {(char*) hashtable_name.duplicate(_ctx->Allocator_Temp).Ptr};
-	StrBuilder fn       = tbl_type.duplicate(_ctx->Allocator_Temp);
-	// c_str_to_lower(fn.Data);
-
-	StrBuilder name_lower = StrBuilder::make( _ctx->Allocator_Temp, hashtable_name );
-	// c_str_to_lower( name_lower.Data );
-
-	StrBuilder hashtable_entry   = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "HTE_%.*s",     hashtable_name.Len, hashtable_name.Ptr );
-	StrBuilder entry_array_name  = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
-	StrBuilder entry_array_fn_ns = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
-
-	CodeBody hashtable_types = parse_global_body( token_fmt(
-		"type",        (Str) type,
-		"tbl_name",    (Str) hashtable_name,
-		"tbl_type",    (Str) tbl_type,
-	stringize(
-		typedef struct HashTable_<type> <tbl_type>;
-		typedef struct HTE_<tbl_name> HTE_<tbl_name>;
-		struct HTE_<tbl_name> {
-			u64    Key;
-			ssize  Next;
-			<type> Value;
-		};
-
-		typedef void (* <tbl_type>_MapProc)    ( <tbl_type> self, u64 key, <type> value );
-		typedef void (* <tbl_type>_MapMutProc) ( <tbl_type> self, u64 key, <type>* value );
-	)));
-
-	CodeBody entry_array = gen_array( hashtable_entry, entry_array_name );
-
-#pragma push_macro( "GEN_ASSERT" )
-#pragma push_macro( "GEN_ASSERT_NOT_NULL" )
-#pragma push_macro( "rcast" )
-#pragma push_macro( "cast" )
-#pragma push_macro( "typeof" )
-#pragma push_macro( "forceinline" )
-#undef GEN_ASSERT
-#undef GEN_ASSERT_NOT_NULL
-#undef GEN_ASSERT
-#undef rcast
-#undef cast
-#undef typeof
-#undef forceinline
-	CodeBody hashtable_def = parse_global_body( token_fmt(
-		"type",           (Str) type,
-		"tbl_name",       (Str) hashtable_name,
-		"tbl_type",       (Str) tbl_type,
-		"fn",             (Str) fn,
-		"entry_type",     (Str) hashtable_entry,
-		"array_entry",    (Str) entry_array_name,
-		"fn_array",       (Str) entry_array_fn_ns,
-	stringize(
-		struct HashTable_<type> {
-			Array_ssize   Hashes;
-			<array_entry> Entries;
-		};
-
-		<tbl_type> <fn>_init        ( AllocatorInfo allocator );
-		<tbl_type> <fn>_init_reserve( AllocatorInfo allocator, ssize num );
-		void       <fn>_clear       ( <tbl_type>  self );
-		void       <fn>_destroy     ( <tbl_type>* self );
-		<type>*    <fn>_get         ( <tbl_type>  self, u64 key );
-		void       <fn>_map         ( <tbl_type>  self, <tbl_type>_MapProc map_proc );
-		void       <fn>_map_mut     ( <tbl_type>  self, <tbl_type>_MapMutProc map_proc );
-		void       <fn>_grow        ( <tbl_type>* self );
-		void       <fn>_rehash      ( <tbl_type>* self, ssize new_num );
-		void       <fn>_rehash_fast ( <tbl_type>  self );
-		void       <fn>_remove      ( <tbl_type>  self, u64 key );
-		void       <fn>_remove_entry( <tbl_type>  self, ssize idx );
-		void       <fn>_set         ( <tbl_type>* self, u64 key, <type> value );
-		ssize      <fn>_slot        ( <tbl_type>  self, u64 key );
-
-		ssize         <fn>__add_entry( <tbl_type>* self, u64 key );
-		HT_FindResult <fn>__find     ( <tbl_type>  self, u64 key );
-		b32           <fn>__full     ( <tbl_type>  self );
-
-		<tbl_type> <fn>_init( AllocatorInfo allocator )
-		{
-			<tbl_type> result = hashtable_init_reserve(<type>, allocator, 8);
-			return result;
-		}
-
-		<tbl_type> <fn>_init_reserve( AllocatorInfo allocator, ssize num )
-		{
-			<tbl_type> result = { NULL, NULL };
-			result.Hashes  = array_init_reserve(ssize, allocator, num );
-			array_get_header(result.Hashes)->Num = num;
-			array_resize(result.Hashes, num);
-			array_fill(result.Hashes, 0, num, -1);
-
-			result.Entries = array_init_reserve(<entry_type>, allocator, num );
-			return result;
-		}
-
-		void <fn>_clear( <tbl_type> self )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			array_clear( self.Entries );
-			s32 what = array_num(self.Hashes);
-			array_fill( self.Hashes, 0, what, (ssize)-1 );
-		}
-
-		void <fn>_destroy( <tbl_type>* self )
-		{
-			GEN_ASSERT_NOT_NULL(self);
-			GEN_ASSERT_NOT_NULL(self->Hashes);
-			GEN_ASSERT_NOT_NULL(self->Entries);
-			if ( self->Hashes && array_get_header(self->Hashes)->Capacity) {
-				array_free( self->Hashes );
-				array_free( self->Entries );
-			}
-		}
-
-		<type>* <fn>_get( <tbl_type> self, u64 key )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			ssize idx = <fn>__find( self, key ).EntryIndex;
-			if ( idx > 0 )
-				return & self.Entries[idx].Value;
-
-			return nullptr;
-		}
-
-		void <fn>_map( <tbl_type> self, <tbl_type>_MapProc map_proc )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			GEN_ASSERT_NOT_NULL( map_proc );
-
-			for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ ) {
-				map_proc( self, self.Entries[idx].Key, self.Entries[idx].Value );
-			}
-		}
-
-		void <fn>_map_mut( <tbl_type> self, <tbl_type>_MapMutProc map_proc )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			GEN_ASSERT_NOT_NULL( map_proc );
-
-			for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ ) {
-				map_proc( self, self.Entries[idx].Key, & self.Entries[idx].Value );
-			}
-		}
-
-		void <fn>_grow( <tbl_type>* self )
-		{
-			GEN_ASSERT_NOT_NULL(self);
-			GEN_ASSERT_NOT_NULL(self->Hashes);
-			GEN_ASSERT_NOT_NULL(self->Entries);
-			ssize new_num = array_grow_formula( array_get_header( self->Entries )->Num );
-			hashtable_rehash( self, new_num );
-		}
-
-		void <fn>_rehash( <tbl_type>* self, ssize new_num )
-		{
-			GEN_ASSERT_NOT_NULL(self);
-			GEN_ASSERT_NOT_NULL(self->Hashes);
-			GEN_ASSERT_NOT_NULL(self->Entries);
-			GEN_ASSERT( new_num > 0 );
-			ssize idx;
-			ssize last_added_index;
-
-			ArrayHeader* old_hash_header    = array_get_header( self->Hashes );
-			ArrayHeader* old_entries_header = array_get_header( self->Entries );
-
-			<tbl_type> new_tbl = hashtable_init_reserve( <type>, old_hash_header->Allocator, old_hash_header->Num );
-
-			ArrayHeader* new_hash_header = array_get_header( new_tbl.Hashes );
-
-			for (ssize idx = 0; idx < cast(ssize, old_hash_header->Num); ++idx)
-			{
-				<entry_type>* entry = & self->Entries[idx];
-				HT_FindResult find_result;
-
-				find_result      = <fn>__find( new_tbl, entry->Key);
-				last_added_index = <fn>__add_entry( & new_tbl, entry->Key);
-
-				if (find_result.PrevIndex < 0)
-					new_tbl.Hashes[find_result.HashIndex] = last_added_index;
-				else
-					new_tbl.Entries[find_result.PrevIndex].Next = last_added_index;
-
-				new_tbl.Entries[last_added_index].Next = find_result.EntryIndex;
-				new_tbl.Entries[last_added_index].Value = entry->Value;
-			}
-
-			<fn>_destroy( self );
-			* self = new_tbl;
-		}
-
-		void <fn>_rehash_fast( <tbl_type> self )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			ssize idx;
-
-			for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
-				self.Entries[ idx ].Next = -1;
-
-			for ( idx = 0; idx < array_get_header( self.Hashes )->Num; idx++ )
-				self.Hashes[ idx ] = -1;
-
-			for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
-			{
-				<entry_type>*     entry;
-				HT_FindResult find_result;
-
-				entry       = & self.Entries[ idx ];
-				find_result = <fn>__find( self, entry->Key );
-
-				if ( find_result.PrevIndex < 0 )
-					self.Hashes[ find_result.HashIndex ] = idx;
-				else
-					self.Entries[ find_result.PrevIndex ].Next = idx;
-			}
-		}
-
-		void <fn>_remove( <tbl_type> self, u64 key )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			HT_FindResult find_result = <fn>__find( self, key );
-
-			if ( find_result.EntryIndex >= 0 ) {
-				array_remove_at( self.Entries, find_result.EntryIndex );
-				hashtable_rehash_fast( self );
-			}
-		}
-
-		void <fn>_remove_entry( <tbl_type> self, ssize idx )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			array_remove_at( self.Entries, idx );
-		}
-
-		void <fn>_set( <tbl_type>* self, u64 key, <type> value )
-		{
-			GEN_ASSERT_NOT_NULL(self);
-			GEN_ASSERT_NOT_NULL(self->Hashes);
-			GEN_ASSERT_NOT_NULL(self->Entries);
-			ssize         idx;
-			HT_FindResult find_result;
-
-			if ( array_get_header( self->Hashes )->Num == 0 )
-				hashtable_grow( self );
-
-			find_result = <fn>__find( * self, key );
-
-			if ( find_result.EntryIndex >= 0 ) {
-				idx = find_result.EntryIndex;
-			}
-			else
-			{
-				idx = <fn>__add_entry( self, key );
-
-				if ( find_result.PrevIndex >= 0 ) {
-					self->Entries[ find_result.PrevIndex ].Next = idx;
-				}
-				else {
-					self->Hashes[ find_result.HashIndex ] = idx;
-				}
-			}
-
-			self->Entries[ idx ].Value = value;
-
-			if ( <fn>__full( * self ) )
-				hashtable_grow( self );
-		}
-
-		ssize <fn>_slot( <tbl_type> self, u64 key )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			for ( ssize idx = 0; idx < array_get_header( self.Hashes )->Num; ++idx )
-				if ( self.Hashes[ idx ] == key )
-					return idx;
-
-			return -1;
-		}
-
-		ssize <fn>__add_entry( <tbl_type>* self, u64 key )
-		{
-			GEN_ASSERT_NOT_NULL(self);
-			GEN_ASSERT_NOT_NULL(self->Hashes);
-			GEN_ASSERT_NOT_NULL(self->Entries);
-			ssize idx;
-			<entry_type> entry = { key, -1 };
-
-			idx = array_get_header( self->Entries )->Num;
-			array_append( self->Entries, entry );
-			return idx;
-		}
-
-		HT_FindResult <fn>__find( <tbl_type> self, u64 key )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			HT_FindResult result = { -1, -1, -1 };
-
-			ArrayHeader* hash_header = array_get_header( self.Hashes );
-			if ( hash_header->Num > 0 )
-			{
-				result.HashIndex  = key % hash_header->Num;
-				result.EntryIndex = self.Hashes[ result.HashIndex ];
-
-				while ( result.EntryIndex >= 0 )
-				{
-					if ( self.Entries[ result.EntryIndex ].Key == key )
-						break;
-
-					result.PrevIndex  = result.EntryIndex;
-					result.EntryIndex = self.Entries[ result.EntryIndex ].Next;
-				}
-			}
-
-			return result;
-		}
-
-		b32 <fn>__full( <tbl_type> self )
-		{
-			GEN_ASSERT_NOT_NULL(self.Hashes);
-			GEN_ASSERT_NOT_NULL(self.Entries);
-			ArrayHeader* hash_header    = array_get_header( self.Hashes );
-			ArrayHeader* entries_header = array_get_header( self.Entries );
-
-			usize critical_load = cast(usize, HashTable_CriticalLoadScale * cast(f32, hash_header->Num));
-			b32 result = entries_header->Num > critical_load;
-			return result;
-		}
-	)));
-#pragma pop_macro( "GEN_ASSERT" )
-#pragma pop_macro( "GEN_ASSERT_NOT_NULL" )
-#pragma pop_macro( "rcast" )
-#pragma pop_macro( "cast" )
-#pragma pop_macro( "typeof" )
-#pragma pop_macro( "forceinline" )
-
-	++ HashTable_DefinitionCounter;
-	Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", HashTable_DefinitionCounter).to_str();
-
-	Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (Str)tbl_type, "slot", (Str)slot_str,
-R"(#define GENERIC_SLOT_<slot>__hashtable_init          <type>,      <tbl_type>_init
-#define GENERIC_SLOT_<slot>__hashtable_init_reserve     <type>,      <tbl_type>_init_reserve
-#define GENERIC_SLOT_<slot>__hashtable_clear            <tbl_type>,  <tbl_type>_clear
-#define GENERIC_SLOT_<slot>__hashtable_destroy          <tbl_type>,  <tbl_type>_destroy
-#define GENERIC_SLOT_<slot>__hashtable_get              <tbl_type>,  <tbl_type>_get
-#define GENERIC_SLOT_<slot>__hashtable_map              <tbl_type>,  <tbl_type>_map
-#define GENERIC_SLOT_<slot>__hashtable_map_mut          <tbl_type>,  <tbl_type>_map_mut
-#define GENERIC_SLOT_<slot>__hashtable_grow             <tbl_type>*, <tbl_type>_grow
-#define GENERIC_SLOT_<slot>__hashtable_rehash           <tbl_type>*, <tbl_type>_rehash
-#define GENERIC_SLOT_<slot>__hashtable_rehash_fast      <tbl_type>,  <tbl_type>_rehash_fast
-#define GENERIC_SLOT_<slot>__hashtable_remove_entry     <tbl_type>,  <tbl_type>_remove_entry
-#define GENERIC_SLOT_<slot>__hashtable_set              <tbl_type>,  <tbl_type>_set
-#define GENERIC_SLOT_<slot>__hashtable_slot             <tbl_type>,  <tbl_type>_slot
-
-#define GENERIC_SLOT_<slot>__hashtable__add_entry       <tbl_type>*, <tbl_type>__add_entry
-#define GENERIC_SLOT_<slot>__hashtable__find            <tbl_type>,  <tbl_type>__find
-#define GENERIC_SLOT_<slot>__hashtable__full            <tbl_type>,  <tbl_type>__full
-)"
-	));
-
-	char const* cmt_str = c_str_fmt_buf( "Name: %.*s Type: %.*s"
-		, tbl_type.length(), tbl_type.Data
-		, type.Len, type.Ptr );
-
-	return def_global_body(args(
-		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", tbl_type ))),
-		fmt_newline,
-		generic_interface_slot,
-		fmt_newline,
-		hashtable_types,
-		fmt_newline,
-		entry_array,
-		hashtable_def,
-		fmt_newline,
-		def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", tbl_type ))),
-		fmt_newline
-	));
-}
-
-CodeBody gen_hashtable_generic_selection_interface()
-{
-	CodeBody interface_defines = def_body(CT_Global_Body);
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_init"), GenericSel_Direct_Type ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_init_reserve"), GenericSel_Direct_Type ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_clear"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_destroy"), GenericSel_By_Ref, GenericSel_One_Arg ) );
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_get") ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_grow"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_rehash") ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_rehash_fast"), GenericSel_Default, GenericSel_One_Arg ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_remove") ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_remove_entry") ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_set"), GenericSel_By_Ref ));
-	interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_slot") ));
-	return interface_defines;
-}

gen_c_library/components/generic_macros.h

@@ -1,116 +0,0 @@
-
-#pragma region _Generic Macros
-//   ____                       _        ______                _   _                ____                  _                 __ _
-//  / ___}                     (_)      |  ____}              | | (_)              / __ \                | |               | |(_)
-// | | ___  ___ _ __   ___ _ __ _  ___  | |__ _   _ _ __   ___| |_ _  ___  _ __   | |  | |_   _____ _ __ | | ___   __ _  __| | _ _ __   __ _
-// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| |  __} | | | '_ \ / __} __} |/ _ \| '_ \  | |  | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
-// | |__j |  __/ | | |  __/ |  | | (__  | |  | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V /  __/ |   | | (_) | (_| | (_| || | | | | (_| |
-//  \____/ \___}_l l_l\___}_l  l_l\___| l_l   \__,_l_l l_l\___}\__}_l\___/l_l l_l  \____/  \_/ \___}_l   l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
-// This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in:                                            __| |
-// https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md                            {___/
-// Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible.
-
-#define GEN_COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly.
-
-// Helper macros for argument selection
-#define GEN_SELECT_ARG_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
-#define GEN_SELECT_ARG_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
-#define GEN_SELECT_ARG_3( _1, _2, _3, ... ) _3 // etc..
-
-#define GEN_GENERIC_SEL_ENTRY_TYPE             GEN_SELECT_ARG_1 // Use the arg expansion macro to select arg 1 which should have the type.
-#define GEN_GENERIC_SEL_ENTRY_FUNCTION         GEN_SELECT_ARG_2 // Use the arg expansion macro to select arg 2 which should have the function.
-#define GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER  GEN_SELECT_ARG_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','.
-
-#define GEN_RESOLVED_FUNCTION_CALL // Just used to indicate where the call "occurs"
-
-// ----------------------------------------------------------------------------------------------------------------------------------
-// GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name).
-// It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma.
-// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
-// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
-#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , )
-//                                                          ^ Selects the comma                              ^ is the type                             ^ is the function                             ^ Insert a comma
-// The slot won't exist if that comma is not found.
-
-// For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to:
-typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION;
-struct GENCPP_NO_RESOLVED_GENERIC_SELECTION {
-	void* _THE_VOID_SLOT_;
-};
-GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = {0};
-// Which will provide the message:  error: called object type 'struct NO_RESOLVED_GENERIC_SELECTION' is not a function or function pointer
-// ----------------------------------------------------------------------------------------------------------------------------------
-
-// Below are generated on demand for an overlaod depdendent on a type:
-// ----------------------------------------------------------------------------------------------------------------------------------
-#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic(             \
-(selector_arg), /* Select Via Expression*/                                 \
-  /* Extendibility slots: */                                               \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
-	default: gen_generic_selection_fail                                    \
-) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
-// ----------------------------------------------------------------------------------------------------------------------------------
-
-// Then each definiton of a function has an associated define:
-#// #define GENERIC_SLOT_<#>_<generic identifier> <typename>, <function_to_resolve>
-
-// Then somehwere later on
-// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
-
-// Concrete example:
-
-// To add support for long:
-#define GENERIC_SLOT_1_gen_example_hash long, gen_example_hash__P_long
-size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
-
-// To add support for long long:
-#define GENERIC_SLOT_2_gen_example_hash  long long, gen_example_hash__P_long_long
-size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
-
-// If using an Editor with support for syntax hightlighting macros:
-// GENERIC_SLOT_1_gen_example_hash and GENERIC_SLOT_2_gen_example_hash should show color highlighting indicating the slot is enabled,
-// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
-#define gen_hash_example( function_arguments ) _Generic(                      \
-(function_arguments), /* Select Via Expression*/                              \
-  /* Extendibility slots: */                                                  \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_3_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_4_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_5_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_6_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_7_gen_example_hash ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_8_gen_example_hash ) \
-	default: gen_generic_selection_fail                                       \
-) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
-
-// Additional Variations:
-
-// If the function takes more than one argument the following is used:
-#define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
-(selector_arg),                                                             \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig )  \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig )  \
-	/* ... */                                                               \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig )   \
-	default: gen_generic_selection_fail                                     \
-) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ )
-
-// If the function does not take the arugment as a parameter:
-#define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
-( GEN_TYPE_TO_EXP(selector_arg) ),                                         \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
-	/* ... */                                                              \
-	GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig )  \
-	default: gen_generic_selection_fail                                    \
-) GEN_RESOLVED_FUNCTION_CALL()
-
-// Used to keep the _Generic keyword happy as bare types are not considered "expressions"
-#define GEN_TYPE_TO_EXP(type) (* (type*)NULL)
-// Instead of using this macro, you'll see it directly expanded by the code generation.
-
-// typedef void* GEN_GenericExampleType;
-// GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( GEN_GenericExampleType );
-#pragma endregion _Generic Macros

gen_c_library/components/header_seg_includes.h

@@ -1,9 +0,0 @@
-#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
-#	error Gen.h : GEN_TIME not defined
-#endif
-
-//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
-// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
-#ifndef GEN_ROLL_OWN_DEPENDENCIES
-#	include "gen.dep.h"
-#endif

gen_c_library/components/header_start.hpp

@@ -1,24 +0,0 @@
-/*
-	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
-
-	See Readme.md for more information from the project repository.
-
-	Public Address:
-	https://github.com/Ed94/gencpp  ---------------------------------------------------------------.
-	|   _____                               _____ _                       _      ___   __     __    |
-	|  / ____)                             / ____} |                     | |   / ,__} /  |   /  |   |
-	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | l_ __ _  __ _, ___  __| |  | |    '-l |  '-l |   |
-	| | |{_  \/ __\ '_ \ / __} '_ l| '_ l  \___ \| __/ _` |/ _` |/ __\/ _` |  | |      | |    | |   |
-	| | l__j | ___/ | | | {__; ;_l } ;_l } ____} | l| (_} | {_| | ___j {_; |  | l___  _J l_  _J l_  |
-	|  \_____|\___}_l |_|\___} .__/| .__/ {_____/ \__\__/_l\__. |\___/\__,_l   \____}{_____}{_____} |
-	|                        | |   | |                      __} |                                   |
-	|                        l_l   l_l                     {___/                                    |
-	! ----------------------------------------------------------------------- VERSION: v0.25-Alpha  |
-	! ============================================================================================= |
-	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                  |
-	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL  |
-	! ============================================================================================= /
-*/
-#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
-#	error Gen.hpp : GEN_TIME not defined
-#endif

gen_c_library/components/memory.fixed_arena.hpp

@@ -1,158 +0,0 @@
-#pragma once
-#include "gen.hpp"
-
-using namespace gen;
-
-CodeBody gen_fixed_arenas()
-{
-	CodeBody result = def_body(CT_Global_Body);
-	result.append(def_pragma(txt("region FixedArena")));
-
-	char const* template_struct = stringize(
-		struct FixedArena_<Name>
-		{
-			char  memory[<Size>];
-			Arena arena;
-		};
-		typedef struct FixedArena_<Name> FixedArena_<Name>;
-	);
-
-	char const* template_interface = stringize(
-		inline
-		void fixed_arena_init_<Name>(FixedArena_<Name>* result)
-		{
-			result->arena = arena_init_from_memory(& result->memory[0], <Size>);
-		}
-
-		inline
-		ssize fixed_arena_size_remaining_<Name>(FixedArena_<Name>* fixed_arena, ssize alignment)
-		{
-			return arena_size_remaining( & fixed_arena->arena, alignment);
-		}
-
-		inline
-		void fixed_arena_free_<Name>(FixedArena_<Name>* fixed_arena) {
-			arena_free( & fixed_arena->arena);
-		}
-	);
-
-	CodeBody arena_struct_1kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"),   "Size", txt("kilobytes(1)"),   template_struct ));
-	CodeBody arena_struct_4kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4KB"),   "Size", txt("kilobytes(4)"),   template_struct ));
-	CodeBody arena_struct_8kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("8KB"),   "Size", txt("kilobytes(8)"),   template_struct ));
-	CodeBody arena_struct_16kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("16KB"),  "Size", txt("kilobytes(16)"),  template_struct ));
-	CodeBody arena_struct_32kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("32KB"),  "Size", txt("kilobytes(32)"),  template_struct ));
-	CodeBody arena_struct_64kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("64KB"),  "Size", txt("kilobytes(64)"),  template_struct ));
-	CodeBody arena_struct_128kb = parse_global_body( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_struct ));
-	CodeBody arena_struct_256kb = parse_global_body( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_struct ));
-	CodeBody arena_struct_512kb = parse_global_body( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_struct ));
-	CodeBody arena_struct_1mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1MB"),   "Size", txt("megabytes(1)"),   template_struct ));
-	CodeBody arena_struct_2mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("2MB"),   "Size", txt("megabytes(2)"),   template_struct ));
-	CodeBody arena_struct_4mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4MB"),   "Size", txt("megabytes(4)"),   template_struct ));
-
-
-	CodeBody arena_interface_1kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"),   "Size", txt("kilobytes(1)"),   template_interface ));
-	CodeBody arena_interface_4kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4KB"),   "Size", txt("kilobytes(4)"),   template_interface ));
-	CodeBody arena_interface_8kb   = parse_global_body( token_fmt_impl( 3, "Name", txt("8KB"),   "Size", txt("kilobytes(8)"),   template_interface ));
-	CodeBody arena_interface_16kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("16KB"),  "Size", txt("kilobytes(16)"),  template_interface ));
-	CodeBody arena_interface_32kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("32KB"),  "Size", txt("kilobytes(32)"),  template_interface ));
-	CodeBody arena_interface_64kb  = parse_global_body( token_fmt_impl( 3, "Name", txt("64KB"),  "Size", txt("kilobytes(64)"),  template_interface ));
-	CodeBody arena_interface_128kb = parse_global_body( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_interface ));
-	CodeBody arena_interface_256kb = parse_global_body( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_interface ));
-	CodeBody arena_interface_512kb = parse_global_body( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_interface ));
-	CodeBody arena_interface_1mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("1MB"),   "Size", txt("megabytes(1)"),   template_interface ));
-	CodeBody arena_interface_2mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("2MB"),   "Size", txt("megabytes(2)"),   template_interface ));
-	CodeBody arena_interface_4mb   = parse_global_body( token_fmt_impl( 3, "Name", txt("4MB"),   "Size", txt("megabytes(4)"),   template_interface ));
-
-	result.append(arena_struct_1kb);
-	result.append(arena_struct_4kb);
-	result.append(arena_struct_8kb);
-	result.append(arena_struct_16kb);
-	result.append(arena_struct_32kb);
-	result.append(arena_struct_64kb);
-	result.append(arena_struct_128kb);
-	result.append(arena_struct_256kb);
-	result.append(arena_struct_512kb);
-	result.append(arena_struct_1mb);
-	result.append(arena_struct_2mb);
-	result.append(arena_struct_4mb);
-
-	result.append(arena_interface_1kb);
-	result.append(arena_interface_4kb);
-	result.append(arena_interface_8kb);
-	result.append(arena_interface_16kb);
-	result.append(arena_interface_32kb);
-	result.append(arena_interface_64kb);
-	result.append(arena_interface_128kb);
-	result.append(arena_interface_256kb);
-	result.append(arena_interface_512kb);
-	result.append(arena_interface_1mb);
-	result.append(arena_interface_2mb);
-	result.append(arena_interface_4mb);
-
-	register_macros( args(
-		( Macro { txt("fixed_arena_allocator_info"), MT_Expression, MF_Functional }),
-		( Macro { txt("fixed_arena_init"),           MT_Expression, MF_Functional }),
-		( Macro { txt("fixed_arena_free"),           MT_Expression, MF_Functional }),
-		( Macro { txt("fixed_arena_size_remaining"), MT_Expression, MF_Functional })
-	));
-
-	CodeDefine def = parse_define(txt("#define fixed_arena_allocator_info(fixed_arena) ( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )\n"));
-	result.append(def);
-	result.append(fmt_newline);
-
-	result.append(parse_global_body(txt(R"(
-#define fixed_arena_init(expr) _Generic((expr),    \
-    FixedArena_1KB*   : fixed_arena_init_1KB,      \
-    FixedArena_4KB*   : fixed_arena_init_4KB,      \
-    FixedArena_8KB*   : fixed_arena_init_8KB,      \
-    FixedArena_16KB*  : fixed_arena_init_16KB,     \
-    FixedArena_32KB*  : fixed_arena_init_32KB,     \
-    FixedArena_64KB*  : fixed_arena_init_64KB,     \
-    FixedArena_128KB* : fixed_arena_init_128KB,    \
-    FixedArena_256KB* : fixed_arena_init_256KB,    \
-    FixedArena_512KB* : fixed_arena_init_512KB,    \
-    FixedArena_1MB*   : fixed_arena_init_1MB,      \
-    FixedArena_2MB*   : fixed_arena_init_2MB,      \
-    FixedArena_4MB*   : fixed_arena_init_4MB,      \
-	default           : gen_generic_selection_fail \
-) GEN_RESOLVED_FUNCTION_CALL(expr)
-
-#define fixed_arena_free(expr) _Generic((expr),    \
-    FixedArena_1KB*   : fixed_arena_free_1KB,      \
-    FixedArena_4KB*   : fixed_arena_free_4KB,      \
-    FixedArena_8KB*   : fixed_arena_free_8KB,      \
-    FixedArena_16KB*  : fixed_arena_free_16KB,     \
-    FixedArena_32KB*  : fixed_arena_free_32KB,     \
-    FixedArena_64KB*  : fixed_arena_free_64KB,     \
-    FixedArena_128KB* : fixed_arena_free_128KB,    \
-    FixedArena_256KB* : fixed_arena_free_256KB,    \
-    FixedArena_512KB* : fixed_arena_free_512KB,    \
-    FixedArena_1MB*   : fixed_arena_free_1MB,      \
-    FixedArena_2MB*   : fixed_arena_free_2MB,      \
-    FixedArena_4MB*   : fixed_arena_free_4MB,      \
-	default           : gen_generic_selection_fail \
-)	GEN_RESOLVED_FUNCTION_CALL(expr)
-
-#define fixed_arena_size_remaining(expr, alignment) _Generic((expr), \
-    FixedArena_1KB*   : fixed_arena_size_remaining_1KB,              \
-    FixedArena_4KB*   : fixed_arena_size_remaining_4KB,              \
-    FixedArena_8KB*   : fixed_arena_size_remaining_8KB,              \
-    FixedArena_16KB*  : fixed_arena_size_remaining_16KB,             \
-    FixedArena_32KB*  : fixed_arena_size_remaining_32KB,             \
-    FixedArena_64KB*  : fixed_arena_size_remaining_64KB,             \
-    FixedArena_128KB* : fixed_arena_size_remaining_128KB,            \
-    FixedArena_256KB* : fixed_arena_size_remaining_256KB,            \
-    FixedArena_512KB* : fixed_arena_size_remaining_512KB,            \
-    FixedArena_1MB*   : fixed_arena_size_remaining_1MB,              \
-    FixedArena_2MB*   : fixed_arena_size_remaining_2MB,              \
-    FixedArena_4MB*   : fixed_arena_size_remaining_4MB,              \
-	default           : gen_generic_selection_fail                   \
-)	GEN_RESOLVED_FUNCTION_CALL(expr, alignment)
-)"
-	)));
-
-	result.append(fmt_newline);
-	result.append(def_pragma(txt("endregion FixedArena")));
-
-	return result;
-}

gen_c_library/components/misc.hpp

@@ -1,247 +0,0 @@
-#pragma once
-#include "gen.hpp"
-
-using namespace gen;
-
-void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
-{
-#pragma push_macro("enum_underlying")
-#undef enum_underlying
-	StrCached  type;
-	CodeTypedef tdef;
-	if (to_convert->UnderlyingType)
-	{
-		type = to_convert->UnderlyingType.to_strbuilder().to_str();
-		tdef = parse_typedef(token_fmt("type", type, "name", to_convert->Name, stringize( typedef <type> <name>; )));
-	}
-	else
-	{
-		type = to_convert->Name;
-		tdef = parse_typedef(token_fmt("type", type, "name", to_convert->Name, stringize( typedef enum <type> <name>; )));
-
-	}
-	if (to_convert->UnderlyingType)
-	{
-		to_convert->UnderlyingTypeMacro = untyped_str(token_fmt("type", to_convert->UnderlyingType->Name, stringize(enum_underlying(<type>))));
-		to_convert->UnderlyingType      = CodeTypename{nullptr};
-	}
-	to_append.append(to_convert);
-	to_append.append(tdef);
-#pragma pop_macro("enum_underlying")
-}
-
-b32 ignore_preprocess_cond_block( Str cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
-{
-	b32 found = false;
-	CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
-	if ( cond->Content.is_equal(cond_sig) )
-	{
-		//log_fmt("Preprocess cond found: %S\n", cond->Content);
-		found = true;
-
-		s32 depth = 0;
-		for(b32 continue_for = true; continue_for && entry_iter != parsed_body.end(); ) switch (entry_iter->Type)
-		{
-			case CT_Preprocess_If:
-			case CT_Preprocess_IfDef:
-			case CT_Preprocess_IfNotDef:
-				++ depth;
-		 		++ entry_iter;
-			break;
-
-			case CT_Preprocess_Else:
-				++ entry_iter;
-				if (depth == 1) for(; entry_iter != parsed_body.end(); ++ entry_iter)
-				{
-					if ( entry_iter->Type == CT_Preprocess_EndIf)
-						break;
-
-					body.append(entry_iter);
-				}
-			break;
-
-			case CT_Preprocess_EndIf:
-			{
-				-- depth;
-				if (depth == 0) {
-					continue_for = false;
-					break;
-				}
-				++ entry_iter;
-			}
-			break;
-			default:
-				++ entry_iter;
-			break;
-		}
-	}
-
-	return found;
-}
-
-constexpr bool GenericSel_One_Arg = true;
-enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
-Code gen_generic_selection_function_macro( s32 num_slots, Str macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
-{
-/* Implements:
-	#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic(      \
-	(selector_arg),                                                          \
-		GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 )     \
-		GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 )     \
-		...                                                                  \
-		GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_N ) \
-	) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
-*/
-	local_persist
-	StrBuilder define_builder = StrBuilder::make_reserve(_ctx->Allocator_Temp, kilobytes(64));
-	define_builder.clear();
-
-	Str macro_begin;
-	if (opts == GenericSel_Direct_Type) {
-		macro_begin = token_fmt( "macro_name", (Str)macro_name,
-R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \
-)"
-		);
-	}
-	else {
-		macro_begin = token_fmt( "macro_name", (Str)macro_name,
-R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
-)"
-		);
-	}
-	define_builder.append(macro_begin);
-
-	for ( s32 slot = 1; slot <= num_slots; ++ slot )
-	{
-		Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", slot).to_str();
-		define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
-R"(GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
-)"
-		));
-	}
-
-	define_builder.append( txt("default: gen_generic_selection_fail\\\n") );
-
-	if ( ! one_arg )
-	{
-		if (opts == GenericSel_By_Ref)
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
-		else if (opts == GenericSel_Direct_Type)
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
-		else
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
-	}
-	else
-	{
-		if (opts == GenericSel_By_Ref)
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
-		else if (opts == GenericSel_Direct_Type)
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL()"));
-		else
-			define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
-	}
-
-	// Add gap for next definition
-	define_builder.append(txt("\n\n"));
-
-	Code macro = untyped_str(define_builder.to_str());
-	return macro;
-}
-
-CodeFn rename_function_to_unique_symbol(CodeFn fn, Str optional_prefix = txt(""))
-{
-    // Get basic components for the name
-    Str        old_name = fn->Name;
-    StrBuilder new_name;
-
-    // Add prefix if provided
-    if (optional_prefix.Len)
-        new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_%S_", optional_prefix, old_name);
-    else
-        new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_", old_name);
-
-    // Add return type to the signature
-    if (fn->ReturnType)
-        new_name.append_fmt("_%S", fn->ReturnType->Name);
-
-    // Add parameter types to create a unique signature
-    bool first_param = true;
-    for (CodeParams param = fn->Params; param.ast; param = param->Next)
-    {
-        if (param->ValueType)
-        {
-            // Add separator for readability
-            if (first_param)
-            {
-                new_name.append("_P_");
-                first_param = false;
-            }
-            else
-                new_name.append("_");
-
-            // Add parameter type, handle any specifiers
-            if (param->ValueType->Specs && param->ValueType->Specs->NumEntries > 0)
-            {
-                // Add specifiers (const, volatile, etc)
-                for (Specifier spec : param->ValueType->Specs)
-                {
-					if (spec == Spec_Ptr) {
-						new_name.append("ptr_");
-						continue;
-					}
-
-                    new_name.append_fmt("%S_", spec_to_str(spec));
-                }
-            }
-
-            new_name.append_fmt("%S", param->ValueType->Name);
-        }
-    }
-
-    // Handle function specifiers if present
-    if (fn->Specs && fn->Specs->NumEntries > 0)
-    {
-        new_name.append("_S_");
-        for (Specifier* spec = begin(fn->Specs);
-             spec != end(fn->Specs);
-             ++spec)
-        {
-            new_name.append_fmt("%S_", spec_to_str(*spec));
-        }
-    }
-
-    fn->Name = new_name;
-    return fn;
-}
-
-using SwapContentProc = CodeBody(void);
-bool swap_pragma_region_implementation( Str region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
-{
-	bool found = false;
-	CodePragma possible_region = cast(CodePragma, entry_iter);
-
-	StrBuilder region_sig    = strbuilder_fmt_buf(_ctx->Allocator_Temp, "region %s",    region_name.Ptr);
-	StrBuilder endregion_sig = strbuilder_fmt_buf(_ctx->Allocator_Temp, "endregion %s", region_name.Ptr);
-	if ( possible_region->Content.contains(region_sig))
-	{
-		found = true;
-		// body.append(possible_region);
-		body.append(swap_content());
-
-		++ entry_iter;
-		for(b32 continue_for = true; continue_for; ++entry_iter) switch
-		(entry_iter->Type) {
-			case CT_Preprocess_Pragma:
-			{
-				CodePragma possible_end_region = cast(CodePragma, entry_iter);
-				if ( possible_end_region->Content.contains(endregion_sig) ) {
-					// body.append(possible_end_region);
-					continue_for = false;
-				}
-			}
-			break;
-		}
-		body.append(entry_iter);
-	}
-	return found;
-}

gen_c_library/components/src_start.c

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

gen_c_library/gen_c_lib.c

@@ -1,6 +0,0 @@
-#define GEN_IMPLEMENTATION
-#define GEN_DONT_ENFORCE_GEN_TIME_GUARD
-#define GEN_DEFINE_LIBRARY_CORE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#define GEN_EXPOSE_BACKEND
-#include "gen/gen_singleheader.h"

gen_segmented/Readme.md

@@ -1,23 +0,0 @@
-## Navigation
-
-# base
-
-[Top](../Readme.md)
-
-* [docs](../docs/Readme.md)
-
-# segmented Library Generation
-
-Create a segmented library using `segmented.cpp`
-
-The principal (user) files are `gen.hpp` and `gen.cpp`.
-They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
-
-Dependencies are bundled into `gen.dep.<hpp/cpp>`. They are included in `gen.<hpp/cpp>` before component includes.
-Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`. The auxiliary content (builder & scanner) is given their own files.
-
-If using the library's provided build scripts:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> segmented
-```

gen_segmented/segmented.cpp

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

gen_singleheader/Readme.md

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

gen_singleheader/components/header_start.hpp

@@ -1,26 +0,0 @@
-/*
-	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
-
-	See Readme.md for more information from the project repository.
-
-	Define GEN_IMPLEMENTATION before including this file in a single compilation unit.
-
-	Public Address:
-	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
-	|   _____                               _____ _                       _                        |
-	|  / ____)                             / ____} |                     | |                       |
-	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
-	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
-	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
-	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
-	|     Singleheader       | |   | |                      __} |                                  |
-	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.25-Alpha |
-	! ============================================================================================ |
-	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
-	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
-	! ============================================================================================ /
-*/
-#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
-#	error Gen.hpp : GEN_TIME not defined
-#endif

gen_singleheader/singleheader.cpp

@@ -1,266 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#include "gen.cpp"
-#include "helpers/push_ignores.inline.hpp"
-
-#include <stdlib.h>
-
-GEN_NS_BEGIN
-#include "helpers/base_codegen.hpp"
-#include "helpers/misc.hpp"
-GEN_NS_END
-
-using namespace gen;
-
-constexpr char const* generation_notice =
-"// This file was generated automatially by gencpp's singleheader.cpp"
-"(See: https://github.com/Ed94/gencpp)\n\n";
-
-constexpr Str implementation_guard_start = txt(R"(
-#pragma region GENCPP IMPLEMENTATION GUARD
-#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
-#	define GEN_IMPLEMENTED
-)");
-
-constexpr Str implementation_guard_end = txt(R"(
-#endif
-#pragma endregion GENCPP IMPLEMENTATION GUARD
-)");
-
-constexpr Str roll_own_dependencies_guard_start = txt(R"(
-//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
-// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
-#ifndef GEN_ROLL_OWN_DEPENDENCIES
-)");
-
-constexpr Str roll_own_dependencies_guard_end = txt(R"(
-// GEN_ROLL_OWN_DEPENDENCIES
-#endif
-)");
-
-global bool generate_gen_dep = true;
-global bool generate_builder = true;
-global bool generate_editor  = true;
-global bool generate_scanner = true;
-
-#define path_format_style "../scripts/.clang-format "
-#define scratch_file      "gen/scratch.hpp"
-#define path_base         "../base/"
-
-Code format( Code code ) {
-	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
-}
-
-int gen_main()
-{
-	Context ctx {};
-	gen::init( & ctx);
-
-	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
-	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
-	Code single_header_start = scan_file( "components/header_start.hpp" );
-
-	Builder
-	header = Builder::open( "gen/gen.hpp" );
-	header.print_fmt( generation_notice );
-	header.print_fmt("#pragma once\n\n");
-	header.print( push_ignores );
-
-	// Headers
-	{
-		header.print( single_header_start );
-
-		if ( generate_gen_dep )
-		{
-			Code platform     = scan_file( path_base "dependencies/platform.hpp" );
-			Code macros       = scan_file( path_base "dependencies/macros.hpp" );
-			Code basic_types  = scan_file( path_base "dependencies/basic_types.hpp" );
-			Code debug        = scan_file( path_base "dependencies/debug.hpp" );
-			Code memory	      = scan_file( path_base "dependencies/memory.hpp" );
-			Code stirng_ops   = scan_file( path_base "dependencies/string_ops.hpp" );
-			Code printing     = scan_file( path_base "dependencies/printing.hpp" );
-			Code containers   = scan_file( path_base "dependencies/containers.hpp" );
-			Code hashing 	  = scan_file( path_base "dependencies/hashing.hpp" );
-			Code strings      = scan_file( path_base "dependencies/strings.hpp" );
-			Code filesystem   = scan_file( path_base "dependencies/filesystem.hpp" );
-			Code timing       = scan_file( path_base "dependencies/timing.hpp" );
-
-			header.print_fmt( roll_own_dependencies_guard_start );
-			header.print( platform );
-			header.print_fmt( "\nGEN_NS_BEGIN\n" );
-
-			header.print( macros );
-			header.print( basic_types );
-			header.print( debug );
-			header.print( memory );
-			header.print( stirng_ops );
-			header.print( printing );
-			header.print( containers );
-			header.print( hashing );
-			header.print( strings );
-			header.print( filesystem );
-			header.print( timing );
-
-			if ( generate_scanner ) {
-				header.print( scan_file( path_base "dependencies/parsing.hpp" ) );
-			}
-
-			header.print(fmt_newline);
-			header.print_fmt( "GEN_NS_END\n" );
-			header.print_fmt( roll_own_dependencies_guard_end );
-			header.print( fmt_newline );
-		}
-
-		Code types        = scan_file( path_base "components/types.hpp" );
-		Code parser_types = scan_file( path_base "components/parser_types.hpp");
-		Code ast          = scan_file( path_base "components/ast.hpp" );
-		Code ast_types    = scan_file( path_base "components/ast_types.hpp" );
-		Code code_types   = scan_file( path_base "components/code_types.hpp" );
-		Code interface    = scan_file( path_base "components/interface.hpp" );
-		Code constants    = scan_file( path_base "components/constants.hpp" );
-		Code inlines 	  = scan_file( path_base "components/inlines.hpp" );
-
-		CodeBody ecode       = gen_ecode     ( path_base "enums/ECodeTypes.csv" );
-		CodeBody eoperator   = gen_eoperator ( path_base "enums/EOperator.csv" );
-		CodeBody especifier  = gen_especifier( path_base "enums/ESpecifier.csv" );
-		CodeBody etoktype    = gen_etoktype  ( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
-		CodeBody ast_inlines = gen_ast_inlines();
-
-		header.print_fmt( "GEN_NS_BEGIN\n\n" );
-
-		header.print_fmt("#pragma region Types\n");
-		header.print( types );
-		header.print( fmt_newline );
-		header.print( format( ecode ));
-		header.print( fmt_newline );
-		header.print( format( eoperator ));
-		header.print( fmt_newline );
-		header.print( format( especifier ));
-		header.print( fmt_newline );
-		header.print( format( etoktype ));
-		header.print( parser_types );
-		header.print( fmt_newline );
-		header.print_fmt("#pragma endregion Types\n\n");
-
-		header.print_fmt("#pragma region AST\n");
-		header.print( ast );
-		header.print( code_types );
-		header.print( ast_types );
-		header.print_fmt("\n#pragma endregion AST\n");
-
-		header.print( interface );
-		header.print( constants );
-
-		header.print_fmt( "\n#pragma region Inlines\n" );
-		header.print( inlines );
-		header.print( format( ast_inlines ));
-		header.print( fmt_newline );
-		header.print_fmt( "#pragma endregion Inlines\n" );
-
-		if ( generate_builder ) {
-			header.print( scan_file( path_base "auxiliary/builder.hpp" ) );
-		}
-		if ( generate_scanner ) {
-			header.print( scan_file( path_base "auxiliary/scanner.hpp" ) );
-		}
-
-		header.print(fmt_newline);
-		header.print_fmt( "GEN_NS_END\n" );
-	}
-
-	// Implementation
-	{
-		header.print_fmt( "%s\n", (char const*) implementation_guard_start );
-
-		if ( generate_gen_dep )
-		{
-			Code impl_start = scan_file( path_base "dependencies/src_start.cpp" );
-			Code debug      = scan_file( path_base "dependencies/debug.cpp" );
-			Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
-			Code printing   = scan_file( path_base "dependencies/printing.cpp" );
-			Code memory     = scan_file( path_base "dependencies/memory.cpp" );
-			Code hashing    = scan_file( path_base "dependencies/hashing.cpp" );
-			Code strings    = scan_file( path_base "dependencies/strings.cpp" );
-			Code filesystem = scan_file( path_base "dependencies/filesystem.cpp" );
-			Code timing     = scan_file( path_base "dependencies/timing.cpp" );
-
-			header.print_fmt( roll_own_dependencies_guard_start );
-			header.print( impl_start );
-			header.print( fmt_newline );
-			header.print_fmt( "GEN_NS_BEGIN\n");
-
-			header.print( debug );
-			header.print( string_ops );
-			header.print( printing );
-			header.print( memory );
-			header.print( hashing );
-			header.print( strings );
-			header.print( filesystem );
-			header.print( timing );
-
-			if ( generate_scanner ) {
-				header.print_fmt( "\n#pragma region Parsing\n" );
-				header.print( scan_file( path_base "dependencies/parsing.cpp" ) );
-				header.print_fmt( "#pragma endregion Parsing\n\n" );
-			}
-
-			header.print_fmt( "GEN_NS_END\n");
-			header.print_fmt( roll_own_dependencies_guard_end );
-		}
-
-		Code static_data 	    = scan_file( path_base "components/static_data.cpp" );
-		Code ast_case_macros    = scan_file( path_base "components/ast_case_macros.cpp" );
-		Code ast                = scan_file( path_base "components/ast.cpp" );
-		Code code               = scan_file( path_base "components/code_serialization.cpp" );
-		Code interface          = scan_file( path_base "components/interface.cpp" );
-		Code upfront            = scan_file( path_base "components/interface.upfront.cpp" );
-		Code lexer              = scan_file( path_base "components/lexer.cpp" );
-		Code parser_case_macros = scan_file( path_base "components/parser_case_macros.cpp" );
-		Code parser             = scan_file( path_base "components/parser.cpp" );
-		Code parsing_interface  = scan_file( path_base "components/interface.parsing.cpp" );
-		Code untyped            = scan_file( path_base "components/interface.untyped.cpp" );
-
-		header.print_fmt( "\nGEN_NS_BEGIN\n");
-		header.print( static_data );
-		header.print( fmt_newline);
-
-		header.print_fmt( "#pragma region AST\n\n" );
-		header.print( ast_case_macros );
-		header.print( ast );
-		header.print( code );
-		header.print_fmt( "#pragma endregion AST\n\n" );
-
-		header.print_fmt( "#pragma region Interface\n" );
-		header.print( interface );
-		header.print( upfront );
-		header.print_fmt( "\n#pragma region Parsing\n\n" );
-		header.print( lexer );
-		header.print( parser_case_macros );
-		header.print( parser );
-		header.print( parsing_interface );
-		header.print_fmt( "\n#pragma endregion Parsing\n" );
-		header.print_fmt("\n#pragma region Untyped\n");
-		header.print( untyped );
-		header.print_fmt("\n#pragma endregion Untyped\n");
-		header.print_fmt( "\n#pragma endregion Interface\n");
-
-		if ( generate_builder ) {
-			header.print( scan_file( path_base "auxiliary/builder.cpp"  ) );
-		}
-
-		if ( generate_scanner ) {
-			header.print( scan_file( path_base "auxiliary/scanner.cpp" ) );
-		}
-
-		header.print( fmt_newline);
-		header.print_fmt( "GEN_NS_END\n");
-
-		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
-	}
-
-	header.print( pop_ignores );
-	header.write();
-
-	gen::deinit( & ctx);
-	return 0;
-}

gen_unreal_engine/Readme.md

@@ -1,34 +0,0 @@
-## Navigation
-
-# base
-
-[Top](../Readme.md)
-
-* [docs](../docs/Readme.md)
-
-# Unreal Engine Version Generator
-
-This generates a variant of gencpp thats compatiable with use as a thirdparty module within a plugin or module of an Unreal Project or the Engine itself.
-
-If using the library's provided build scripts:
-
-```ps1
-.\build.ps1 <compiler> <debug or omit> unreal
-```
-
-## Notables
-
-For the most part this follows the same conventions as `gen_segmented`.
-
-This generator uses a separate enumeration definitions for the following:
-
-* [AttributeTokens.csv](./enums/AttributeTokens.csv) : Add your own <MODULE>_API attributes, etc here that are encountered within the Engine.
-* [ESpecifier.csv](./enums/ESpecifier.csv) : Adds the `FORCEINLINE` & `FORCEINLINE_DEBUGGABLE` specfiers (additions are made as they are encountered)
-* [ETokType.csv](./enums/ETokType.csv) : Same modifications as ESpecifier.csv.
-
-A separate [parser_case_macros.cpp](./components/parser_case_macros.cpp) is used to accomodate for the new forceinline specifiers.
-
-The `global` macro the library uses is redefined as an empty substiution.
-
-
-The expected usage of this library is to put into into a third-party plugin module to then use either in editor modules or in shell script done in some stage of hot-reloading or building the Unreal Engine or Project.

gen_unreal_engine/components/header_start.hpp

@@ -1,45 +0,0 @@
-/*
-	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
-
-	See Readme.md for more information from the project repository.
-
-	Public Address:
-	https://github.com/Ed94/gencpp
-
-	This is a variant intended for use with Unreal Engine 5
-	https://github.com/Ed94/gencpp  --------------------------------------------------------------.
-	|   _____                               _____ _                       _                        |
-	|  / ____)                             / ____} |                     | |                       |
-	| | / ___  ___ _ __   ___ _ __  _ __  | {___ | |__ _ _, __ _, ___  __| |                       |
-	| | |{_  |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` |                       |
-	| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| |                       |
-	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
-	|  Unreal Engine         | |   | |                      __} |                                  |
-	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.25-Alpha |
-	! ============================================================================================ |
-	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
-	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
-	! ============================================================================================ /
-*/
-#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
-#	error Gen.hpp : GEN_TIME not defined
-#endif
-
-//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
-// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
-#ifndef GEN_ROLL_OWN_DEPENDENCIES
-#	include "gen.dep.hpp"
-#endif
-
-#ifndef GEN_NS_BEGIN
-#	ifdef GEN_DONT_USE_NAMESPACE
-#		define GEN_NS
-#		define GEN_NS_BEGIN
-#		define GEN_NS_END
-#	else
-#		define GEN_NS       gen::
-#		define GEN_NS_BEGIN namespace gen {
-#		define GEN_NS_END   }
-#	endif
-#endif

gen_unreal_engine/components/parser_case_macros.cpp

@@ -1,114 +0,0 @@
-// These macros are used in the swtich cases within parser.cpp
-
-#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
-case Tok_Spec_Consteval:              \
-case Tok_Spec_Constexpr:              \
-case Tok_Spec_Constinit:              \
-case Tok_Spec_Explicit:               \
-case Tok_Spec_ForceInline:            \
-case Tok_Spec_ForceInline_Debuggable: \
-case Tok_Spec_Inline:                 \
-case Tok_Spec_Mutable:                \
-case Tok_Spec_NeverInline:            \
-case Tok_Spec_Static:                 \
-case Tok_Spec_Volatile:               \
-case Tok_Spec_Virtual
-
-#define GEN_PARSER_CLASS_STRUCT_BODY_ALLOWED_MEMBER_SPECIFIER_CASES \
-case Spec_Constexpr:              \
-case Spec_Constinit:              \
-case Spec_Explicit:               \
-case Spec_Inline:                 \
-case Spec_ForceInline:            \
-case Spec_ForceInline_Debuggable: \
-case Spec_Mutable:                \
-case Spec_NeverInline:            \
-case Spec_Static:                 \
-case Spec_Volatile:               \
-case Spec_Virtual
-
-#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \
-case Tok_Spec_Consteval:              \
-case Tok_Spec_Constexpr:              \
-case Tok_Spec_Constinit:              \
-case Tok_Spec_Extern:                 \
-case Tok_Spec_ForceInline:            \
-case Tok_Spec_ForceInline_Debuggable: \
-case Tok_Spec_Global:                 \
-case Tok_Spec_Inline:                 \
-case Tok_Spec_Internal_Linkage:       \
-case Tok_Spec_NeverInline:            \
-case Tok_Spec_Static
-
-#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \
-case Spec_Constexpr:              \
-case Spec_Constinit:              \
-case Spec_ForceInline:            \
-case Spec_ForceInline_Debuggable: \
-case Spec_Global:                 \
-case Spec_External_Linkage:       \
-case Spec_Internal_Linkage:       \
-case Spec_Inline:                 \
-case Spec_Mutable:                \
-case Spec_NeverInline:            \
-case Spec_Static:                 \
-case Spec_Volatile
-
-#define GEN_PARSER_FRIEND_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:       \
-case Spec_Inline:      \
-case Spec_ForceInline
-
-#define GEN_PARSER_FUNCTION_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:                  \
-case Spec_Consteval:              \
-case Spec_Constexpr:              \
-case Spec_External_Linkage:       \
-case Spec_Internal_Linkage:       \
-case Spec_ForceInline:            \
-case Spec_ForceInline_Debuggable: \
-case Spec_Inline:                 \
-case Spec_NeverInline:            \
-case Spec_Static
-
-#define GEN_PARSER_OPERATOR_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:       \
-case Spec_Constexpr:   \
-case Spec_ForceInline: \
-case Spec_Inline:      \
-case Spec_NeverInline: \
-case Spec_Static
-
-#define GEN_PARSER_TEMPLATE_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:                  \
-case Spec_Constexpr:              \
-case Spec_Constinit:              \
-case Spec_External_Linkage:       \
-case Spec_Global:                 \
-case Spec_Inline:                 \
-case Spec_ForceInline:            \
-case Spec_ForceInline_Debuggable: \
-case Spec_Local_Persist:          \
-case Spec_Mutable:                \
-case Spec_Static:                 \
-case Spec_Thread_Local:           \
-case Spec_Volatile
-
-#define GEN_PARSER_VARIABLE_ALLOWED_SPECIFIER_CASES \
-case Spec_Const:            \
-case Spec_Constexpr:        \
-case Spec_Constinit:        \
-case Spec_External_Linkage: \
-case Spec_Global:           \
-case Spec_Inline:           \
-case Spec_Local_Persist:    \
-case Spec_Mutable:          \
-case Spec_Static:           \
-case Spec_Thread_Local:     \
-case Spec_Volatile
-
-#define GEN_PARSER_TYPENAME_ALLOWED_SUFFIX_SPECIFIER_CASES \
-case Spec_Const:    \
-case Spec_Ptr:      \
-case Spec_Ref:      \
-case Spec_RValue

gen_unreal_engine/components/src_start.cpp

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

gen_unreal_engine/enums/AttributeTokens.csv

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

gen_unreal_engine/enums/ESpecifier.csv

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

gen_unreal_engine/enums/ETokType.csv

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

gen_unreal_engine/unreal.cpp

@@ -1,411 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-#include "gen.cpp"
-#include "helpers/push_ignores.inline.hpp"
-
-#include <stdlib.h>
-
-GEN_NS_BEGIN
-#include "helpers/base_codegen.hpp"
-#include "helpers/misc.hpp"
-GEN_NS_END
-
-using namespace gen;
-
-constexpr char const* generation_notice =
-"// This file was generated automatially by gencpp's unreal.cpp "
-"(See: https://github.com/Ed94/gencpp)\n\n";
-
-constexpr Str implementation_guard_start = txt(R"(
-#pragma region GENCPP IMPLEMENTATION GUARD
-#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
-#	define GEN_IMPLEMENTED
-)");
-
-constexpr Str implementation_guard_end = txt(R"(
-#endif
-#pragma endregion GENCPP IMPLEMENTATION GUARD
-)");
-
-constexpr Str roll_own_dependencies_guard_start = txt(R"(
-//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
-// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
-#ifndef GEN_ROLL_OWN_DEPENDENCIES
-
-)");
-
-constexpr Str roll_own_dependencies_guard_end = txt(R"(
-// GEN_ROLL_OWN_DEPENDENCIES
-#endif
-)");
-
-global bool generate_gen_dep = true;
-global bool generate_builder = true;
-global bool generate_editor  = true;
-global bool generate_scanner = true;
-
-#define path_format_style "../scripts/.clang-format "
-#define scratch_file      "gen/scratch.hpp"
-#define path_base         "../base/"
-
-Code format( Code code ) {
-	return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
-}
-
-int gen_main()
-{
-	Context ctx {};
-	gen::init( & ctx);
-
-	Code push_ignores        = scan_file( path_base "helpers/push_ignores.inline.hpp" );
-	Code pop_ignores         = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
-
-	Code ue_forceinline = code_str(FORCEINLINE);
-	// Code
-
-	register_macros( args(
-		(Macro { txt("bit"),                          MT_Expression, MF_Functional }),
-		(Macro { txt("bitfield_is_set"),              MT_Expression, MF_Functional }),
-		(Macro { txt("GEN_C_LIKE_CPP"),               MT_Expression, MF_Null       }),
-		(Macro { txt("cast"),                         MT_Expression, MF_Functional }),
-		(Macro { txt("ccast"),                        MT_Expression, MF_Functional }),
-		(Macro { txt("rcast"),                        MT_Expression, MF_Functional }),
-		(Macro { txt("pcast"),                        MT_Expression, MF_Functional }),
-		(Macro { txt("scast"),                        MT_Expression, MF_Functional }),
-		(Macro { txt("stringize_va"),                 MT_Expression, MF_Functional }),
-		(Macro { txt("stringize"),                    MT_Expression, MF_Functional }),
-		(Macro { txt("do_once"),                      MT_Expression, MF_Functional }), 
-		(Macro { txt("do_once_defer"),                MT_Expression, MF_Functional }),
-		(Macro { txt("do_once_start"),                MT_Statement,  MF_Null       }), 
-		(Macro { txt("do_once_end"),                  MT_Statement,  MF_Null       }), 
-		(Macro { txt("labeled_scope_start"),          MT_Statement,  MF_Null       }), 
-		(Macro { txt("labeled_scope_end"),            MT_Statement,  MF_Null       }), 
-		(Macro { txt("compiler_decorated_func_name"), MT_Expression, MF_Null       }), 
-		(Macro { txt("num_args_impl"),                MT_Expression, MF_Functional }),
-		(Macro { txt("num_args"),                     MT_Expression, MF_Functional }),
-		(Macro { txt("count_of"),                     MT_Expression, MF_Functional }),
-		(Macro { txt("clamp"),                        MT_Expression, MF_Functional }),
-		(Macro { txt("is_between"),                   MT_Expression, MF_Functional }),
-		(Macro { txt("size_of"),                      MT_Expression, MF_Functional }),
-		(Macro { txt("min"),                          MT_Expression, MF_Functional }),
-		(Macro { txt("max"),                          MT_Expression, MF_Functional }),
-		(Macro { txt("offset_of"),                    MT_Expression, MF_Functional }),
-		(Macro { txt("static_assert"),                MT_Statement,  MF_Functional }),
-		(Macro { txt("typeof"),                       MT_Expression, MF_Null       }),
-		(Macro { txt("GEN_API_C_BEGIN"),              MT_Statement,  MF_Null       }),
-		(Macro { txt("GEN_API_C_END"),                MT_Statement,  MF_Null       }),
-		(Macro { txt("nullptr"),                      MT_Expression, MF_Null       }),
-		(Macro { txt("GEN_REMOVE_PTR"),               MT_Expression, MF_Functional }),
-		(Macro { txt("GEN_PARAM_DEFAULT"),            MT_Expression, MF_Null       }),
-		(Macro { txt("struct_init"),                  MT_Expression, MF_Functional }),
-		(Macro { txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"),  MT_Statement,  MF_Null       }),
-		(Macro { txt("GEN_OPITMIZE_MAPPINGS_END"),    MT_Statement,  MF_Null       }),
-		(Macro { txt("src_line_str"),                 MT_Expression, MF_Null       })
-	));
-
-	// gen_dep.hpp
-	{
-		CodeBody macros = def_body( CT_Global_Body );
-		{
-			FileContents content    = file_read_contents( ctx.Allocator_Temp, file_zero_terminate, path_base "dependencies/macros.hpp" );
-			CodeBody     ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
-
-			for (Code	code =  ori_macros.begin();
-						code != ori_macros.end();
-						++ code )
-			{
-				switch (code->Type)
-				{
-					case CT_Preprocess_Define:
-					{
-						CodeDefine define = cast(CodeDefine, code);
-						if ( define->Name.starts_with(txt("global")) )
-						{
-							macros.append(parse_global_body(txt("#define global // Global variables")));
-							continue;
-						}
-
-						macros.append(define);
-					}
-					break;
-
-					default:
-						macros.append(code);
-					break;
-				}
-			}
-		}
-
-		Code platform     = scan_file( path_base "dependencies/platform.hpp" );
-		Code basic_types  = scan_file( path_base "dependencies/basic_types.hpp" );
-		Code debug        = scan_file( path_base "dependencies/debug.hpp" );
-		Code memory	      = scan_file( path_base "dependencies/memory.hpp" );
-		Code string_ops   = scan_file( path_base "dependencies/string_ops.hpp" );
-		Code printing     = scan_file( path_base "dependencies/printing.hpp" );
-		Code containers   = scan_file( path_base "dependencies/containers.hpp" );
-		Code hashing 	  = scan_file( path_base "dependencies/hashing.hpp" );
-		Code strings      = scan_file( path_base "dependencies/strings.hpp" );
-		Code filesystem   = scan_file( path_base "dependencies/filesystem.hpp" );
-		Code timing       = scan_file( path_base "dependencies/timing.hpp" );
-		Code parsing      = scan_file( path_base "dependencies/parsing.hpp" );
-
-		Builder
-		header = Builder::open("gen/gen.dep.hpp");
-		header.print_fmt( generation_notice );
-		header.print( pragma_once );
-		header.print( push_ignores );
-		header.print( platform );
-		header.print_fmt( "\nGEN_NS_BEGIN\n" );
-
-		header.print( fmt_newline);
-		header.print( format(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(parsing);
-
-		header.print_fmt( "\nGEN_NS_END\n" );
-		header.print( fmt_newline );
-		header.print( pop_ignores );
-		header.write();
-	}
-
-	// gen_dep.cpp
-	{
-		Code src_start  = scan_file( path_base "dependencies/src_start.cpp" );
-		Code debug      = scan_file( path_base "dependencies/debug.cpp" );
-		Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
-		Code printing   = scan_file( path_base "dependencies/printing.cpp" );
-		Code memory     = scan_file( path_base "dependencies/memory.cpp" );
-		Code hashing    = scan_file( path_base "dependencies/hashing.cpp" );
-		Code strings    = scan_file( path_base "dependencies/strings.cpp" );
-		Code filesystem = scan_file( path_base "dependencies/filesystem.cpp" );
-		Code timing     = scan_file( path_base "dependencies/timing.cpp" );
-		Code parsing    = scan_file( path_base "dependencies/parsing.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.dep.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( def_include(txt("gen.dep.hpp")));
-		src.print( fmt_newline );
-		src.print( push_ignores );
-		src.print( src_start );
-		src.print_fmt( "\nGEN_NS_BEGIN\n" );
-
-		src.print( debug );
-		src.print( string_ops );
-		src.print( printing );
-		src.print( hashing );
-		src.print( memory );
-		src.print( strings );
-		src.print( filesystem );
-		src.print( timing );
-		src.print( parsing );
-
-		src.print_fmt( "\nGEN_NS_END\n" );
-		src.print( fmt_newline );
-		src.print( pop_ignores );
-		src.write();
-	}
-
-	// gen.hpp
-	{
-		Code header_start = scan_file(           "components/header_start.hpp" );
-		Code types        = scan_file( path_base "components/types.hpp" );
-		Code parser_types = scan_file( path_base "components/parser_types.hpp");
-		Code ast          = scan_file( path_base "components/ast.hpp" );
-		Code ast_types    = scan_file( path_base "components/ast_types.hpp" );
-		Code code_types   = scan_file( path_base "components/code_types.hpp" );
-		Code interface    = scan_file( path_base "components/interface.hpp" );
-		Code constants    = scan_file( path_base "components/constants.hpp" );
-		Code inlines      = scan_file( path_base "components/inlines.hpp" );
-
-		CodeBody ecode       = gen_ecode     ( path_base "enums/ECodeTypes.csv" );
-		CodeBody eoperator   = gen_eoperator ( path_base "enums/EOperator.csv" );
-		CodeBody especifier  = gen_especifier(           "enums/ESpecifier.csv" );
-		CodeBody ast_inlines = gen_ast_inlines();
-
-		// Note(Ed): The Attribute tokens need to be expanded and regenerated on a per-project/installation of this library for a specific codebase of Unreal.
-		// We can support an arbitrary set of modules or plugin apis for parsing
-		// but its up to the user to define them all (This will just provide whats I've used up till now).
-		CodeBody etoktype = gen_etoktype( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-
-		Builder
-		header = Builder::open( "gen/gen.hpp" );
-		header.print_fmt( generation_notice );
-		header.print_fmt( "#pragma once\n\n" );
-		header.print( push_ignores );
-		header.print( fmt_newline );
-		header.print( header_start );
-		header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
-
-		header.print_fmt( "#pragma region Types\n" );
-		header.print( types );
-		header.print( fmt_newline );
-		header.print( format(ecode) );
-		header.print( fmt_newline );
-		header.print( format(eoperator) );
-		header.print( fmt_newline );
-		header.print( format(especifier) );
-		header.print( fmt_newline );
-		header.print( format(etoktype) );
-		header.print( parser_types );
-		header.print_fmt( "#pragma endregion Types\n\n" );
-
-		header.print_fmt( "#pragma region AST\n" );
-		header.print( ast );
-		header.print( code_types );
-		header.print( ast_types );
-		header.print_fmt( "\n#pragma endregion AST\n" );
-
-		header.print( interface );
-		header.print( constants );
-
-		header.print_fmt( "\n#pragma region Inlines\n" );
-		header.print( inlines );
-		header.print( fmt_newline );
-		header.print( format(ast_inlines) );
-		header.print( fmt_newline );
-		header.print_fmt( "#pragma endregion Inlines\n" );
-
-		header.print_fmt( "\nGEN_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( path_base "components/static_data.cpp" );
-		Code        ast_case_macros    = scan_file( path_base "components/ast_case_macros.cpp" );
-		Code        ast			       = scan_file( path_base "components/ast.cpp" );
-		Code        code_serialization = scan_file( path_base "components/code_serialization.cpp" );
-		Code        interface	       = scan_file( path_base "components/interface.cpp" );
-		Code        upfront 	       = scan_file( path_base "components/interface.upfront.cpp" );
-		Code        lexer              = scan_file( path_base "components/lexer.cpp" );
-		Code        parser_case_macros = scan_file(           "components/parser_case_macros.cpp" );
-		Code        parser             = scan_file( path_base "components/parser.cpp" );
-		Code 	    parsing_interface  = scan_file( path_base "components/interface.parsing.cpp" );
-		Code        untyped 	       = scan_file( path_base "components/interface.untyped.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( push_ignores );
-		src.print( fmt_newline );
-		src.print( src_start );
-		src.print( fmt_newline );
-		src.print_fmt( "GEN_NS_BEGIN\n");
-
-		src.print( static_data );
-
-		src.print_fmt( "\n#pragma region AST\n\n" );
-		src.print( ast_case_macros );
-		src.print( ast );
-		src.print( code_serialization );
-		src.print_fmt( "\n#pragma endregion AST\n" );
-
-		src.print_fmt( "\n#pragma region Interface\n" );
-		src.print( interface );
-
-		src.print( upfront );
-
-		src.print_fmt( "\n#pragma region Parsing\n\n" );
-		src.print( lexer );
-		src.print( parser_case_macros );
-		src.print( parser );
-		src.print( parsing_interface );
-		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
-
-		src.print_fmt( "\n#pragma region Untyped\n\n" );
-		src.print( untyped );
-		src.print_fmt( "#pragma endregion \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( path_base "auxiliary/builder.hpp" );
-
-		Builder
-		header = Builder::open( "gen/gen.builder.hpp" );
-		header.print_fmt( generation_notice );
-		header.print( push_ignores );
-		header.print( fmt_newline );
-		header.print_fmt( "#pragma once\n\n" );
-		header.print( def_include( txt("gen.hpp") ));
-		header.print_fmt( "\nGEN_NS_BEGIN\n" );
-		header.print( builder );
-		header.print_fmt( "\nGEN_NS_END\n" );
-		header.print( fmt_newline );
-		header.print( pop_ignores );
-		header.write();
-	}
-
-	// gen_builder.cpp
-	{
-		Code builder = scan_file( path_base "auxiliary/builder.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.builder.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( push_ignores );
-		src.print( fmt_newline );
-		src.print( def_include( txt("gen.builder.hpp") ) );
-		src.print_fmt( "\nGEN_NS_BEGIN\n" );
-		src.print( builder );
-		src.print_fmt( "\nGEN_NS_END\n" );
-		src.print( fmt_newline );
-		src.print( pop_ignores );
-		src.write();
-	}
-
-	// gen_scanner.hpp
-	{
-		Code scanner = scan_file( path_base "auxiliary/scanner.hpp" );
-
-		Builder
-		header = Builder::open( "gen/gen.scanner.hpp" );
-		header.print_fmt( generation_notice );
-		header.print_fmt( "#pragma once\n\n" );
-		header.print( push_ignores );
-		header.print( fmt_newline );
-		header.print( def_include( txt("gen.hpp") ) );
-		header.print_fmt( "\nGEN_NS_BEGIN\n" );
-		header.print( scanner );
-		header.print_fmt( "\nGEN_NS_END\n" );
-		header.print( fmt_newline );
-		header.print( pop_ignores );
-		header.write();
-	}
-
-	// gen.scanner.cpp
-	{
-		Code scanner = scan_file( path_base "auxiliary/scanner.cpp" );
-
-		Builder
-		src = Builder::open( "gen/gen.scanner.cpp" );
-		src.print_fmt( generation_notice );
-		src.print( push_ignores );
-		src.print( fmt_newline );
-		src.print( def_include( txt("gen.scanner.hpp") ) );
-		src.print_fmt( "\nGEN_NS_BEGIN\n" );
-		src.print( scanner );
-		src.print_fmt( "\nGEN_NS_END\n" );
-		src.print( fmt_newline );
-		src.print( pop_ignores );
-		src.write();
-	}
-}

gen_unreal_engine/unreal.refactor

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

gencpp.10x

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

gencpp.sln

@@ -0,0 +1,48 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.33516.290
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gencpp", "gencpp.vcxproj", "{53AF600D-C09C-4F39-83E0-E022AA9479F2}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		bootstrap debug|x64 = bootstrap debug|x64
+		bootstrap debug|x86 = bootstrap debug|x86
+		bootstrap release|x64 = bootstrap release|x64
+		bootstrap release|x86 = bootstrap release|x86
+		singleheader debug|x64 = singleheader debug|x64
+		singleheader debug|x86 = singleheader debug|x86
+		singleheader release|x64 = singleheader release|x64
+		singleheader release|x86 = singleheader release|x86
+		test debug|x64 = test debug|x64
+		test debug|x86 = test debug|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.ActiveCfg = bootstrap release|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x64.Build.0 = bootstrap release|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.ActiveCfg = bootstrap debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap debug|x86.Build.0 = bootstrap debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x64.ActiveCfg = bootstrap release|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.ActiveCfg = bootstrap release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.bootstrap release|x86.Build.0 = bootstrap release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.ActiveCfg = singleheader debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x64.Build.0 = singleheader debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.ActiveCfg = singleheader debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader debug|x86.Build.0 = singleheader debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.ActiveCfg = bootstrap debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x64.Build.0 = bootstrap debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.ActiveCfg = singleheader release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.singleheader release|x86.Build.0 = singleheader release|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.ActiveCfg = test debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x64.Build.0 = test debug|x64
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.ActiveCfg = test debug|Win32
+		{53AF600D-C09C-4F39-83E0-E022AA9479F2}.test debug|x86.Build.0 = test debug|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {B12D2F1D-037C-44E1-B24B-2612E3DE0193}
+	EndGlobalSection
+EndGlobal

gencpp.sln.DotSettings.user

@@ -0,0 +1,3 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:String></wpf:ResourceDictionary>

gencpp.vcxproj

@@ -0,0 +1,375 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="bootstrap debug|Win32">
+      <Configuration>bootstrap debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="bootstrap debug|x64">
+      <Configuration>bootstrap debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="bootstrap release|Win32">
+      <Configuration>bootstrap release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="bootstrap release|x64">
+      <Configuration>bootstrap release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader debug|Win32">
+      <Configuration>singleheader debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader debug|x64">
+      <Configuration>singleheader debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader release|Win32">
+      <Configuration>singleheader release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="singleheader release|x64">
+      <Configuration>singleheader release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="test debug|Win32">
+      <Configuration>test debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="test debug|x64">
+      <Configuration>test debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectGuid>{53AF600D-C09C-4F39-83E0-E022AA9479F2}</ProjectGuid>
+    <Keyword>MakeFileProj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|Win32'">
+    <NMakeBuildCommandLine>./scripts/build.ps1</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>./scripts/clean.ps1</NMakeCleanCommandLine>
+    <NMakeReBuildCommandLine>./scripts/build.ps1</NMakeReBuildCommandLine>
+    <NMakePreprocessorDefinitions>WIN32;_DEBUG;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug bootstrap</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug test</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine />
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc debug singleheader</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release singleheader</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
+    <NMakeBuildCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1" msvc release bootstrap</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>
+    </NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>pwsh.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
+    <NMakePreprocessorDefinitions>GEN_INTELLISENSE_DIRECTIVES;GEN_TIME;GEN_BENCHMARK;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <IncludePath>$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
+    <SourcePath>$(ProjectDir)project;$(SourcePath)</SourcePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc11</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <None Include=".editorconfig" />
+    <None Include="project\enums\AttributeTokens.csv" />
+    <None Include="project\enums\ECode.csv" />
+    <None Include="project\enums\EOperator.csv" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
+    <None Include="Readme.md" />
+    <None Include="scripts\.clang-format" />
+    <None Include="scripts\build.ci.ps1" />
+    <None Include="scripts\build.ps1" />
+    <None Include="scripts\clean.ps1" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
+    <None Include="test\gen\meson.build" />
+    <None Include="test\meson.build" />
+    <None Include="test\Readme.md" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="project\auxillary\builder.hpp" />
+    <ClInclude Include="project\auxillary\editor.hpp" />
+    <ClInclude Include="project\auxillary\scanner.hpp" />
+    <ClInclude Include="project\components\ast.hpp" />
+    <ClInclude Include="project\components\ast_types.hpp" />
+    <ClInclude Include="project\components\code_types.hpp" />
+    <ClInclude Include="project\components\gen\ast_inlines.hpp" />
+    <ClInclude Include="project\components\gen\ecode.hpp" />
+    <ClInclude Include="project\components\gen\eoperator.hpp" />
+    <ClInclude Include="project\components\gen\especifier.hpp" />
+    <ClInclude Include="project\components\header_end.hpp" />
+    <ClInclude Include="project\components\header_start.hpp" />
+    <ClInclude Include="project\components\inlines.hpp" />
+    <ClInclude Include="project\components\interface.hpp" />
+    <ClInclude Include="project\components\types.hpp" />
+    <ClInclude Include="project\dependencies\basic_types.hpp" />
+    <ClInclude Include="project\dependencies\containers.hpp" />
+    <ClInclude Include="project\dependencies\debug.hpp" />
+    <ClInclude Include="project\dependencies\filesystem.hpp" />
+    <ClInclude Include="project\dependencies\hashing.hpp" />
+    <ClInclude Include="project\dependencies\header_start.hpp" />
+    <ClInclude Include="project\dependencies\macros.hpp" />
+    <ClInclude Include="project\dependencies\memory.hpp" />
+    <ClInclude Include="project\dependencies\parsing.hpp" />
+    <ClInclude Include="project\dependencies\printing.hpp" />
+    <ClInclude Include="project\dependencies\strings.hpp" />
+    <ClInclude Include="project\dependencies\string_ops.hpp" />
+    <ClInclude Include="project\dependencies\timing.hpp" />
+    <ClInclude Include="project\gen.dep.hpp" />
+    <ClInclude Include="project\gen.hpp" />
+    <ClInclude Include="project\helpers\helper.hpp" />
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\undef.macros.hpp" />
+    <ClInclude Include="singleheader\components\header_start.hpp" />
+    <ClInclude Include="test\CURSED_TYPEDEF.h" />
+    <ClInclude Include="test\DummyInclude.hpp" />
+    <ClInclude Include="test\Parsed\Buffer.Parsed.hpp" />
+    <ClInclude Include="test\Parsed\HashTable.Parsed.hpp" />
+    <ClInclude Include="test\Parsed\Ring.Parsed.hpp" />
+    <ClInclude Include="test\parsing.hpp" />
+    <ClInclude Include="test\SOA.hpp" />
+    <ClInclude Include="test\upfront.hpp" />
+    <ClInclude Include="test\Upfront\Array.Upfront.hpp" />
+    <ClInclude Include="test\Upfront\Buffer.Upfront.hpp" />
+    <ClInclude Include="test\Upfront\HashTable.Upfront.hpp" />
+    <ClInclude Include="test\Upfront\Ring.Upfront.hpp" />
+    <ClInclude Include="test\Upfront\Sanity.Upfront.hpp" />
+    <ClInclude Include="test\Parsed\Array.Parsed.hpp" />
+    <ClInclude Include="test\Parsed\Sanity.Parsed.hpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="project\auxillary\builder.cpp" />
+    <ClCompile Include="project\auxillary\scanner.cpp" />
+    <ClCompile Include="project\bootstrap.cpp" />
+    <ClCompile Include="project\components\ast.cpp" />
+    <ClCompile Include="project\components\ast_case_macros.cpp" />
+    <ClCompile Include="project\components\code_serialization.cpp" />
+    <ClCompile Include="project\components\gen\etoktype.cpp" />
+    <ClCompile Include="project\components\interface.cpp" />
+    <ClCompile Include="project\components\interface.parsing.cpp" />
+    <ClCompile Include="project\components\interface.untyped.cpp" />
+    <ClCompile Include="project\components\interface.upfront.cpp" />
+    <ClCompile Include="project\components\lexer.cpp" />
+    <ClCompile Include="project\components\parser.cpp" />
+    <ClCompile Include="project\components\src_start.cpp" />
+    <ClCompile Include="project\components\static_data.cpp" />
+    <ClCompile Include="project\dependencies\debug.cpp" />
+    <ClCompile Include="project\dependencies\filesystem.cpp" />
+    <ClCompile Include="project\dependencies\hashing.cpp" />
+    <ClCompile Include="project\dependencies\memory.cpp" />
+    <ClCompile Include="project\dependencies\parsing.cpp" />
+    <ClCompile Include="project\dependencies\printing.cpp" />
+    <ClCompile Include="project\dependencies\src_start.cpp" />
+    <ClCompile Include="project\dependencies\strings.cpp" />
+    <ClCompile Include="project\dependencies\string_ops.cpp" />
+    <ClCompile Include="project\dependencies\timing.cpp" />
+    <ClCompile Include="project\Example.cpp" />
+    <ClCompile Include="project\gen.cpp" />
+    <ClCompile Include="project\gen.dep.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\enums\AttributeTokens.csv" />
+    <Content Include="project\enums\ECode.csv" />
+    <Content Include="project\enums\EOperator.csv" />
+    <Content Include="project\enums\ESpecifier.csv" />
+    <Content Include="project\enums\ETokType.csv" />
+    <Content Include="scripts\.clang-format" />
+    <Content Include="scripts\helpers\devshell.ps1" />
+    <Content Include="scripts\helpers\target_arch.psm1" />
+    <Content Include="scripts\refactor.ps1" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="singleheader\gen\" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

gencpp.vcxproj.filters

@@ -0,0 +1,320 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="project\gen.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.Upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\gen.dep.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\sanity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\SOA.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\ast_case_macros.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\src_start.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\static_data.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\bootstrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\debug.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\filesystem.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\hashing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\memory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\printing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\src_start.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\string_ops.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\strings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\timing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\builder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\auxillary\scanner.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="singleheader\singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\test.singleheader_ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\parsed\test.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\upfront\test.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_singleheader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test\validate_bootstrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\interface.untyped.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\gen\etoktype.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\Example.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\parser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\lexer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\code_serialization.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="project\gen.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\DummyInclude.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Parsed\Buffer.Parsed.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Parsed\HashTable.Parsed.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Parsed\Ring.Parsed.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\SOA.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Upfront\Array.Upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Upfront\Buffer.Upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Upfront\HashTable.Upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Upfront\Ring.Upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Upfront\Sanity.Upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Parsed\Array.Parsed.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\Parsed\Sanity.Parsed.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\gen.dep.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\ast.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\ast_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\header_end.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\inlines.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\interface.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\helper.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\pop_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\push_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\undef.macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\basic_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\containers.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\debug.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\filesystem.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\hashing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\memory.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\printing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\string_ops.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\strings.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\timing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\builder.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\editor.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\auxillary\scanner.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="singleheader\components\header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\ast_inlines.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\ecode.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\eoperator.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen\especifier.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\CURSED_TYPEDEF.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\code_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include=".editorconfig" />
+    <None Include="Readme.md" />
+    <None Include="scripts\build.ci.ps1" />
+    <None Include="scripts\build.ps1" />
+    <None Include="scripts\clean.ps1" />
+    <None Include="test\gen\meson.build" />
+    <None Include="test\meson.build" />
+    <None Include="test\Readme.md" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
+    <None Include="project\enums\AttributeTokens.csv" />
+    <None Include="project\enums\ECode.csv" />
+    <None Include="project\enums\EOperator.csv" />
+    <None Include="project\enums\ESpecifier.csv" />
+    <None Include="project\enums\ETokType.csv" />
+    <None Include="scripts\helpers\devshell.ps1" />
+    <None Include="scripts\helpers\target_arch.psm1" />
+    <None Include="scripts\package_release.ps1" />
+    <None Include="scripts\refactor.ps1" />
+    <None Include="scripts\.clang-format" />
+  </ItemGroup>
+  <ItemGroup>
+    <Natvis Include=".vscode\gencpp.natvis" />
+    <Natvis Include="scripts\gencpp.natvis" />
+  </ItemGroup>
+</Project>

gencpp.vcxproj.user

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ShowAllFiles>true</ShowAllFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap debug|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test debug|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader debug|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='singleheader release|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='bootstrap release|x64'">
+    <LocalDebuggerAttach>false</LocalDebuggerAttach>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <LocalDebuggerCommand>$(ProjectDir)project\build\bootstrap.exe</LocalDebuggerCommand>
+  </PropertyGroup>
+</Project>

project/Readme.md

@@ -0,0 +1,59 @@
+# Documentation
+
+The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a tailored format for the target `gen` files.
+
+The principal (user) files are `gen.hpp` and `gen.cpp`.  
+They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
+
+Dependencies are bundled into `gen.dep.<hpp/cpp>`.  
+Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`
+
+Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
+
+Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.
+
+The default `gen.bootstrap.cpp` located in the project folder is meant to be produce a standard segmented library, where the components of the library  
+have relatively dedicated header and source files. Dependencies included at the top of the file and each header starting with a pragma once.  
+The output will be in the `project/gen` directory (if the directory does not exist, it will create it).
+
+Use those to get a general idea of how to make your own tailored version.
+
+Feature Macros:
+
+* `GEN_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing. 
+  * This is auto-generated if using the bootstrap or single-header generation
+  * *Note: The user will use the `AttributeTokens.csv` when the library is fully self-hosting.*
+* `GEN_DEFINE_LIBRARY_CORE_CONSTANTS` : Optional typename codes as they are non-standard to C/C++ and not necessary to library usage
+* `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
+* `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
+* `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
+* `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
+* `GEN_DONT_ALLOW_INVALID_CODE` (Not implemented yet) : Will fail when an invalid code is constructed, parsed, or serialized.
+
+## On multi-threading
+
+Currently unsupported. I want the library to be *stable* and *correct*, with the addition of exhausting all basic single-threaded optimizations before I consider multi-threading.
+
+## Extending the library
+
+This library is relatively very small, and can be extended without much hassle.
+
+The convention you'll see used throughout the interface of the library is as follows:
+
+1. Check name or parameters to make sure they are valid for the construction requested
+2. Create a code object using `make_code`.
+3. Populate immediate fields (Name, Type, ModuleFlags, etc)
+4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected).
+
+Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.
+
+`def_operator` is the most sophisticated constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
+
+The library has its code segmented into component files, use it to help create a derived version without needing to have to rewrite a generated file directly or build on top of the header via composition or inheritance.
+
+The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.
+
+## A note on compilation and runtime generation speed
+
+The library is designed to be fast to compile and generate code at runtime as fast as resonable possible on a debug build.
+Its recommended that your metaprogam be compiled using a single translation unit (unity build).

project/auxillary/builder.cpp

@@ -0,0 +1,59 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	include "builder.hpp"
+#endif
+
+Builder Builder::open( char const* path )
+{
+	Builder result;
+	
+	FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
+	if ( error != EFileError_NONE )
+	{
+		log_failure( "gen::File::open - Could not open file: %s", path);
+		return result;
+	}
+
+	result.Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+
+	// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
+	return result;
+}
+
+void Builder::pad_lines( s32 num )
+{
+	Buffer.append( "\n" );
+}
+
+void Builder::print( Code code )
+{
+	String   str = code->to_string();
+	// const sw len = str.length();
+	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
+	Buffer.append( str );
+}
+
+void Builder::print_fmt( char const* fmt, ... )
+{
+	sw   res;
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+	va_end( va );
+
+	// log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf );
+	Buffer.append( buf, res );
+}
+
+void Builder::write()
+{
+	bool result = file_write( & File, Buffer, Buffer.length() );
+
+	if ( result == false )
+		log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & File ) );
+
+	log_fmt( "Generated: %s\n", File.filename );
+	file_close( & File );
+	Buffer.free();
+}

project/auxillary/builder.hpp

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

project/auxillary/scanner.cpp

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

project/auxillary/scanner.hpp

@@ -0,0 +1,159 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "gen.hpp"
+#endif
+
+// This is a simple file reader that reads the entire file into memory.
+// It has an extra option to skip the first few lines for undesired includes.
+// This is done so that includes can be kept in dependency and component files so that intellisense works.
+Code scan_file( char const* path )
+{
+	FileInfo file;
+
+	FileError error = file_open_mode( & file, EFileMode_READ, path );
+	if ( error != EFileError_NONE )
+	{
+		GEN_FATAL( "scan_file: Could not open: %s", path );
+	}
+
+	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;
+
+	// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
+	// Its designed so that the directive should be the first thing in the file.
+	// Anything that comes before it will also be omitted.
+	{
+	#define current (*scanner)
+	#define matched    0
+	#define move_fwd() do { ++ scanner; -- left; } while (0)
+		const StrC directive_start = txt( "ifdef" );
+		const StrC directive_end   = txt( "endif" );
+		const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
+
+		bool        found_directive = false;
+		char const* scanner         = str.Data;
+		s32         left            = fsize;
+		while ( left )
+		{
+			// Processing directive.
+			if ( current == '#' )
+			{
+				move_fwd();
+				while ( left && char_is_space( current ) )
+					move_fwd();
+
+				if ( ! found_directive )
+				{
+					if ( left && str_compare( scanner, directive_start.Ptr, directive_start.Len ) == matched )
+					{
+						scanner += directive_start.Len;
+						left    -= directive_start.Len;
+
+						while ( left && char_is_space( current ) )
+							move_fwd();
+
+						if ( left && str_compare( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
+						{
+							scanner += def_intellisense.Len;
+							left    -= def_intellisense.Len;
+
+							found_directive = true;
+						}
+					}
+
+					// Skip to end of line
+					while ( left && current != '\r' && current != '\n' )
+						move_fwd();
+					move_fwd();
+
+					if ( left && current == '\n' )
+						move_fwd();
+
+					continue;
+				}
+
+				if ( left && str_compare( scanner, directive_end.Ptr, directive_end.Len ) == matched )
+				{
+					scanner += directive_end.Len;
+					left    -= directive_end.Len;
+
+					// Skip to end of line
+					while ( left && current != '\r' && current != '\n' )
+						move_fwd();
+					move_fwd();
+
+					if ( left && current == '\n' )
+						move_fwd();
+
+					// sptr skip_size = fsize - left;
+					if ( (scanner + 2) >= ( str.Data + fsize ) )
+					{
+						mem_move( str, scanner, left );
+						str.get_header().Length = left;
+						break;
+					}
+
+					mem_move( str, scanner, left );
+					str.get_header().Length = left;
+
+					break;
+				}
+
+			}
+
+			move_fwd();
+		}
+	#undef move_fwd
+	#undef matched
+	#undef current
+	}
+
+	file_close( & file );
+	return untyped_str( str );
+}
+
+#if 0
+struct CodeFile
+{
+	using namespace Parser;
+
+	String              FilePath;
+	TokArray            Tokens;
+	Array<ParseFailure> ParseFailures;
+	Code                CodeRoot;
+};
+
+namespace Parser
+{
+	struct ParseFailure
+	{
+		String Reason;
+		Code   Node;
+	};
+}
+
+CodeFile scan_file( char const* path )
+{
+	using namespace Parser;
+
+	CodeFile
+	result = {};
+	result.FilePath = String::make( GlobalAllocator, path );
+
+	Code code = scan_file( path );
+	result.CodeRoot = code;
+
+	ParseContext context = parser_get_last_context();
+	result.Tokens        = context.Tokens;
+	result.ParseFailures = context.Failures;
+
+	return result;
+}
+#endif

project/auxillary/vis_ast/build.ps1

@@ -0,0 +1,126 @@
+Clear-Host
+
+$path_root     = git rev-parse --show-toplevel
+$path_scripts  = Join-Path $path_root 'scripts'
+
+$target_arch        = Join-Path $path_scripts 'helpers/target_arch.psm1'
+$devshell           = Join-Path $path_scripts 'helpers/devshell.ps1'
+$format_cpp	        = Join-Path $path_scripts 'helpers/format_cpp.psm1'
+$incremental_checks = Join-Path $path_scripts 'helpers/incremental_checks.ps1'
+$vendor_toolchain   = Join-Path $path_scripts 'helpers/vendor_toolchain.ps1'
+
+$path_project  = Join-Path $path_root     'project'
+$path_aux      = Join-Path $path_project  'auxillary'
+$path_vis_root = Join-Path $path_aux      'vis_ast'
+$path_binaries = Join-Path $path_vis_root 'binaries'
+$path_build    = Join-Path $path_vis_root 'build'
+$path_code     = Join-Path $path_vis_root 'code'
+$path_deps     = Join-Path $path_vis_root 'dependencies'
+$path_win32    = Join-Path $path_code     'win32'
+
+Import-Module $target_arch
+Import-Module $format_cpp
+
+#region Arguments
+$vendor           = $null
+$optimize         = $null
+$debug 	          = $null
+$analysis	      = $false
+$dev              = $false
+$verbose          = $null
+$platform         = $null
+$module_specified = $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 }
+ "optimize"            { $optimize  = $true }
+ "debug"               { $debug     = $true }
+ "analysis"            { $analysis  = $true }
+ "dev"                 { $dev       = $true }
+ "verbose"             { $verbose   = $true }
+ "platform"            { $platform  = $true; $module_specified = $true }
+}
+}}
+#endregion Argument
+
+if ( -not $module_specified )
+{
+	$platform = $true
+}
+
+# Load up toolchain configuraion
+. $vendor_toolchain
+. $incremental_checks
+
+write-host "Building Vis AST with $vendor"
+
+if ( (Test-Path $path_build) -eq $false ) {
+	New-Item $path_build -ItemType Directory
+}
+
+if ( (Test-Path $path_binaries) -eq $false ) {
+	New-Item $path_binaries -ItemType Directory
+}
+
+$path_raylib     = join-path $path_deps   'raylib'
+$path_raylib_inc = join-path $path_raylib 'include'
+$path_raylib_lib = join-path $path_raylib 'lib'
+
+$path_raylib_dll     = join-path $path_raylib_lib 'raylib.dll'
+$path_raylib_dll_bin = join-path $path_binaries   'raylib.dll'
+
+Copy-Item $path_raylib_dll $path_raylib_dll_bin -Force
+
+$includes = @(
+	$path_code,
+	$path_deps
+)
+
+write-host $path_code
+
+foreach ( $include in $includes ) {
+	Write-Host 'include: ' $include
+}
+
+# Microsoft
+$lib_gdi32  = 'Gdi32.lib'
+$lib_xinput = 'Xinput.lib'
+$lib_user32 = 'User32.lib'
+$lib_winmm  = 'Winmm.lib'
+
+$stack_size = 1024 * 1024 * 4
+
+$compiler_args = @(
+	( $flag_define + 'UNICODE'),
+	( $flag_define + '_UNICODE')
+	( $flag_define + 'INTELLISENSE_DIRECTIVES=0'),
+	( $flag_define + 'RL_USE_LIBTYPE_SHARED')
+	# ($flag_set_stack_size + $stack_size)
+	$flag_wall
+	$flag_warnings_as_errors
+	$flag_optimize_intrinsics
+)
+
+if ( $dev ) {
+	$compiler_args += ( $flag_define + 'Build_Development=1' )
+}
+else {
+	$compiler_args += ( $flag_define + 'Build_Development=0' )
+}
+
+$linker_args = @(
+	$flag_link_win_subsystem_windows,
+	$flag_link_optiiize_references,
+
+	( join-path $path_raylib_lib 'raylib.lib' )
+)
+
+$unit       = join-path $path_code     'vis_ast_windows.cpp'
+$executable = join-path $path_binaries 'vis_ast.exe'
+
+$build_result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable