test completes singleheader ast construction and serailizes with corruption

Made it to line 2597 of self parsing its singleheader

Complex global or member defintions are now supported.

.gitignore

@@ -4,6 +4,13 @@ build/*
 .vs
 
 **/*.gen.*
+**/gen/gen.hpp
+**/gen/gen.cpp
+**/gen/gen_dep.hpp
+**/gen/gen_dep.cpp
+
+gencpp.hpp
+gencpp.cpp
 
 # Build results
 [Dd]ebug/

.vscode/c_cpp_properties.json

@@ -9,7 +9,7 @@
                 "_DEBUG",
                 "UNICODE",
                 "_UNICODE",
-                "gen_time"
+                "GEN_TIME"
             ],
             "windowsSdkVersion": "10.0.19041.0",
             "compilerPath": "C:/Users/Ed/scoop/apps/llvm/current/bin/clang++.exe",

.vscode/launch.json

@@ -22,6 +22,24 @@
 			"args": [],
 			"cwd": "${workspaceFolder}/test/gen/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug bootstrap vsdbg",
+			"program": "${workspaceFolder}/project/build/gencpp_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"
 		}
 	]
 }

.vscode/settings.json

@@ -22,6 +22,13 @@
 	},
 	"C_Cpp.intelliSenseEngineFallback": "disabled",
 	"mesonbuild.configureOnOpen": true,
-	"C_Cpp.errorSquiggles": "enabled",
-	"godot_tools.scene_file_config": ""
-}
+	"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
+	}
+}

Readme.md

@@ -2,49 +2,26 @@
 
 An attempt at simple staged metaprogramming for c/c++.
 
-The library API is a compositon of code element constructors.  
+The library API is a composition of code element constructors.  
 These build up a code AST to then serialize with a file builder.
 
-### TOC
-
-* [Notes](#notes)
-* [Usage](#usage)
-* [Building](#notes)
-* [Outline](#outline)
-* [What is not provided](#what-is-not-provided)
-* [The four constructors](#there-are-four-sets-of-interfaces-for-code-ast-generation-the-library-provides)
-* [Predefined Codes](#predefined-codes)
-* [Code generation and modification](#code-generation-and-modification)
-* [On multithreading](#on-multi-threading)
-* [Extending the library](#extending-the-library)
-* [TODO](#todo)
+This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto),  
+its not meant to be a black box metaprogramming utility, its meant for the user to extend for their project domain.
 
 ## Notes
 
-The project has reached an *alpha* state, all the current functionality works for the test cases but it will most likely break in many other cases.
-
-The project has no external dependencies beyond:
-
-* `stdarg.h`
-* `stddef.h`
-* `stdio.h`
-* `errno.h`
-* `unistd.h` (Linux/Mac)
-* `intrin.h` (Windows)
-* `windows.h` (Windows)
-
-Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).  
-The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
+The project has reached an *alpha* state, all the current functionality works for the test cases but it will most likely break in many other cases.  
+The [issues](https://github.com/Ed94/gencpp/issues) marked with v1.0 Feature indicate whats left before the library is considered feature complete.
 
 A `natvis` and `natstepfilter` are provided in the scripts directory.
 
 ***The editor and scanner have not been implemented yet. The scanner will come first, then the editor.***
 
-A C variant is hosted [here](https://github.com/Ed94/genc); I haven't gotten headwind on it, should be easier to make than this...
+A C variant is hosted [here](https://github.com/Ed94/genc); I will complete it when this library is feature complete, it should be easier to make than this...
 
 ## Usage
 
-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.
+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 will dictate everything that should be generated.
 
@@ -53,10 +30,9 @@ In order to keep the locality of this code within the same files the following p
 Within `program.cpp` :
 
 ```cpp
+#ifdef GEN_TIME
 #include "gen.hpp"
 
-#ifdef gen_time
-
 ...
 
 u32 gen_main()
@@ -65,8 +41,7 @@ u32 gen_main()
 }
 #endif
 
-
-#ifndef gen_time
+#ifndef GEN_TIME
 #include "program.gen.cpp"
 
     // Regular runtime dependent on the generated code here.
@@ -75,7 +50,7 @@ u32 gen_main()
 ```
 
 The design uses a constructive builder API for the code to generate.  
-The user is given `Code` objects that are used to build up the AST.
+The user is provided `Code` objects that are used to build up the AST.
 
 Example using each construction interface:
 
@@ -115,19 +90,20 @@ Code header = parse_struct( code(
 ### Untyped
 
 ```cpp
-Code header = untyped_str( code(
+Code header = code_str(
     struct ArrayHeader
     {
         uw        Num;
         uw        Capacity;
         allocator Allocator;
     };
-));
+);
 ```
 
-`name` is a helper macro for providing a string literal with its size, intended for the name paraemter of functions.  
+`name` is a helper macro for providing a string literal with its size, intended for the name parameter of functions.  
 `code` is a helper macro for providing a string literal with its size, but intended for code string parameters.  
 `args` is a helper macro for providing the number of arguments to varadic constructors.
+`code_str` is a helper macro for writting `untyped_str( code( <content> ))`
 
 All three constrcuton interfaces will generate the following C code:
 
@@ -141,540 +117,8 @@ struct ArrayHeader
 ```
 
 **Note: The formatting shown here is not how it will look. For your desired formatting its recommended to run a pass through the files with an auto-formatter.**
+*(The library currently uses clang-format for formatting, beaware its pretty slow...)*
 
 ## Building
 
-An example of building is provided in the test directory.
-
-There are two meson build files the one within test is the program's build specification.  
-The other one in the gen directory within test is the metaprogram's build specification.
-
-Both of them build the same source file: `test.cpp`. The only differences are that gen needs a different relative path to the include directories and defines the macro definition: `gen_time`.
-
-This method is setup where all the metaprogram's code are the within the same files as the regular program's code.  
-
-## Outline
-
-### *WHAT IS NOT PROVIDED*
-
-* Lambdas
-* Lang provided dynamic dispatch (virtuals) : `override` and `final` specifiers complicate the specifier parsing and serialization. (Its a todo)
-* Suffix specifiers for functions (Ex: void() const ). Same reason as virtual/override/final missing for now.
-* RTTI
-* Exceptions
-* Execution statement validation              : Execution expressions are defined using the untyped API.
-* Parsing support for module specifiers and attributes. (Its a todo)
-
-Keywords kept from "Modern C++":
-
-* constexpr : Great to store compile-time constants.
-* consteval : Technically fine, need to make sure to execute in moderation.
-* constinit : Better than constexpr at doing its job, however, its only c++ 20.
-* export    : Useful if c++ modules ever come around to actually being usable.
-* import    : ^^
-* module    : ^^
-
-When it comes to expressions:
-
-**There is no support for validating expressions.**  
-**The reason:** Its difficult to parse without enough benefits.  
-Most of the time, the critical complex metaprogramming conundrums are producing the frame of abstractions around the expressions (which this library provides constructors to help validate, you can skip that process by using the untyped constructors).  
-Its not a priority to add such a level of complexity to the library when there isn't a high reward or need for it.  
-Especially when the priority is to keep this library small and easy to grasp for what it is.
-
-When it comes to templates:
-
-Only trivial template support is provided. the intention is for only simple, non-recursive subsitution.  
-The parameters of the template are treated like regular parameter AST entries.  
-This means that the typename entry for the parameter AST would be either:
-
-* `class`
-* `typename`
-* A fundamental type, function, or pointer type.
-
-Anything beyond this usage is not supported by parse_template for arguments (at least not intentionally).  
-Use at your own mental peril...
-
-*Concepts and Constraints are not supported, its usage is non-tirival substiution.*
-
-### The Data & Interface
-
-As mentioned in [Usage](#usage), the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
-
-The AST is managed by the library and provided the user via its interface.  
-However, the user may specifiy memory configuration.
-
-Data layout of AST struct:
-
-```cpp
-union {
-    struct
-    {
-        AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
-        AST*      Specs;          // Function, Operator, Type symbol, Variable
-        union {
-            AST*  ParentType;     // Class, Struct
-            AST*  ReturnType;     // Function, Operator
-            AST*  UnderlyingType; // Enum, Typedef
-            AST*  ValueType;      // Parameter, Variable
-        };
-        AST*      Params;         // Function, Operator, Template
-        union {
-            AST*  ArrExpr;        // Type Symbol
-            AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
-            AST*  Declaration;    // Friend, Template
-            AST*  Value;          // Parameter, Variable
-        };
-    };
-    StringCached  Content;        // Attributes, Comment, Execution, Include
-    SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
-};
-union {
-    AST* Prev;
-    AST* Front; // Used by CodeBody
-    AST* Last;  // Used by CodeParam
-};
-union {
-    AST* Next;
-    AST* Back;  // Used by CodeBody
-};
-AST*              Parent;
-StringCached      Name;
-CodeT             Type;
-ModuleFlag        ModuleFlags;
-union {
-    OperatorT     Op;
-    AccessSpec    ParentAccess;
-    s32           NumEntries;
-};
-```
-
-*`CodeT` is a typedef for `ECode::Type` which has an underlying type of `u32`*  
-*`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*  
-*`StringCahced` is a typedef for `String const`, to denote it is an interned string*  
-*`String` is the dynamically allocated string type for the library*
-
-AST widths are setup to be AST_POD_Size.
-The width dictates how much the static array can hold before it must give way to using an allocated array:
-
-```cpp
-constexpr static
-uw ArrSpecs_Cap =
-(
-        AST_POD_Size
-        - sizeof(AST*) * 3
-        - sizeof(StringCached)
-        - sizeof(CodeT)
-        - sizeof(ModuleFlag)
-        - sizeof(s32)
-)
-/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
-```
-
-*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
-
-Data Notes:
-
-* The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `gen_string_allocator`, `get_cached_string`, `make_code`.
-* ASTs are wrapped for the user in a Code struct which is a warpper for a AST* type.
-* Both AST and Code have member symbols but their data layout is enforced to be POD types.
-* This library treats memory failures as fatal.
-* 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 seralization and file buffers are not contained by those used for cached strings.
-  * They are currently using `Memory::GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
-  * Memory within the buckets is not resused, so its inherently wasteful (most likely will give non-cached strings their own tailored allocator later)
-* Linked lists used children nodes on bodies, and parameters.
-* Its intended to generate the AST in one go and serialize after. The contructors and serializer are designed to be a "one pass, front to back" setup.
-
-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 explictly cast to each other.
-
-Otherwise the library is free of any templates.
-
-The following CodeTypes are used which the user may optionally use strong typeing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
-
-* CodeBody : Has support for `for-range` iterating across Code objects.
-* CodeAttributes
-* CodeComment
-* CodeClass
-* CodeEnum
-* CodeExec
-* CodeExtern
-* CodeInclude
-* CodeFriend
-* CodeFn
-* CodeModule
-* CodeNamespace
-* CodeOperator
-* CodeOpCast
-* CodeParam : Has suppor for `for-range` iterating across parameters.
-* CodeSpecifier : Has support for `for-range` iterating across specifiers.
-* CodeStruct
-* CodeTemplate
-* CodeType
-* CodeTypedef
-* CodeUnion
-* CodeUsing
-* CodeUsingNamespace
-* CodeVar
-
-Each Code boy has an assoicated "filtered AST" with the naming convention: `AST_<CodeName>`
-Unrelated fields of the AST for that node type are omitted and only necesary padding members are defined otherwise.
-Retreiving a raw version of the ast can be done using the `raw()` function defined in each AST.
-
-## There are three sets of interfaces for Code AST generation the library provides
-
-* Upfront
-* Parsing
-* Untyped
-
-### Upfront Construction
-
-All component ASTs must be previously constructed, and provided on creation of the code AST.
-The construction will fail and return Code::Invalid otherwise.
-
-Interface :``
-
-* def_attributes
-  * *This is preappened right before the function symbol, or placed after the class or struct keyword for any flavor of attributes used.*
-  * *Its up to the user to use the desired attribute formatting: `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU).*
-* def_comment
-* def_class
-* def_enum
-* def_execution
-  * *This is equivalent to untyped_str, except that its intended for use only in execution scopes.*
-* def_extern_link
-* def_friend
-* def_function
-* def_include
-* def_module
-* def_namespace
-* def_operator
-* def_operator_cast
-* def_param
-* def_params
-* def_specifier
-* def_specifiers
-* def_struct
-* def_template
-* def_type
-* def_typedef
-* def_union
-* def_using
-* def_using_namespace
-* def_variable
-
-Bodies:
-
-* def_body
-* def_class_body
-* def_enum_body
-* def_export_body
-* def_extern_link_body
-* def_function_body
-  * *Use this for operator bodies as well*
-* def_global_body
-* def_namespace_body
-* def_struct_body
-* def_union_body
-
-Usage:
-
-```cpp
-<name> = def_<function type>( ... );
-
-Code <name>
-{
-    ...
-    <name> = def_<function name>( ... );
-}
-
-```
-
-When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
-```cpp
-def_global_body( args( ht_entry, array_ht_entry, hashtable ));
-
-// instead of:
-def_global_body( 3, ht_entry, array_ht_entry, hashtable );
-```
-
-If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.  
-When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
-
-### Parse construction
-
-A string provided to the API is parsed for the intended language construct.
-
-Interface :
-
-* parse_class
-* parse_enum
-* parse_export_body
-* parse_extern_link
-* parse_friend
-  * Purposefully are only support forward declares with this constructor.
-* parse_function
-* parse_global_body
-* parse_namespace
-* parse_operator
-* parse_operator_cast
-* parse_struct
-* parse_template
-* parse_type
-* parse_typedef
-* parse_union
-* parse_using
-* parse_variable
-
-The lexing and parsing takes shortcuts from whats expected in the standard.
-
-* Numeric literals are not check for validity.
-* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
-  * *This includes the assignment of variables.*
-* Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
-  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function
-  * Or in the usual spot for class, structs, (*right after the declaration keyword*)
-  * typedefs have attributes with the type (`parse_type`)
-* As a general rule; if its not available from the upfront contructors, its not available in the parsing constructors.
-  * *Upfront constructors are not necessarily used in the parsing constructors, this is just a good metric to know what can be parsed.*
-
-Usage:
-
-```cpp
-Code <name> = parse_<function name>( string with code );
-
-Code <name> = def_<function name>( ..., parse_<function name>(
-    <string with code>
-));
-
-Code <name> = make_<function name>( ... )
-{
-    <name>->add( parse_<function name>(
-        <string with code>
-    ));
-}
-```
-
-### Untyped constructions
-
-Code ASTs are constructed using unvalidated strings.
-
-Interface :
-
-* token_fmt_va
-* token_fmt
-* untyped_str
-* untyped_fmt
-* untyped_token_fmt
-
-During serialization any untyped Code AST has its string value directly injected inline of whatever context the content existed as an entry within.  
-Even though these are not validated from somewhat correct c/c++ syntax or components, it doesn't mean that Untyped code can be added as any component of a Code AST:
-
-* Untyped code cannot have children, thus there cannot be recursive injection this way.
-* Untyped code can only be a child of a parent of body AST, or for values of an assignment (ex: variable assignment).
-
-These restrictions help prevent abuse of untyped code to some extent.
-
-Usage Conventions:
-
-```cpp
-Code <name> = def_varaible( <type>, <name>, untyped_<function name>(
-    <string with code>
-));
-```
-
-Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
-
-```cpp
-StrC value = txt_StrC("Something");
-
-char const* template_str = txt(
-    Code with <key> to replace with token_values
-    ...
-);
-char const* gen_code_str = token_fmt( "key", value, template_str );
-Code        <name>       = parse_<function name>( gen_code_str );
-```
-
-## Predefined Codes
-
-The following are provided predefined by the library as they are commonly used:
-
-* `access_public`
-* `access_protected`
-* `access_private`
-* `module_global_fragment`
-* `module_private_fragment`
-* `pragma_once`
-* `spec_const`
-* `spec_consteval`
-* `spec_constexpr`
-* `spec_constinit`
-* `spec_extern_linkage` (extern)
-* `spec_global` (global macro)
-* `spec_inline`
-* `spec_internal_linkage` (internal macro)
-* `spec_local_persist` (local_persist macro)
-* `spec_mutable`
-* `spec_ptr`
-* `spec_ref`
-* `spec_register`
-* `spec_rvalue`
-* `spec_static_member` (static)
-* `spec_thread_local`
-* `spec_volatile`
-* `spec_type_signed`
-* `spec_type_unsigned`
-* `spec_type_short`
-* `spec_type_long`
-* `t_auto`
-* `t_void`
-* `t_int`
-* `t_bool`
-* `t_char`
-* `t_wchar_t`
-* `t_class`
-* `t_typename`
-
-Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` is defined
-
-* `t_b32`
-* `t_s8`
-* `t_s16`
-* `t_s32`
-* `t_s64`
-* `t_u8`
-* `t_u16`
-* `t_u32`
-* `t_u64`
-* `t_sw`
-* `t_uw`
-* `t_f32`
-* `t_f64`
-
-## Extent of operator overload validation
-
-The AST and constructors will be able to validate that the arguments provided for the operator type match the expected form:
-
-* If return type must match a parameter
-* If number of parameters is correct
-* If added as a member symbol to a class or struct, that operator matches the requirements for the class (types match up)
-
-The user is responsible for making sure the code types provided are correct
-and have the desired specifiers assigned to them beforehand.
-
-## Code generation and modification
-
-There are three provided file interfaces:
-
-* Builder
-* Editor
-* Scanner
-
-Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FEATURE_SCANNER` to enable them.
-
-### Builder is a similar object to the jai language's string_builder
-
-* The purpose of it is to generate a file.
-* A file is specified and opened for writting using the open( file_path) ) function.
-* The code is provided via print( code ) function  will be seralized to its buffer.
-* When all seralization is finished, use the write() command to write the buffer to the file.
-
-### Editor is for editing a series of files based on a set of requests provided to it
-
-**Note: Not implemented yet**
-
-* The purpose is to overrite a specific file, it places its contents in a buffer to scan.
-* Requests are populated using the following interface:
-  * add : Add code.
-  * remove : Remove code.
-  * replace: Replace code.
-
-All three have the same parameters with exception to remove which only has SymbolInfo and Policy:
-
-* SymbolInfo:
-  * File      : The file the symbol resides in. Leave null to indicate to search all files. Leave null to indicated all-file search.
-  * Marker    : #define symbol that indicates a location or following signature is valid to manipulate. Leave null to indicate the signature should only be used.
-  * Signature : Use a Code symbol to find a valid location to manipulate, can be further filtered with the marker. Leave null to indicate the marker should only be used.
-
-* Policy : Additional policy info for completing the request (empty for now)
-* Code   : Code to inject if adding, or replace existing code with.
-
-Additionally if `GEN_FEATURE_EDITOR_REFACTOR` is defined, refactor( file_path, specification_path ) wil be made available.  
-Refactor is based of the refactor library and uses its interface.  
-It will on call add a request to the queue to run the refactor script on the file.
-
-### Scanner allows the user to generate Code ASTs by reading files
-
-**Note: Not implemented yet**
-
-* The purpose is to grab definitions to generate metadata or generate new code from these definitions.
-* Requests are populated using the add( SymbolInfo, Policy ) function. The symbol info is the same as the one used for the editor. So is the case with Policy.
-
-The file will only be read from, no writting supported.
-
-One great use case is for example: generating the single-header library for gencpp!
-
-### Additional Info (Editor and Scanner)
-
-When all requests have been populated, call process_requests().  
-It will provide an output of receipt data of the results when it completes.
-
-Files may be added to the Editor and Scanner additionally with add_files( num, files ).  
-This is intended for when you have requests that are for multiple files.
-
-Request queue in both Editor and Scanner are cleared once process_requests completes.
-
-## On multi-threading
-
-Currently unsupported. The following changes would have to be made:
-
-* Setup static data accesss with fences if more than one thread will generate ASTs ( or keep a different set for each thread)
-* Make sure local peristent data of functions are also thread local.
-* The builder should be done on a per-thread basis.
-* Due to the design of the editor and scanner, it will most likely be best to make each file a job to process request entries on. Receipts should have an an array to store per thread. They can be combined to the final reciepts array when all files have been processed.
-
-## Extending the library
-
-This library is relatively very small, and can be extended without much hassle.
-
-The untyped codes and builder/editor/scanner can be technically be used to circumvent
-any sort of constrictions the library has with: modern c++, templates, macros, etc.
-
-Typical use case is for getting define constants an old C/C++ library with the scanner:  
-Code parse_defines() can emit a custom code AST with Macro_Constant type.
-
-Another would be getting preprocessor or template metaprogramming Codes from Unreal Engine definitions, etc.
-
-The rules for constructing the AST are largely bound the syntax rules for what can be composed with whichever version of C++ your targeting.
-
-The convention you'll see used throughout the API of the library is as follows:
-
-1. Check name or parameters to make sure they are valid for the construction requested
-2. Create a code object using `make_code`.
-3. Populate immediate fields (Name, Type, ModuleFlags, etc)
-4. Populate sub-entires using `add_entry`. If using the default seralization 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 sophisitacated constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
-
-# TODO
-
-* Implement a context stack for the parsing, allows for accurate scope validation for the AST types.
-* Make a more robust test suite.
-* Generate a single-header library.
-* Improve the allocation strategy for strings in `Builder`, `AST::to_string`, `Parser::lex`, all three can use some form of slab allocation strategy...
-  * Can most likely use a simple slag allocator.
-* May be in need of a better name, I found a few repos with this same one...
-* Support module and attribute parsing (Marked with TODOs for now..)
-* Suffix specifiers for functions (const, override, final)
-* Implement the Scanner
-* Implement the Editor
+See the [scripts directory](scripts/).

docs/Parsing.md

@@ -0,0 +1,52 @@
+# Parsing
+
+The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.  
+This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept under 5000 loc.
+
+The parsing implementation supports the following for the user:
+
+```cpp
+CodeClass     parse_class        ( StrC class_def     );
+CodeEnum      parse_enum         ( StrC enum_def      );
+CodeBody      parse_export_body  ( StrC export_def    );
+CodeExtern    parse_extern_link  ( StrC exten_link_def);
+CodeFriend    parse_friend       ( StrC friend_def    );
+CodeFn        parse_function     ( StrC fn_def        );
+CodeBody      parse_global_body  ( StrC body_def      );
+CodeNamespace parse_namespace    ( StrC namespace_def );
+CodeOperator  parse_operator     ( StrC operator_def  );
+CodeOpCast    parse_operator_cast( StrC operator_def  );
+CodeStruct    parse_struct       ( StrC struct_def    );
+CodeTemplate  parse_template     ( StrC template_def  );
+CodeType      parse_type         ( StrC type_def      );
+CodeTypedef   parse_typedef      ( StrC typedef_def   );
+CodeUnion     parse_union        ( StrC union_def     );
+CodeUsing     parse_using        ( StrC using_def     );
+CodeVar       parse_variable     ( StrC var_def       );
+```
+
+***Parsing will aggregate any tokens within a function body or expression statement to an untyped Code AST.***
+
+Everything is done in one pass for both the preprocessor directives and the rest of the language.  
+The parser performs no macro expansion as the scope of gencpp feature-set is to only support the preprocessor for the goal of having rudimentary awareness of preprocessor ***conditionals***,  ***defines***, and ***includes***, and ***`pragmas`**.  
+
+The keywords supported for the preprocessor are:
+
+* include
+* define
+* if
+* ifdef
+* elif
+* endif
+* undef
+* pragma
+
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.
+All keywords except *include* are suppported as members of a scope for a class/struct, global, or namespace body.  
+
+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 to the above rule (If its too hard to keep track of just follow the above notion):
+
+* Typedefs allow of a macro exansion to be defined after the keyword; Ex: `typedef GEN_FILE_OPEN_PROC( file_open_proc );`
+

docs/Readme.md

@@ -0,0 +1,538 @@
+## Documentation
+
+The project has no external dependencies beyond:
+
+* `errno.h`
+* `stat.h`
+* `stdarg.h`
+* `stddef.h`
+* `stdio.h`
+* `copyfile.h` (Mac)
+* `types.h`    (Linux)
+* `unistd.h`   (Linux/Mac)
+* `intrin.h`   (Windows)
+* `io.h`       (Windows with gcc)
+* `windows.h`  (Windows)
+
+Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).  
+The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
+
+This library was written in a subset of C++ where the following are not used at all:
+
+* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
+* Language provide dynamic dispatch, RTTI
+* Object-Oriented Inheritance
+* Exceptions
+
+Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.  
+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*
+
+* Execution statement validation : Execution expressions are defined using the untyped AST.
+  * Lambdas (This naturally means its unsupported)
+* Non-trivial template validation support.
+* RAII : This needs support for constructors/destructor parsing
+  * Haven't gotten around to yet (its in the github issues)
+
+Keywords kept from "Modern C++":
+
+* constexpr : Great to store compile-time constants.
+* consteval : Technically fine, need to make sure to execute in moderation.
+* constinit : Better than constexpr at doing its job, however, its only c++ 20.
+* export    : Useful if c++ modules ever come around to actually being usable.
+* import    : ^^
+* module    : ^^
+
+When it comes to expressions:
+
+**There is no support for validating expressions.**  
+Its difficult to parse without enough benefits (At the metaprogramming level).  
+
+When it comes to templates:
+
+**Only trivial template support is provided.**  
+The intention is for only simple, non-recursive substitution.  
+The parameters of the template are treated like regular parameter AST entries.  
+This means that the typename entry for the parameter AST would be either:
+
+* `class`
+* `typename`
+* A fundamental type, function, or pointer type.
+
+Anything beyond this usage is not supported by parse_template for arguments (at least not intentionally).  
+Use at your own mental peril.
+
+*Concepts and Constraints are not supported, its usage is non-trivial substitution.*
+
+### The Data & Interface
+
+As mentioned in [Usage](#usage), the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
+
+The AST is managed by the library and provided the user via its interface.  
+However, the user may specifiy memory configuration.
+
+Data layout of AST struct:
+
+```cpp
+union {
+    struct
+    {
+        AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
+        AST*      Specs;          // Function, Operator, Type symbol, Variable
+        union {
+            AST*  ParentType;     // Class, Struct
+            AST*  ReturnType;     // Function, Operator
+            AST*  UnderlyingType; // Enum, Typedef
+            AST*  ValueType;      // Parameter, Variable
+        };
+        AST*      Params;         // Function, Operator, Template
+        union {
+            AST*  ArrExpr;        // Type Symbol
+            AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
+            AST*  Declaration;    // Friend, Template
+            AST*  Value;          // Parameter, Variable
+        };
+    };
+    StringCached  Content;        // Attributes, Comment, Execution, Include
+    SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
+};
+union {
+    AST* Prev;
+    AST* Front; // Used by CodeBody
+    AST* Last;  // Used by CodeParam
+};
+union {
+    AST* Next;
+    AST* Back;  // Used by CodeBody
+};
+AST*              Parent;
+StringCached      Name;
+CodeT             Type;
+ModuleFlag        ModuleFlags;
+union {
+    OperatorT     Op;
+    AccessSpec    ParentAccess;
+    s32           NumEntries;
+};
+```
+
+*`CodeT` is a typedef for `ECode::Type` which has an underlying type of `u32`*  
+*`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*  
+*`StringCahced` is a typedef for `String const`, to denote it is an interned string*  
+*`String` is the dynamically allocated string type for the library*
+
+AST widths are setup to be AST_POD_Size.
+The width dictates how much the static array can hold before it must give way to using an allocated array:
+
+```cpp
+constexpr static
+uw ArrSpecs_Cap =
+(
+    AST_POD_Size
+    - sizeof(AST*) * 3
+    - sizeof(StringCached)
+    - sizeof(CodeT)
+    - sizeof(ModuleFlag)
+    - sizeof(s32)
+)
+/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
+```
+
+*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
+
+Data Notes:
+
+* The allocator definitions used are exposed to the user incase they want to dictate memory usage
+  * You'll find the memory handling in `init`, `gen_string_allocator`, `get_cached_string`, `make_code`.
+* ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
+* Both AST and Code have member symbols but their data layout is enforced to be POD types.
+* This library treats memory failures as fatal.
+* Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
+  * `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
+* Strings used for serialization and file buffers are not contained by those used for cached strings.
+  * They are currently using `GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
+  * Memory within the buckets is not reused, so its inherently wasteful.
+  * I will be augmenting the single arena with a simple slag allocator.
+* Linked lists used children nodes on bodies, and parameters.
+* Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
+* Allocations can be tuned by defining the folloiwng macros:
+  * `GEN_BUILDER_STR_BUFFER_RESERVE`
+  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
+  * `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
+  * `GEN_LEX_ALLOCATOR_SIZE`
+  * `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
+  * `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
+  * `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
+  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
+  * `GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE` : token_fmt_va uses local_persit memory of this size for the hashtable.
+
+The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
+
+* CodeBody : Has support for `for-range` iterating across Code objects.
+* CodeAttributes
+* CodeComment
+* CodeClass
+* CodeConstructor
+* CodeDefine
+* CodeDestructor
+* CodePreprocessCond
+* CodeEnum
+* CodeExec
+* CodeExtern
+* CodeInclude
+* CodeFriend
+* CodeFn
+* CodeModule
+* CodeNamespace
+* CodeOperator
+* CodeOpCast
+* CodeParam : Has support for `for-range` iterating across parameters.
+* CodeSpecifiers : Has support for `for-range` iterating across specifiers.
+* CodeStruct
+* CodeTemplate
+* CodeType
+* CodeTypedef
+* CodeUnion
+* CodeUsing
+* CodeVar
+
+Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
+Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
+Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
+
+## There are three sets of interfaces for Code AST generation the library provides
+
+* Upfront
+* Parsing
+* Untyped
+
+### Upfront Construction
+
+All component ASTs must be previously constructed, and provided on creation of the code AST.
+The construction will fail and return Code::Invalid otherwise.
+
+Interface :``
+
+* def_attributes
+  * *This is pre-appended right before the function symbol, or placed after the class or struct keyword for any flavor of attributes used.*
+  * *Its up to the user to use the desired attribute formatting: `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU).*
+* def_comment
+* def_class
+* def_constructor
+* def_destructor
+* def_enum
+* def_execution
+  * *This is equivalent to untyped_str, except that its intended for use only in execution scopes.*
+* def_extern_link
+* def_friend
+* def_function
+* def_include
+* def_module
+* def_namespace
+* def_operator
+* def_operator_cast
+* def_param
+* def_params
+* def_specifier
+* def_specifiers
+* def_struct
+* def_template
+* def_type
+* def_typedef
+* def_union
+* def_using
+* def_using_namespace
+* def_variable
+
+Bodies:
+
+* def_body
+* def_class_body
+* def_enum_body
+* def_export_body
+* def_extern_link_body
+* def_function_body
+  * *Use this for operator bodies as well*
+* def_global_body
+* def_namespace_body
+* def_struct_body
+* def_union_body
+
+Usage:
+
+```cpp
+<name> = def_<function type>( ... );
+
+Code <name>
+{
+    ...
+    <name> = def_<function name>( ... );
+}
+
+```
+
+When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
+```cpp
+def_global_body( args( ht_entry, array_ht_entry, hashtable ));
+
+// instead of:
+def_global_body( 3, ht_entry, array_ht_entry, hashtable );
+```
+
+If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.  
+When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
+
+### Parse construction
+
+A string provided to the API is parsed for the intended language construct.
+
+Interface :
+
+* parse_class
+* parse_constructor
+* parse_destructor
+* parse_enum
+* parse_export_body
+* parse_extern_link
+* parse_friend
+  * Purposefully are only support forward declares with this constructor.
+* parse_function
+* parse_global_body
+* parse_namespace
+* parse_operator
+* parse_operator_cast
+* parse_struct
+* parse_template
+* parse_type
+* parse_typedef
+* parse_union
+* parse_using
+* parse_variable
+
+The lexing and parsing takes shortcuts from whats expected in the standard.
+
+* Numeric literals are not check for validity.
+* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
+  * *This includes the assignment of variables.*
+* Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
+  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function
+  * Or in the usual spot for class, structs, (*right after the declaration keyword*)
+  * typedefs have attributes with the type (`parse_type`)
+* As a general rule; if its not available from the upfront constructors, its not available in the parsing constructors.
+  * *Upfront constructors are not necessarily used in the parsing constructors, this is just a good metric to know what can be parsed.*
+* Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
+
+Usage:
+
+```cpp
+Code <name> = parse_<function name>( string with code );
+
+Code <name> = def_<function name>( ..., parse_<function name>(
+    <string with code>
+));
+
+Code <name> = make_<function name>( ... )
+{
+    <name>->add( parse_<function name>(
+        <string with code>
+    ));
+}
+```
+
+### Untyped constructions
+
+Code ASTs are constructed using unvalidated strings.
+
+Interface :
+
+* token_fmt_va
+* token_fmt
+* untyped_str
+* untyped_fmt
+* untyped_token_fmt
+
+During serialization any untyped Code AST has its string value directly injected inline of whatever context the content existed as an entry within.  
+Even though these are not validated from somewhat correct c/c++ syntax or components, it doesn't mean that Untyped code can be added as any component of a Code AST:
+
+* Untyped code cannot have children, thus there cannot be recursive injection this way.
+* Untyped code can only be a child of a parent of body AST, or for values of an assignment (ex: variable assignment).
+
+These restrictions help prevent abuse of untyped code to some extent.
+
+Usage Conventions:
+
+```cpp
+Code <name> = def_variable( <type>, <name>, untyped_<function name>(
+    <string with code>
+));
+
+Code <name> = untyped_str( code(
+    <some code without "" quotes>
+));
+```
+
+Optionally, `code_str`, and `code_fmt` macros can be used so that the code macro doesn't have to be used:
+```cpp
+Code <name> = code_str( <some code without "" quotes > )
+```
+
+Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
+
+```cpp
+StrC value = txt_StrC("Something");
+
+char const* template_str = txt(
+    Code with <key> to replace with token_values
+    ...
+);
+char const* gen_code_str = token_fmt( "key", value, template_str );
+Code        <name>       = parse_<function name>( gen_code_str );
+```
+
+## Predefined Codes
+
+The following are provided predefined by the library as they are commonly used:
+
+* `access_public`
+* `access_protected`
+* `access_private`
+* `module_global_fragment`
+* `module_private_fragment`
+* `param_varaidc` (Used for varadic definitions)
+* `preprocess_else`
+* `preprocess_endif`
+* `pragma_once`
+* `spec_const`
+* `spec_consteval`
+* `spec_constexpr`
+* `spec_constinit`
+* `spec_extern_linkage` (extern)
+* `spec_final`
+* `spec_global` (global macro)
+* `spec_inline`
+* `spec_internal_linkage` (internal macro)
+* `spec_local_persist` (local_persist macro)
+* `spec_mutable`
+* `spec_override`
+* `spec_ptr`
+* `spec_ref`
+* `spec_register`
+* `spec_rvalue`
+* `spec_static_member` (static)
+* `spec_thread_local`
+* `spec_virtual`
+* `spec_volatile`
+* `spec_type_signed`
+* `spec_type_unsigned`
+* `spec_type_short`
+* `spec_type_long`
+* `t_empty` (Used for varaidc macros)
+* `t_auto`
+* `t_void`
+* `t_int`
+* `t_bool`
+* `t_char`
+* `t_wchar_t`
+* `t_class`
+* `t_typename`
+
+Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` is defined
+
+* `t_b32`
+* `t_s8`
+* `t_s16`
+* `t_s32`
+* `t_s64`
+* `t_u8`
+* `t_u16`
+* `t_u32`
+* `t_u64`
+* `t_sw`
+* `t_uw`
+* `t_f32`
+* `t_f64`
+
+## Extent of operator overload validation
+
+The AST and constructors will be able to validate that the arguments provided for the operator type match the expected form:
+
+* If return type must match a parameter
+* If number of parameters is correct
+* If added as a member symbol to a class or struct, that operator matches the requirements for the class (types match up)
+
+The user is responsible for making sure the code types provided are correct
+and have the desired specifiers assigned to them beforehand.
+
+## Code generation and modification
+
+There are three provided file interfaces:
+
+* Builder
+* Editor
+* Scanner
+
+Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FEATURE_SCANNER` to enable them.
+
+### Builder is a similar object to the jai language's string_builder
+
+* The purpose of it is to generate a file.
+* A file is specified and opened for writing using the open( file_path) ) function.
+* The code is provided via print( code ) function  will be serialized to its buffer.
+* When all serialization is finished, use the write() command to write the buffer to the file.
+
+### Editor is for editing a series of files based on a set of requests provided to it
+
+**Note: Not implemented yet**
+
+* The purpose is to overrite a specific file, it places its contents in a buffer to scan.
+* Requests are populated using the following interface:
+  * add : Add code.
+  * remove : Remove code.
+  * replace: Replace code.
+
+All three have the same parameters with exception to remove which only has SymbolInfo and Policy:
+
+* SymbolInfo:
+  * File      : The file the symbol resides in. Leave null to indicate to search all files. Leave null to indicated all-file search.
+  * Marker    : #define symbol that indicates a location or following signature is valid to manipulate. Leave null to indicate the signature should only be used.
+  * Signature : Use a Code symbol to find a valid location to manipulate, can be further filtered with the marker. Leave null to indicate the marker should only be used.
+
+* Policy : Additional policy info for completing the request (empty for now)
+* Code   : Code to inject if adding, or replace existing code with.
+
+Additionally if `GEN_FEATURE_EDITOR_REFACTOR` is defined, refactor( file_path, specification_path ) wil be made available.  
+Refactor is based of the refactor library and uses its interface.  
+It will on call add a request to the queue to run the refactor script on the file.
+
+### Scanner allows the user to generate Code ASTs by reading files
+
+**Note: Not implemented yet**
+
+* The purpose is to grab definitions to generate metadata or generate new code from these definitions.
+* Requests are populated using the add( SymbolInfo, Policy ) function. The symbol info is the same as the one used for the editor. So is the case with Policy.
+
+The file will only be read from, no writing supported.
+
+One great use case is for example: generating the single-header library for gencpp!
+
+### Additional Info (Editor and Scanner)
+
+When all requests have been populated, call process_requests().  
+It will provide an output of receipt data of the results when it completes.
+
+Files may be added to the Editor and Scanner additionally with add_files( num, files ).  
+This is intended for when you have requests that are for multiple files.
+
+Request queue in both Editor and Scanner are cleared once process_requests completes.

gencpp.10x

@@ -0,0 +1,61 @@
+<?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>powershell ./scripts/test.gen_run.ps1</BuildCommand>
+		<RebuildCommand></RebuildCommand>
+		<BuildFileCommand></BuildFileCommand>
+		<CleanCommand>powershell ./scripts/clean.ps1</CleanCommand>
+		<BuildWorkingDirectory></BuildWorkingDirectory>
+		<CancelBuild></CancelBuild>
+		<RunCommand>./test/gen/build/gencpp.exe</RunCommand>
+		<RunCommandWorkingDirectory></RunCommandWorkingDirectory>
+		<DebugCommand>powershell ./scripts/build.ps1</DebugCommand>
+		<ExePathCommand>./test/gen/build/gencpp.exe</ExePathCommand>
+		<DebugSln>gencpp.sln</DebugSln>
+		<UseVisualStudioEnvBat>false</UseVisualStudioEnvBat>
+		<Configurations>
+			<Configuration>Debug</Configuration>
+			<Configuration>Release</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.19041.0\ucrt</AdditionalIncludePath>
+			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.19041.0\\um</AdditionalIncludePath>
+			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.19041.0\\shared</AdditionalIncludePath>
+			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.19041.0\\winrt</AdditionalIncludePath>
+			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\10\\include\10.0.19041.0\\cppwinrt</AdditionalIncludePath>
+			<AdditionalIncludePath>C:\Program Files (x86)\Windows Kits\NETFXSDK\4.8\include\um</AdditionalIncludePath>
+		</AdditionalIncludePaths>
+		<Defines>
+			<Define>GEN_TIME</Define>
+		</Defines>
+		<ConfigProperties>
+			<ConfigAndPlatform>
+				<Name>Debug:x64</Name>
+				<Defines></Defines>
+				<ForceIncludes></ForceIncludes>
+			</ConfigAndPlatform>
+			<Config>
+				<Name>Debug</Name>
+				<Defines></Defines>
+			</Config>
+			<Platform>
+				<Name>x64</Name>
+				<Defines></Defines>
+			</Platform>
+		</ConfigProperties>
+		<Children></Children>
+	</Workspace>
+</N10X>

gencpp.vcxproj

@@ -79,7 +79,7 @@
     <NMakeBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeReBuildCommandLine>
     <NMakeCleanCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>gen_time;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>GEN_TIME;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
     <IncludePath>$(ProjectDir)thirdparty;$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
     <SourcePath>$(ProjectDir)project;$(ProjectDir)test;$(SourcePath)</SourcePath>
   </PropertyGroup>
@@ -87,7 +87,7 @@
     <NMakeBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\build.ps1"</NMakeReBuildCommandLine>
     <NMakeCleanCommandLine>powershell.exe -ExecutionPolicy Unrestricted -File "$(ProjectDir)scripts\clean.ps1"</NMakeCleanCommandLine>
-    <NMakePreprocessorDefinitions>gen_time;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>GEN_TIME;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
     <IncludePath>$(ProjectDir)thirdparty;$(ProjectDir)project;$(ProjectDir)test;$(IncludePath)</IncludePath>
     <SourcePath>$(ProjectDir)project;$(ProjectDir)test;$(SourcePath)</SourcePath>
   </PropertyGroup>
@@ -102,24 +102,52 @@
     <None Include="scripts\build.ci.ps1" />
     <None Include="scripts\build.ps1" />
     <None Include="scripts\clean.ps1" />
+    <None Include="scripts\gen.ps1" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
     <None Include="scripts\get_sources.ps1" />
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="project\components\gen.data_structures.hpp" />
+    <ClInclude Include="project\components\gen.ecode.hpp" />
+    <ClInclude Include="project\components\gen.eoperator.hpp" />
+    <ClInclude Include="project\components\gen.especifier.hpp" />
+    <ClInclude Include="project\components\gen.header_end.hpp" />
+    <ClInclude Include="project\components\gen.header_start.hpp" />
+    <ClInclude Include="project\components\gen.interface.hpp" />
+    <ClInclude Include="project\components\gen.types.hpp" />
+    <ClInclude Include="project\dependencies\gen.basic_types.hpp" />
+    <ClInclude Include="project\dependencies\gen.containers.hpp" />
+    <ClInclude Include="project\dependencies\gen.debug.hpp" />
+    <ClInclude Include="project\dependencies\gen.file_handling.hpp" />
+    <ClInclude Include="project\dependencies\gen.hashing.hpp" />
+    <ClInclude Include="project\dependencies\gen.header_start.hpp" />
+    <ClInclude Include="project\dependencies\gen.macros.hpp" />
+    <ClInclude Include="project\dependencies\gen.memory.hpp" />
+    <ClInclude Include="project\dependencies\gen.parsing.hpp" />
+    <ClInclude Include="project\dependencies\gen.printing.hpp" />
+    <ClInclude Include="project\dependencies\gen.string.hpp" />
+    <ClInclude Include="project\dependencies\gen.string_ops.hpp" />
+    <ClInclude Include="project\dependencies\gen.timing.hpp" />
+    <ClInclude Include="project\filesystem\gen.builder.hpp" />
+    <ClInclude Include="project\filesystem\gen.editor.hpp" />
+    <ClInclude Include="project\filesystem\gen.scanner.hpp" />
+    <ClInclude Include="project\gen.dep.hpp" />
     <ClInclude Include="project\gen.hpp" />
-    <ClInclude Include="project\gen.undef.macros.hpp" />
+    <ClInclude Include="project\helpers\gen.pop_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\gen.push_ignores.inline.hpp" />
+    <ClInclude Include="project\helpers\gen.undef.macros.hpp" />
+    <ClInclude Include="singleheader\components\gen.header_start.hpp" />
     <ClInclude Include="test\DummyInclude.hpp" />
-    <ClInclude Include="test\gen\array.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\buffer.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\hashtable.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\ring.Upfront.gen.hpp" />
-    <ClInclude Include="test\gen\sanity.Upfront.gen.hpp" />
     <ClInclude Include="test\Parsed\Buffer.Parsed.hpp" />
     <ClInclude Include="test\Parsed\HashTable.Parsed.hpp" />
     <ClInclude Include="test\Parsed\Ring.Parsed.hpp" />
+    <ClInclude Include="test\parsing.hpp" />
     <ClInclude Include="test\SOA.hpp" />
+    <ClInclude Include="test\upfront.hpp" />
     <ClInclude Include="test\Upfront\Array.Upfront.hpp" />
     <ClInclude Include="test\Upfront\Buffer.Upfront.hpp" />
     <ClInclude Include="test\Upfront\HashTable.Upfront.hpp" />
@@ -129,17 +157,58 @@
     <ClInclude Include="test\Parsed\Sanity.Parsed.hpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="project\components\gen.ast.cpp" />
+    <ClCompile Include="project\components\gen.ast_case_macros.cpp" />
+    <ClCompile Include="project\components\gen.data.cpp" />
+    <ClCompile Include="project\components\gen.etoktype.cpp" />
+    <ClCompile Include="project\components\gen.impl_start.cpp" />
+    <ClCompile Include="project\components\gen.interface.cpp" />
+    <ClCompile Include="project\components\gen.interface.parsing.cpp" />
+    <ClCompile Include="project\components\gen.interface.upfront.cpp" />
+    <ClCompile Include="project\components\gen.untyped.cpp" />
+    <ClCompile Include="project\dependencies\gen.debug.cpp" />
+    <ClCompile Include="project\dependencies\gen.file_handling.cpp" />
+    <ClCompile Include="project\dependencies\gen.hashing.cpp" />
+    <ClCompile Include="project\dependencies\gen.impl_start.cpp" />
+    <ClCompile Include="project\dependencies\gen.memory.cpp" />
+    <ClCompile Include="project\dependencies\gen.parsing.cpp" />
+    <ClCompile Include="project\dependencies\gen.printing.cpp" />
+    <ClCompile Include="project\dependencies\gen.string.cpp" />
+    <ClCompile Include="project\dependencies\gen.string_ops.cpp" />
+    <ClCompile Include="project\dependencies\gen.timing.cpp" />
+    <ClCompile Include="project\gen.bootstrap.cpp" />
     <ClCompile Include="project\gen.cpp" />
-    <ClCompile Include="singleheader\gen\gen.singleheader.cpp" />
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckc.c" />
-    <ClCompile Include="test\gen\build\meson-private\sanitycheckcpp.cc" />
+    <ClCompile Include="project\gen.dep.cpp" />
+    <ClCompile Include="singleheader\gen.singleheader.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.Upfront.cpp" />
+    <ClCompile Include="test\upfront.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />
     <Natvis Include="scripts\gencpp.natvis" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="project\components\AttributeTokens.csv" />
+    <Content Include="project\components\ECode.csv" />
+    <Content Include="project\components\EOperator.csv" />
+    <Content Include="project\components\ESpecifier.csv" />
+    <Content Include="project\components\ETokType.csv" />
+    <Content Include="project\meson.build" />
+    <Content Include="scripts\.clang-format" />
+    <Content Include="scripts\bootstrap.ci.ps1" />
+    <Content Include="scripts\bootstrap.ps1" />
+    <Content Include="scripts\msvc\build_msvc.ps1" />
+    <Content Include="scripts\msvc\devshell.ps1" />
+    <Content Include="scripts\refactor.ps1" />
+    <Content Include="scripts\singleheader.ci.ps1" />
+    <Content Include="scripts\singleheader.ps1" />
+    <Content Include="singleheader\meson.build" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

gencpp.vcxproj.filters

@@ -33,6 +33,48 @@
     <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\gen.ast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\gen.interface.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\components\gen.interface.upfront.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\gen.dep.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\gen.file_handling.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\gen.memory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\gen.parsing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="project\dependencies\gen.printing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="project\gen.hpp">
@@ -92,6 +134,87 @@
     <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="project\gen.editor.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\gen.pop_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\gen.push_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\gen.scanner.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="test\upfront.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen.data_structures.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen.interface.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\components\gen.types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.basic_types.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.containers.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.dep.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.file_handling.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.header_start.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.memory.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.parsing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.printing.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.string.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\dependencies\gen.string_ops.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\filesystem\gen.builder.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\filesystem\gen.editor.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\filesystem\gen.scanner.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\gen.pop_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\gen.push_ignores.inline.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="project\helpers\gen.undef.macros.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include=".editorconfig" />
@@ -103,6 +226,9 @@
     <None Include="test\gen\meson.build" />
     <None Include="test\meson.build" />
     <None Include="test\Readme.md" />
+    <None Include="scripts\gen.ps1" />
+    <None Include="scripts\genccp.natstepfilter" />
+    <None Include="scripts\gencpp.refactor" />
   </ItemGroup>
   <ItemGroup>
     <Natvis Include=".vscode\gencpp.natvis" />

project/Readme.md

@@ -1,84 +1,57 @@
 # Documentation
 
-All the library code is contained in two files: `gen.hpp` and `gen.cpp`
+The library is fragmented into a series of headers and sources files meant to be scanned in and then generated to a tailored format for the target
+`gen` files.
 
-## gen.hpp
+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>`
+
+The fle processors are in their own respective files. (Ex: `file_processors/<file_processor>.<hpp/cpp>` )  
+They directly include `depedencies/file_handling.<hpp/cpp>` as the core library does not include file processing by defualt.
+
+**TODO : Right now the library is not finished, as such the first self-hosting iteration is still WIP**  
+Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.  
+(sort of a verification that the generated version is equivalent).
+
+The default `gen.bootstrap.cpp` located in the project folder is meant to be produce a standard segmented library, where the components of the library  
+have relatively dedicated header and source files. Dependencies included at the top of the file and each header starting with a pragma once.  
+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_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
+* `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_USE_NAMESPACE` : By default, the library is wrapped in a `gen` namespace, this will disable that expose it to the global scope.
+* `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
 * `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
-* `GEN_FEATURE_PARSING` : Defines the parse constructors
-* `GEN_FEATURE_EDITOR` : Defines the file editing features for changing definitions based on ASTs
-* `GEN_FEATURE_SCANNER` : Defines the file scanning features for generating ASTs
+* `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_USE_RECURSIVE_AST_DUPLICATION` is available but its not well tested and should not need to be used.
-If constructing ASTs properly. There should be no modification of ASTs, and thus this would never become an issue.
+## On multi-threading
 
-Due to the design of `gen.hpp` to support being written alongside runtime intended code (in the same file), all the code is wrapped in a `gen_time` `#ifdef` and then wrapped further in a `gen` namespace to avoid pollution of the global scope.
+Currently unsupported. The following changes would have to be made:
 
-*Note: Its possible with the scanner feature to support parsing runtime files that use "generic" macros or identifiers with certain patterns.  
-This can be used to auto-queue generation of dependent definitions for the symbols used.*
+## Extending the library
 
-### Organization
+This library is relatively very small, and can be extended without much hassle.
 
-Dependencies : Mostly from the c-zpl library.
+The convention you'll see used throughout the API of the library is as follows:
 
-log_failure definition : based on whether to always use fatal on all errors
+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).
 
-Major enum definitions and their associated functions used with the AST data
+Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.
 
-* `ECode` : Used to tag ASTs by their type
-* `EOperator` : Used to tag operator overloads with thier op type
-* `ESpecifier` : Used with specifier ASTs for all specifiers the user may tag an associated
-AST with.
-* `AccessSpec` : Used with class and struct ASTs to denote the public, protected, or private fields.
-* `EnumT` : Used with def_enum to determine if constructing a regular enum or an enum class.
-* `ModuleFlag` : Used with any valid definition that can have export or import related keywords assoicated with it.
+`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.
 
-#### Data Structures
-
-`StringCache` : Hash table for cached strings. (`StringCached` typedef used to denote strings managed by it)
-
-`Code` : Wrapper for `AST` with functionality for handling it appropriately.  
-`AST` : The node data strucuture for the code.  
-`Code Types` : Codes with typed ASTs. Body, Param, and Specifier have unique implementation, the rest use `Define_CodeType`  
-`AST Types` : Filtered AST definitions.  
-
-#### Gen Interface
-
-First set of fowards are either backend functions used for various aspects of AST generation or configurating allocators used for different containers.
-
-Interface fowards defined in order of: Upfront, Parsing, Untyped.
-
-From there forwards for the File handlers are defined: Builder, Editor, Scanner.
-
-#### Macros
-
-General helper macros are defined along with the optional DSL macros.
-
-#### Constants
-
-Constants including optional ones are defined.
-
-#### Inlines
-
-Inlined functions related to the AST datatype that required forwards for gen interface functions are defined.
-
-## gen.cpp
-
-* Dependencies
-* Static data
-* AST Body case macros are next.
-* AST implementation
-* Gen interface begins with its `init`, `deinit`, etc.. Until `make_code_entires`
-* operator__validate defined, which will be used to verify if an operator definition is constructible.
-* Allocator interface for data arrays, code pool, code entries, string arenas, and string table.
-* Helper macros used throughout the constructor API
-* Upfront constructors, following the same order as shown in the header.
-* Parsing constructors, it defines its own lexer, and has many helper functions for parsing not exposed through the header.
-* Untyped constructors
-* Builder
-* Editor
-* Scanner
+The library has its code segmented into component files, use it to help create a derived version without needing to have to rewrite a generated file directly or build on top of the header via composition or inheritance.
+When the scanner is implemented, this will be even easier to customize.

project/components/ast.cpp

@@ -0,0 +1,920 @@
+#pragma region AST
+
+Code Code::Global;
+Code Code::Invalid;
+
+AST* AST::duplicate()
+{
+	using namespace ECode;
+
+	AST* result = make_code().ast;
+
+	mem_copy( result, this, sizeof( AST ) );
+
+	result->Parent = nullptr;
+	return result;
+}
+
+String AST::to_string()
+{
+	local_persist thread_local
+	char SerializationLevel = 0;
+
+	// TODO : Need to refactor so that intermeidate strings are freed conviently.
+	String result = String::make( GlobalAllocator, "" );
+
+	switch ( Type )
+	{
+		using namespace ECode;
+
+		case Invalid:
+			log_failure("Attempted to serialize invalid code! - %s", Parent ? Parent->debug_str() : Name );
+		break;
+
+		case Untyped:
+		case Execution:
+			result.append( Content );
+		break;
+
+		case Comment:
+		{
+			result.append("\n");
+
+			static char line[MaxCommentLineLength];
+
+			s32 left  = Content.length();
+			s32 index = 0;
+			s32 curr  = 0;
+			do
+			{
+				s32 length = 0;
+				while ( left && Content[index] != '\n' )
+				{
+					length++;
+					left--;
+					index++;
+				}
+				index++;
+
+				str_copy( line, Content + curr, length );
+				result.append_fmt( "//%.*s", length, line );
+				mem_set( line, 0, MaxCommentLineLength);
+
+				length++;
+				left--;
+				curr = index;
+			}
+			while ( left--, left > 0 );
+		}
+		break;
+
+		case Access_Private:
+		case Access_Protected:
+		case Access_Public:
+			result.append( Name );
+		break;
+
+		case PlatformAttributes:
+			result.append( Content );
+
+		case Class:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes || ParentType )
+			{
+				result.append( "class " );
+
+				if ( Attributes )
+				{
+					result.append_fmt( "%s ", Attributes->to_string() );
+				}
+
+				if ( ParentType )
+				{
+					char const* access_level = to_str( ParentAccess );
+
+					result.append_fmt( "%s : %s %s\n{\n%s\n};"
+						, Name
+						, access_level
+						, ParentType->to_string()
+						, Body->to_string()
+					);
+
+					CodeType interface = Next->cast<CodeType>();
+					if ( interface )
+						result.append("\n");
+
+					while ( interface )
+					{
+						result.append_fmt( ", %s", interface.to_string() );
+
+						interface = interface->Next->cast<CodeType>();
+					}
+				}
+				else
+				{
+					result.append_fmt( "%s \n{\n%s\n}", Name, Body->to_string() );
+				}
+			}
+			else
+			{
+				result.append_fmt( "class %s\n{\n%s\n}", Name, Body->to_string() );
+			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Class_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "class %s %s", Attributes->to_string(), Name );
+
+			else result.append_fmt( "class %s", Name );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Enum:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes || UnderlyingType )
+			{
+				result.append( "enum " );
+
+				if ( Attributes )
+					result.append_fmt( "%s ", Attributes->to_string() );
+
+				if ( UnderlyingType )
+					result.append_fmt( "%s : %s\n{\n%s\n}"
+						, Name
+						, UnderlyingType->to_string()
+						, Body->to_string()
+					);
+
+				else result.append_fmt( "%s\n{\n%s\n}"
+					, Name
+					, Body->to_string()
+				);
+			}
+			else result.append_fmt( "enum %s\n{\n%s\n}"
+				, Name
+				, Body->to_string()
+			);
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Enum_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			result.append_fmt( "enum %s : %s", Name, UnderlyingType->to_string() );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Enum_Class:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes || UnderlyingType )
+			{
+				result.append( "enum class " );
+
+				if ( Attributes )
+				{
+					result.append_fmt( "%s ", Attributes->to_string() );
+				}
+
+				if ( UnderlyingType )
+				{
+					result.append_fmt( "%s : %s\n{\n%s\n}"
+						, Name
+						, UnderlyingType->to_string()
+						, Body->to_string()
+					);
+				}
+				else
+				{
+					result.append_fmt( "%s\n{\n%s\n}"
+						, Name
+						, Body->to_string()
+					);
+				}
+			}
+			else
+			{
+				result.append_fmt( "enum class %s\n{\n%s\n}"
+					, Body->to_string()
+				);
+			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Enum_Class_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			result.append( "enum class " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			result.append_fmt( "%s : %s", Name, UnderlyingType->to_string() );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Export_Body:
+		{
+			result.append_fmt( "export\n{\n" );
+
+			Code curr = { this };
+			s32  left = NumEntries;
+			while ( left-- )
+			{
+				result.append_fmt( "%s\n", curr.to_string() );
+				++curr;
+			}
+
+			result.append_fmt( "};" );
+		}
+		break;
+
+		case Extern_Linkage:
+			result.append_fmt( "extern \"%s\"\n{\n%s\n}"
+				, Name
+				, Body->to_string()
+			);
+		break;
+
+		case Friend:
+			result.append_fmt( "friend %s", Declaration->to_string() );
+
+			if ( result[ result.length() -1 ] != ';' )
+				result.append( ";" );
+		break;
+
+		case Function:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( Specs )
+				result.append_fmt( "%s", Specs->to_string() );
+
+			if ( ReturnType )
+				result.append_fmt( "%s %s(", ReturnType->to_string(), Name );
+
+			else
+				result.append_fmt( "%s(", Name );
+
+			if ( Params )
+				result.append_fmt( "%s)", Params->to_string() );
+
+			else
+				result.append( "void)" );
+
+			if ( Specs )
+			{
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+			}
+
+			result.append_fmt( "\n{\n%s\n}"
+				, Body->to_string()
+			);
+		}
+		break;
+
+		case Function_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( Specs )
+				result.append_fmt( "%s", Specs->to_string() );
+
+			if ( ReturnType )
+				result.append_fmt( "%s %s(", ReturnType->to_string(), Name );
+
+			else
+				result.append_fmt( "%s(", Name );
+
+			if ( Params )
+				result.append_fmt( "%s)", Params->to_string() );
+
+			else
+				result.append( "void)" );
+
+			if ( Specs )
+			{
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+			}
+
+			result.append( ";" );
+		}
+		break;
+
+		case Module:
+			if (((u32(ModuleFlag::Export) & u32(ModuleFlags)) == u32(ModuleFlag::Export)))
+				result.append("export ");
+
+			if (((u32(ModuleFlag::Import) & u32(ModuleFlags)) == u32(ModuleFlag::Import)))
+				result.append("import ");
+
+			result.append_fmt( "%s;", Name );
+			break;
+
+		case Namespace:
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			result.append_fmt( "namespace %s\n{\n%s}"
+				, Name
+				, Body->to_string()
+			);
+		break;
+
+		case Operator:
+		case Operator_Member:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( Attributes )
+				result.append_fmt( "%s\n", Attributes->to_string() );
+
+			if ( ReturnType )
+				result.append_fmt( "%s %s (", ReturnType->to_string(), Name );
+
+			if ( Params )
+				result.append_fmt( "%s)", Params->to_string() );
+
+			else
+				result.append( "void)" );
+
+			if ( Specs )
+			{
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+			}
+
+			result.append_fmt( "\n{\n%s\n}"
+				, Body->to_string()
+			);
+		}
+		break;
+
+		case Operator_Fwd:
+		case Operator_Member_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( Specs )
+				result.append_fmt( "%s", Specs->to_string() );
+
+			result.append_fmt( "%s %s (", ReturnType->to_string(), Name );
+
+			if ( Params )
+				result.append_fmt( "%s)", Params->to_string() );
+
+			else
+				result.append_fmt( "void)" );
+
+			if ( Specs )
+			{
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+			}
+
+			result.append( ";" );
+		}
+		break;
+
+		case Operator_Cast:
+		{
+			if ( Specs )
+			{
+				if ( Name && Name.length() )
+					result.append_fmt( "%.*soperator %s()", Name.length(), Name, EOperator::to_str( Op ));
+				else
+					result.append_fmt( "operator %s()", EOperator::to_str( Op ) );
+
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+
+				result.append_fmt( "\n{\n%s\n}", Body->to_string() );
+				break;
+			}
+
+			if ( Name && Name.length() )
+				result.append_fmt("%.*soperator %s()\n{\n%s\n}", Name.length(), Name, ValueType->to_string(), Body->to_string() );
+			else
+				result.append_fmt("operator %s()\n{\n%s\n}", ValueType->to_string(), Body->to_string() );
+		}
+		break;
+
+		case Operator_Cast_Fwd:
+			if ( Specs )
+			{
+				result.append_fmt( "operator %s()",  ValueType->to_string() );
+
+				CodeSpecifiers specs = cast<CodeSpecifiers>();
+
+				for ( SpecifierT spec : specs )
+				{
+					if ( ESpecifier::is_trailing( spec ) )
+						result.append_fmt( " %s", (char const*)ESpecifier::to_str( spec ) );
+				}
+
+				result.append( ";" );
+				break;
+			}
+
+			result.append_fmt("operator %s();", ValueType->to_string() );
+		break;
+
+		case Parameters:
+		{
+			if ( ValueType == nullptr )
+			{
+				result.append_fmt( "%s", Name );
+				break;
+			}
+
+			if ( Name )
+				result.append_fmt( "%s %s", ValueType->to_string(), Name );
+
+			else
+				result.append_fmt( "%s", ValueType->to_string() );
+
+			if ( Value )
+				result.append_fmt( "= %s", Value->to_string() );
+
+			if ( NumEntries - 1 > 0)
+			{
+				for ( CodeParam param :  CodeParam { (AST_Param*) Next } )
+				{
+					result.append_fmt( ", %s", param.to_string() );
+				}
+			}
+		}
+		break;
+
+		case Preprocess_Define:
+			result.append_fmt( "#define %s%s", Name, Content );
+		break;
+
+		case Preprocess_If:
+			result.append_fmt( "#if %s", Content );
+		break;
+
+		case Preprocess_IfDef:
+			result.append_fmt( "#ifdef %s", Content );
+		break;
+
+		case Preprocess_IfNotDef:
+			result.append_fmt( "#ifndef %s", Content );
+		break;
+
+		case Preprocess_Include:
+			result.append_fmt( "#include \"%s\"", Content );
+		break;
+
+		case Preprocess_ElIf:
+			result.append_fmt( "#elif %s", Content );
+		break;
+
+		case Preprocess_Else:
+			result.append_fmt( "#else" );
+		break;
+
+		case Preprocess_EndIf:
+			result.append_fmt( "#endif\n" );
+		break;
+
+		case Preprocess_Pragma:
+			result.append_fmt( "#pragma %s", Content );
+		break;
+
+		case Specifiers:
+		{
+			s32 idx  = 0;
+			s32 left = NumEntries;
+			while ( left-- )
+			{
+				if ( ESpecifier::is_trailing( ArrSpecs[idx])  )
+				{
+					idx++;
+					continue;
+				}
+
+				result.append_fmt( "%s ", (char const*)ESpecifier::to_str( ArrSpecs[idx]) );
+				idx++;
+			}
+		}
+		break;
+
+		case Struct:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Name == nullptr)
+			{
+				result.append( "struct\n{\n%s\n};", Body->to_string() );
+				break;
+			}
+
+			if ( Attributes || ParentType )
+			{
+				result.append( "struct " );
+
+				if ( Attributes )
+					result.append_fmt( "%s ", Attributes->to_string() );
+
+				if ( ParentType )
+				{
+					char const* access_level = to_str( ParentAccess );
+
+					result.append_fmt( "%s : %s %s\n{\n%s\n};"
+						, Name
+						, access_level
+						, ParentType->to_string()
+						, Body->to_string()
+					);
+
+					CodeType interface = Next->cast<CodeType>();
+					if ( interface )
+						result.append("\n");
+
+					while ( interface )
+					{
+						result.append_fmt( ", public %s", interface.to_string() );
+
+						interface = interface->Next->cast<CodeType>();
+					}
+				}
+				else
+				{
+					if ( Name )
+
+					result.append_fmt( "%s \n{\n%s\n}", Name, Body->to_string() );
+				}
+			}
+			else
+			{
+				result.append_fmt( "struct %s\n{\n%s\n}", Name, Body->to_string() );
+			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Struct_Fwd:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "struct %s %s", Attributes->to_string(), Name );
+
+			else result.append_fmt( "struct %s", Name );
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Template:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			result.append_fmt( "template< %s >\n%s", Params->to_string(), Declaration->to_string() );
+		}
+		break;
+
+		case Typedef:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			result.append( "typedef ");
+
+			result.append_fmt( "%s %s", UnderlyingType->to_string(), Name );
+
+			if ( UnderlyingType->Type == Typename && UnderlyingType->ArrExpr )
+			{
+				result.append_fmt( "[%s];", UnderlyingType->ArrExpr->to_string() );
+			}
+			else
+			{
+				result.append( ";" );
+			}
+		}
+		break;
+
+		case Typename:
+		{
+			if ( Attributes || Specs )
+			{
+				if ( Attributes )
+					result.append_fmt( "%s ", Attributes->to_string() );
+
+				if ( Specs )
+					result.append_fmt( "%s %s", Name, Specs->to_string() );
+
+				else
+					result.append_fmt( "%s", Name );
+			}
+			else
+			{
+				result.append_fmt( "%s", Name );
+			}
+		}
+		break;
+
+		case Union:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			result.append( "union " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( Name )
+			{
+				result.append_fmt( "%s\n{\n%s\n}"
+					, Name
+					, Body->to_string()
+				);
+			}
+			else
+			{
+				// Anonymous union
+				result.append_fmt( "\n{\n%s\n}"
+					, Body->to_string()
+				);
+			}
+
+			if ( Parent == nullptr || ( Parent->Type != ECode::Typedef && Parent->Type != ECode::Variable ) )
+				result.append(";");
+		}
+		break;
+
+		case Using:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes )
+				result.append_fmt( "%s ", Attributes->to_string() );
+
+			if ( UnderlyingType )
+			{
+				result.append_fmt( "using %s = %s", Name, UnderlyingType->to_string() );
+
+				if ( UnderlyingType->ArrExpr )
+					result.append_fmt( "[%s]", UnderlyingType->ArrExpr->to_string() );
+
+				result.append( ";" );
+			}
+			else
+				result.append_fmt( "using %s;", Name );
+		}
+		break;
+
+		case Using_Namespace:
+			result.append_fmt( "using namespace %s;", Name );
+		break;
+
+		case Variable:
+		{
+			if ( bitfield_is_equal( u32, ModuleFlags, ModuleFlag::Export ))
+				result.append( "export " );
+
+			if ( Attributes || Specs )
+			{
+				if ( Attributes )
+					result.append_fmt( "%s ", Specs->to_string() );
+
+				if ( Specs )
+					result.append_fmt( "%s\n", Specs->to_string() );
+
+				result.append_fmt( "%s %s", ValueType->to_string(), Name );
+
+				if ( ValueType->ArrExpr )
+					result.append_fmt( "[%s]", ValueType->ArrExpr->to_string() );
+
+				if ( BitfieldSize )
+					result.append_fmt( " : %s", BitfieldSize->to_string() );
+
+				if ( Value )
+					result.append_fmt( " = %s", Value->to_string() );
+
+				result.append( ";" );
+
+				break;
+			}
+
+			if ( BitfieldSize )
+				result.append_fmt( "%s : %s", ValueType->to_string(), BitfieldSize->to_string() );
+
+			else if ( UnderlyingType->ArrExpr )
+				result.append_fmt( "%s %s[%s];", UnderlyingType->to_string(), Name, UnderlyingType->ArrExpr->to_string() );
+
+			else
+				result.append_fmt( "%s %s;", UnderlyingType->to_string(), Name );
+		}
+		break;
+
+		case Class_Body:
+		case Enum_Body:
+		case Extern_Linkage_Body:
+		case Function_Body:
+		case Global_Body:
+		case Namespace_Body:
+		case Struct_Body:
+		case Union_Body:
+		{
+			Code curr = Front->cast<Code>();
+			s32  left = NumEntries;
+			while ( left -- )
+			{
+				result.append_fmt( "%s\n", curr.to_string() );
+				++curr;
+			}
+		}
+		break;
+	}
+
+	return result;
+}
+
+bool AST::is_equal( AST* other )
+{
+	if ( Type != other->Type )
+		return false;
+
+	switch ( Type )
+	{
+		case ECode::Typedef:
+		case ECode::Typename:
+		{
+			if ( Name != other->Name )
+				return false;
+
+			return true;
+		}
+	}
+
+	if ( Name != other->Name )
+		return false;
+
+	return true;
+}
+
+bool AST::validate_body()
+{
+	using namespace ECode;
+
+#define CheckEntries( Unallowed_Types )                                                               \
+	do                                                                                                \
+	{                                                                                                 \
+		for ( Code entry : cast<CodeBody>() )                                                         \
+		{                                                                                             \
+			switch ( entry->Type )                                                                    \
+			{                                                                                         \
+				Unallowed_Types                                                                       \
+					log_failure( "AST::validate_body: Invalid entry in body %s", entry.debug_str() ); \
+					return false;                                                                     \
+			}                                                                                         \
+		}                                                                                             \
+	}                                                                                                 \
+	while (0);
+
+	switch ( Type )
+	{
+		case Class_Body:
+			CheckEntries( GEN_AST_BODY_CLASS_UNALLOWED_TYPES );
+		break;
+		case Enum_Body:
+			for ( Code entry : cast<CodeBody>() )
+			{
+				if ( entry->Type != Untyped )
+				{
+					log_failure( "AST::validate_body: Invalid entry in enum body (needs to be untyped or comment) %s", entry.debug_str() );
+					return false;
+				}
+			}
+		break;
+		case Export_Body:
+			CheckEntries( GEN_AST_BODY_CLASS_UNALLOWED_TYPES );
+		break;
+		case Extern_Linkage:
+			CheckEntries( GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES );
+		break;
+		case Function_Body:
+			CheckEntries( GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES );
+		break;
+		case Global_Body:
+			CheckEntries( GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES );
+		break;
+		case Namespace_Body:
+			CheckEntries( GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES );
+		break;
+		case Struct_Body:
+			CheckEntries( GEN_AST_BODY_STRUCT_UNALLOWED_TYPES );
+		break;
+		case Union_Body:
+			for ( Code entry : Body->cast<CodeBody>() )
+			{
+				if ( entry->Type != Untyped )
+				{
+					log_failure( "AST::validate_body: Invalid entry in union body (needs to be untyped or comment) %s", entry.debug_str() );
+					return false;
+				}
+			}
+		break;
+
+		default:
+			log_failure( "AST::validate_body: Invalid this AST does not have a body %s", debug_str() );
+			return false;
+	}
+
+	return false;
+
+#undef CheckEntries
+}
+
+#pragma endregion AST

project/components/ast_case_macros.cpp

@@ -0,0 +1,79 @@
+#	define GEN_AST_BODY_CLASS_UNALLOWED_TYPES \
+	case PlatformAttributes:                  \
+	case Class_Body:                          \
+	case Enum_Body:                           \
+	case Extern_Linkage:                      \
+	case Function_Body:                       \
+	case Function_Fwd:                        \
+	case Global_Body:                         \
+	case Namespace:                           \
+	case Namespace_Body:                      \
+	case Operator:                            \
+	case Operator_Fwd:                        \
+	case Parameters:                          \
+	case Specifiers:                          \
+	case Struct_Body:                         \
+	case Typename:
+#	define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
+
+#	define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES \
+	case Access_Public:                          \
+	case Access_Protected:                       \
+	case Access_Private:                         \
+	case PlatformAttributes:                     \
+	case Class_Body:                             \
+	case Enum_Body:                              \
+	case Extern_Linkage:                         \
+	case Friend:                                 \
+	case Function_Body:                          \
+	case Function_Fwd:                           \
+	case Global_Body:                            \
+	case Namespace:                              \
+	case Namespace_Body:                         \
+	case Operator:                               \
+	case Operator_Fwd:                           \
+	case Operator_Member:                        \
+	case Operator_Member_Fwd:                    \
+	case Parameters:                             \
+	case Specifiers:                             \
+	case Struct_Body:                            \
+	case Typename:
+
+#	define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES \
+	case Access_Public: 				       \
+	case Access_Protected: 				       \
+	case Access_Private: 				       \
+	case PlatformAttributes:                   \
+	case Class_Body: 					       \
+	case Enum_Body: 					       \
+	case Execution: 					       \
+	case Friend: 						       \
+	case Function_Body: 				       \
+	case Global_Body: 					       \
+	case Namespace_Body: 				       \
+	case Operator_Member: 				       \
+	case Operator_Member_Fwd: 			       \
+	case Parameters: 					       \
+	case Specifiers: 					       \
+	case Struct_Body: 					       \
+	case Typename:
+#	define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES         GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
+#	define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
+
+#	define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES \
+	case Access_Public: 				          \
+	case Access_Protected: 				          \
+	case Access_Private: 				          \
+	case PlatformAttributes:                      \
+	case Class_Body: 					          \
+	case Enum_Body: 					          \
+	case Execution: 					          \
+	case Friend: 						          \
+	case Function_Body: 				          \
+	case Namespace_Body: 				          \
+	case Operator_Member: 				          \
+	case Operator_Member_Fwd: 			          \
+	case Parameters: 					          \
+	case Specifiers: 					          \
+	case Struct_Body: 					          \
+	case Typename:

project/components/ecode.hpp

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

project/components/eoperator.hpp

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

project/components/especifier.hpp

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

project/components/etoktype.cpp

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

project/components/header_end.hpp

@@ -0,0 +1,558 @@
+#pragma region Inlines
+
+void AST::append( AST* other )
+{
+	if ( other->Parent )
+		other = other->duplicate();
+
+	other->Parent = this;
+
+	if ( Front == nullptr )
+	{
+		Front = other;
+		Back  = other;
+
+		NumEntries++;
+		return;
+	}
+
+	AST*
+		Current       = Back;
+	Current->Next = other;
+	other->Prev   = Current;
+	Back          = other;
+	NumEntries++;
+}
+
+char const* AST::debug_str()
+{
+	if ( Parent )
+	{
+		char const* fmt = stringize(
+			\nType    : %s
+			\nParent  : %s %s
+			\nName    : %s
+		);
+
+		// These should be used immediately in a log.
+		// Thus if its desired to keep the debug str
+		// for multiple calls to bprintf,
+		// allocate this to proper string.
+		return str_fmt_buf( fmt
+			,	type_str()
+			,	Parent->Name
+			,   Parent->type_str()
+			,	Name     ? Name         : ""
+		);
+	}
+
+	char const* fmt = stringize(
+		\nType    : %s
+		\nName    : %s
+	);
+
+	// These should be used immediately in a log.
+	// Thus if its desired to keep the debug str
+	// for multiple calls to bprintf,
+	// allocate this to proper string.
+	return str_fmt_buf( fmt
+		,	type_str()
+		,	Name     ? Name         : ""
+	);
+}
+
+Code& AST::entry( u32 idx )
+{
+	AST** current = & Front;
+	while ( idx >= 0 && current != nullptr )
+	{
+		if ( idx == 0 )
+			return * rcast( Code*, current);
+
+		current = & ( * current )->Next;
+		idx--;
+	}
+
+	return * rcast( Code*, current);
+}
+
+bool AST::has_entries()
+{
+	return NumEntries;
+}
+
+char const* AST::type_str()
+{
+	return ECode::to_str( Type );
+}
+
+AST::operator Code()
+{
+	return { this };
+}
+
+Code& Code::operator ++()
+{
+	if ( ast )
+		ast = ast->Next;
+
+	return *this;
+}
+
+#pragma region AST & Code Gen Common
+
+#define Define_CodeImpl( Typename )                                                  \
+char const* Typename::debug_str()                                                    \
+{                                                                                    \
+	if ( ast == nullptr )                                                            \
+		return "Code::debug_str: AST is null!";                                      \
+	                                                                                 \
+	return rcast(AST*, ast)->debug_str();                                            \
+}                                                                                    \
+Code Typename::duplicate()														     \
+{                                                                                    \
+	if ( ast == nullptr )                                                            \
+	{                                                                                \
+		log_failure("Code::duplicate: Cannot duplicate code, AST is null!");         \
+		return Code::Invalid;                                                        \
+	}                                                                                \
+	                                                                                 \
+	return { rcast(AST*, ast)->duplicate() };                                        \
+}                                                                                    \
+bool Typename::is_equal( Code other )                                                \
+{                                                                                    \
+	if ( ast == nullptr || other.ast == nullptr )                                    \
+	{                                                                                \
+		log_failure("Code::is_equal: Cannot compare code, AST is null!");            \
+		return false;                                                                \
+	}                                                                                \
+                                                                                     \
+	return rcast(AST*, ast)->is_equal( other.ast );                                  \
+}                                                                                    \
+bool Typename::is_valid()                                                            \
+{                                                                                    \
+	return (AST*) ast != nullptr && rcast( AST*, ast)->Type != CodeT::Invalid;       \
+}                                                                                    \
+void Typename::set_global()                                                          \
+{                                                                                    \
+	if ( ast == nullptr )                                                            \
+	{                                                                                \
+		log_failure("Code::set_global: Cannot set code as global, AST is null!");    \
+		return;                                                                      \
+	}                                                                                \
+	                                                                                 \
+	rcast(AST*, ast)->Parent = Code::Global.ast;                                     \
+}                                                                                    \
+String Typename::to_string()													     \
+{                                                                                    \
+	if ( ast == nullptr )                                                            \
+	{                                                                                \
+	log_failure("Code::to_string: Cannot convert code to string, AST is null!");     \
+	return { nullptr };                                                              \
+	}                                                                                \
+	                                                                                 \
+	return rcast(AST*, ast)->to_string();                                            \
+}                                                                                    \
+Typename& Typename::operator =( Code other )                                         \
+{                                                                                    \
+	if ( other.ast && other->Parent )                                                \
+	{                                                                                \
+		ast = rcast( decltype(ast), other.ast->duplicate() );                        \
+		rcast( AST*, ast)->Parent = nullptr;                                         \
+	}                                                                                \
+                                                                                     \
+	ast = rcast( decltype(ast), other.ast );                                         \
+	return *this;                                                                    \
+}                                                                                    \
+bool Typename::operator ==( Code other )                                             \
+{                                                                                    \
+	return (AST*) ast == other.ast;                                                  \
+}                                                                                    \
+bool Typename::operator !=( Code other )                                             \
+{                                                                                    \
+	return (AST*) ast != other.ast;                                                  \
+}
+
+Define_CodeImpl( Code );
+Define_CodeImpl( CodeBody );
+Define_CodeImpl( CodeAttributes );
+Define_CodeImpl( CodeComment );
+Define_CodeImpl( CodeClass );
+Define_CodeImpl( CodeDefine );
+Define_CodeImpl( CodeEnum );
+Define_CodeImpl( CodeExec );
+Define_CodeImpl( CodeExtern );
+Define_CodeImpl( CodeInclude );
+Define_CodeImpl( CodeFriend );
+Define_CodeImpl( CodeFn );
+Define_CodeImpl( CodeModule );
+Define_CodeImpl( CodeNamespace );
+Define_CodeImpl( CodeOperator );
+Define_CodeImpl( CodeOpCast );
+Define_CodeImpl( CodeParam );
+Define_CodeImpl( CodePragma );
+Define_CodeImpl( CodePreprocessCond );
+Define_CodeImpl( CodeSpecifiers );
+Define_CodeImpl( CodeStruct );
+Define_CodeImpl( CodeTemplate );
+Define_CodeImpl( CodeType );
+Define_CodeImpl( CodeTypedef );
+Define_CodeImpl( CodeUnion );
+Define_CodeImpl( CodeUsing );
+Define_CodeImpl( CodeVar );
+#undef Define_CodeImpl
+
+#define Define_AST_Cast( typename )              \
+AST::operator Code ## typename()                 \
+{                                                \
+	return { rcast( AST_ ## typename*, this ) }; \
+}
+
+Define_AST_Cast( Body );
+Define_AST_Cast( Attributes );
+Define_AST_Cast( Comment );
+Define_AST_Cast( Class );
+Define_AST_Cast( Define );
+Define_AST_Cast( Enum );
+Define_AST_Cast( Exec );
+Define_AST_Cast( Extern );
+Define_AST_Cast( Include );
+Define_AST_Cast( Friend );
+Define_AST_Cast( Fn );
+Define_AST_Cast( Module );
+Define_AST_Cast( Namespace );
+Define_AST_Cast( Operator );
+Define_AST_Cast( OpCast );
+Define_AST_Cast( Param );
+Define_AST_Cast( Pragma );
+Define_AST_Cast( PreprocessCond );
+Define_AST_Cast( Struct );
+Define_AST_Cast( Specifiers );
+Define_AST_Cast( Template );
+Define_AST_Cast( Type );
+Define_AST_Cast( Typedef );
+Define_AST_Cast( Union );
+Define_AST_Cast( Using );
+Define_AST_Cast( Var );
+#undef Define_AST_Cast
+
+#define Define_CodeCast( type )     \
+Code::operator Code ## type() const \
+{                                   \
+	return { (AST_ ## type*) ast }; \
+}
+
+Define_CodeCast( Attributes );
+Define_CodeCast( Comment );
+Define_CodeCast( Class );
+Define_CodeCast( Define );
+Define_CodeCast( Exec );
+Define_CodeCast( Enum );
+Define_CodeCast( Extern );
+Define_CodeCast( Include );
+Define_CodeCast( Friend );
+Define_CodeCast( Fn );
+Define_CodeCast( Module );
+Define_CodeCast( Namespace );
+Define_CodeCast( Operator );
+Define_CodeCast( OpCast );
+Define_CodeCast( Param );
+Define_CodeCast( Pragma );
+Define_CodeCast( PreprocessCond );
+Define_CodeCast( Specifiers );
+Define_CodeCast( Struct );
+Define_CodeCast( Template );
+Define_CodeCast( Type );
+Define_CodeCast( Typedef );
+Define_CodeCast( Union );
+Define_CodeCast( Using );
+Define_CodeCast( Var );
+Define_CodeCast( Body);
+#undef Define_CodeCast
+
+#pragma endregion AST & Code Gen Common
+
+void CodeClass::add_interface( CodeType type )
+{
+	if ( ! ast->Next )
+	{
+		ast->Next = type;
+		ast->Last = ast->Next;
+		return;
+	}
+
+	ast->Next->Next = type;
+	ast->Last       = ast->Next->Next;
+}
+
+void CodeParam::append( CodeParam other )
+{
+	AST* self  = (AST*) ast;
+	AST* entry = (AST*) other.ast;
+
+	if ( entry->Parent )
+		entry = entry->duplicate();
+
+	entry->Parent = self;
+
+	if ( self->Last == nullptr )
+	{
+		self->Last = entry;
+		self->Next = entry;
+		self->NumEntries++;
+		return;
+	}
+
+	self->Last->Next = entry;
+	self->Last       = entry;
+	self->NumEntries++;
+}
+
+CodeParam CodeParam::get( s32 idx )
+{
+	CodeParam param = *this;
+	do
+	{
+		if ( ! ++ param )
+			return { nullptr };
+
+		return { (AST_Param*) param.raw()->Next };
+	}
+	while ( --idx );
+
+	return { nullptr };
+}
+
+bool CodeParam::has_entries()
+{
+	return ast->NumEntries > 0;
+}
+
+CodeParam& CodeParam::operator ++()
+{
+	ast = ast->Next.ast;
+	return * this;
+}
+
+void CodeStruct::add_interface( CodeType type )
+{
+	if ( ! ast->Next )
+	{
+		ast->Next = type;
+		ast->Last = ast->Next;
+	}
+
+	ast->Next->Next = type;
+	ast->Last       = ast->Next->Next;
+}
+
+CodeBody def_body( CodeT type )
+{
+	switch ( type )
+	{
+		using namespace ECode;
+		case Class_Body:
+		case Enum_Body:
+		case Export_Body:
+		case Extern_Linkage:
+		case Function_Body:
+		case Global_Body:
+		case Namespace_Body:
+		case Struct_Body:
+		case Union_Body:
+			break;
+
+		default:
+			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
+			return (CodeBody)Code::Invalid;
+	}
+
+	Code
+	result       = make_code();
+	result->Type = type;
+	return (CodeBody)result;
+}
+
+//! Do not use directly. Use the token_fmt macro instead.
+// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
+StrC token_fmt_impl( sw num, ... )
+{
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+	mem_set( buf, 0, GEN_PRINTF_MAXLEN );
+
+	va_list va;
+	va_start(va, num );
+	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
+	va_end(va);
+
+	return { result, buf };
+}
+
+#pragma endregion Inlines
+
+#pragma region Constants
+
+#ifndef GEN_GLOBAL_BUCKET_SIZE
+#	define GEN_GLOBAL_BUCKET_SIZE megabytes(10)
+#endif
+#ifndef GEN_CODEPOOL_NUM_BLOCKS
+#	define GEN_CODEPOOL_NUM_BLOCKS kilobytes(64)
+#endif
+#ifndef GEN_SIZE_PER_STRING_ARENA
+#	define GEN_SIZE_PER_STRING_ARENA megabytes(1)
+#endif
+#ifndef GEN_MAX_COMMENT_LINE_LENGTH
+#	define GEN_MAX_COMMENT_LINE_LENGTH 1024
+#endif
+#ifndef GEN_MAX_NAME_LENGTH
+#	define GEN_MAX_NAME_LENGTH 128
+#endif
+#ifndef GEN_MAX_UNTYPED_STR_LENGTH
+#	define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
+#endif
+#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
+#	define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(4)
+#endif
+#ifndef GEN_LEX_ALLOCATOR_SIZE
+#	define GEN_LEX_ALLOCATOR_SIZE megabytes(10)
+#endif
+#ifndef GEN_BUILDER_STR_BUFFER_RESERVE
+#	define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(1)
+#endif
+
+// These constexprs are used for allocation behavior of data structures
+// or string handling while constructing or serializing.
+// Change them to suit your needs.
+
+constexpr s32 InitSize_DataArrays = 16;
+
+// NOTE: This limits the maximum size of an allocation
+// If you are generating a string larger than this, increase the size of the bucket here.
+constexpr uw  Global_BucketSize         = GEN_GLOBAL_BUCKET_SIZE;
+constexpr s32 CodePool_NumBlocks        = GEN_CODEPOOL_NUM_BLOCKS;
+constexpr s32 SizePer_StringArena       = GEN_SIZE_PER_STRING_ARENA;
+
+constexpr s32 MaxCommentLineLength      = GEN_MAX_COMMENT_LINE_LENGTH;
+constexpr s32 MaxNameLength             = GEN_MAX_NAME_LENGTH;
+constexpr s32 MaxUntypedStrLength       = GEN_MAX_UNTYPED_STR_LENGTH;
+constexpr s32 TokenFmt_TokenMap_MemSize	= GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
+constexpr s32 LexAllocator_Size         = GEN_LEX_ALLOCATOR_SIZE;
+constexpr s32 Builder_StrBufferReserve  = GEN_BUILDER_STR_BUFFER_RESERVE;
+
+extern Code access_public;
+extern Code access_protected;
+extern Code access_private;
+
+extern CodeAttributes attrib_api_export;
+extern CodeAttributes attrib_api_import;
+
+extern Code module_global_fragment;
+extern Code module_private_fragment;
+
+extern CodePragma pragma_once;
+
+extern CodeParam param_varadic;
+
+extern CodePreprocessCond preprocess_else;
+extern CodePreprocessCond preprocess_endif;
+
+extern CodeSpecifiers spec_const;
+extern CodeSpecifiers spec_consteval;
+extern CodeSpecifiers spec_constexpr;
+extern CodeSpecifiers spec_constinit;
+extern CodeSpecifiers spec_extern_linkage;
+extern CodeSpecifiers spec_final;
+extern CodeSpecifiers spec_global;
+extern CodeSpecifiers spec_inline;
+extern CodeSpecifiers spec_internal_linkage;
+extern CodeSpecifiers spec_local_persist;
+extern CodeSpecifiers spec_mutable;
+extern CodeSpecifiers spec_neverinline;
+extern CodeSpecifiers spec_override;
+extern CodeSpecifiers spec_ptr;
+extern CodeSpecifiers spec_ref;
+extern CodeSpecifiers spec_register;
+extern CodeSpecifiers spec_rvalue;
+extern CodeSpecifiers spec_static_member;
+extern CodeSpecifiers spec_thread_local;
+extern CodeSpecifiers spec_virtual;
+extern CodeSpecifiers spec_volatile;
+
+extern CodeType t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
+extern CodeType t_auto;
+extern CodeType t_void;
+extern CodeType t_int;
+extern CodeType t_bool;
+extern CodeType t_char;
+extern CodeType t_wchar_t;
+extern CodeType t_class;
+extern CodeType t_typename;
+
+#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+	// Predefined typename codes. Are set to readonly and are setup during gen::init()
+
+	extern CodeType t_b32;
+
+	extern CodeType t_s8;
+	extern CodeType t_s16;
+	extern CodeType t_s32;
+	extern CodeType t_s64;
+
+	extern CodeType t_u8;
+	extern CodeType t_u16;
+	extern CodeType t_u32;
+	extern CodeType t_u64;
+
+	extern CodeType t_sw;
+	extern CodeType t_uw;
+
+	extern CodeType t_f32;
+	extern CodeType t_f64;
+#endif
+
+#pragma endregion Constants
+
+#pragma region Macros
+
+#	define gen_main main
+
+#	define __ NoCode
+
+	//	Convienence for defining any name used with the gen api.
+	//  Lets you provide the length and string literal to the functions without the need for the DSL.
+#	define name( Id_ )   { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
+
+	//  Same as name just used to indicate intention of literal for code instead of names.
+#	define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
+
+#	define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
+
+#	define code_str( ... ) gen::untyped_str( code( __VA_ARGS__ ) )
+#	define code_fmt( ... ) gen::untyped_str( token_fmt( __VA_ARGS__ ) )
+
+	// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
+#	define token_fmt( ... ) gen::token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
+
+#pragma endregion Macros
+
+#ifdef GEN_EXPOSE_BACKEND
+
+	// Global allocator used for data with process lifetime.
+	extern AllocatorInfo  GlobalAllocator;
+	extern Array< Arena > Global_AllocatorBuckets;
+	extern Array< Pool >  CodePools;
+	extern Array< Arena > StringArenas;
+
+	extern StringTable StringCache;
+
+	extern Arena LexArena;
+
+	extern AllocatorInfo Allocator_DataArrays;
+	extern AllocatorInfo Allocator_CodePool;
+	extern AllocatorInfo Allocator_Lexer;
+	extern AllocatorInfo Allocator_StringArena;
+	extern AllocatorInfo Allocator_StringTable;
+	extern AllocatorInfo Allocator_TypeTable;
+
+#endif

project/components/header_start.hpp

@@ -0,0 +1,17 @@
+/*
+	gencpp: An attempt at "simple" staged metaprogramming for c/c++.
+
+	See Readme.md for more information from the project repository.
+
+	Public Address:
+	https://github.com/Ed94/gencpp
+*/
+#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
+#	error Gen.hpp : GEN_TIME not defined
+#endif
+
+//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
+// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
+#ifndef GEN_ROLL_OWN_DEPENDENCIES
+#	include "gen.dep.hpp"
+#endif

project/components/impl_start.cpp

@@ -0,0 +1,9 @@
+#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.cpp"
+#endif

project/components/interface.cpp

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

project/components/interface.hpp

@@ -0,0 +1,170 @@
+#pragma region Gen Interface
+
+// Initialize the library.
+// This currently just initializes the CodePool.
+void init();
+
+// Currently manually free's the arenas, code for checking for leaks.
+// However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
+void deinit();
+
+// Clears the allocations, but doesn't return to the heap, the calls init() again.
+// Ease of use.
+void reset();
+
+// Used internally to retrive or make string allocations.
+// Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
+StringCached get_cached_string( StrC str );
+
+/*
+	This provides a fresh Code AST.
+	The gen interface use this as their method from getting a new AST object from the CodePool.
+	Use this if you want to make your own API for formatting the supported Code Types.
+*/
+Code make_code();
+
+// Set these before calling gen's init() procedure.
+// Data
+
+void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
+void set_allocator_code_pool   ( AllocatorInfo pool_allocator );
+void set_allocator_lexer       ( AllocatorInfo lex_allocator );
+void set_allocator_string_arena( AllocatorInfo string_allocator );
+void set_allocator_string_table( AllocatorInfo string_allocator );
+void set_allocator_type_table  ( AllocatorInfo type_reg_allocator );
+
+#pragma region Upfront
+
+CodeAttributes def_attributes( StrC content );
+CodeComment    def_comment   ( StrC content );
+
+CodeClass def_class( StrC name
+	, Code           body         = NoCode
+	, CodeType       parent       = NoCode, AccessSpec access = AccessSpec::Default
+	, CodeAttributes attributes   = NoCode
+	, ModuleFlag     mflags       = ModuleFlag::None
+	, CodeType*      interfaces   = nullptr, s32 num_interfaces = 0 );
+
+CodeDefine def_define( StrC name, StrC content );
+
+CodeEnum def_enum( StrC name
+	, Code         body      = NoCode,      CodeType       type       = NoCode
+	, EnumT        specifier = EnumRegular, CodeAttributes attributes = NoCode
+	, ModuleFlag   mflags    = ModuleFlag::None );
+
+CodeExec   def_execution  ( StrC content );
+CodeExtern def_extern_link( StrC name, Code body );
+CodeFriend def_friend     ( Code symbol );
+
+CodeFn def_function( StrC name
+	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag mflags     = ModuleFlag::None );
+
+CodeInclude   def_include  ( StrC content );
+CodeModule    def_module   ( StrC name,            ModuleFlag mflags = ModuleFlag::None );
+CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag::None );
+
+CodeOperator def_operator( OperatorT op, StrC nspace
+	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag::None );
+
+CodeOpCast def_operator_cast( CodeType type, Code body = NoCode, CodeSpecifiers specs = NoCode );
+
+CodeParam  def_param ( CodeType type, StrC name, Code value = NoCode );
+CodePragma def_pragma( StrC directive );
+
+CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
+
+CodeSpecifiers def_specifier( SpecifierT specifier );
+
+CodeStruct def_struct( StrC name
+	, Code           body       = NoCode
+	, CodeType       parent     = NoCode, AccessSpec access = AccessSpec::Default
+	, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag::None
+	, CodeType*      interfaces = nullptr, s32 num_interfaces = 0 );
+
+CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag::None );
+
+CodeType    def_type   ( StrC name, Code arrayexpr = NoCode, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode );
+CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );
+
+CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );
+
+CodeUsing def_using( StrC name, CodeType type = NoCode
+	, CodeAttributes attributess = NoCode
+	, ModuleFlag     mflags      = ModuleFlag::None );
+
+CodeUsing def_using_namespace( StrC name );
+
+CodeVar def_variable( CodeType type, StrC name, Code value = NoCode
+	, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
+	, ModuleFlag     mflags     = ModuleFlag::None );
+
+// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
+CodeBody def_body( CodeT type );
+
+// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
+/// or provide as an array of Code objects.
+
+CodeBody       def_class_body      ( s32 num, ... );
+CodeBody       def_class_body      ( s32 num, Code* codes );
+CodeBody       def_enum_body       ( s32 num, ... );
+CodeBody       def_enum_body       ( s32 num, Code* codes );
+CodeBody       def_export_body     ( s32 num, ... );
+CodeBody       def_export_body     ( s32 num, Code* codes);
+CodeBody       def_extern_link_body( s32 num, ... );
+CodeBody       def_extern_link_body( s32 num, Code* codes );
+CodeBody       def_function_body   ( s32 num, ... );
+CodeBody       def_function_body   ( s32 num, Code* codes );
+CodeBody       def_global_body     ( s32 num, ... );
+CodeBody       def_global_body     ( s32 num, Code* codes );
+CodeBody       def_namespace_body  ( s32 num, ... );
+CodeBody       def_namespace_body  ( s32 num, Code* codes );
+CodeParam      def_params          ( s32 num, ... );
+CodeParam      def_params          ( s32 num, CodeParam* params );
+CodeSpecifiers def_specifiers      ( s32 num, ... );
+CodeSpecifiers def_specifiers      ( s32 num, SpecifierT* specs );
+CodeBody       def_struct_body     ( s32 num, ... );
+CodeBody       def_struct_body     ( s32 num, Code* codes );
+CodeBody       def_union_body      ( s32 num, ... );
+CodeBody       def_union_body      ( s32 num, Code* codes );
+
+#pragma endregion Upfront
+
+#pragma region Parsing
+
+CodeClass     parse_class        ( StrC class_def     );
+CodeEnum      parse_enum         ( StrC enum_def      );
+CodeBody      parse_export_body  ( StrC export_def    );
+CodeExtern    parse_extern_link  ( StrC exten_link_def);
+CodeFriend    parse_friend       ( StrC friend_def    );
+CodeFn        parse_function     ( StrC fn_def        );
+CodeBody      parse_global_body  ( StrC body_def      );
+CodeNamespace parse_namespace    ( StrC namespace_def );
+CodeOperator  parse_operator     ( StrC operator_def  );
+CodeOpCast    parse_operator_cast( StrC operator_def  );
+CodeStruct    parse_struct       ( StrC struct_def    );
+CodeTemplate  parse_template     ( StrC template_def  );
+CodeType      parse_type         ( StrC type_def      );
+CodeTypedef   parse_typedef      ( StrC typedef_def   );
+CodeUnion     parse_union        ( StrC union_def     );
+CodeUsing     parse_using        ( StrC using_def     );
+CodeVar       parse_variable     ( StrC var_def       );
+
+#pragma endregion Parsing
+
+#pragma region Untyped text
+
+sw   token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
+StrC token_fmt_impl( sw, ... );
+
+Code untyped_str      ( StrC content);
+Code untyped_fmt      ( char const* fmt, ... );
+Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
+
+#pragma endregion Untyped text
+
+#pragma endregion Gen Interface

project/components/static_data.cpp

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

project/components/types.hpp

@@ -0,0 +1,116 @@
+using LogFailType = sw(*)(char const*, ...);
+
+// By default this library will either crash or exit if an error is detected while generating codes.
+// Even if set to not use fatal, fatal will still be used for memory failures as the library is unusable when they occur.
+#ifdef GEN_DONT_USE_FATAL
+	constexpr LogFailType log_failure = log_fmt;
+#else
+	constexpr LogFailType log_failure = fatal;
+#endif
+
+enum class AccessSpec : u32
+{
+	Default,
+	Public,
+	Protected,
+	Private,
+
+	Num_AccessSpec,
+	Invalid,
+};
+
+inline
+char const* to_str( AccessSpec type )
+{
+	local_persist
+	char const* lookup[ (u32)AccessSpec::Num_AccessSpec ] = {
+		"",
+		"public",
+		"protected",
+		"private",
+	};
+
+	if ( type > AccessSpec::Public )
+		return "Invalid";
+
+	return lookup[ (u32)type ];
+}
+
+// Used to indicate if enum definitoin is an enum class or regular enum.
+enum class EnumT : u8
+{
+	Regular,
+	Class
+};
+
+constexpr EnumT EnumClass   = EnumT::Class;
+constexpr EnumT EnumRegular = EnumT::Regular;
+
+
+enum class ModuleFlag : u32
+{
+	None    = 0,
+	Export  = bit(0),
+	Import  = bit(1),
+	// Private = bit(2),
+
+	Num_ModuleFlags,
+	Invalid,
+};
+
+ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
+{
+	return (ModuleFlag)( (u32)A | (u32)B );
+}
+
+enum class EPreprocessCond : u32
+{
+	If,
+	IfDef,
+	IfNotDef,
+	ElIf
+};
+
+constexpr EPreprocessCond PreprocessCond_If       = EPreprocessCond::If;
+constexpr EPreprocessCond PreprocessCond_IfDef    = EPreprocessCond::IfDef;
+constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
+constexpr EPreprocessCond PreprocessCond_ElIf     = EPreprocessCond::ElIf;
+
+/*
+	Predefined attributes
+	Used for the parser constructors to identify non-standard attributes
+
+	Override these to change the attribute to your own unique identifier convention.
+
+	The tokenizer identifies attribute defines with the GEN_DEFINE_ATTRIBUTE_TOKENS macros.
+	See the example below and the Define_TokType macro used in gen.cpp to know the format.
+	While the library can parse raw attributes, most projects use defines to wrap them for compiler
+	platform indendence. The token define allows support for them without having to modify the library.
+*/
+#if defined(GEN_SYSTEM_WINDOWS) || defined( __CYGWIN__ )
+#ifndef GEN_Attribute_Keyword
+#	define GEN_API_Export_Code   __declspec(dllexport)
+#	define GEN_API_Import_Code   __declspec(dllimport)
+#	define GEN_Attribute_Keyword __declspec
+#endif
+
+constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword);
+
+#elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 )
+#ifndef GEN_Attribute_Keyword
+#	define GEN_API_Export_Code   __attribute__ ((visibility ("default")))
+#	define GEN_API_Import_Code   __attribute__ ((visibility ("default")))
+#	define GEN_Attribute_Keyword __attribute__
+#endif
+
+constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword );
+
+#else
+#ifndef GEN_Attribute_Keyword
+#	define GEN_API_Export_Code
+#	define GEN_API_Import_Code
+#	define GEN_Attribute_Keyword
+#endif
+
+constexpr char const* Attribute_Keyword = "";
+#endif

project/components/untyped.cpp

@@ -0,0 +1,183 @@
+sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
+{
+	char const* buf_begin = buf;
+	sw          remaining = buf_size;
+
+	local_persist
+	Arena tok_map_arena;
+
+	HashTable<StrC> tok_map;
+	{
+		local_persist
+		char tok_map_mem[ TokenFmt_TokenMap_MemSize ];
+
+		tok_map_arena = Arena::init_from_memory( tok_map_mem, sizeof(tok_map_mem) );
+		tok_map       = HashTable<StrC>::init( tok_map_arena );
+
+		s32 left = num_tokens - 1;
+
+		while ( left-- )
+		{
+			char const* token = va_arg( va, char const* );
+			StrC        value = va_arg( va, StrC );
+
+			u32 key = crc32( token, str_len(token) );
+
+			tok_map.set( key, value );
+		}
+	}
+
+	char const* fmt     = va_arg( va, char const* );
+	char        current = *fmt;
+
+	while ( current )
+	{
+		sw len = 0;
+
+		while ( current && current != '<' && remaining )
+		{
+			* buf = * fmt;
+			buf++;
+			fmt++;
+			remaining--;
+
+			current = * fmt;
+		}
+
+		if ( current == '<' )
+		{
+			char const* scanner = fmt + 1;
+
+			s32 tok_len = 0;
+
+			while ( *scanner != '>' )
+			{
+				tok_len++;
+				scanner++;
+			}
+
+			char const* token = fmt + 1;
+
+			u32       key   = crc32( token, tok_len );
+			StrC*     value = tok_map.get( key );
+
+			if ( value )
+			{
+				sw          left = value->Len;
+				char const* str  = value->Ptr;
+
+				while ( left-- )
+				{
+					* buf = * str;
+					buf++;
+					str++;
+					remaining--;
+				}
+
+				scanner++;
+				fmt     = scanner;
+				current = * fmt;
+				continue;
+			}
+
+			* buf = * fmt;
+			buf++;
+			fmt++;
+			remaining--;
+
+			current = * fmt;
+		}
+	}
+
+	tok_map.clear();
+	tok_map_arena.free();
+
+	sw result = buf_size - remaining;
+
+	return result;
+}
+
+Code untyped_str( StrC content )
+{
+	if ( content.Len == 0 )
+	{
+		log_failure( "untyped_str: empty string" );
+		return CodeInvalid;
+	}
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( content );
+	result->Type    = ECode::Untyped;
+	result->Content = result->Name;
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_str: could not cache string" );
+		return CodeInvalid;
+	}
+
+	return result;
+}
+
+Code untyped_fmt( char const* fmt, ...)
+{
+	if ( fmt == nullptr )
+	{
+		log_failure( "untyped_fmt: null format string" );
+		return CodeInvalid;
+	}
+
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, fmt);
+	sw length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	va_end(va);
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( { str_len(fmt, MaxNameLength), fmt } );
+	result->Type    = ECode::Untyped;
+	result->Content = get_cached_string( { length, buf } );
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return CodeInvalid;
+	}
+
+	return result;
+}
+
+Code untyped_token_fmt( s32 num_tokens, ... )
+{
+	if ( num_tokens == 0 )
+	{
+		log_failure( "untyped_token_fmt: zero tokens" );
+		return CodeInvalid;
+	}
+
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+	va_start(va, num_tokens);
+	sw length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
+	va_end(va);
+
+	Code
+	result          = make_code();
+	result->Name    = get_cached_string( { length, buf } );
+	result->Type    = ECode::Untyped;
+	result->Content = result->Name;
+
+	if ( result->Name == nullptr )
+	{
+		log_failure( "untyped_fmt: could not cache string" );
+		return CodeInvalid;
+	}
+
+	return result;
+}

project/dependencies/basic_types.hpp

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

project/dependencies/containers.hpp

@@ -0,0 +1,535 @@
+#pragma region Containers
+
+template<class Type>
+struct Array
+{
+	struct Header
+	{
+		AllocatorInfo Allocator;
+		uw            Capacity;
+		uw            Num;
+	};
+
+	static
+	Array init( AllocatorInfo allocator )
+	{
+		return init_reserve( allocator, grow_formula(0) );
+	}
+
+	static
+	Array init_reserve( AllocatorInfo allocator, sw capacity )
+	{
+		Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) * capacity ));
+
+		if ( header == nullptr )
+			return { nullptr };
+
+		header->Allocator = allocator;
+		header->Capacity  = capacity;
+		header->Num       = 0;
+
+		return { rcast( Type*, header + 1) };
+	}
+
+	static
+	uw grow_formula( uw value )
+	{
+		return 2 * value + 8;
+	}
+
+	bool append( Type value )
+	{
+		Header* header = get_header();
+
+		if ( header->Num == header->Capacity )
+		{
+			if ( ! grow( header->Capacity ))
+				return false;
+
+			header = get_header();
+		}
+
+		Data[ header->Num ] = value;
+		header->Num++;
+
+		return true;
+	}
+
+	bool append( Type* items, uw item_num )
+	{
+		Header* header = get_header();
+
+		if ( header->Num + item_num > header->Capacity )
+		{
+			if ( ! grow( header->Capacity + item_num ))
+				return false;
+
+			header = get_header();
+		}
+
+		mem_copy( Data + header->Num, items, item_num * sizeof(Type) );
+		header->Num += item_num;
+
+		return true;
+	}
+
+	bool append_at( Type item, uw idx )
+	{
+		Header* header = get_header();
+
+		if ( idx >= header->Num )
+			idx = header->Num - 1;
+
+		if ( idx < 0 )
+			idx = 0;
+
+		if ( header->Capacity < header->Num + 1 )
+		{
+			if ( ! grow( header->Capacity + 1 ))
+				return false;
+
+			header = get_header();
+		}
+
+		Type* target = Data + idx;
+
+		mem_move( target + 1, target, (header->Num - idx) * sizeof(Type) );
+		header->Num++;
+
+		return true;
+	}
+
+	bool append_at( Type* items, uw item_num, uw idx )
+	{
+		Header* header = get_header();
+
+		if ( idx >= header->Num )
+		{
+			return append( items, item_num );
+		}
+
+		if ( item_num > header->Capacity )
+		{
+			if ( ! grow( header->Capacity + item_num ) )
+				return false;
+
+			header = get_header();
+		}
+
+		Type* target = Data + idx + item_num;
+		Type* src    = 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;
+	}
+
+	Type& back( void )
+	{
+		Header& header = * get_header();
+		return Data[ header.Num - 1 ];
+	}
+
+	void clear( void )
+	{
+		Header& header = * get_header();
+		header.Num     = 0;
+	}
+
+	bool fill( uw begin, uw end, Type value )
+	{
+		Header& header = * get_header();
+
+		if ( begin < 0 || end >= header.Num )
+			return false;
+
+		for ( sw idx = begin; idx < end; idx++ )
+		{
+			Data[ idx ] = value;
+		}
+
+		return true;
+	}
+
+	void free( void )
+	{
+		Header& header = * get_header();
+		gen::free( header.Allocator, &header );
+		Data = nullptr;
+	}
+
+	Header* get_header( void )
+	{
+		return rcast( Header*, Data ) - 1 ;
+	}
+
+	bool grow( uw min_capacity )
+	{
+		Header& header       = * get_header();
+		uw      new_capacity = grow_formula( header.Capacity );
+
+		if ( new_capacity < min_capacity )
+			new_capacity = min_capacity;
+
+		return set_capacity( new_capacity );
+	}
+
+	uw num( void )
+	{
+		return get_header()->Num;
+	}
+
+	bool pop( void )
+	{
+		Header& header = * get_header();
+
+		GEN_ASSERT( header.Num > 0 );
+		header.Num--;
+	}
+
+	void remove_at( uw idx )
+	{
+		Header* header = get_header();
+		GEN_ASSERT( idx < header->Num );
+
+		mem_move( header + idx, header + idx + 1, sizeof( Type ) * ( header->Num - idx - 1 ) );
+		header->Num--;
+	}
+
+	bool reserve( uw new_capacity )
+	{
+		Header& header = * get_header();
+
+		if ( header.Capacity < new_capacity )
+			return set_capacity( new_capacity );
+
+		return true;
+	}
+
+	bool resize( uw num )
+	{
+		Header* header = get_header();
+
+		if ( header->Capacity < num )
+		{
+			if ( ! grow( num ) )
+				return false;
+
+			header = get_header();
+		}
+
+		header->Num = num;
+		return true;
+	}
+
+	bool set_capacity( uw new_capacity )
+	{
+		Header& header = * get_header();
+
+		if ( new_capacity == header.Capacity )
+			return true;
+
+		if ( new_capacity < header.Num )
+			header.Num = new_capacity;
+
+		sw      size       = sizeof( Header ) + sizeof( Type ) * new_capacity;
+		Header* new_header = rcast( Header*, alloc( header.Allocator, size ) );
+
+		if ( new_header == nullptr )
+			return false;
+
+		mem_move( new_header, &header, sizeof( Header ) + sizeof( Type ) * header.Num );
+
+		new_header->Capacity = new_capacity;
+
+		gen::free( header.Allocator, &header );
+
+		Data = rcast( Type*, new_header + 1);
+		return true;
+	}
+
+	Type* Data;
+
+	operator Type*()
+	{
+		return Data;
+	}
+
+	operator Type const*() const
+	{
+		return Data;
+	}
+
+	// For-range based support
+
+	Type* begin()
+	{
+		return Data;
+	}
+
+	Type* end()
+	{
+		return Data + get_header()->Num;
+	}
+};
+
+template<typename Type>
+struct HashTable
+{
+	struct FindResult
+	{
+		sw HashIndex;
+		sw PrevIndex;
+		sw EntryIndex;
+	};
+
+	struct Entry
+	{
+		u64  Key;
+		sw   Next;
+		Type Value;
+	};
+
+	static
+	HashTable init( AllocatorInfo allocator )
+	{
+		HashTable<Type> result = { { nullptr }, { nullptr } };
+
+		result.Hashes  = Array<sw>::init( allocator );
+		result.Entries = Array<Entry>::init( allocator );
+
+		return result;
+	}
+
+	static
+	HashTable init_reserve( AllocatorInfo allocator, uw num )
+	{
+		HashTable<Type> result = { { nullptr }, { nullptr } };
+
+		result.Hashes  = Array<sw>::init_reserve( allocator, num );
+		result.Hashes.get_header()->Num = num;
+
+		result.Entries = Array<Entry>::init_reserve( allocator, num );
+
+		return result;
+	}
+
+	void clear( void )
+	{
+		for ( sw idx = 0; idx < Hashes.num(); idx++ )
+			Hashes[ idx ] = -1;
+
+		Hashes.clear();
+		Entries.clear();
+	}
+
+	void destroy( void )
+	{
+		if ( Hashes && Hashes.get_header()->Capacity )
+		{
+			Hashes.free();
+			Entries.free();
+		}
+	}
+
+	Type* get( u64 key )
+	{
+		sw idx = find( key ).EntryIndex;
+		if ( idx >= 0 )
+			return & Entries[ idx ].Value;
+
+		return nullptr;
+	}
+
+	using MapProc = void (*)( u64 key, Type  value );
+
+	void map( MapProc map_proc )
+	{
+		GEN_ASSERT_NOT_NULL( map_proc );
+
+		for ( sw idx = 0; idx < Entries.num(); idx++ )
+		{
+			map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
+		}
+	}
+
+	using MapMutProc = void (*)( u64 key, Type* value );
+
+	void map_mut( MapMutProc map_proc )
+	{
+		GEN_ASSERT_NOT_NULL( map_proc );
+
+		for ( sw idx = 0; idx < Entries.num(); idx++ )
+		{
+			map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
+		}
+	}
+
+	void grow()
+	{
+		sw new_num = Array<Entry>::grow_formula( Entries.num() );
+		rehash( new_num );
+	}
+
+	void rehash( sw new_num )
+	{
+		sw idx;
+		sw last_added_index;
+
+		HashTable<Type> new_ht = init_reserve( Hashes.get_header()->Allocator, new_num );
+
+		Array<sw>::Header* hash_header = new_ht.Hashes.get_header();
+
+		for ( idx = 0; idx < new_ht.Hashes.num(); ++idx )
+			new_ht.Hashes[ idx ] = -1;
+
+		for ( idx = 0; idx < Entries.num(); ++idx )
+		{
+			Entry& entry = Entries[ idx ];
+
+			FindResult find_result;
+
+			if ( new_ht.Hashes.num() == 0 )
+				new_ht.grow();
+
+			entry            = Entries[ idx ];
+			find_result      = new_ht.find( entry.Key );
+			last_added_index = new_ht.add_entry( entry.Key );
+
+			if ( find_result.PrevIndex < 0 )
+				new_ht.Hashes[ find_result.HashIndex ] = last_added_index;
+
+			else
+				new_ht.Entries[ find_result.PrevIndex ].Next = last_added_index;
+
+			new_ht.Entries[ last_added_index ].Next  = find_result.EntryIndex;
+			new_ht.Entries[ last_added_index ].Value = entry.Value;
+		}
+
+		destroy();
+		*this = new_ht;
+	}
+
+	void rehash_fast()
+	{
+		sw idx;
+
+		for ( idx = 0; idx < Entries.num(); idx++ )
+			Entries[ idx ].Next = -1;
+
+		for ( idx = 0; idx < Hashes.num(); idx++ )
+			Hashes[ idx ] = -1;
+
+		for ( idx = 0; idx < Entries.num(); idx++ )
+		{
+			Entry* entry;
+
+			FindResult find_result;
+		}
+	}
+
+	void remove( u64 key )
+	{
+		FindResult find_result = find( key);
+
+		if ( find_result.EntryIndex >= 0 )
+		{
+			Entries.remove_at( find_result.EntryIndex );
+			rehash_fast();
+		}
+	}
+
+	void remove_entry( sw idx )
+	{
+		Entries.remove_at( idx );
+	}
+
+	void set( u64 key, Type value )
+	{
+		sw idx;
+		FindResult find_result;
+
+		if ( Hashes.num() == 0 )
+			grow();
+
+		find_result = find( key );
+
+		if ( find_result.EntryIndex >= 0 )
+		{
+			idx = find_result.EntryIndex;
+		}
+		else
+		{
+			idx = add_entry( key );
+
+			if ( find_result.PrevIndex >= 0 )
+			{
+				Entries[ find_result.PrevIndex ].Next = idx;
+			}
+			else
+			{
+				Hashes[ find_result.HashIndex ] = idx;
+			}
+		}
+
+		Entries[ idx ].Value = value;
+
+		if ( full() )
+			grow();
+	}
+
+	sw slot( u64 key )
+	{
+		for ( sw idx = 0; idx < Hashes.num(); ++idx )
+			if ( Hashes[ idx ] == key )
+				return idx;
+
+		return -1;
+	}
+
+	Array< sw>    Hashes;
+	Array< Entry> Entries;
+
+protected:
+
+	sw add_entry( u64 key )
+	{
+		sw idx;
+		Entry entry = { key, -1 };
+
+		idx = Entries.num();
+		Entries.append( entry );
+		return idx;
+	}
+
+	FindResult find( u64 key )
+	{
+		FindResult result = { -1, -1, -1 };
+
+		if ( Hashes.num() > 0 )
+		{
+			result.HashIndex    = key % Hashes.num();
+			result.EntryIndex  = Hashes[ result.HashIndex ];
+
+			while ( result.EntryIndex >= 0 )
+			{
+				if ( Entries[ result.EntryIndex ].Key == key )
+					break;
+
+				result.PrevIndex  = result.EntryIndex;
+				result.EntryIndex = Entries[ result.EntryIndex ].Next;
+			}
+		}
+
+		return result;
+	}
+
+	b32 full()
+	{
+		return 0.75f * Hashes.num() < Entries.num();
+	}
+};
+
+#pragma endregion Containers

project/dependencies/debug.cpp

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

project/dependencies/debug.hpp

@@ -0,0 +1,36 @@
+#pragma endregion Debug
+
+#if defined( _MSC_VER )
+#	if _MSC_VER < 1300
+#		define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
+#	else
+#		define GEN_DEBUG_TRAP() __debugbreak()
+#	endif
+#elif defined( GEN_COMPILER_TINYC )
+#	define GEN_DEBUG_TRAP() process_exit( 1 )
+#else
+#	define GEN_DEBUG_TRAP() __builtin_trap()
+#endif
+
+#define GEN_ASSERT( cond ) GEN_ASSERT_MSG( cond, NULL )
+
+#define GEN_ASSERT_MSG( cond, msg, ... )                                                     \
+	do                                                                                       \
+	{                                                                                        \
+		if ( ! ( cond ) )                                                                    \
+		{                                                                                    \
+			assert_handler( #cond, __FILE__, zpl_cast( s64 ) __LINE__, msg, ##__VA_ARGS__ ); \
+			GEN_DEBUG_TRAP();                                                                \
+		}                                                                                    \
+	} while ( 0 )
+
+#define GEN_ASSERT_NOT_NULL( ptr ) GEN_ASSERT_MSG( ( ptr ) != NULL, #ptr " must not be NULL" )
+
+// NOTE: Things that shouldn't happen with a message!
+#define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
+
+void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
+s32  assert_crash( char const* condition );
+void process_exit( u32 code );
+
+#pragma endregion Debug

project/dependencies/file_handling.cpp

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

project/dependencies/file_handling.hpp

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

project/dependencies/hashing.cpp

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

project/dependencies/hashing.hpp

@@ -0,0 +1,6 @@
+#pragma region Hashing
+
+u32 crc32( void const* data, sw len );
+u64 crc64( void const* data, sw len );
+
+#pragma endregion Hashing

project/dependencies/header_start.hpp

@@ -0,0 +1,131 @@
+#pragma region Platform Detection
+
+/* Platform architecture */
+
+#if defined( _WIN64 ) || defined( __x86_64__ ) || defined( _M_X64 ) || defined( __64BIT__ ) || defined( __powerpc64__ ) || defined( __ppc64__ ) || defined( __aarch64__ )
+#	ifndef GEN_ARCH_64_BIT
+#		define GEN_ARCH_64_BIT 1
+#	endif
+#else
+#	ifndef GEN_ARCH_32_BItxt_StrCaT
+#		define GEN_ARCH_32_BIT 1
+#	endif
+#endif
+
+/* Platform OS */
+
+#if defined( _WIN32 ) || defined( _WIN64 )
+#	ifndef GEN_SYSTEM_WINDOWS
+#		define GEN_SYSTEM_WINDOWS 1
+#	endif
+#elif defined( __APPLE__ ) && defined( __MACH__ )
+#	ifndef GEN_SYSTEM_OSX
+#		define GEN_SYSTEM_OSX 1
+#	endif
+#	ifndef GEN_SYSTEM_MACOS
+#		define GEN_SYSTEM_MACOS 1
+#	endif
+#	include <TargetConditionals.h>
+#	if TARGET_IPHONE_SIMULATOR == 1 || TARGET_OS_IPHONE == 1
+#		ifndef GEN_SYSTEM_IOS
+#			define GEN_SYSTEM_IOS 1
+#		endif
+#	endif
+#elif defined( __unix__ )
+#	ifndef GEN_SYSTEM_UNIX
+#		define GEN_SYSTEM_UNIX 1
+#	endif
+#	if defined( ANDROID ) || defined( __ANDROID__ )
+#		ifndef GEN_SYSTEM_ANDROID
+#			define GEN_SYSTEM_ANDROID 1
+#		endif
+#		ifndef GEN_SYSTEM_LINUX
+#			define GEN_SYSTEM_LINUX 1
+#		endif
+#	elif defined( __linux__ )
+#		ifndef GEN_SYSTEM_LINUX
+#			define GEN_SYSTEM_LINUX 1
+#		endif
+#	elif defined( __FreeBSD__ ) || defined( __FreeBSD_kernel__ )
+#		ifndef GEN_SYSTEM_FREEBSD
+#			define GEN_SYSTEM_FREEBSD 1
+#		endif
+#	elif defined( __OpenBSD__ )
+#		ifndef GEN_SYSTEM_OPENBSD
+#			define GEN_SYSTEM_OPENBSD 1
+#		endif
+#	elif defined( __EMSCRIPTEN__ )
+#		ifndef GEN_SYSTEM_EMSCRIPTEN
+#			define GEN_SYSTEM_EMSCRIPTEN 1
+#		endif
+#	elif defined( __CYGWIN__ )
+#		ifndef GEN_SYSTEM_CYGWIN
+#			define GEN_SYSTEM_CYGWIN 1
+#		endif
+#	else
+#		error This UNIX operating system is not supported
+#	endif
+#else
+#	error This operating system is not supported
+#endif
+
+/* Platform compiler */
+
+#if defined( _MSC_VER )
+#	define GEN_COMPILER_MSVC 1
+#elif defined( __GNUC__ )
+#	define GEN_COMPILER_GCC 1
+#elif defined( __clang__ )
+#	define GEN_COMPILER_CLANG 1
+#elif defined( __MINGW32__ )
+#	define GEN_COMPILER_MINGW 1
+#	error Unknown compiler
+#endif
+
+#if defined( __has_attribute )
+#	define GEN_HAS_ATTRIBUTE( attribute ) __has_attribute( attribute )
+#else
+#	define GEN_HAS_ATTRIBUTE( attribute ) ( 0 )
+#endif
+
+#if defined(GEN_GCC_VERSION_CHECK)
+#  undef GEN_GCC_VERSION_CHECK
+#endif
+#if defined(GEN_GCC_VERSION)
+#  define GEN_GCC_VERSION_CHECK(major,minor,patch) (GEN_GCC_VERSION >= GEN_VERSION_ENCODE(major, minor, patch))
+#else
+#  define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#define GEN_DEF_INLINE  static
+#define GEN_IMPL_INLINE static inline
+
+#ifdef GEN_COMPILER_MSVC
+#	define forceinline __forceinline
+#	define neverinline __declspec( noinline )
+#elif defined(GEN_COMPILER_GCC)
+#	define forceinline inline __attribute__((__always_inline__))
+#	define neverinline __attribute__( ( __noinline__ ) )
+#elif defined(GEN_COMPILER_CLANG)
+#if __has_attribute(__always_inline__)
+#	define forceinline inline __attribute__((__always_inline__))
+#	define neverinline __attribute__( ( __noinline__ ) )
+#else
+#	define forceinline
+#	define neverinline
+#endif
+#else
+#	define forceinline
+#	define neverinline
+#endif
+
+#pragma endregion Platform Detection
+
+#pragma region Mandatory Includes
+#	include <stdarg.h>
+#	include <stddef.h>
+
+#	if defined( GEN_SYSTEM_WINDOWS )
+#		include <intrin.h>
+#	endif
+#pragma endregion Mandatory Includes

project/dependencies/impl_start.cpp

@@ -0,0 +1,80 @@
+#pragma region Macros and Includes
+
+#	include <stdio.h>
+// NOTE: Ensure we use standard methods for these calls if we use GEN_PICO
+#	if ! defined( GEN_PICO_CUSTOM_ROUTINES )
+#		if ! defined( GEN_MODULE_CORE )
+#			define _strlen                   strlen
+#			define _printf_err( fmt, ... )   fprintf( stderr, fmt, __VA_ARGS__ )
+#			define _printf_err_va( fmt, va ) vfprintf( stderr, fmt, va )
+#		else
+#			define _strlen                   str_len
+#			define _printf_err( fmt, ... )   str_fmt_out_err( fmt, __VA_ARGS__ )
+#			define _printf_err_va( fmt, va ) str_fmt_out_err_va( fmt, va )
+#		endif
+#	endif
+#
+#	include <errno.h>
+#
+#	if defined( GEN_SYSTEM_UNIX ) || defined( GEN_SYSTEM_MACOS )
+#		include <unistd.h>
+#	elif defined( GEN_SYSTEM_WINDOWS )
+#		if ! defined( GEN_NO_WINDOWS_H )
+#			ifndef WIN32_LEAN_AND_MEAN
+#				ifndef NOMINMAX
+#					define NOMINMAX
+#				endif
+#
+#				define WIN32_LEAN_AND_MEAN
+#				define WIN32_MEAN_AND_LEAN
+#				define VC_EXTRALEAN
+#			endif
+#			include <windows.h>
+#			undef NOMINMAX
+#			undef WIN32_LEAN_AND_MEAN
+#			undef WIN32_MEAN_AND_LEAN
+#			undef VC_EXTRALEAN
+#		endif
+#	endif
+
+#include <sys/stat.h>
+
+#ifdef GEN_SYSTEM_MACOS
+#	include <copyfile.h>
+#endif
+
+#ifdef GEN_SYSTEM_CYGWIN
+#	include <windows.h>
+#endif
+
+#if defined( GEN_SYSTEM_WINDOWS ) && ! defined( GEN_COMPILER_GCC )
+#	include <io.h>
+#endif
+
+#if defined( GEN_SYSTEM_LINUX )
+#	include <sys/types.h>
+#endif
+
+#ifdef GEN_BENCHMARK
+// Timing includes
+#if defined( GEN_SYSTEM_MACOS ) || GEN_SYSTEM_UNIX
+#	include <time.h>
+#	include <sys/time.h>
+#endif
+
+#if defined( GEN_SYSTEM_MACOS )
+#	include <mach/mach.h>
+#	include <mach/mach_time.h>
+#	include <mach/clock.h>
+#endif
+
+#if defined( GEN_SYSTEM_EMSCRIPTEN )
+#	include <emscripten.h>
+#endif
+
+#if defined( GEN_SYSTEM_WINDOWS )
+#	include <timezoneapi.h>
+#endif
+#endif
+
+#pragma endregion Macros and Includes

project/dependencies/macros.hpp

@@ -0,0 +1,107 @@
+#pragma region Macros
+
+#define zpl_cast( Type ) ( Type )
+
+// Keywords
+
+#define global        static    // Global variables
+#define internal      static    // Internal linkage
+#define local_persist static    // Local Persisting variables
+
+// Bits
+
+#define bit( Value )                             ( 1 << Value )
+#define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
+
+// Casting
+#define ccast( Type, Value ) ( * const_cast< Type* >( & (Value) ) )
+#define pcast( Type, Value ) ( * reinterpret_cast< Type* >( & ( Value ) ) )
+#define rcast( Type, Value ) reinterpret_cast< Type >( Value )
+#define scast( Type, Value ) static_cast< Type >( Value )
+
+// Num Arguments (Varadics)
+#if defined(__GNUC__) || defined(__clang__)
+// Supports 0-10 arguments
+#define num_args_impl( _0,                                \
+		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,  \
+		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
+		N, ...                                            \
+	) N
+	// _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
+	// _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
+	// _41, _42, _43, _44, _45, _46, _47, _48, _49, _50,
+
+	// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
+#define num_args(...)                           \
+	num_args_impl(_, ## __VA_ARGS__,            \
+		20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
+		10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
+		0                                       \
+	)
+	// 50, 49, 48, 47, 46, 45, 44, 43, 42, 41,              \
+	// 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,              \
+	// 30, 29, 28, 27, 26, 25, 24, 23, 22, 21,
+#else
+// Supports 1-10 arguments
+#define num_args_impl(                                    \
+		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,  \
+		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
+		N, ...                                            \
+	) N
+
+#define num_args(...)                           \
+	num_args_impl( __VA_ARGS__,                 \
+		20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
+		10,  9,  8,  7,  6,  5,  4,  3,  2,  1  \
+	)
+#endif
+
+// Stringizing
+#define stringize_va( ... ) #__VA_ARGS__
+#define stringize( ... )    stringize_va( __VA_ARGS__ )
+
+// Function do once
+
+#define do_once()          \
+	do                     \
+	{                      \
+		static             \
+		bool Done = false; \
+		if ( Done )        \
+			return;        \
+		Done = true;       \
+	}                      \
+	while(0)
+
+#define do_once_start      \
+	do                     \
+	{                      \
+		static             \
+		bool Done = false; \
+		if ( Done )        \
+			break;         \
+		Done = true;
+
+#define do_once_end        \
+	}                      \
+	while(0);
+
+#define labeled_scope_start if ( false ) {
+#define labeled_scope_end   }
+
+#define clamp( x, lower, upper )      min( max( ( x ), ( lower ) ), ( upper ) )
+#define count_of( x )                 ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( sw )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
+#define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
+#define max( a, b )                   ( ( a ) > ( b ) ? ( a ) : ( b ) )
+#define min( a, b )                   ( ( a ) < ( b ) ? ( a ) : ( b ) )
+#define size_of( x )                  ( sw )( sizeof( x ) )
+
+template< class Type >
+void swap( Type& a, Type& b )
+{
+	Type tmp = a;
+	a = b;
+	b = tmp;
+}
+
+#pragma endregion Macros

project/dependencies/memory.cpp

@@ -0,0 +1,389 @@
+#pragma region Memory
+
+void* mem_copy( void* dest, void const* source, sw n )
+{
+	if ( dest == NULL )
+	{
+		return NULL;
+	}
+
+	return memcpy( dest, source, n );
+}
+
+void const* mem_find( void const* data, u8 c, sw n )
+{
+	u8 const* s = zpl_cast( u8 const* ) data;
+	while ( ( zpl_cast( uptr ) s & ( sizeof( uw ) - 1 ) ) && n && *s != c )
+	{
+		s++;
+		n--;
+	}
+	if ( n && *s != c )
+	{
+		sw const* w;
+		sw        k = GEN__ONES * c;
+		w           = zpl_cast( sw const* ) s;
+		while ( n >= size_of( sw ) && ! GEN__HAS_ZERO( *w ^ k ) )
+		{
+			w++;
+			n -= size_of( sw );
+		}
+		s = zpl_cast( u8 const* ) w;
+		while ( n && *s != c )
+		{
+			s++;
+			n--;
+		}
+	}
+
+	return n ? zpl_cast( void const* ) s : NULL;
+}
+
+#define GEN_HEAP_STATS_MAGIC 0xDEADC0DE
+
+struct _heap_stats
+{
+	u32 magic;
+	sw  used_memory;
+	sw  alloc_count;
+};
+
+global _heap_stats _heap_stats_info;
+
+void heap_stats_init( void )
+{
+	zero_item( &_heap_stats_info );
+	_heap_stats_info.magic = GEN_HEAP_STATS_MAGIC;
+}
+
+sw heap_stats_used_memory( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	return _heap_stats_info.used_memory;
+}
+
+sw heap_stats_alloc_count( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	return _heap_stats_info.alloc_count;
+}
+
+void heap_stats_check( void )
+{
+	GEN_ASSERT_MSG( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" );
+	GEN_ASSERT( _heap_stats_info.used_memory == 0 );
+	GEN_ASSERT( _heap_stats_info.alloc_count == 0 );
+}
+
+struct _heap_alloc_info
+{
+	sw    size;
+	void* physical_start;
+};
+
+void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+{
+	void* ptr = NULL;
+	// unused( allocator_data );
+	// unused( old_size );
+	if ( ! alignment )
+		alignment = GEN_DEFAULT_MEMORY_ALIGNMENT;
+
+#ifdef GEN_HEAP_ANALYSIS
+	sw alloc_info_size      = size_of( _heap_alloc_info );
+	sw alloc_info_remainder = ( alloc_info_size % alignment );
+	sw track_size           = max( alloc_info_size, alignment ) + alloc_info_remainder;
+	switch ( type )
+	{
+		case EAllocation_FREE :
+			{
+				if ( ! old_memory )
+					break;
+				_heap_alloc_info* alloc_info  = zpl_cast( _heap_alloc_info* ) old_memory - 1;
+				_heap_stats_info.used_memory -= alloc_info->size;
+				_heap_stats_info.alloc_count--;
+				old_memory = alloc_info->physical_start;
+			}
+			break;
+		case EAllocation_ALLOC :
+			{
+				size += track_size;
+			}
+			break;
+		default :
+			break;
+	}
+#endif
+
+	switch ( type )
+	{
+#if defined( GEN_COMPILER_MSVC ) || ( defined( GEN_COMPILER_GCC ) && defined( GEN_SYSTEM_WINDOWS ) ) || ( defined( GEN_COMPILER_TINYC ) && defined( GEN_SYSTEM_WINDOWS ) )
+		case EAllocation_ALLOC :
+			ptr = _aligned_malloc( size, alignment );
+			if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				zero_size( ptr, size );
+			break;
+		case EAllocation_FREE :
+			_aligned_free( old_memory );
+			break;
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+
+#elif defined( GEN_SYSTEM_LINUX ) && ! defined( GEN_CPU_ARM ) && ! defined( GEN_COMPILER_TINYC )
+		case EAllocation_ALLOC :
+			{
+				ptr = aligned_alloc( alignment, ( size + alignment - 1 ) & ~( alignment - 1 ) );
+
+				if ( flags & GEN_ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				{
+					zero_size( ptr, size );
+				}
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				free( old_memory );
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+#else
+		case EAllocation_ALLOC :
+			{
+				posix_memalign( &ptr, alignment, size );
+
+				if ( flags & GEN_ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+				{
+					zero_size( ptr, size );
+				}
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				free( old_memory );
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				AllocatorInfo a = heap();
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+#endif
+
+		case EAllocation_FREE_ALL :
+			break;
+	}
+
+#ifdef GEN_HEAP_ANALYSIS
+	if ( type == EAllocation_ALLOC )
+	{
+		_heap_alloc_info* alloc_info = zpl_cast( _heap_alloc_info* )( zpl_cast( char* ) ptr + alloc_info_remainder );
+		zero_item( alloc_info );
+		alloc_info->size              = size - track_size;
+		alloc_info->physical_start    = ptr;
+		ptr                           = zpl_cast( void* )( alloc_info + 1 );
+		_heap_stats_info.used_memory += alloc_info->size;
+		_heap_stats_info.alloc_count++;
+	}
+#endif
+
+	return ptr;
+}
+
+void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+{
+	Arena* arena = rcast(Arena*, allocator_data);
+	void*      ptr   = NULL;
+
+	// unused( old_size );
+
+	switch ( type )
+	{
+		case EAllocation_ALLOC :
+			{
+				void* end        = pointer_add( arena->PhysicalStart, arena->TotalUsed );
+				sw    total_size = align_forward_i64( size, alignment );
+
+				// NOTE: Out of memory
+				if ( arena->TotalUsed + total_size > (sw) arena->TotalSize )
+				{
+					// zpl__printf_err("%s", "Arena out of memory\n");
+					fatal("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
+					return nullptr;
+				}
+
+				ptr              = align_forward( end, alignment );
+				arena->TotalUsed += total_size;
+
+				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+					zero_size( ptr, size );
+			}
+			break;
+
+		case EAllocation_FREE :
+			// NOTE: Free all at once
+			// Use Temp_Arena_Memory if you want to free a block
+			break;
+
+		case EAllocation_FREE_ALL :
+			arena->TotalUsed = 0;
+			break;
+
+		case EAllocation_RESIZE :
+			{
+				// TODO : Check if ptr is on top of stack and just extend
+				AllocatorInfo a = arena->Backing;
+				ptr             = default_resize_align( a, old_memory, old_size, size, alignment );
+			}
+			break;
+	}
+	return ptr;
+}
+
+void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+{
+	Pool* pool = zpl_cast( Pool* ) allocator_data;
+	void* ptr  = NULL;
+
+	// unused( old_size );
+
+	switch ( type )
+	{
+		case EAllocation_ALLOC :
+			{
+				uptr next_free;
+
+				GEN_ASSERT( size == pool->BlockSize );
+				GEN_ASSERT( alignment == pool->BlockAlign );
+				GEN_ASSERT( pool->FreeList != NULL );
+
+				next_free        = *zpl_cast( uptr* ) pool->FreeList;
+				ptr              = pool->FreeList;
+				pool->FreeList   = zpl_cast( void* ) next_free;
+				pool->TotalSize += pool->BlockSize;
+
+				if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
+					zero_size( ptr, size );
+			}
+			break;
+
+		case EAllocation_FREE :
+			{
+				uptr* next;
+				if ( old_memory == NULL )
+					return NULL;
+
+				next             = zpl_cast( uptr* ) old_memory;
+				*next            = zpl_cast( uptr ) pool->FreeList;
+				pool->FreeList   = old_memory;
+				pool->TotalSize -= pool->BlockSize;
+			}
+			break;
+
+		case EAllocation_FREE_ALL :
+			{
+				sw    actual_block_size, block_index;
+				void* curr;
+				uptr* end;
+
+				actual_block_size = pool->BlockSize + pool->BlockAlign;
+				pool->TotalSize   = 0;
+
+				// NOTE: Init intrusive freelist
+				curr = pool->PhysicalStart;
+				for ( block_index = 0; block_index < pool->NumBlocks - 1; block_index++ )
+				{
+					uptr* next = zpl_cast( uptr* ) curr;
+					*next      = zpl_cast( uptr ) curr + actual_block_size;
+					curr       = pointer_add( curr, actual_block_size );
+				}
+
+				end            = zpl_cast( uptr* ) curr;
+				*end           = zpl_cast( uptr ) NULL;
+				pool->FreeList = pool->PhysicalStart;
+			}
+			break;
+
+		case EAllocation_RESIZE :
+			// NOTE: Cannot resize
+			GEN_PANIC( "You cannot resize something allocated by with a pool." );
+			break;
+	}
+
+	return ptr;
+}
+
+Pool Pool::init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align )
+{
+	Pool pool = {};
+
+	sw    actual_block_size, pool_size, block_index;
+	void *data, *curr;
+	uptr* end;
+
+	zero_item( &pool );
+
+	pool.Backing     = backing;
+	pool.BlockSize   = block_size;
+	pool.BlockAlign  = block_align;
+	pool.NumBlocks   = num_blocks;
+
+	actual_block_size = block_size + block_align;
+	pool_size         = num_blocks * actual_block_size;
+
+	data = alloc_align( backing, pool_size, block_align );
+
+	// NOTE: Init intrusive freelist
+	curr = data;
+	for ( block_index = 0; block_index < num_blocks - 1; block_index++ )
+	{
+		uptr* next = ( uptr* ) curr;
+		*next      = ( uptr  ) curr + actual_block_size;
+		curr       = pointer_add( curr, actual_block_size );
+	}
+
+	end  =  ( uptr* ) curr;
+	*end =  ( uptr )  NULL;
+
+	pool.PhysicalStart = data;
+	pool.FreeList      = data;
+
+	return pool;
+}
+
+void Pool::clear()
+{
+	sw    actual_block_size, block_index;
+	void* curr;
+	uptr* end;
+
+	actual_block_size = BlockSize + BlockAlign;
+
+	curr = PhysicalStart;
+	for ( block_index = 0; block_index < NumBlocks - 1; block_index++ )
+	{
+		uptr* next = ( uptr* ) curr;
+		*next      = ( uptr  ) curr + actual_block_size;
+		curr       = pointer_add( curr, actual_block_size );
+	}
+
+	end  =  ( uptr* ) curr;
+	*end =  ( uptr )  NULL;
+
+	FreeList = PhysicalStart;
+}
+
+#pragma endregion Memory

project/dependencies/memory.hpp

@@ -0,0 +1,486 @@
+#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          ( zpl_cast( uw ) - 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 )
+
+//! Checks if value is power of 2.
+GEN_DEF_INLINE b32 is_power_of_two( sw x );
+
+//! Aligns address to specified alignment.
+GEN_DEF_INLINE void* align_forward( void* ptr, sw alignment );
+
+//! Aligns value to a specified alignment.
+GEN_DEF_INLINE s64 align_forward_i64( s64 value, sw alignment );
+
+//! Moves pointer forward by bytes.
+GEN_DEF_INLINE void* pointer_add( void* ptr, sw bytes );
+
+//! Moves pointer forward by bytes.
+GEN_DEF_INLINE void const* pointer_add_const( void const* ptr, sw bytes );
+
+//! Calculates difference between two addresses.
+GEN_DEF_INLINE sw pointer_diff( void const* begin, void const* end );
+
+//! Copy non-overlapping memory from source to destination.
+void* mem_copy( void* dest, void const* source, sw size );
+
+//! Search for a constant value within the size limit at memory location.
+void const* mem_find( void const* data, u8 byte_value, sw size );
+
+//! Copy memory from source to destination.
+GEN_DEF_INLINE void* mem_move( void* dest, void const* source, sw size );
+
+//! Set constant value at memory location with specified size.
+GEN_DEF_INLINE void* mem_set( void* data, u8 byte_value, sw size );
+
+//! @param ptr Memory location to clear up.
+//! @param size The size to clear up with.
+GEN_DEF_INLINE void zero_size( void* ptr, sw size );
+
+//! 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,
+};
+
+using AllocatorProc = void* ( void* allocator_data, AllocType type
+	, sw size, sw alignment
+	, void* old_memory, sw 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.
+GEN_DEF_INLINE void* alloc( AllocatorInfo a, sw size );
+
+//! Allocate memory with specified alignment.
+GEN_DEF_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment );
+
+//! Free allocated memory.
+GEN_DEF_INLINE void free( AllocatorInfo a, void* ptr );
+
+//! Free all memory allocated by an allocator.
+GEN_DEF_INLINE void free_all( AllocatorInfo a );
+
+//! Resize an allocated memory.
+GEN_DEF_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size );
+
+//! Resize an allocated memory with specified alignment.
+GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
+
+//! Allocate memory for an item.
+#define alloc_item( allocator_, Type ) ( Type* )alloc( allocator_, size_of( Type ) )
+
+//! Allocate memory for an array of items.
+#define alloc_array( allocator_, Type, count ) ( Type* )alloc( allocator_, size_of( Type ) * ( count ) )
+
+/* heap memory analysis tools */
+/* define GEN_HEAP_ANALYSIS to enable this feature */
+/* call zpl_heap_stats_init at the beginning of the entry point */
+/* you can call zpl_heap_stats_check near the end of the execution to validate any possible leaks */
+void heap_stats_init( void );
+sw   heap_stats_used_memory( void );
+sw   heap_stats_alloc_count( void );
+void heap_stats_check( void );
+
+//! Allocate/Resize memory using default options.
+
+//! Use this if you don't need a "fancy" resize allocation
+GEN_DEF_INLINE void* default_resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
+
+void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+
+//! The heap allocator backed by operating system's memory manager.
+constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr }; }
+
+//! 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 )
+
+GEN_IMPL_INLINE b32 is_power_of_two( sw x )
+{
+	if ( x <= 0 )
+		return false;
+	return ! ( x & ( x - 1 ) );
+}
+
+GEN_IMPL_INLINE void* align_forward( void* ptr, sw alignment )
+{
+	uptr p;
+
+	GEN_ASSERT( is_power_of_two( alignment ) );
+
+	p = zpl_cast( uptr ) ptr;
+	return zpl_cast( void* )( ( p + ( alignment - 1 ) ) & ~( alignment - 1 ) );
+}
+
+GEN_IMPL_INLINE s64 align_forward_i64( s64 value, sw alignment )
+{
+	return value + ( alignment - value % alignment ) % alignment;
+}
+
+GEN_IMPL_INLINE void* pointer_add( void* ptr, sw bytes )
+{
+	return zpl_cast( void* )( zpl_cast( u8* ) ptr + bytes );
+}
+
+GEN_IMPL_INLINE void const* pointer_add_const( void const* ptr, sw bytes )
+{
+	return zpl_cast( void const* )( zpl_cast( u8 const* ) ptr + bytes );
+}
+
+GEN_IMPL_INLINE sw pointer_diff( void const* begin, void const* end )
+{
+	return zpl_cast( sw )( zpl_cast( u8 const* ) end - zpl_cast( u8 const* ) begin );
+}
+
+GEN_IMPL_INLINE void* mem_move( void* dest, void const* source, sw n )
+{
+	if ( dest == NULL )
+	{
+		return NULL;
+	}
+
+	u8*       d = zpl_cast( u8* ) dest;
+	u8 const* s = zpl_cast( u8 const* ) source;
+
+	if ( d == s )
+		return d;
+	if ( s + n <= d || d + n <= s )    // NOTE: Non-overlapping
+		return mem_copy( d, s, n );
+
+	if ( d < s )
+	{
+		if ( zpl_cast( uptr ) s % size_of( sw ) == zpl_cast( uptr ) d % size_of( sw ) )
+		{
+			while ( zpl_cast( uptr ) d % size_of( sw ) )
+			{
+				if ( ! n-- )
+					return dest;
+				*d++ = *s++;
+			}
+			while ( n >= size_of( sw ) )
+			{
+				*zpl_cast( sw* ) d  = *zpl_cast( sw* ) s;
+				n                  -= size_of( sw );
+				d                  += size_of( sw );
+				s                  += size_of( sw );
+			}
+		}
+		for ( ; n; n-- )
+			*d++ = *s++;
+	}
+	else
+	{
+		if ( ( zpl_cast( uptr ) s % size_of( sw ) ) == ( zpl_cast( uptr ) d % size_of( sw ) ) )
+		{
+			while ( zpl_cast( uptr )( d + n ) % size_of( sw ) )
+			{
+				if ( ! n-- )
+					return dest;
+				d[ n ] = s[ n ];
+			}
+			while ( n >= size_of( sw ) )
+			{
+				n                         -= size_of( sw );
+				*zpl_cast( sw* )( d + n )  = *zpl_cast( sw* )( s + n );
+			}
+		}
+		while ( n )
+			n--, d[ n ] = s[ n ];
+	}
+
+	return dest;
+}
+
+GEN_IMPL_INLINE void* mem_set( void* dest, u8 c, sw n )
+{
+	if ( dest == NULL )
+	{
+		return NULL;
+	}
+
+	u8* s = zpl_cast( u8* ) dest;
+	sw  k;
+	u32 c32 = ( ( u32 )-1 ) / 255 * c;
+
+	if ( n == 0 )
+		return dest;
+	s[ 0 ] = s[ n - 1 ] = c;
+	if ( n < 3 )
+		return dest;
+	s[ 1 ] = s[ n - 2 ] = c;
+	s[ 2 ] = s[ n - 3 ] = c;
+	if ( n < 7 )
+		return dest;
+	s[ 3 ] = s[ n - 4 ] = c;
+	if ( n < 9 )
+		return dest;
+
+	k  = -zpl_cast( sptr ) s & 3;
+	s += k;
+	n -= k;
+	n &= -4;
+
+	*zpl_cast( u32* )( s + 0 )     = c32;
+	*zpl_cast( u32* )( s + n - 4 ) = c32;
+	if ( n < 9 )
+		return dest;
+	*zpl_cast( u32* )( s + 4 )      = c32;
+	*zpl_cast( u32* )( s + 8 )      = c32;
+	*zpl_cast( u32* )( s + n - 12 ) = c32;
+	*zpl_cast( u32* )( s + n - 8 )  = c32;
+	if ( n < 25 )
+		return dest;
+	*zpl_cast( u32* )( s + 12 )     = c32;
+	*zpl_cast( u32* )( s + 16 )     = c32;
+	*zpl_cast( u32* )( s + 20 )     = c32;
+	*zpl_cast( u32* )( s + 24 )     = c32;
+	*zpl_cast( u32* )( s + n - 28 ) = c32;
+	*zpl_cast( u32* )( s + n - 24 ) = c32;
+	*zpl_cast( u32* )( s + n - 20 ) = c32;
+	*zpl_cast( u32* )( s + n - 16 ) = c32;
+
+	k  = 24 + ( zpl_cast( uptr ) s & 4 );
+	s += k;
+	n -= k;
+
+	{
+		u64 c64 = ( zpl_cast( u64 ) c32 << 32 ) | c32;
+		while ( n > 31 )
+		{
+			*zpl_cast( u64* )( s + 0 )  = c64;
+			*zpl_cast( u64* )( s + 8 )  = c64;
+			*zpl_cast( u64* )( s + 16 ) = c64;
+			*zpl_cast( u64* )( s + 24 ) = c64;
+
+			n -= 32;
+			s += 32;
+		}
+	}
+
+	return dest;
+}
+
+GEN_IMPL_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment )
+{
+	return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+GEN_IMPL_INLINE void* alloc( AllocatorInfo a, sw size )
+{
+	return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+GEN_IMPL_INLINE void free( AllocatorInfo a, void* ptr )
+{
+	if ( ptr != nullptr )
+		a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+GEN_IMPL_INLINE void free_all( AllocatorInfo a )
+{
+	a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+GEN_IMPL_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size )
+{
+	return resize_align( a, ptr, old_size, new_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+GEN_IMPL_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment )
+{
+	return a.Proc( a.Data, EAllocation_RESIZE, new_size, alignment, ptr, old_size, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+GEN_IMPL_INLINE void* default_resize_align( AllocatorInfo a, void* old_memory, sw old_size, sw new_size, sw alignment )
+{
+	if ( ! old_memory )
+		return alloc_align( a, new_size, alignment );
+
+	if ( new_size == 0 )
+	{
+		free( a, old_memory );
+		return nullptr;
+	}
+
+	if ( new_size < old_size )
+		new_size = old_size;
+
+	if ( old_size == new_size )
+	{
+		return old_memory;
+	}
+	else
+	{
+		void* new_memory = alloc_align( a, new_size, alignment );
+		if ( ! new_memory )
+			return nullptr;
+		mem_move( new_memory, old_memory, min( new_size, old_size ) );
+		free( a, old_memory );
+		return new_memory;
+	}
+}
+
+GEN_IMPL_INLINE void zero_size( void* ptr, sw size )
+{
+	mem_set( ptr, 0, size );
+}
+
+struct Arena
+{
+	static
+	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+
+	static
+	Arena init_from_memory( void* start, sw size )
+	{
+		return
+		{
+			{ nullptr, nullptr },
+			start,
+			size,
+			0,
+			0
+		};
+	}
+
+	static
+	Arena init_from_allocator( AllocatorInfo backing, sw size )
+	{
+		Arena result =
+		{
+		backing,
+		alloc( backing, size),
+		size,
+		0,
+		0
+		};
+		return result;
+	}
+
+	static
+	Arena init_sub( Arena& parent, sw size )
+	{
+		return init_from_allocator( parent.Backing, size );
+	}
+
+	sw alignment_of( sw alignment )
+	{
+		sw alignment_offset, result_pointer, mask;
+		GEN_ASSERT( is_power_of_two( alignment ) );
+
+		alignment_offset = 0;
+		result_pointer   = (sw) PhysicalStart + TotalUsed;
+		mask             = alignment - 1;
+
+		if ( result_pointer & mask )
+			alignment_offset = alignment - ( result_pointer & mask );
+
+		return alignment_offset;
+	}
+
+	void check()
+	{
+		GEN_ASSERT( TempCount == 0 );
+	}
+
+	void free()
+	{
+		if ( Backing.Proc )
+		{
+			gen::free( Backing, PhysicalStart );
+			PhysicalStart = nullptr;
+		}
+	}
+
+	sw size_remaining( sw alignment )
+	{
+		sw result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
+		return result;
+	}
+
+	AllocatorInfo Backing;
+	void*         PhysicalStart;
+	sw            TotalSize;
+	sw            TotalUsed;
+	sw            TempCount;
+
+	operator AllocatorInfo()
+	{
+		return { allocator_proc, this };
+	}
+};
+
+struct Pool
+{
+	static
+	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+
+	static
+	Pool init( AllocatorInfo backing, sw num_blocks, sw block_size )
+	{
+		return init_align( backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+	}
+
+	static
+	Pool init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align );
+
+	void clear();
+
+	void free()
+	{
+		if ( Backing.Proc )
+		{
+			gen::free( Backing, PhysicalStart );
+		}
+	}
+
+	AllocatorInfo Backing;
+	void*         PhysicalStart;
+	void*         FreeList;
+	sw            BlockSize;
+	sw            BlockAlign;
+	sw            TotalSize;
+	sw            NumBlocks;
+
+	operator AllocatorInfo()
+	{
+		return { allocator_proc, this };
+	}
+};
+
+#pragma endregion Memory

project/dependencies/parsing.hpp

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

project/dependencies/printing.cpp

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

project/dependencies/printing.hpp

@@ -0,0 +1,63 @@
+#pragma region Printing
+
+struct FileInfo;
+
+#ifndef GEN_PRINTF_MAXLEN
+#	define GEN_PRINTF_MAXLEN kilobytes(128)
+#endif
+
+// NOTE: A locally persisting buffer is used internally
+char* str_fmt_buf       ( char const* fmt, ... );
+char* str_fmt_buf_va    ( char const* fmt, va_list va );
+sw    str_fmt_va        ( char* str, sw n, char const* fmt, va_list va );
+sw    str_fmt_out_va    ( char const* fmt, va_list va );
+sw    str_fmt_out_err   ( char const* fmt, ... );
+sw    str_fmt_out_err_va( char const* fmt, va_list va );
+
+// TODO : Move these to file handling.
+
+sw    str_fmt_file      ( FileInfo* f, char const* fmt, ... );
+sw    str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+
+constexpr
+char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
+
+inline
+sw log_fmt(char const* fmt, ...)
+{
+	sw res;
+	va_list va;
+
+	va_start(va, fmt);
+	res = str_fmt_out_va(fmt, va);
+	va_end(va);
+
+	return res;
+}
+
+inline
+sw fatal(char const* fmt, ...)
+{
+	local_persist thread_local
+	char buf[GEN_PRINTF_MAXLEN] = { 0 };
+
+	va_list va;
+
+#if Build_Debug
+	va_start(va, fmt);
+	str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	va_end(va);
+
+	assert_crash(buf);
+	return -1;
+#else
+	va_start(va, fmt);
+	str_fmt_out_err_va( fmt, va);
+	va_end(va);
+
+	exit(1);
+	return -1;
+#endif
+}
+
+#pragma endregion Printing

project/dependencies/string.cpp

@@ -0,0 +1,39 @@
+#pragma region String
+
+String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
+{
+	va_list va;
+	va_start( va, fmt );
+	str_fmt_va( buf, buf_size, fmt, va );
+	va_end( va );
+
+	return make( allocator, buf );
+}
+
+String String::fmt_buf( AllocatorInfo allocator, char const* fmt, ... )
+{
+	local_persist thread_local
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	va_list va;
+	va_start( va, fmt );
+	str_fmt_va( buf, GEN_PRINTF_MAXLEN, fmt, va );
+	va_end( va );
+
+	return make( allocator, buf );
+}
+
+bool String::append_fmt( char const* fmt, ... )
+{
+	sw   res;
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+	va_end( va );
+
+	return append( buf, res );
+}
+
+#pragma endregion String

project/dependencies/string.hpp

@@ -0,0 +1,375 @@
+#pragma region String
+
+// Constant string with length.
+struct StrC
+{
+	sw          Len;
+	char const* Ptr;
+
+	operator char const* () const
+	{
+		return Ptr;
+	}
+};
+
+#define txt_StrC( text ) StrC { sizeof( text ) - 1, text }
+
+StrC to_StrC( char const* str )
+{
+	return { str_len( str ), str };
+}
+
+sw StrC_len( char const* str )
+{
+	return (sw) ( str - 1 );
+}
+
+// Dynamic String
+// This is directly based off the ZPL string api.
+// They used a header pattern
+// I kept it for simplicty of porting but its not necessary to keep it that way.
+struct String
+{
+	struct Header
+	{
+		AllocatorInfo Allocator;
+		sw            Length;
+		sw            Capacity;
+	};
+
+	static
+	uw grow_formula( uw value )
+	{
+		// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
+		return 4 * value + 8;
+	}
+
+	static
+	String make( AllocatorInfo allocator, char const* str )
+	{
+		sw length = str ? str_len( str ) : 0;
+		return make_length( allocator, str, length );
+	}
+
+	static
+	String make( AllocatorInfo allocator, StrC str )
+	{
+		return make_length( allocator, str.Ptr, str.Len );
+	}
+
+	static
+	String make_reserve( AllocatorInfo allocator, sw capacity )
+	{
+		constexpr sw header_size = sizeof( Header );
+
+		s32   alloc_size = header_size + capacity + 1;
+		void* allocation = alloc( allocator, alloc_size );
+
+		if ( allocation == nullptr )
+			return { nullptr };
+
+		mem_set( allocation, 0, alloc_size );
+
+		Header*
+			header            = rcast(Header*, allocation);
+		header->Allocator = allocator;
+		header->Capacity  = capacity;
+		header->Length    = 0;
+
+		String result = { (char*)allocation + header_size };
+		return result;
+	}
+
+	static
+	String make_length( AllocatorInfo allocator, char const* str, sw length )
+	{
+		constexpr sw header_size = sizeof( Header );
+
+		s32   alloc_size = header_size + length + 1;
+		void* allocation = alloc( allocator, alloc_size );
+
+		if ( allocation == nullptr )
+			return { nullptr };
+
+		Header&
+			header = * rcast(Header*, allocation);
+		header = { allocator, length, length };
+
+		String  result = { rcast( char*, allocation) + header_size };
+
+		if ( length && str )
+			mem_copy( result, str, length );
+		else
+			mem_set( result, 0, alloc_size - header_size );
+
+		result[ length ] = '\0';
+
+		return result;
+	}
+
+	static
+	String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
+
+	static
+	String fmt_buf( AllocatorInfo allocator, char const* fmt, ... );
+
+	static
+	String join( AllocatorInfo allocator, char const** parts, sw num_parts, char const* glue )
+	{
+		String result = make( allocator, "" );
+
+		for ( sw idx = 0; idx < num_parts; ++idx )
+		{
+			result.append( parts[ idx ] );
+
+			if ( idx < num_parts - 1 )
+				result.append( glue );
+		}
+
+		return result;
+	}
+
+	static
+	bool are_equal( String lhs, String rhs )
+	{
+		if ( lhs.length() != rhs.length() )
+			return false;
+
+		for ( sw idx = 0; idx < lhs.length(); ++idx )
+			if ( lhs[ idx ] != rhs[ idx ] )
+				return false;
+
+		return true;
+	}
+
+	bool make_space_for( char const* str, sw add_len )
+	{
+		sw available = avail_space();
+
+		// NOTE: Return if there is enough space left
+		if ( available >= add_len )
+		{
+			return true;
+		}
+		else
+		{
+			sw new_len, old_size, new_size;
+
+			void* ptr;
+			void* new_ptr;
+
+			AllocatorInfo allocator = get_header().Allocator;
+			Header*       header	= nullptr;
+
+			new_len  = grow_formula( length() + add_len );
+			ptr      = & get_header();
+			old_size = size_of( Header ) + length() + 1;
+			new_size = size_of( Header ) + new_len + 1;
+
+			new_ptr = resize( allocator, ptr, old_size, new_size );
+
+			if ( new_ptr == nullptr )
+				return false;
+
+			header            = zpl_cast( Header* ) new_ptr;
+			header->Allocator = allocator;
+			header->Capacity  = new_len;
+
+			Data = rcast( char*, header + 1 );
+
+			return str;
+		}
+	}
+
+	bool append( char const* str )
+	{
+		return append( str, str_len( str ) );
+	}
+
+	bool append( char const* str, sw length )
+	{
+		if ( sptr(str) > 0 )
+		{
+			sw curr_len = this->length();
+
+			if ( ! make_space_for( str, length ) )
+				return false;
+
+			Header& header = get_header();
+
+			mem_copy( Data + curr_len, str, length );
+
+			Data[ curr_len + length ] = '\0';
+
+			header.Length = curr_len + length;
+		}
+		return str;
+	}
+
+	bool append( StrC str)
+	{
+		return append( str.Ptr, str.Len );
+	}
+
+	bool append( const String other )
+	{
+		return append( other.Data, other.length() );;
+	}
+
+	bool append_fmt( char const* fmt, ... );
+
+	sw avail_space() const
+	{
+		Header const&
+		header = * rcast( Header const*, Data - sizeof( Header ));
+
+		return header.Capacity - header.Length;
+	}
+
+	sw capacity() const
+	{
+		Header const&
+		header = * rcast( Header const*, Data - sizeof( Header ));
+
+		return header.Capacity;
+	}
+
+	void clear()
+	{
+		get_header().Length = 0;
+	}
+
+	String duplicate( AllocatorInfo allocator )
+	{
+		return make_length( allocator, Data, length() );
+	}
+
+	void free()
+	{
+		if ( ! Data )
+			return;
+
+		Header& header = get_header();
+
+		gen::free( header.Allocator, & header );
+	}
+
+	Header& get_header()
+	{
+		return *(Header*)(Data - sizeof(Header));
+	}
+
+	sw length() const
+	{
+		Header const&
+		header = * rcast( Header const*, Data - sizeof( Header ));
+
+		return header.Length;
+	}
+
+	void trim( char const* cut_set )
+	{
+		sw len = 0;
+
+		char* start_pos = Data;
+		char* end_pos   = Data + length() - 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( sw, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
+
+		if ( Data != start_pos )
+			mem_move( Data, start_pos, len );
+
+		Data[ len ] = '\0';
+
+		get_header().Length = len;
+	}
+
+	void trim_space()
+	{
+		return trim( " \t\r\n\v\f" );
+	}
+
+	// For-range support
+
+	char* begin()
+	{
+		return Data;
+	}
+
+	char* end()
+	{
+		Header const&
+		header = * rcast( Header const*, Data - sizeof( Header ));
+
+		return Data + header.Length;
+	}
+
+	operator bool()
+	{
+		return Data;
+	}
+
+	operator char* ()
+	{
+		return Data;
+	}
+
+	operator char const* () const
+	{
+		return Data;
+	}
+
+	operator StrC() const
+	{
+		return
+		{
+			length(),
+			Data
+		};
+	}
+
+	// Used with cached strings
+	// Essentially makes the string a string view.
+	String const& operator = ( String const& other ) const
+	{
+		if ( this == & other )
+			return *this;
+
+		String& this_ = ccast( String, *this );
+
+		this_.Data = other.Data;
+
+		return this_;
+	}
+
+	char& operator [] ( sw index )
+	{
+		return Data[ index ];
+	}
+
+	char const& operator [] ( sw index ) const
+	{
+		return Data[ index ];
+	}
+
+	char* Data = nullptr;
+};
+
+struct String_POD
+{
+	char* Data;
+
+	operator String()
+	{
+		return * rcast(String*, this);
+	}
+};
+static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
+
+#pragma endregion String

project/dependencies/string_ops.cpp

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

project/dependencies/string_ops.hpp

@@ -0,0 +1,262 @@
+#pragma region String Ops
+
+GEN_DEF_INLINE const char* char_first_occurence( const char* str, char c );
+constexpr auto str_find = &char_first_occurence;
+
+GEN_DEF_INLINE b32   char_is_alpha( char c );
+GEN_DEF_INLINE b32   char_is_alphanumeric( char c );
+GEN_DEF_INLINE b32   char_is_digit( char c );
+GEN_DEF_INLINE b32   char_is_hex_digit( char c );
+GEN_DEF_INLINE b32   char_is_space( char c );
+GEN_DEF_INLINE char  char_to_lower( char c );
+GEN_DEF_INLINE char  char_to_upper( char c );
+
+GEN_DEF_INLINE s32  digit_to_int( char c );
+GEN_DEF_INLINE s32  hex_digit_to_int( char c );
+
+GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2 );
+GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2, sw len );
+GEN_DEF_INLINE char*       str_copy( char* dest, const char* source, sw len );
+GEN_DEF_INLINE sw          str_copy_nulpad( char* dest, const char* source, sw len );
+GEN_DEF_INLINE sw          str_len( const char* str );
+GEN_DEF_INLINE sw          str_len( const char* str, sw max_len );
+GEN_DEF_INLINE char*       str_reverse( char* str );    // NOTE: ASCII only
+GEN_DEF_INLINE char const* str_skip( char const* str, char c );
+GEN_DEF_INLINE char const* str_skip_any( char const* str, char const* char_list );
+GEN_DEF_INLINE char const* str_trim( char const* str, b32 catch_newline );
+
+// NOTE: ASCII only
+GEN_DEF_INLINE void str_to_lower( char* str );
+GEN_DEF_INLINE void str_to_upper( char* str );
+
+s64  str_to_i64( const char* str, char** end_ptr, s32 base );
+void i64_to_str( s64 value, char* string, s32 base );
+void u64_to_str( u64 value, char* string, s32 base );
+f64  str_to_f64( const char* str, char** end_ptr );
+
+GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
+{
+	char ch = c;
+	for ( ; *s != ch; s++ )
+	{
+		if ( *s == '\0' )
+			return NULL;
+	}
+	return s;
+}
+
+GEN_IMPL_INLINE b32 char_is_alpha( char c )
+{
+	if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
+		return true;
+	return false;
+}
+
+GEN_IMPL_INLINE b32 char_is_alphanumeric( char c )
+{
+	return char_is_alpha( c ) || char_is_digit( c );
+}
+
+GEN_IMPL_INLINE b32 char_is_digit( char c )
+{
+	if ( c >= '0' && c <= '9' )
+		return true;
+	return false;
+}
+
+GEN_IMPL_INLINE b32 char_is_hex_digit( char c )
+{
+	if ( char_is_digit( c ) || ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) )
+		return true;
+	return false;
+}
+
+GEN_IMPL_INLINE b32 char_is_space( char c )
+{
+	if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
+		return true;
+	return false;
+}
+
+GEN_IMPL_INLINE char char_to_lower( char c )
+{
+	if ( c >= 'A' && c <= 'Z' )
+		return 'a' + ( c - 'A' );
+	return c;
+}
+
+GEN_IMPL_INLINE char char_to_upper( char c )
+{
+	if ( c >= 'a' && c <= 'z' )
+		return 'A' + ( c - 'a' );
+	return c;
+}
+
+GEN_IMPL_INLINE s32 digit_to_int( char c )
+{
+	return char_is_digit( c ) ? c - '0' : c - 'W';
+}
+
+GEN_IMPL_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;
+}
+
+GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
+{
+	while ( *s1 && ( *s1 == *s2 ) )
+	{
+		s1++, s2++;
+	}
+	return *( u8* )s1 - *( u8* )s2;
+}
+
+GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
+{
+	for ( ; len > 0; s1++, s2++, len-- )
+	{
+		if ( *s1 != *s2 )
+			return ( ( s1 < s2 ) ? -1 : +1 );
+		else if ( *s1 == '\0' )
+			return 0;
+	}
+	return 0;
+}
+
+GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw 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;
+}
+
+GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
+{
+	sw 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;
+}
+
+GEN_IMPL_INLINE sw str_len( const char* str )
+{
+	if ( str == NULL )
+	{
+		return 0;
+	}
+	const char* p = str;
+	while ( *str )
+		str++;
+	return str - p;
+}
+
+GEN_IMPL_INLINE sw str_len( const char* str, sw max_len )
+{
+	const char* end = zpl_cast( const char* ) mem_find( str, 0, max_len );
+	if ( end )
+		return end - str;
+	return max_len;
+}
+
+GEN_IMPL_INLINE char* str_reverse( char* str )
+{
+	sw    len  = str_len( str );
+	char* a    = str + 0;
+	char* b    = str + len - 1;
+	len       /= 2;
+	while ( len-- )
+	{
+		swap( *a, *b );
+		a++, b--;
+	}
+	return str;
+}
+
+GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
+{
+	while ( *str && *str != c )
+	{
+		++str;
+	}
+	return str;
+}
+
+GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list )
+{
+	char const* closest_ptr     = zpl_cast( char const* ) pointer_add( ( void* )str, str_len( str ) );
+	sw          char_list_count = str_len( char_list );
+	for ( sw i = 0; i < char_list_count; i++ )
+	{
+		char const* p = str_skip( str, char_list[ i ] );
+		closest_ptr   = min( closest_ptr, p );
+	}
+	return closest_ptr;
+}
+
+GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
+{
+	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
+	{
+		++str;
+	}
+	return str;
+}
+
+GEN_IMPL_INLINE void str_to_lower( char* str )
+{
+	if ( ! str )
+		return;
+	while ( *str )
+	{
+		*str = char_to_lower( *str );
+		str++;
+	}
+}
+
+GEN_IMPL_INLINE void str_to_upper( char* str )
+{
+	if ( ! str )
+		return;
+	while ( *str )
+	{
+		*str = char_to_upper( *str );
+		str++;
+	}
+}
+
+#pragma endregion String Ops

project/dependencies/timing.cpp

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

project/dependencies/timing.hpp

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

project/enums/AttributeTokens.csv

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

project/enums/ECode.csv

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

project/enums/EOperator.csv

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

project/enums/ESpecifier.csv

@@ -0,0 +1,23 @@
+Invalid,          INVALID
+Consteval,        consteval
+Constexpr,        constexpr
+Constinit,        constinit
+Explicit,         explicit
+External_Linkage, extern
+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
+Volatile,         volatile
+Virtual,          virtual
+Const,            const
+Final,            final
+Override,         override

project/enums/ETokType.csv

@@ -0,0 +1,86 @@
+Invalid,                "__invalid__"
+Access_Private,         "private"
+Access_Protected,       "protected"
+Access_Public,          "public"
+Access_MemberSymbol,    "."
+Access_StaticSymbol,    "::"
+Ampersand,              "&"
+Ampersand_DBL,          "&&"
+Assign_Classifer,       ":"
+Attribute_Open,         "[["
+Attribute_Close,        "]]"
+BraceCurly_Open,        "{"
+BraceCurly_Close,       "}"
+BraceSquare_Open,       "["
+BraceSquare_Close,      "]"
+Capture_Start,          "("
+Capture_End,            ")"
+Comment,                "__comemnt__"
+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"
+Number,                 "__number__"
+Operator,               "__operator__"
+Preprocess_Define,      "define"
+Preprocess_If,          "if"
+Preprocess_IfDef, 	    "ifdef"
+Preprocess_IfNotDef, 	"ifndef"
+Preprocess_ElIf,		"elif"
+Preprocess_Else,        "else"
+Preprocess_EndIf,       "endif"
+Preprocess_Include,     "include"
+Preprocess_Pragma,      "pragma"
+Preprocess_Macro,       "__macro__"
+Preprocess_Unsupported, "__unsupported__"
+Spec_Alignas,           "alignas"
+Spec_Const,             "const"
+Spec_Consteval,         "consteval"
+Spec_Constexpr,         "constexpr"
+Spec_Constinit,         "constinit"
+Spec_Explicit,          "explicit"
+Spec_Extern,            "extern"
+Spec_Final,             "final"
+Spec_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"
+Star,                   "*"
+Statement_End,          ";"
+StaticAssert,           "static_assert"
+String,                 "__string__"
+Type_Unsigned,          "unsigned"
+Type_Signed,            "signed"
+Type_Short,             "short"
+Type_Long,              "long"
+Type_char,              "char"
+Type_int,               "int"
+Type_double,            "double"
+Type_MS_int8, 		    "__int8"
+Type_MS_int16, 		    "__int16"
+Type_MS_int32, 		    "__int32"
+Type_MS_int64, 		    "__int64"
+Type_MS_W64, 		    "_W64"
+Varadic_Argument,       "..."
+__Attributes_Start,     "__attrib_start__"

project/file_processors/builder.cpp

@@ -0,0 +1,43 @@
+void Builder::print( Code code )
+{
+	Buffer.append( code->to_string() );
+}
+
+void Builder::print_fmt( char const* fmt, ... )
+{
+	sw   res;
+	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
+
+	va_list va;
+	va_start( va, fmt );
+	res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
+	va_end( va );
+
+	Buffer.append( buf, res );
+}
+
+bool Builder::open( char const* path )
+{
+	FileError error = file_open_mode( & File, EFileMode_WRITE, path );
+
+	if ( error != EFileError_NONE )
+	{
+		log_failure( "gen::File::open - Could not open file: %s", path);
+		return false;
+	}
+
+	Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );
+
+	return true;
+}
+
+void Builder::write()
+{
+	bool result = file_write( & File, Buffer, Buffer.length() );
+
+	if ( result == false )
+		log_failure("gen::File::write - Failed to write to file: %s", file_name( & File ) );
+
+	file_close( & File );
+	Buffer.free();
+}

project/file_processors/builder.hpp

@@ -0,0 +1,11 @@
+struct Builder
+{
+	FileInfo File;
+	String   Buffer;
+
+	void print( Code );
+	void print_fmt( char const* fmt, ... );
+
+	bool open( char const* path );
+	void write();
+};

project/file_processors/editor.hpp

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

project/file_processors/scanner.hpp

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

project/gen.bootstrap.cpp

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

project/gen.dep.cpp

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

project/gen.dep.hpp

@@ -0,0 +1,30 @@
+// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)
+#pragma once
+
+#include "dependencies/header_start.hpp"
+
+#ifdef GEN_DONT_USE_NAMESPACE
+#	define GEN_NS_BEGIN
+#	define GEN_NS_END
+#else
+#	define GEN_NS_BEGIN namespace gen {
+#	define GEN_NS_END   }
+#endif
+
+GEN_NS_BEGIN
+
+#include "dependencies/macros.hpp"
+#include "dependencies/basic_types.hpp"
+#include "dependencies/debug.hpp"
+#include "dependencies/memory.hpp"
+#include "dependencies/string_ops.hpp"
+#include "dependencies/printing.hpp"
+#include "dependencies/containers.hpp"
+#include "dependencies/hashing.hpp"
+#include "dependencies/string.hpp"
+#include "dependencies/parsing.hpp"
+#include "dependencies/timing.hpp"
+
+#include "dependencies/file_handling.hpp"
+
+GEN_NS_END

project/helpers/helper.hpp

@@ -0,0 +1,315 @@
+#pragma once
+
+#include "gen.hpp"
+
+using namespace gen;
+
+CodeBody gen_ecode( char const* path )
+{
+	char  scratch_mem[kilobytes(1)];
+	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( scratch, zero_terminate, path );
+
+	CSV_Object csv_nodes;
+	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
+
+	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
+
+	String enum_entries   = String::make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
+
+	for ( ADT_Node node : enum_strs )
+	{
+		char const* code = node.string;
+		enum_entries.append_fmt( "%s,\n", code );
+		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
+	}
+
+	CodeEnum enum_code = parse_enum( token_fmt( "entries", (StrC)enum_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			NumTypes
+		};
+	)));
+
+#pragma push_macro( "local_persist" )
+#undef local_persist
+	CodeFn to_str = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+#pragma pop_macro( "local_persist" )
+
+	CodeNamespace nspace = def_namespace( name(ECode), def_namespace_body( args( enum_code, to_str ) ) );
+	CodeUsing    code_t  = def_using( name(CodeT), def_type( name(ECode::Type) ) );
+
+	return def_global_body( args( nspace, code_t ) );
+}
+
+CodeBody gen_eoperator( char const* path )
+{
+	char scratch_mem[kilobytes(1)];
+	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( scratch, zero_terminate, path );
+
+	CSV_Object csv_nodes;
+	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
+
+	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
+	Array<ADT_Node> str_strs  = csv_nodes.nodes[1].nodes;
+
+	String enum_entries   = String::make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
+
+	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = str_strs [idx].string;
+
+		enum_entries.append_fmt( "%s,\n", enum_str );
+		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			NumOps
+		};
+	)));
+
+#pragma push_macro( "local_persist" )
+#undef local_persist
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		StrC to_str( Type op )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ op ];
+		}
+	)));
+#pragma pop_macro( "local_persist" )
+
+	CodeNamespace nspace = def_namespace( name(EOperator), def_namespace_body( args( enum_code, to_str ) ) );
+
+	CodeUsing operator_t = def_using( name(OperatorT), def_type( name(EOperator::Type) ) );
+
+	return def_global_body( args( nspace, operator_t ) );
+}
+
+CodeBody gen_especifier( char const* path )
+{
+	char scratch_mem[kilobytes(1)];
+	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	file_read_contents( scratch, zero_terminate, path );
+
+	CSV_Object csv_nodes;
+	csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
+
+	Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
+	Array<ADT_Node> str_strs  = csv_nodes.nodes[1].nodes;
+
+	String enum_entries   = String::make_reserve( GlobalAllocator, kilobytes(1) );
+	String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
+
+	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = str_strs [idx].string;
+
+		enum_entries.append_fmt( "%s,\n", enum_str );
+		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	CodeEnum  enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			NumSpecifiers
+		};
+	)));
+
+	CodeFn is_trailing = parse_function(token_fmt("specifier", (StrC)to_str_entries, stringize(
+		bool is_trailing( Type specifier )
+		{
+			return specifier > Virtual;
+		}
+	)));
+
+#pragma push_macro( "local_persist" )
+#pragma push_macro( "do_once_start" )
+#pragma push_macro( "do_once_end" )
+#undef local_persist
+#undef do_once_start
+#undef do_once_end
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+
+	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		Type to_type( StrC str )
+		{
+			local_persist
+			u32 keymap[ NumSpecifiers ];
+			do_once_start
+				for ( u32 index = 0; index < NumSpecifiers; index++ )
+				{
+					StrC enum_str = to_str( (Type)index );
+
+					// We subtract 1 to remove the null terminator
+					// This is because the tokens lexed are not null terminated.
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+				}
+			do_once_end
+
+			u32 hash = crc32( str.Ptr, str.Len );
+
+			for ( u32 index = 0; index < NumSpecifiers; index++ )
+			{
+				if ( keymap[index] == hash )
+					return (Type)index;
+			}
+
+			return Invalid;
+		}
+	)));
+#pragma pop_macro( "local_persist" )
+#pragma pop_macro( "do_once_start" )
+#pragma pop_macro( "do_once_end" )
+
+	CodeNamespace nspace = def_namespace( name(ESpecifier), def_namespace_body( args( enum_code, is_trailing, to_str, to_type ) ) );
+
+	CodeUsing specifier_t = def_using( name(SpecifierT), def_type( name(ESpecifier::Type) ) );
+
+	return def_global_body( args( nspace, specifier_t ) );
+}
+
+CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
+{
+	char  scratch_mem[kilobytes(64)];
+	Arena scratch = Arena::init_from_memory( scratch_mem, sizeof(scratch_mem) );
+
+	FileContents enum_content = file_read_contents( scratch, zero_terminate, etok_path );
+
+	CSV_Object csv_enum_nodes;
+	csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), GlobalAllocator, false );
+
+	FileContents attrib_content = file_read_contents( scratch, zero_terminate, attr_path );
+
+	CSV_Object csv_attr_nodes;
+	csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), GlobalAllocator, false );
+
+	Array<ADT_Node> enum_strs          = csv_enum_nodes.nodes[0].nodes;
+	Array<ADT_Node> enum_str_strs      = csv_enum_nodes.nodes[1].nodes;
+	Array<ADT_Node> attribute_strs     = csv_attr_nodes.nodes[0].nodes;
+	Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes;
+
+	String enum_entries      = String::make_reserve( GlobalAllocator, kilobytes(2) );
+	String to_str_entries    = String::make_reserve( GlobalAllocator, kilobytes(4) );
+	String attribute_entries = String::make_reserve( GlobalAllocator, kilobytes(2) );
+	String to_str_attributes = String::make_reserve( GlobalAllocator, kilobytes(4) );
+
+	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	{
+		char const* enum_str     = enum_strs[idx].string;
+		char const* entry_to_str = enum_str_strs [idx].string;
+
+		enum_entries.append_fmt( "%s,\n", enum_str );
+		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	for ( uw idx = 0; idx < attribute_strs.num(); idx++ )
+	{
+		char const* attribute_str = attribute_strs[idx].string;
+		char const* entry_to_str  = attribute_str_strs [idx].string;
+
+		attribute_entries.append_fmt( "%s,\n", attribute_str );
+		to_str_attributes.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
+	}
+
+	CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, "attribute_toks", (StrC)attribute_entries, stringize(
+		enum Type : u32
+		{
+			<entries>
+			<attribute_toks>
+			NumTokens
+		};
+	)));
+
+#pragma push_macro( "local_persist" )
+#pragma push_macro( "do_once_start" )
+#pragma push_macro( "do_once_end" )
+#undef local_persist
+#undef do_once_start
+#undef do_once_end
+	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, "attribute_toks", (StrC)to_str_attributes, stringize(
+		StrC to_str( Type type )
+		{
+			local_persist
+			StrC lookup[] {
+				<entries>
+				<attribute_toks>
+			};
+
+			return lookup[ type ];
+		}
+	)));
+
+	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		Type to_type( StrC str )
+		{
+			local_persist
+			u32 keymap[ NumTokens ];
+			do_once_start
+				for ( u32 index = 0; index < NumTokens; index++ )
+				{
+					StrC enum_str = to_str( (Type)index );
+
+					// We subtract 1 to remove the null terminator
+					// This is because the tokens lexed are not null terminated.
+					keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
+				}
+			do_once_end
+
+			u32 hash = crc32( str.Ptr, str.Len );
+
+			for ( u32 index = 0; index < NumTokens; index++ )
+			{
+				if ( keymap[index] == hash )
+					return (Type)index;
+			}
+
+			return Invalid;
+		}
+	)));
+#pragma pop_macro( "local_persist" )
+#pragma pop_macro( "do_once_start" )
+#pragma pop_macro( "do_once_end" )
+
+	CodeNamespace nspace     = def_namespace( name(ETokType), def_namespace_body( args( enum_code, to_str, to_type ) ) );
+	CodeUsing     td_toktype = def_using( name(TokType), def_type( name(ETokType::Type) ) );
+
+	return def_global_body( args( nspace, td_toktype ) );
+}

project/helpers/pop_ignores.inline.hpp

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

project/helpers/push_ignores.inline.hpp

@@ -0,0 +1,17 @@
+#if __clang__
+#	pragma clang diagnostic push
+#	pragma clang diagnostic ignored "-Wunused-const-variable"
+#	pragma clang diagnostic ignored "-Wswitch"
+#	pragma clang diagnostic ignored "-Wunused-variable"
+#   pragma clang diagnostic ignored "-Wunknown-pragmas"
+#	pragma clang diagnostic ignored "-Wvarargs"
+#	pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+#if __GNUC__
+#	pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#	pragma GCC diagnostic ignored "-Wcomment"
+#	pragma GCC diagnostic ignored "-Wswitch"
+#	pragma GCC diagnostic ignored "-Wunused-variable"
+#endif

project/helpers/undef.macros.hpp

@@ -1,4 +1,4 @@
-#if gen_time
+#if GEN_TIME
 // This undefines the macros used by the gen library but are not necessary for the user.
 
 #undef GEN_ARCH_64_BIT
@@ -66,11 +66,15 @@
 #undef stringize_va
 #undef txt_StrC
 
-#undef __
-#undef args
+#undef GEN_TIME
 #undef gen_main
-#undef gen_time
+#undef __
+#undef name
+#undef code
+#undef args
+#undef code_str
+#undef code_fmt
 #undef token_fmt
 
-// gen_time
+// GEN_TIME
 #endif

project/meson.build

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

scripts/.clang-format

@@ -3,7 +3,7 @@
 AccessModifierOffset: -4
 
 AlignAfterOpenBracket: BlockIndent
-AlignArrayOfStructures: Right
+AlignArrayOfStructures: Left
 AlignConsecutiveAssignments:
   Enabled: true
   AcrossEmptyLines: false
@@ -12,8 +12,11 @@ AlignConsecutiveAssignments:
   PadOperators: true
 AlignConsecutiveBitFields: AcrossComments
 AlignConsecutiveDeclarations: AcrossComments
-AlignConsecutiveMacros: AcrossComments
-AlignEscapedNewlines: Right
+AlignConsecutiveMacros:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: true
+AlignEscapedNewlines: Left
 AlignOperands: DontAlign
 
 AlignTrailingComments: true
@@ -38,7 +41,7 @@ BinPackParameters: false
 
 BitFieldColonSpacing: Both
 
-BraceWrapping: 
+BraceWrapping:
   AfterCaseLabel: false
   AfterClass: false
   AfterControlStatement: false
@@ -58,7 +61,7 @@ BraceWrapping:
   BeforeLambdaBody: false
   BeforeWhile: false
 
-# BreakAfterAttributes: Always
+BreakAfterAttributes: Always
 # BreakArrays: false
 # BreakBeforeInlineASMColon: OnlyMultiline
 BreakBeforeBinaryOperators: NonAssignment
@@ -70,14 +73,14 @@ BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeComma
 BreakStringLiterals: true
 
-ColumnLimit: 180
+ColumnLimit: 120
 
 CompactNamespaces: true
 
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth : 4
 
-ContinuationIndentWidth: 4
+ContinuationIndentWidth: 0
 
 Cpp11BracedListStyle: false
 
@@ -90,17 +93,17 @@ FixNamespaceComments: true
 IncludeBlocks: Preserve
 
 
-IndentCaseBlocks: true
+IndentCaseBlocks: false
 IndentCaseLabels: true
 IndentExternBlock: AfterExternBlock
 IndentGotoLabels: true
 IndentPPDirectives: AfterHash
 IndentRequires: true
 IndentWidth: 4
-IndentWrappedFunctionNames: false
+IndentWrappedFunctionNames: true
 
 # InsertNewlineAtEOF: true
-InsertTrailingCommas: Wrapped
+# InsertTrailingCommas: Wrapped
 
 LambdaBodyIndentation: OuterScope
 
@@ -124,7 +127,7 @@ SeparateDefinitionBlocks: Always
 
 ShortNamespaceLines: 40
 
-SortIncludes: true
+SortIncludes: false
 SortUsingDeclarations: true
 
 SpaceAfterCStyleCast: false

scripts/Readme.md

@@ -1,12 +1,34 @@
 # Scripts
 
-Build and cleanup scripts for the test deirectory are found here along with `natvis` and `natstepfilter` files for debugging.
+Generation, testing, and cleanup scripts for the test directory are found here along with `natvis` and `natstepfilter` files for debugging.
 
-The build works as follows:
+## Refactoring
 
-* Compile and run the meta-program, it will dump files to the `test/gen` directory.
-* Format the files using clang-format
-* Build a program that uses some the generated definitions. (Have not done yet)
+`refactor.ps1` Provides a way to run the [refactor](github.com/Ed94/refactor) program. It uses the `gencpp.refactor` script to complete a mass refactor of all content within the files of the specified within the script.
 
-The `test/gen` directory has the meson.build config for the meta-program
-The `test` directory has the one for the depdendent-program.
+Currently `refactor` only supports naive sort of *find and replace* feature set and will not be able to rename identifiers excluisvely to a specific context (such as only renaming member names of a specific struct, etc).
+
+## Build & Run Scripts
+
+**`clean.ps1`**  
+Remove any generated content from the repository.
+
+**`bootstrap.ps1`**  
+Generate a version of gencpp where components are inlined directly to `gen.<hpp/cpp>` and `gen. <hpp/cpp>`  
+Any heavily preprocessed code is not inlined and are instead generated using the code in the `helpers` directory.
+
+**`singlheader.build.ps1`**  
+Generate a single-header version of the library where all code that would normally good in the usual four files (see bootstrap) are inlined into a single `gen.hpp` file.  
+As with the bootstrap, any heavily preprocessed code is not inlined and instead generated with helper code.
+
+**`test.gen.build.ps1`**  
+Build the metaprogram for generating the test code.
+
+**`test.gen.ps1`**  
+Build (if not already) the metaprogram for generating test code, then run it to generate code.
+
+**`test.build.ps1`**  
+Build and run metaprogram, build test program.
+
+**`test.run.ps1`**  
+Build and run metaprogram, build and run test program.

scripts/bootstrap.ci.ps1

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

scripts/bootstrap.ps1

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

scripts/build.ps1

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

scripts/clean.ps1

@@ -1,13 +1,34 @@
-$path_root       = git rev-parse --show-toplevel
-$path_build      = Join-Path $path_root build
-$path_test       = Join-Path $path_root test
-$path_gen        = Join-Path $path_test gen
-$path_test_build = Join-Path $path_test build
-$path_gen_build  = Join-Path $path_gen  build
+$path_root               = git rev-parse --show-toplevel
+$path_project            = Join-Path $path_root project
+$path_project_build      = Join-Path $path_project build
+$path_project_gen		 = Join-Path $path_project gen
+$path_singleheader       = Join-Path $path_root singleheader
+$path_singleheader_build = Join-Path $path_singleheader build
+$path_singleheader_gen	 = Join-Path $path_singleheader gen
+$path_test               = Join-Path $path_root test
+$path_test_build         = Join-Path $path_test build
+$path_gen                = Join-Path $path_test gen
+$path_gen_build          = Join-Path $path_gen  build
+$path_x64				 = Join-Path $path_root x64
 
-if ( Test-Path $path_build ) 
+if ( Test-Path $path_project_build)
 {
-	Remove-Item $path_build -Recurse 
+	Remove-Item $path_project_build -Recurse
+}
+
+if ( Test-Path $path_project_gen )
+{
+	Remove-Item $path_project_gen -Recurse
+}
+
+if ( Test-Path $path_singleheader_build)
+{
+	Remove-Item $path_singleheader_build -Recurse
+}
+
+if ( Test-Path $path_singleheader_gen )
+{
+	Remove-Item $path_singleheader_gen -Recurse
 }
 
 if ( Test-Path $path_test_build )
@@ -20,8 +41,30 @@ if ( Test-Path $path_gen_build )
 	Remove-Item $path_gen_build -Recurse
 }
 
-[string[]] $include = '*.h', '*.hpp', '*.cpp'
-[string[]] $exclude =
+if ( Test-Path $path_x64)
+{
+	Remove-Item $path_x64 -Recurse
+}
+
+# [string[]] $include = 'gen.hpp', 'gen.cpp', 'gen_dep.hpp', 'gen_dep.cpp'
+# [string[]] $exclude =
+
+# $files = Get-ChildItem -Recurse -Path $path_project_gen -Include $include -Exclude $exclude
+
+# if ( $files )
+# {
+# 	Remove-Item $files
+# }
+
+# $files = Get-ChildItem -Recurse -Path $path_singleheader_gen -Include $include -Exclude $exclude
+
+# if ( $files )
+# {
+# 	Remove-Item $files
+# }
+
+$include = '*.h', '*.hpp', '*.cpp'
+$exclude =
 
 $files = Get-ChildItem -Recurse -Path $path_gen -Include $include -Exclude $exclude
 

scripts/genccp.natstepfilter

@@ -24,4 +24,7 @@
 		<Name>gen::Code.*::to_string</Name>
 		<Action>NoStepInto</Action>
 	</Function>
+	<Function>
+		<Name>gen::String::operator .*</Name>
+	</Function>
 </StepFilter>

scripts/gencpp.natvis

@@ -5,6 +5,18 @@
 		<DisplayString>Data:{Data} Proc:{Proc}</DisplayString>
 	</Type>
 
+	<Type Name="gen::Pool">
+		<DisplayString>NumBlocks: {NumBlocks} TotalSize: {TotalSize}</DisplayString>
+		<Expand>
+			<LinkedListItems>
+				<Size>NumBlocks</Size>
+				<HeadPointer>FreeList</HeadPointer>
+				<NextPointer>FreeList</NextPointer>
+				<ValueNode>PhysicalStart</ValueNode>
+			</LinkedListItems>
+		</Expand>
+	</Type>
+
 	<Type Name="gen::Array&lt;*&gt;">
 		<DisplayString>Num:{((Header*)((char*)Data - sizeof(Header)))->Num},
 			Capacity:{((Header*)((char*)Data - sizeof(Header)))->Capacity}</DisplayString>
@@ -70,7 +82,8 @@
 			<Item Name="Content">ast->Content</Item>
 			<Item Name="Body">ast->Body</Item>
 			<Item Name="Parent">ast->Parent</Item>
-			<Item Name="ModuleFlags" Condition="ast->ModuleFlags != ModuleFlag::Invalid">ast->ModuleFlags</Item>
+			<Item Name="ModuleFlags" Condition="ast->ModuleFlags != ModuleFlag::Invalid">
+				ast->ModuleFlags</Item>
 			<Item Name="ArrSpecs" Condition="ast->ArrSpecs[0] &lt; 18">ast->ArrSpecs</Item>
 			<Item Name="Prev">ast->Prev</Item>
 			<Item Name="Next">ast->Next</Item>
@@ -230,6 +243,7 @@
 	<Type Name="gen::AST_OpCast">
 		<DisplayString>{Name} Type: {Type}</DisplayString>
 		<Expand>
+			<Item Name="Specs">Specs</Item>
 			<Item Name="ValueType">ValueType</Item>
 			<Item Name="Body">Body</Item>
 			<Item Name="Parent">Parent</Item>
@@ -538,7 +552,7 @@
 		</Expand>
 	</Type>
 
-	<Type Name="gen::CodeSpecifier">
+	<Type Name="gen::CodeSpecifiers">
 		<DisplayString Condition="ast == nullptr">Null</DisplayString>
 		<DisplayString Condition="ast != nullptr">{ast->Name} {ast->Type}</DisplayString>
 		<Expand>
@@ -665,4 +679,4 @@
 		<DisplayString>Current[ { Arr[Idx] } ] Idx:{ Idx }</DisplayString>
 	</Type>
 
-</AutoVisualizer>
+</AutoVisualizer>

scripts/gencpp.refactor

@@ -19,349 +19,349 @@
 // word, namespace, regex
 
 // Gen Macro namespace
-// namespace GEN_ new_namespace_
+// namespace GEN_, new_namespace_
 
 // ---------- ZPL Macros
 
-// word GEN_ARCH_64_BIT new_name
-// word GEN_ARCH_32_BIT new_name
+// word GEN_ARCH_64_BIT, new_name
+// word GEN_ARCH_32_BIT, new_name
 
-// word GEN_SYSTEM_ANDROID    new_name
-// word GEN_SYSTEM_CYGWIN     new_name
-// word GEN_SYSTEM_EMSCRIPTEN new_name
-// word GEN_SYSTEM_FREEBSD    new_name
-// word GEN_SYSTEM_IOS	      new_name
-// word GEN_SYSTEM_LINUX      new_name
-// word GEN_SYSTEM_MACOS      new_name
-// word GEN_SYSTEM_OPENBSD    new_name
-// word GEN_SYSTEM_OSX        new_name
-// word GEN_SYSTEM_UNIX       new_name
-// word GEN_SYSTEM_WINDOWS    new_name
+// word GEN_SYSTEM_ANDROID,    new_name
+// word GEN_SYSTEM_CYGWIN,     new_name
+// word GEN_SYSTEM_EMSCRIPTEN, new_name
+// word GEN_SYSTEM_FREEBSD,    new_name
+// word GEN_SYSTEM_IOS,	       new_name
+// word GEN_SYSTEM_LINUX,      new_name
+// word GEN_SYSTEM_MACOS,      new_name
+// word GEN_SYSTEM_OPENBSD,    new_name
+// word GEN_SYSTEM_OSX,        new_name
+// word GEN_SYSTEM_UNIX,       new_name
+// word GEN_SYSTEM_WINDOWS,    new_name
 
-// word GEN_COMPILER_CLANG new_name
-// word GEN_COMPILER_GCC   new_name
-// word GEN_COMPILER_MINGW new_name
-// word GEN_COMPILER_MSVC  new_name
+// word GEN_COMPILER_CLANG, new_name
+// word GEN_COMPILER_GCC,   new_name
+// word GEN_COMPILER_MINGW, new_name
+// word GEN_COMPILER_MSVC,  new_name
 
-// word forceinline new_name
-// word neverinline new_name
+// word forceinline, new_name
+// word neverinline, new_name
 
-// word zpl_cast new_name
+// word zpl_cast, new_name
 
-// word global        new_name
-// word internal      new_name
-// word local_persist new_name
+// word global,        new_name
+// word internal,      new_name
+// word local_persist, new_name
 
-// word GEN_DEBUG_TRAP      new_name
-// word GEN_ASSERT          new_name
-// word GEN_ASSERT_MSG      new_name
-// word GEN_ASSERT_NOT_NULL new_name
-// word GEN_PANIC           new_name
+// word GEN_DEBUG_TRAP,      new_name
+// word GEN_ASSERT,          new_name
+// word GEN_ASSERT_MSG,      new_name
+// word GEN_ASSERT_NOT_NULL, new_name
+// word GEN_PANIC,           new_name
 
-// word zero_item  new_name
-// word zero_array new_name
+// word zero_item,  new_name
+// word zero_array, new_name
 
-// word alloc_item  new_name
-// word alloc_array new_name
+// word alloc_item,  new_name
+// word alloc_array, new_name
 
-// word malloc new_name
-// word mfree  new_name
+// word malloc, new_name
+// word mfree,  new_name
 
-// word count_of      new_name
-// word is_between    new_name
-// word min           new_name
-// word size_of       new_name
-// word swap          new_name
+// word count_of,   new_name
+// word is_between, new_name
+// word min,        new_name
+// word size_of,    new_name
+// word swap,       new_name
 
 // ---------- ZPL Types
 
-// word b8   new_name
-// word b16  new_name
-// word b32  new_name
-// word s8   new_name
-// word s16  new_name
-// word s32  new_name
-// word s64  new_name
-// word u8   new_name
-// word u16  new_name
-// word u32  new_name
-// word u64  new_name
-// word uw   new_name
-// word sw   new_name
-// word sptr new_name
-// word uptr new_name
-// word f32  new_name
-// word f64  new_name
+// word b8,   new_name
+// word b16,  new_name
+// word b32,  new_name
+// word s8,   new_name
+// word s16,  new_name
+// word s32,  new_name
+// word s64,  new_name
+// word u8,   new_name
+// word u16,  new_name
+// word u32,  new_name
+// word u64,  new_name
+// word uw,   new_name
+// word sw,   new_name
+// word sptr, new_name
+// word uptr, new_name
+// word f32,  new_name
+// word f64,  new_name
 
-// namespace EAllocator_ new_namespace_
-// namespace EFileMode_  new_namespace_
-// namespace EFileError_ new_namespace_
+// namespace EAllocator_, new_namespace_
+// namespace EFileMode_,  new_namespace_
+// namespace EFileError_, new_namespace_
 
-// word AllocatorInfo    new_name
-// word AllocatorProc    new_name
-// word AllocFlag        new_name
-// word AllocType        new_name
-// word ArrayHeader      new_name
-// word DirEntry         new_name
-// word DirInfo          new_name
-// word DirType          new_name
-// word FileDescriptor   new_name
-// word FileError        new_name
-// word FileInfo         new_name
-// word FileTime         new_name
-// word FileModeFlag     new_name
-// word FileOperations   new_name
-// word FileStandardType new_name
-// word SeekWhenceType   new_name
+// word AllocatorInfo,    new_name
+// word AllocatorProc,    new_name
+// word AllocFlag,        new_name
+// word AllocType,        new_name
+// word ArrayHeader,      new_name
+// word DirEntry,         new_name
+// word DirInfo,          new_name
+// word DirType,          new_name
+// word FileDescriptor,   new_name
+// word FileError,        new_name
+// word FileInfo,         new_name
+// word FileTime,         new_name
+// word FileModeFlag,     new_name
+// word FileOperations,   new_name
+// word FileStandardType, new_name
+// word SeekWhenceType,   new_name
 
 // ---------- ZPL Data
 
-// word default_file_operations new_name
+// word default_file_operations, new_name
 
 // ---------- ZPL Procedures
 
-// word align_forward          new_name
-// word align_fordward_i64     new_name
-// word alloc                  new_name
-// word alloc_align            new_name
-// word assert_handler         new_name
-// word assert_crash           new_name
-// word char_first_occurence   new_name
-// word char_is_alpha          new_name
-// word char_is_alphanumeric   new_name
-// word char_is_digit          new_name
-// word char_is_hex_digit      new_name
-// word char_is_space          new_name
-// word char_to_lower		   new_name
-// word char_to_upper		   new_name
-// word crc32                  new_name
-// word default_resize_align   new_name
-// word digit_to_int		   new_name
-// word file_close  		   new_name
-// word file_get_standard      new_name
-// word file_name              new_name
-// word file_open              new_name
-// word file_open_mode         new_name
-// word file_seek 			   new_name
-// word file_tell 			   new_name
-// word file_write 		       new_name
-// word file_write_at 		   new_name
-// word file_write_at_check    new_name
-// word free                   new_name
-// word free_all               new_name
-// word heap                   new_name
-// word heap_allocator_proc    new_name
-// word heap_stats_check       new_name
-// word heap_stats_alloc_count new_name
-// word heap_stats_init        new_name
-// word heap_stats_used_memory new_name
-// word hex_digit_to_int	   new_name
-// word i64_to_str			   new_name
-// word is_power_of_two        new_name
-// word mem_copy               new_name
-// word mem_move               new_name
-// word mem_set                new_name
-// word pointer_add            new_name
-// word mem_copy               new_name
-// word mem_find               new_name
-// word mem_move               new_name
-// word mem_set                new_name
-// word resize                 new_name
-// word resize_align           new_name
-// word process_exit           new_name
-// word str_compare            new_name
-// word str_copy               new_name
-// word str_copy_nulpad 	   new_name
-// word str_fmt_buf            new_name
-// word str_fmt_buf_va	       new_name
-// word str_fmt_file_va        new_name
-// word str_fmt_out_va         new_name
-// word str_fmt_out_err        new_name
-// word str_fmt_out_err_va	   new_name
-// word str_fmt_va             new_name
-// word str_len                new_name
-// word str_reverse 		   new_name
-// word str_to_i64 		       new_name
-// word str_to_lower 		   new_name
-// word str_to_upper  	       new_name
-// word u64_to_str 		       new_name
-// word zero_size              new_name
+// word align_forward,          new_name
+// word align_fordward_i64,     new_name
+// word alloc,                  new_name
+// word alloc_align,            new_name
+// word assert_handler,         new_name
+// word assert_crash,           new_name
+// word char_first_occurence,   new_name
+// word char_is_alpha,          new_name
+// word char_is_alphanumeric,   new_name
+// word char_is_digit,          new_name
+// word char_is_hex_digit,      new_name
+// word char_is_space,          new_name
+// word char_to_lower,		    new_name
+// word char_to_upper,		    new_name
+// word crc32,                  new_name
+// word default_resize_align,   new_name
+// word digit_to_int,		    new_name
+// word file_close,  		    new_name
+// word file_get_standard,      new_name
+// word file_name,              new_name
+// word file_open,              new_name
+// word file_open_mode,         new_name
+// word file_seek, 			    new_name
+// word file_tell, 			    new_name
+// word file_write, 		    new_name
+// word file_write_at, 		    new_name
+// word file_write_at_check,    new_name
+// word free,                   new_name
+// word free_all,               new_name
+// word heap,                   new_name
+// word heap_allocator_proc,    new_name
+// word heap_stats_check,       new_name
+// word heap_stats_alloc_count, new_name
+// word heap_stats_init,        new_name
+// word heap_stats_used_memory, new_name
+// word hex_digit_to_int,	    new_name
+// word i64_to_str,			    new_name
+// word is_power_of_two,        new_name
+// word mem_copy,               new_name
+// word mem_move,               new_name
+// word mem_set,                new_name
+// word pointer_add,            new_name
+// word mem_copy,               new_name
+// word mem_find,               new_name
+// word mem_move,               new_name
+// word mem_set,                new_name
+// word resize,                 new_name
+// word resize_align,           new_name
+// word process_exit,           new_name
+// word str_compare,            new_name
+// word str_copy,               new_name
+// word str_copy_nulpad, 	    new_name
+// word str_fmt_buf,            new_name
+// word str_fmt_buf_va,	        new_name
+// word str_fmt_file_va,        new_name
+// word str_fmt_out_va,         new_name
+// word str_fmt_out_err,        new_name
+// word str_fmt_out_err_va,	    new_name
+// word str_fmt_va,             new_name
+// word str_len,                new_name
+// word str_reverse, 		    new_name
+// word str_to_i64, 		    new_name
+// word str_to_lower, 		    new_name
+// word str_to_upper,  	        new_name
+// word u64_to_str, 		    new_name
+// word zero_size,              new_name
 
 // ---------- gencpp Macros
 
-// word bit               new_name
-// word bitfield_is_equal new_name
+// word bit,               new_name
+// word bitfield_is_equal, new_name
 
-// word ccast new_name
-// word pcast new_name
-// word rcast new_name
-// word scast new_name
+// word ccast, new_name
+// word pcast, new_name
+// word rcast, new_name
+// word scast, new_name
 
-// word do_once       new_name
-// word do_once_start new_name
-// word do_once_end   new_name
-// word num_args      new_name
-// word num_args_impl new_name
-// word stringize     new_name
-// word stringize_va  new_name
-// word txt_StrC      new_name
+// word do_once,       new_name
+// word do_once_start, new_name
+// word do_once_end,   new_name
+// word num_args,      new_name
+// word num_args_impl, new_name
+// word stringize,     new_name
+// word stringize_va,  new_name
+// word txt_StrC,      new_name
 
 // ------------ gencpp common
 
-// word Arena         new_name
-// word Array         new_name
-// word HashTable     new_name
-// word Pool          new_name
-// word StrC          new_name
-// word String        new_name
+// word Arena,     new_name
+// word Array,     new_name
+// word HashTable, new_name
+// word Pool,      new_name
+// word StrC,      new_name
+// word String,    new_name
 
-// word log_fmt  new_name
-// word fatal    new_name
-// word to_str   new_name
-// word to_StrC  new_name
-// word to_type  new_name
+// word log_fmt,  new_name
+// word fatal,    new_name
+// word to_str,   new_name
+// word to_StrC,  new_name
+// word to_type,  new_name
 
 // ------------ gencpp Types & Constants
 
-// word LogFailType new_name
-// word log_failure new_name
+// word LogFailType, new_name
+// word log_failure, new_name
 
-// word AccessSpec     new_name
-// word ECode          new_name
-// word EnumClass      new_name
-// word EnumRegular    new_name
-// word EnumT          new_name
-// word EOperator      new_name
-// word ESpecifier     new_name
-// word OperatorT      new_name
-// word ModuleFlag     new_name
-// word SpecifierT     new_name
-// word StringCached new_name
-// word StringTable  new_name
-// word UsingRegular   new_name
-// word UsingNamespace new_name
+// word AccessSpec,     new_name
+// word ECode,          new_name
+// word EnumClass,      new_name
+// word EnumRegular,    new_name
+// word EnumT,          new_name
+// word EOperator,      new_name
+// word ESpecifier,     new_name
+// word OperatorT,      new_name
+// word ModuleFlag,     new_name
+// word SpecifierT,     new_name
+// word StringCached,   new_name
+// word StringTable,    new_name
+// word UsingRegular,   new_name
+// word UsingNamespace, new_name
 
-// gencpp Data
+// ------------ gencpp Data
 
-// word API_Export   new_name
-// word API_Import   new_name
-// word AST_POD_Size new_name
-// word AST          new_name
-// word AST_POD      new_name
-// word Code         new_name
-// word Code_POD     new_name
-// word Keyword      new_name
-// word NoCode       new_name
+// word API_Export,   new_name
+// word API_Import,   new_name
+// word AST_POD_Size, new_name
+// word AST,          new_name
+// word AST_POD,      new_name
+// word Code,         new_name
+// word Code_POD,     new_name
+// word Keyword,      new_name
+// word NoCode,       new_name
 
-// gencpp API
+// ------------ gencpp API
 
-// word init                             new_name
-// word deinit                           new_name
+// word init,                             new_name
+// word deinit,                           new_name
 
-// word get_cached_string                new_name
-// word make_code                        new_name
-// word make_code_entries                new_name
+// word get_cached_string,                new_name
+// word make_code,                        new_name
+// word make_code_entries,                new_name
 
-// word set_allocator_data_arrays        new_name
-// word set_allocator_code_pool          new_name
-// word set_allocator_code_entries_arena new_name
-// word set_allocator_string_arena       new_name
-// word set_allocator_string_table       new_name
-// word set_allocator_type_table         new_name
+// word set_allocator_data_arrays,        new_name
+// word set_allocator_code_pool,          new_name
+// word set_allocator_code_entries_arena, new_name
+// word set_allocator_string_arena,       new_name
+// word set_allocator_string_table,       new_name
+// word set_allocator_type_table,         new_name
 
-// upfront constructor namespace
+// ------------ upfront constructor namespace
 // namespace def_ new_namespace_
 
-// upfront constructor individual
+// ------------ upfront constructor individual
 
-// word def_attributes      new_name
-// word def_comment         new_name
-// word def_class           new_name
-// word def_enum            new_name
-// word def_execution       new_name
-// word def_extern_link     new_name
-// word def_friend          new_name
-// word def_function        new_name
-// word def_include         new_name
-// word def_module          new_name
-// word def_namespace       new_name
-// word def_operator        new_name
-// word def_param           new_name
-// word def_specifier       new_name
-// word def_struct          new_name
-// word def_template        new_name
-// word def_type            new_name
-// word def_typedef         new_name
-// word def_union           new_name
-// word def_using           new_name
-// word def_using_namespace new_name
-// word def_variable        new_name
+// word def_attributes,      new_name
+// word def_comment,         new_name
+// word def_class,           new_name
+// word def_enum,            new_name
+// word def_execution,       new_name
+// word def_extern_link,     new_name
+// word def_friend,          new_name
+// word def_function,        new_name
+// word def_include,         new_name
+// word def_module,          new_name
+// word def_namespace,       new_name
+// word def_operator,        new_name
+// word def_param,           new_name
+// word def_specifier,       new_name
+// word def_struct,          new_name
+// word def_template,        new_name
+// word def_type,            new_name
+// word def_typedef,         new_name
+// word def_union,           new_name
+// word def_using,           new_name
+// word def_using_namespace, new_name
+// word def_variable,        new_name
 
-// word def_body             new_name
-// word def_class_body       new_name
-// word def_enum_body        new_name
-// word def_export_body      new_name
-// word def_extern_link_body new_name
-// word def_function_body    new_name
-// word def_global_body      new_name
-// word def_namespace_body   new_name
-// word def_params           new_name
-// word def_specifiers       new_name
-// word def_struct_body      new_name
-// word def_union_body       new_name
+// word def_body,             new_name
+// word def_class_body,       new_name
+// word def_enum_body,        new_name
+// word def_export_body,      new_name
+// word def_extern_link_body, new_name
+// word def_function_body,    new_name
+// word def_global_body,      new_name
+// word def_namespace_body,   new_name
+// word def_params,           new_name
+// word def_specifiers,       new_name
+// word def_struct_body,      new_name
+// word def_union_body,       new_name
 
-// parse constructor namespace
-// namespace parse_ new_namespace_
+// ------------ parse constructor namespace
+// namespace parse_, new_namespace_
 
-// parse constructor individual
+// ------------ parse constructor individual
 
-// word parse_class       new_name
-// word parse_enum        new_name
-// word parse_export_body new_name
-// word parse_extern_link new_name
-// word parse_friend      new_name
-// word parse_function    new_name
-// word parse_global_body new_name
-// word parse_namespace   new_name
-// word parse_operator    new_name
-// word parse_struct      new_name
-// word parse_template    new_name
-// word parse_type        new_name
-// word parse_typedef     new_name
-// word parse_union       new_name
-// word parse_using       new_name
-// word parse_variable    new_name
+// word parse_class,       new_name
+// word parse_enum,        new_name
+// word parse_export_body, new_name
+// word parse_extern_link, new_name
+// word parse_friend,      new_name
+// word parse_function,    new_name
+// word parse_global_body, new_name
+// word parse_namespace,   new_name
+// word parse_operator,    new_name
+// word parse_struct,      new_name
+// word parse_template,    new_name
+// word parse_type,        new_name
+// word parse_typedef,     new_name
+// word parse_union,       new_name
+// word parse_using,       new_name
+// word parse_variable,    new_name
 
-// untyped constructor namespace
-// namespace untyped_ new_namespace_
+// ------------ untyped constructor namespace
+// namespace untyped_, new_namespace_
 
-// untyped constructor individual
+// ------------ untyped constructor individual
 
-// word token_fmt_impl    new_name
-// word token_fmt_va      new_name
-// word untyped_str       new_name
-// word untyped_fmt       new_name
-// word untyped_token_fmt new_name
+// word token_fmt_impl,    new_name
+// word token_fmt_va,      new_name
+// word untyped_str,       new_name
+// word untyped_fmt,       new_name
+// word untyped_token_fmt, new_name
 
-// File Handling
+// ------------ File Handling
 
-// word Builder new_name
-// word Editor  new_name
-// word Scanner new_name
+// word Builder, new_name
+// word Editor,  new_name
+// word Scanner, new_name
 
-// gencpp macros
+// ------------ gencpp macros
 
-// word gen_main     new_name
-// word gen_time     new_name
+// word gen_main,     new_name
+// word GEN_TIME,     new_name
 
-// word __           new_name
-// word code         new_name
-// word name         new_name
-// word args         new_name
-// word token_fmt    new_name
+// word __,           new_name
+// word code,         new_name
+// word name,         new_name
+// word args,         new_name
+// word token_fmt,    new_name
 
-// Type AST namespace
-// namespace t_ new_namespace_
+// ------------ Type AST namespace
+// namespace t_, new_namespace_
 
-// Specifier AST namespace
-// namespace spec_ new_namespace_
+// ------------ Specifier AST namespace
+// namespace spec_, new_namespace_

scripts/get_sources.ps1

@@ -1,12 +0,0 @@
-[string[]] $include = 'gen.cpp' #'*.c', '*.cc', '*.cpp'
-# [string[]] $exclude =
-
-$path_root = git rev-parse --show-toplevel
-$path_proj = Join-Path $path_root project
-
-$files = Get-ChildItem -Recurse -Path $path_proj -Include $include -Exclude $exclude
-
-$sources = $files | Select-Object -ExpandProperty FullName | Resolve-Path -Relative
-$sources = $sources.Replace( '\', '/' )
-
-return $sources

scripts/msvc/build_msvc.ps1

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

scripts/msvc/devshell.ps1

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

scripts/refactor.ps1

@@ -0,0 +1,53 @@
+[string] $format = $false
+
+foreach ( $arg in $args )
+{
+	if ( $arg -eq "format" )
+	{
+		$format = $true
+	}
+}
+
+[string[]] $include = 'gen.*.hpp', 'gen.*.cpp', 'gen.hpp', 'gen.cpp'
+[string[]] $exclude
+
+$path_root               = git rev-parse --show-toplevel
+$path_project            = Join-Path $path_root project
+$path_scripts            = Join-Path $path_root scripts
+$path_singlheader        = Join-Path $path_root singleheader
+$path_singleheader_comp  = Join-Path $path_singlheader components
+
+$file_spec = Join-Path $path_scripts gencpp.refactor
+
+# Gather the files to be formatted.
+$targetFiles = @()
+$targetFiles += Get-ChildItem -Recurse -Path $path_project           -Include $include -Exclude $exclude | Select-Object -ExpandProperty FullName
+$targetFiles += Get-ChildItem -Recurse -Path $path_singleheader_comp -Include $include -Exclude $exclude | Select-Object -ExpandProperty FullName
+
+# Format the files.
+$formatParams = @(
+    '-i'                          # In-place
+    '-style=file:./.clang-format' # Search for a .clang-format file in the parent directory of the source file.
+    '-verbose'
+)
+
+write-host "Beginning refactor...`n"
+
+$refactorParams = @(
+    # "-debug",
+    "-num=$($targetFiles.Count)"
+    "-src=$($targetFiles)",
+    "-spec=$($file_spec)"
+)
+
+& refactor $refactorParams
+
+Write-Host "`nRefactoring complete`n`n"
+
+if ( $format -eq $true ) {
+	Write-Host "Beginning format...`n"
+
+	& clang-format $formatParams $targetFiles
+
+	Write-Host "`nFormatting complete"
+}

scripts/singleheader.ci.ps1

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

scripts/singleheader.ps1

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

scripts/test.gen_build.ci.ps1

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

scripts/test.gen_build.ps1

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

scripts/test.gen_run.ps1

@@ -48,14 +48,16 @@ Push-location $path_gen
 # Run meta-program
 	$gencpp = Join-Path $path_gen_build gencpp.exe
 
-	Write-Host `nGenerating files -- Parsed...
+	Write-Host `nRunning tests...
 	& $gencpp
 
 # Format generated files
+	$path_clang_format = Join-Path $path_scripts .clang-format
+
 	Write-Host `nBeginning format...
 	$formatParams = @(
 		'-i'          # In-place
-		'-style=file' # Search for a .clang-format file in the parent directory of the source file.
+		"-style=file:$path_clang_format" # Search for a .clang-format file in the parent directory of the source file.
 		'-verbose'
 	)
 

singleheader/Readme.md

@@ -0,0 +1,6 @@
+# Singleheader
+
+`gen.singleheader.cpp` with its own `meson.build` generates the library as a single header `gen.hpp`.
+Following the same convention seen in the gb, stb, and zpl libraries.
+
+( Currently WIP )

singleheader/components/header_start.hpp

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

singleheader/gen.singleheader.cpp

@@ -0,0 +1,212 @@
+#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
+#define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#include "gen.cpp"
+#include "file_processors/scanner.hpp"
+#include "helpers/helper.hpp"
+
+using namespace gen;
+
+bool namespace_by_default = true;
+
+constexpr StrC nspace_default = txt_StrC(R"(
+#if defined(GEN_DONT_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
+#	define GEN_NS_BEGIN
+#	define GEN_NS_END
+#elif ! defined(GEN_NS_BEGIN)
+#  define GEN_NS_BEGIN namespace gen {
+#  define GEN_NS_END   }
+#endif
+)");
+
+constexpr StrC nspace_non_default = txt_StrC(R"(
+#if ! defined(GEN_USE_NAMESPACE) && ! defined(GEN_NS_BEGIN)
+#	define GEN_NS_BEGIN
+#	define GEN_NS_END
+#elif ! defined(GEN_NS_BEGIN)
+#  define GEN_NS_BEGIN namespace gen {
+#  define GEN_NS_END   }
+#endif
+)");
+
+constexpr StrC implementation_guard_start = txt_StrC(R"(
+#pragma region GENCPP IMPLEMENTATION GUARD
+#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
+#	define GEN_IMPLEMENTED
+)");
+
+constexpr StrC implementation_guard_end = txt_StrC(R"(
+#endif
+#pragma endregion GENCPP IMPLEMENTATION GUARD
+)");
+
+constexpr StrC roll_own_dependencies_guard_start = txt_StrC(R"(
+//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
+// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
+#ifndef GEN_ROLL_OWN_DEPENDENCIES
+
+)");
+
+constexpr StrC roll_own_dependencies_guard_end = txt_StrC(R"(
+// GEN_ROLL_OWN_DEPENDENCIES
+#endif
+
+)");
+
+int gen_main()
+{
+	gen::init();
+
+#define project_dir "../project/"
+
+	Code push_ignores = scan_file( project_dir "helpers/push_ignores.inline.hpp" );
+	Code pop_ignores  = scan_file( project_dir "helpers/pop_ignores.inline.hpp" );
+
+	Code header_start = scan_file( "components/header_start.hpp" );
+	Code nspace_macro = untyped_str( namespace_by_default ? nspace_default : nspace_non_default );
+
+	Builder
+	header;
+	header.open( "gen/gen.hpp" );
+	header.print( push_ignores );
+
+	header.print_fmt("#pragma once\n\n");
+
+	// Headers
+	{
+		header.print( header_start );
+		header.print( nspace_macro );
+
+		{
+			header.print_fmt( roll_own_dependencies_guard_start );
+
+			Code header_start  = scan_file( project_dir "dependencies/header_start.hpp" );
+			Code macros        = scan_file( project_dir "dependencies/macros.hpp" );
+			Code basic_types   = scan_file( project_dir "dependencies/basic_types.hpp" );
+			Code debug         = scan_file( project_dir "dependencies/debug.hpp" );
+			Code memory	       = scan_file( project_dir "dependencies/memory.hpp" );
+			Code string_ops    = scan_file( project_dir "dependencies/string_ops.hpp" );
+			Code printing      = scan_file( project_dir "dependencies/printing.hpp" );
+			Code containers    = scan_file( project_dir "dependencies/containers.hpp" );
+			Code hashing 	   = scan_file( project_dir "dependencies/hashing.hpp" );
+			Code string        = scan_file( project_dir "dependencies/string.hpp" );
+			Code file_handling = scan_file( project_dir "dependencies/file_handling.hpp" );
+			Code parsing       = scan_file( project_dir "dependencies/parsing.hpp" );
+			Code timing        = scan_file( project_dir "dependencies/timing.hpp" );
+
+			header.print( header_start );
+			header.print_fmt( "GEN_NS_BEGIN\n\n" );
+			header.print( macros );
+			header.print( basic_types );
+			header.print( debug );
+			header.print( memory );
+			header.print( string_ops );
+			header.print( printing );
+			header.print( containers );
+			header.print( hashing );
+			header.print( string );
+			header.print( file_handling );
+			header.print( parsing );
+			header.print( timing );
+			header.print_fmt( "GEN_NS_END\n" );
+
+			header.print_fmt( roll_own_dependencies_guard_end );
+		}
+
+		Code types        = scan_file( project_dir "components/types.hpp" );
+		Code data_structs = scan_file( project_dir "components/data_structures.hpp" );
+		Code interface    = scan_file( project_dir "components/interface.hpp" );
+		Code header_end   = scan_file( project_dir "components/header_end.hpp" );
+
+		CodeBody ecode      = gen_ecode( project_dir "enums/ECode.csv" );
+		CodeBody eoperator  = gen_eoperator( project_dir "enums/EOperator.csv" );
+		CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
+
+		Code builder = scan_file( project_dir "file_processors/builder.hpp" );
+
+		header.print_fmt( "GEN_NS_BEGIN\n\n" );
+
+		header.print_fmt("#pragma region Types\n\n");
+		header.print( types );
+		header.print( ecode );
+		header.print( eoperator );
+		header.print( especifier );
+		header.print_fmt("#pragma endregion Types\n\n");
+
+		header.print( data_structs );
+		header.print( interface );
+		header.print( header_end );
+		header.print( builder );
+		header.print_fmt( "GEN_NS_END\n" );
+	}
+
+	// Implementation
+	{
+		header.print_fmt( "%s\n", (char const*) implementation_guard_start );
+		{
+			header.print_fmt( roll_own_dependencies_guard_start );
+
+			Code impl_start = scan_file( project_dir "dependencies/impl_start.cpp" );
+			Code debug      = scan_file( project_dir "dependencies/debug.cpp" );
+			Code string_ops = scan_file( project_dir "dependencies/string_ops.cpp" );
+			Code printing   = scan_file( project_dir "dependencies/printing.cpp" );
+			Code memory     = scan_file( project_dir "dependencies/memory.cpp" );
+			Code parsing    = scan_file( project_dir "dependencies/parsing.cpp" );
+			Code hashing    = scan_file( project_dir "dependencies/hashing.cpp" );
+			Code string     = scan_file( project_dir "dependencies/string.cpp" );
+			Code timing     = scan_file( project_dir "dependencies/timing.cpp" );
+
+			Code file_handling = scan_file( project_dir "dependencies/file_handling.cpp" );
+
+			header.print_fmt( "GEN_NS_BEGIN\n\n");
+			header.print( impl_start );
+			header.print( debug );
+			header.print( string_ops );
+			header.print( printing );
+			header.print( memory );
+			header.print( parsing );
+			header.print( hashing );
+			header.print( string );
+			header.print( timing );
+
+			header.print( file_handling );
+
+			header.print_fmt( "GEN_NS_END\n");
+
+			header.print_fmt( roll_own_dependencies_guard_end );
+		}
+
+		Code data 	         = scan_file( project_dir "components/static_data.cpp" );
+		Code ast_case_macros = scan_file( project_dir "components/ast_case_macros.cpp" );
+		Code ast             = scan_file( project_dir "components/ast.cpp" );
+		Code interface       = scan_file( project_dir "components/interface.cpp" );
+		Code upfront         = scan_file( project_dir "components/interface.upfront.cpp" );
+		Code parsing         = scan_file( project_dir "components/interface.parsing.cpp" );
+		Code untyped         = scan_file( project_dir "components/untyped.cpp" );
+
+		CodeBody etoktype = gen_etoktype( project_dir "enums/ETokType.csv", project_dir "enums/AttributeTokens.csv" );
+		CodeNamespace parser_nspace = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
+
+		Code builder = scan_file( project_dir "file_processors/builder.cpp" );
+
+		header.print_fmt( "GEN_NS_BEGIN\n\n");
+		header.print( data );
+		header.print( ast_case_macros );
+		header.print( ast );
+		header.print( interface );
+		header.print( upfront );
+		header.print( parser_nspace );
+		header.print( parsing );
+		header.print( untyped );
+			header.print( builder );
+		header.print_fmt( "GEN_NS_END\n");
+
+		header.print_fmt( "%s\n", (char const*) implementation_guard_end );
+	}
+
+	header.print( pop_ignores );
+	header.write();
+
+	gen::deinit();
+	return 0;
+}

singleheader/gen/Readme.md

@@ -1,5 +0,0 @@
-# Singleheader generator
-
-This will require the scanner to be implemented before it can be done properly.
-
-

singleheader/meson.build

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

test/DummyInclude.hpp

@@ -1 +0,0 @@
-// Only for gen testing.

test/Readme.md

@@ -2,10 +2,10 @@
 
 The following tests focus on attempting to generate some math, containers, and the memory module of zpl.
 
-Not all the files are written how I would practically use the librarry, the containers for example would
+Not all the files are written how I would practically use the library, the containers for example would
 be better on in c++ as templates, since the templates they generate are trivial symbols to inspect or debug.
 
-An exmaple of a non-trival generation is a container for elements with SOA or AOS policy for layout.
+An example of a non-trivial generation is a container for elements with SOA or AOS policy for layout.
 (If a unified element syntax is desired)
 
 The test is divided between two major sets of tests: Parsed and Upfront.

test/SOA.cpp

@@ -1,9 +1,8 @@
-#pragma once
-
-#ifdef gen_time
-#define GEN_FEATURE_PARSING
+#if GEN_TIME
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#define GEN_BENCHMARK
 #include "gen.hpp"
 using namespace gen;
 
@@ -91,7 +90,7 @@ Code gen_SOA( CodeStruct struct_def, s32 num_entries = 0 )
 			}
 		));
 
-		String content = String::make( Memory::GlobalAllocator, "return\n{\n" );
+		String content = String::make( GlobalAllocator, "return\n{\n" );
 
 		for ( CodeVar member : vars )
 		{
@@ -114,4 +113,33 @@ Code gen_SOA( CodeStruct struct_def, s32 num_entries = 0 )
 
 	return soa;
 }
+
+void check_SOA()
+{
+	log_fmt("\ncheck_SOA:");
+	gen::init();
+	Builder soa_test; soa_test.open( "SOA.gen.hpp" );
+
+	soa_test.print( parse_using( code(
+		using u16 = unsigned short;
+	)));
+	soa_test.print( def_include( txt_StrC("gen.hpp")));
+	soa_test.print( def_using_namespace( name(gen) ) );
+
+	soa_test.print( gen_SOA(
+		parse_struct( code(
+			struct TestStruct
+			{
+				u8  A;
+				u16 B;
+				u32 C;
+				u64 D;
+			};
+		))
+	));
+
+	soa_test.write();
+	gen::deinit();
+	log_fmt(" passed!\n");
+}
 #endif

test/gen/meson.build

@@ -22,6 +22,6 @@ endif
   # add_project_arguments('-E', language : ['c', 'cpp'])
   # add_global_arguments( '-E', language : ['cpp'])
 
-add_project_arguments('-Dgen_time', language : ['c', 'cpp'])
+add_project_arguments('-DGEN_TIME', language : ['c', 'cpp'])
 
 executable( 'gencpp', sources, include_directories : includes )

test/parsed/Array.Parsed.hpp

@@ -1,9 +1,10 @@
 #pragma once
 
-#if gen_time
-#define GEN_FEATURE_PARSING
+#if GEN_TIME
 #define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 #define GEN_ENFORCE_STRONG_CODE_TYPES
+#define GEN_EXPOSE_BACKEND
+#define GEN_BENCHMARK
 #include "gen.hpp"
 
 using namespace gen;
@@ -228,7 +229,7 @@ Array<GenArrayRequest> GenArrayRequests;
 void gen__array_request( StrC type, StrC dep = {} )
 {
 	do_once_start
-		GenArrayRequests = Array<GenArrayRequest>::init( Memory::GlobalAllocator );
+		GenArrayRequests = Array<GenArrayRequest>::init( GlobalAllocator );
 	do_once_end
 
 	// Make sure we don't already have a request for the type.