Need cstdlib for systems calls in generator files. update to package_release.ps1

They don't really work great right now...

.gitignore

@@ -28,3 +28,6 @@ release/**
 **/Unreal/*.cpp
 ! **/Unreal/validate.unreal.cpp
 project/auxillary/vis_ast/dependencies/temp
+test/gen/original
+singleheader/gen/scratch.hpp
+test/gen/scratch.cpp

.vscode/bookmarks.json

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

.vscode/launch.json

@@ -41,6 +41,15 @@
 			"cwd": "${workspaceFolder}/singleheader/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
 		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug unreal vsdbg",
+			"program": "${workspaceFolder}/unreal_engine/build/unreal.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/unreal_engine/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
 		{
 			"type": "cppvsdbg",
 			"request": "launch",
@@ -49,6 +58,15 @@
 			"args": [],
 			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/temp/raylib-master/src/",
 			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug VIS AST",
+			"program": "${workspaceFolder}/project/auxillary/vis_ast/binaries/vis_ast.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/project/auxillary/vis_ast/binaries/",
+			"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
 		}
 	]
 }

.vscode/settings.json

@@ -30,7 +30,14 @@
 		"list": "cpp",
 		"xhash": "cpp",
 		"glfw3.h": "c",
-		"stdbool.h": "c"
+		"stdbool.h": "c",
+		"objbase.h": "c",
+		"mmreg.h": "c",
+		"mmsystem.h": "c",
+		"propidl.h": "c",
+		"android_native_app_glue.h": "c",
+		"raylib.h": "c",
+		"*.m": "cpp"
 	},
 	"C_Cpp.intelliSenseEngineFallback": "disabled",
 	"mesonbuild.configureOnOpen": true,
@@ -42,5 +49,7 @@
 		"**/.vscode": true,
 		"**/.vs": true,
 		"**/sanity.gen.hpp": true
-	}
+	},
+	"autoHide.autoHidePanel": false,
+	"autoHide.autoHideSideBar": false
 }

Readme.md

@@ -10,7 +10,9 @@ Its not meant to be a black box metaprogramming utility, it should be easy to in
 
 ## Notes
 
-**On Partial Hiatus: Working on handmade hero for now. Only fixes will be pushed as I come across them until I get what I want done from the series**
+**On Partial Hiatus: Life has got me tackling other issues..**  
+I will be passively updating the library with bug fixes and minor improvements as I use it for my personal projects.  
+There won't be any major reworks or features to this thing for a while.
 
 This project is still in development (very much an alpha state), so expect bugs and missing features.  
 See [issues](https://github.com/Ed94/gencpp/issues) for a list of known bugs or todos.
@@ -65,7 +67,7 @@ Example using each construction interface:
 Validation and construction through a functional interface.
 
 ```cpp
-Code t_uw           = def_type( name(uw) );
+Code t_uw           = def_type( name(usize) );
 Code t_allocator    = def_type( name(allocator) );
 Code t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
 
@@ -88,8 +90,8 @@ Validation through ast construction.
 Code header = parse_struct( code(
     struct ArrayHeader
     {
-        uw        Num;
-        uw        Capacity;
+        usize        Num;
+        usize        Capacity;
         allocator Allocator;
     };
 ));
@@ -104,8 +106,8 @@ No validation, just glorified text injection.
 Code header = code_str(
     struct ArrayHeader
     {
-        uw        Num;
-        uw        Capacity;
+        usize        Num;
+        usize        Capacity;
         allocator Allocator;
     };
 );
@@ -121,8 +123,8 @@ All three constrcuton interfaces will generate the following C code:
 ```cpp
 struct ArrayHeader
 {
-    uw        Num;
-    uw        Capacity;
+    usize        Num;
+    usize        Capacity;
     allocator Allocator;
 };
 ```

docs/AST_Design.md

@@ -1,11 +1,3 @@
-# Forward
-
-Was never satisfied with how I did the wrap of the management of the AST.  
-For C++, the current design may be as good as it gets for the limitations of the langauge.
-
-I'll at least try in this issue to brainstorm something simpiler without losing ergonomics.  
-This will also be a good place to document the current design.
-
 ## Current Design
 
 `AST` is the actual managed node object for the library.  
@@ -22,10 +14,8 @@ The simpliest being just a type alias.
 using Code = AST*;
 ```
 
-This is what the genc library would have to use due to its constraints of a langauge.
-Anything else and it would either be an unergonomic mess of struct wrapping with a mess of macros & procedures to interface with it.
-
-Further, to provide intuitive filters on the AST, there are AST types (covered in [AST_Types.md](AST_Types.md)).
+This is what the genc library would have to use due to its constraints of a langauge.  
+The actual content per type of AST is covered within [AST_Types.md](AST_Types.md).
 
 These are pure PODS that just have the lay members relevant to the type of AST node they represent.  
 Each of them has a Code type alias specific to it.
@@ -35,3 +25,20 @@ Again, the simpliest case for these would be a type alias.
 ```cpp
 using struct AST_Typedef CodeTypedef;
 ```
+
+As of November 21st, 2023, the AST has had a strict layout for how its content is laid out.  
+This will be abandoned during its redesign that will occur starting with support for statments & expressions for either execution and type declarations.  
+Having a strict layout is too resctrictive vs allowing each AST type to have maximum control over the layout.
+
+The redesign will occur after the following todos are addressed:
+
+* [Improvements Lexer & Token struct#27](https://github.com/Ed94/gencpp/issues/27)
+* [Generalize AST Flags to a single 4-byte flag#42](https://github.com/Ed94/gencpp/issues/42)
+* [AST-Code Object Redesign.#38](https://github.com/Ed94/gencpp/issues/38)
+* [Code-AST Documentation#40](https://github.com/Ed94/gencpp/issues/40)
+* [AST::debug_str() improvements#33](https://github.com/Ed94/gencpp/issues/33)
+* [AST::is_equal implemented and works with singleheader-test#31](https://github.com/Ed94/gencpp/issues/31)
+* [Parser : Add ability to have a parse failure and continue with errors recorded.#35](https://github.com/Ed94/gencpp/issues/35)
+* [Scanner : Add CodeFile#29](https://github.com/Ed94/gencpp/issues/29)
+* [Auxiliary : AST visual debugger#36](https://github.com/Ed94/gencpp/issues/36)
+

docs/AST_Types.md

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

docs/Parser_Algo.md

@@ -1,40 +1,51 @@
 # Parser's Algorithim
 
-gencpp uses a hand-written recursive descent parser. Both the lexer and parser handle a full C/C++ file in a single pass.
+gencpp uses a hand-written recursive descent parser. Both the lexer and parser currently handle a full C/C++ file in a single pass.
 
 ## Notable implementation background
 
 ### Lexer
 
 The lex procedure does the lexical pass of content provided as a `StrC` type.
-The tokens are stored (for now) in `gen::Parser::Tokens`.
+The tokens are stored (for now) in `gen::parser::Tokens`.
 
 Fields:
+
 ```cpp
 Array<Token> Arr;
 s32          Idx;
 ```
 
-
 What token types are supported can be found in [ETokType.csv](../project/enums/ETokType.csv) you can also find the token types in [ETokType.h](../project/components/gen/etoktype.cpp) , which is the generated enum from the csv file.
 
-Tokens are defined with the struct `gen::Parser::Token`:
+Tokens are defined with the struct `gen::parser::Token`:
 
 Fields:
+
 ```cpp
 char const* Text;
 sptr        Length;
 TokType     Type;
 s32         Line;
 s32         Column;
-bool 	    IsAssign;
+u32         Flags;
 ```
 
-`IsAssign` is a flag that is set when the token is an assignment operator. Which is used for various purposes:
+Flags is a bitfield made up of TokFlags (Token Flags):
 
-* Using statment assignment
-* Parameter argument default value assignment
-* Variable declaration initialization assignment
+* `TF_Operator` : Any operator token used in expressions
+* `TF_Assign`
+  * Using statment assignment
+  * Parameter argument default value assignment
+  * Variable declaration initialization assignment
+* `TF_Preprocess` : Related to a preprocessing directive
+* `TF_Preprocess_Cond` : A preprocess conditional
+* `TF_Attribute` : An attribute token
+* `TF_AccessSpecifier` : An accesor operation token
+* `TF_Specifier` : One of the specifier tokens
+* `TF_EndDefinition` : Can be interpreted as an end definition for a scope.
+* `TF_Formatting` : Considered a part of the formatting
+* `TF_Literal` : Anything considered a literal by C++.
 
 I plan to replace IsAssign with a general flags field and properly keep track of all operator types instead of abstracting it away to `ETokType::Operator`.
 
@@ -53,12 +64,12 @@ Traversing the tokens is done with the following interface macros:
 
 ### Parser
 
-The parser has a limited user interface, only specific types of definitions or statements are expected to be provided by the user directly when using to construct an AST dynamically (See SOA for example). It however does attempt to provide capability to parse a full C/C++ from production codebases. 
+The parser has a limited user interface, only specific types of definitions or statements are expected to be provided by the user directly when using to construct an AST dynamically (See SOA for example). It however does attempt to provide capability to parse a full C/C++ from production codebases.
 
 Each public user interface procedure has the following format:
 
 ```cpp
-CodeStruct parse_<definition type>( StrC def )
+<code type> parse_<definition type>( StrC def )
 {
     check_parse_args( def );
     using namespace Parser;
@@ -76,14 +87,616 @@ The most top-level parsing procedure used for C/C++ file parsing is `parse_globa
 
 It uses a helper procedure called `parse_global_nspace`.
 
-Each internal procedure will be 
+Each internal procedure will have the following format:
 
-## parse_global_nspace
+```cpp
+internal
+<code type> parse_<definition_type>( <empty or contextual params> )
+{
+    push_scope();
 
-1. Make sure the type provided to the helper function is a `Namespace_Body`, `Global_Body`, `Export_Body`, `Extern_Linkage_body`.
-2. If its not a `Global_Body` eat the opening brace for the scope.
-3. 
+    ...
+
+    <code type> result = (<code type>) make_code();
+    ...
+
+    Context.pop();
+    return result;
+}
+```
+
+Below is an outline of the general alogirithim used for these internal procedures. The intention is to provide a basic briefing to aid the user in traversing the actual code definitions. These appear in the same order as they are in the `parser.cpp` file
+
+***NOTE: This is still heavily in an alpha state. A large swaph of this can change, make sure these docs are up to date before considering them 1:1 with the repo commit your considering.***
+
+## `parse_array_decl`
+
+1. Check if its an array declaration with no expression.
+    1. Consume and return empty array declaration
+2. Opening square bracket
+3. Consume expression
+4. Closing square bracket
+5. If adjacent opening bracket
+    1. Repeat array declaration parse until no brackets remain
+
+## `parse_assignment_expression`
+
+1. Eat the assignment operator
+2. Make sure there is content or at least an end statement after.
+3. Flatten the assignment expression to an untyped Code string.
+
+## `parse_attributes`
+
+1. Check for standard attribute
+2. Check for GNU attribute
+3. Check for MSVC attribute
+4. Check for a token registered as an attribute
+  a. Check and grab the arguments of a token registered of an attribute if it has any.
+5. Repeat for chained attributes. Flatten them to a single attribute AST node.
+
+## `parse_class_struct`
+
+1. Check for export module specifier
+2. class or struct keyword
+3. `parse_attributes`
+4. If identifier : `parse_identifier`
+5. Parse inherited parent or interfaces
+6. If opening curly brace : `parse_class_struct_body`
+7. If not an inplace definition
+    1. End statement
+    2. Check for inline comment
+
+## `parse_class_struct_body`
+
+1. Opening curly brace
+2. Parse the body (Possible options):
+    1. Ignore dangling end statements
+    2. Newline : ast constant
+    3. Comment : `parse_comment`
+    4. Access_Public : ast constant
+    5. Access_Protected : ast constant
+    6. Access_Private : ast constant
+    7. Decl_Class : `parse_complicated_definition`
+    8. Decl_Enum : `parse_complicated_definition`
+    9. Decl_Friend : `parse_friend`
+    10. Decl_Operator : `parse_operator_cast`
+    11. Decl_Struct : `parse_complicated_definition`
+    12. Decl_Template : `parse_template`
+    13. Decl_Typedef : `parse_typedef`
+    14. Decl_Union : `parse_complicated_definition`
+    15. Decl_Using : `parse_using`
+    16. Operator == '~'
+        1. `parse_destructor`
+    17. Preprocess_Define : `parse_define`
+    18. Preprocess_Include : `parse_include`
+    19. Preprocess_Conditional (if, ifdef, ifndef, elif, else, endif) : `parse_preprocess_cond` or else/endif ast constant
+    20. Preprocess_Macro : `parse_simple_preprocess`
+    21. Preprocess_Pragma : `parse_pragma`
+    22. Preprocess_Unsupported : `parse_simple_preprocess`
+    23. StaticAssert : `parse_static_assert`
+    24. The following compound into a resolved definition or declaration:
+        1. Attributes (Standard, GNU, MSVC) : `parse_attributes`
+        2. Specifiers (consteval, constexpr, constinit, explicit, forceinline, inline, mutable, neverinline, static, volatile, virtual)
+        3. Possible Destructor : `parse_destructor`
+        4. Possible User defined operator cast : `parse_operator_cast`
+        5. Possible Constructor : `parse_constructor`
+        6. Something that has the following: (identifier, const, unsigned, signed, short, long, bool, char, int, double)
+            1. Possible Constructor `parse_constructor`
+            2. Possible Operator, Function, or varaible : `parse_operator_function_or_variable`
+    25. Something completely unknown (will just make untyped...) : `parse_untyped`
+
+## `parse_comment`
+
+1. Just wrap the token into a cached string ( the lexer did the processing )
+
+## `parse_compilcated_definition`
+
+This is a helper function used by the following functions to help resolve a declaration or definition:
+
+* `parse_class_struct_body`
+* `parse_global_nspace`
+* `parse_union`
+
+A portion of the code in `parse_typedef` is very similar to this as both have to resolve a similar issue.
+
+1. Look ahead to the termination token (End statement)
+2. Check to see if it fits the pattern for a forward declare
+3. If the previous token was an identifier ( `token[-1]` ):
+    1. Look back one more token : `[-2]`
+    2. If the token has a closing brace its an inplace definition
+    3. If the `token[-2]` is an identifier & `token[-3]` is the declaration type, its a variable using a namespaced type.
+    4. If the `token[-2]` is an indirection, then its a variable using a namespaced/forwarded type.
+    5. If the `token[-2]` is an assign classifier, and the starting tokens were the which type with possible `class` token after, its an enum forward declaration.
+    6. If any of the above is the case, `parse_operator_function_or_variable`
+4. If the `token[2]` is a vendor fundamental type (builtin) then it is an enum forward declaration.
+5. If the previous token was a closing curly brace, its a definition : `parse_forward_or_definition`
+6. If the previous token was a closing square brace, its an array definition : `parse_operator_function_or_variable`
+
+## `parse_define`
+
+1. Define directive
+2. Get identifier
+3. Get Content (Optional)
+
+## `parse_forward_or_definition`
+
+* Parse any of the following for either a forward declaration or definition:
+    1. Decl_Class : `parse_class`
+    2. Decl_Enum : `parse_enum`
+    3. Decl_Struct : `parse_struct`
+    4. Decl_Union : `parse_union`
+
+## `parse_function_after_name`
+
+This is needed as a function defintion is not easily resolvable early on, as such this function handles resolving a function
+after its been made ceratin that the type of declaration or definition is indeed for a function signature.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, return type, & name
+
+1. `parse_parameters`
+2. parse postfix specifiers (we do not check if the specifier here is correct or not to be here... yet)
+3. If there is a body : `parse_body`
+4. Otherwise :
+     1. Statment end
+     2. Check for inline comment
+
+## `parse_function_body`
+
+Currently there is no actual parsing of the function body. Any content with the braces is shoved into an execution AST node.
+In the future statements and expressions will be parsed.
+
+1. Open curly brace
+2. Grab all tokens between the brace and the closing brace, shove them in a execution AST node.
+3. Closing curly brace
+
+## `parse_global_nspace`
+
+1. Make sure this is being called for a valid type (namespace, global body, export body, linkage body)
+2. If its not a global body, consume the opening curly brace
+3. Parse the body (Possible options):
+    1. Ignore dangling end statements
+    2. NewLine : ast constant
+    3. Comment : `parse_comment`
+    4. Decl_Cass : `parse_complicated_definition`
+    5. Decl_Enum : `parse_complicated_definition`
+    6. Decl_Extern_Linkage : `parse_extern_link`
+    7. Decl_Namespace : `parse_namespace`
+    8. Decl_Struct : `parse_complicated_definition`
+    9. Decl_Template : `parse_template`
+    10. Decl_Typedef : `parse_typedef`
+    11. Decl_Union : `parse_complicated_definition`
+    12. Decl_Using : `parse_using`
+    13. Preprocess_Define : `parse_define`
+    14. Preprocess_Include : `parse_include`
+    15. Preprocess_If, IfDef, IfNotDef, Elif : `parse_preprocess_cond`
+    16. Preprocess_Else : ast constant
+    17. Preprocess_Endif : ast constant
+    18. Preprocess_Macro : `parse_simple_preprocess`
+    19. Preprocess_Pragma : `parse_pragma`
+    20. Preprocess_Unsupported : `parse_simple_preprocess`
+    21. StaticAssert : `parse_static_assert`
+    22. Module_Export : `parse_export_body`
+    23. Module_Import : NOT_IMPLEMENTED
+    24. The following compound into a resolved definition or declaration:
+        1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes`
+        2. Specifiers ( consteval, constexpr, constinit, extern, forceinline, global, inline, internal_linkage, neverinline, static )
+        3. Is either ( identifier, const specifier, long, short, signed, unsigned, bool, char, double, int)
+            1. Attempt to parse as constrcutor or destructor : `parse_global_nspace_constructor_destructor`
+            2. If its an operator cast (definition outside class) : `parse_operator_cast`
+            3. Its an operator, function, or varaible : `parse_operator_function_or_varaible`
+4. If its not a global body, consume the closing curly brace
+
+## `parse_global_nspace_constructor_destructor`
+
+1. Look ahead for the start of the arguments for a possible constructor/destructor
+2. Go back past the identifier
+3. Check to see if its a destructor by checking for the `~`
+4. Continue the next token should be a `::`
+5. Determine if the next valid identifier (ignoring possible template parameters) is the same as the first identifier of the function.
+6. If it is we have either a constructor or destructor so parse using their respective functions (`parse_constructor`, `parse_destructor`).
+
+## `parse_identifier`
+
+This is going to get heavily changed down the line to have a more broken down "identifier expression" so that the qualifier, template args, etc, can be distinguished between the targeted identifier.  
+The function can parse all of them, however the AST node compresses them all into a string.
+
+1. Consume first identifier
+2. `parse_template_args`
+3. While there is a static symbol accessor ( `::` )
+    1. Consume `::`
+    2. Consume member identifier
+    3. `parse_template args` (for member identifier)
+    4. If a `~` is encounted and the scope is for a destructor's identifier, do not consume it and return with what parsed.
+
+## `parse_include`
+
+1. Consume include directive
+2. Consume the path
+
+## `parse_operator_after_ret_type`
+
+This is needed as a operator defintion is not easily resolvable early on, as such this function handles resolving a operator after its been made ceratin that the type of declaration or definition is indeed for a operator signature.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, return type
+
+1. If there is any qualifiers for the operator, parse them
+2. Consume operator keyword
+3. Determine the operator type (This will be offloaded to the lexer moreso than how it is now) & consume
+4. `parse_params`
+5. If there is no parameters this is operator is a member of pointer if its symbols is a *.
+6. Parse postfix specifiers
+7. If there is a opening curly brace, `parse function_body`
+8. Otherwise: consume end statement, check for inline comment.
+
+## `parse_operator_function_or_variable`
+
+When this function is called, attribute and specifiers may have been resolved, however what comes next can still be either an operator, function, or varaible.
+
+1. Check for preprocessor macro, if there is one : `parse_simple_preprocess`
+2. `parse_type` (Does the bulk of the work)
+3. Begin lookahead to see if we get qualifiers or we eventually find the operator declaration
+4. If we find an operator keyword : `parse_operator_after_ret_type`
+5. otherwise :
+    1. `parse_identifier`
+    2. If we se a opening parenthesis (capture start), its a function : `parse_function_after_name`
+    3. Its a variable : `parse_variable_after_name`
+
+## `parse_pragma`
+
+1. Consume pragma directive
+2. Process the token content into cached string
+
+## `parse_params`
+
+1. Consume either a `(` or `<` based on `use_template_capture` arg
+2. If the we immdiately find a closing token, consume it and finish.
+3. If we encounter a varadic argument, consume it and return a `param_varadic` ast constant
+4. `parse_type`
+5. If we have a macro, parse it (Unreal has macros as tags to parameters and or as entire arguments).
+6. So long as next token isn't a comma
+  a. If we have an identifier
+    1. Consume it
+    2. Check for assignment:
+      a. Consume assign operator
+      b. Parse the expression
+7. While we continue to encounter commas
+    a. Consume them
+    b. Repeat steps 3 to 6.2.b
+8. Consume the closing token
+
+## `parse_preprocess_cond`
+
+1. Parse conditional directive
+2. Process directive's content expression
+
+## `parse_simple_preprocess`
+
+There is still decent room for improvement in this setup. Right now the entire macro's relevant tokens are shoved into an untyped AST. It would be better to store it instead in an `AST_Macro` node instead down the line.
+
+1. Consume the macro token
+2. Check for an opening curly brace
+    1. Consume opening curly brace
+    2. Until the closing curly is encountered consume all tokens.
+    3. If the parent context is a typedef
+        1. Check for end stement
+            1. Consume it
+            2. Consume potential inline comment
+3. Otherwise do steps 3 to 3.1.2
+4. Shove it all in an untyped string
+
+## `parse_static_assert`
+
+1. Consume static assert and opening curly brace
+2. Consume all tokens until the the closing brace is reached.
+3. Consume curly brace and end statement
+4. Place all tokens within braces into a content for the assert.
+
+## `parse_template_args`
+
+This will get changed heavily once we have better support for typename expressions
+
+1. Consume opening angle bracket
+2. Consume all tokens until closing angle bracket
+3. Consme closing angle bracket
+4. Return the currtok with the ammended length.
+
+## `parse_variable_after_name`
+
+This is needed as a variable defintion is not easily resolvable early on, it takes a long evaluation period before its known that the declaration or definition is a variable. As such this function handles resolving a variable.
+
+By the point this function is called the following are known : export module flag, attributes, specifiers, value type, name
+
+1. If its an assignment, parse the assignment expression (currently to an untyped string)
+2. If its an opening curly brace, parse the expression within (currnelty to an untyped stirng).
+    1. Consume the closing curly brace
+3. If its a `:`, we're dealing with bitfield definition:
+    1. Consume the assign classifier
+    2. Consume the expression (currently to an untyped string)
+4. If a comma is encountered : `parse_variable declaration_list`
+5. Consume statement end
+6. Check for inline comment
+
+## `parse_variable_declaration_list`
+
+1. Consume the comma
+2. Parse specifiers
+3. `parse_variable_after_name`
+
+## `parse_class`
+
+1. `parse_class_struct`
+
+## `parse_constructor`
+
+This currently doesn't support postfix specifiers (planning to in the future)
+
+1. `parse_identifier`
+2. `parse_parameters`
+3. If currtok is a `:`
+    1. Consume `:`
+    2. Parse the initializer list
+    3. `parse_function_body`
+4. If currtok is an opening curly brace
+    1. `parse_function_body`
+5. Otherwise:
+    1. Consume statement end
+    2. Check for inline comment
+
+## `parse_destructor`
+
+1. Check for and consume virtual specifier
+2. Check for the `~` operator
+3. `parse_identifier`
+4. Consume opening and closing parenthesis
+5. Check for assignment operator:
+    1. Consume assignment op
+    2. Consume pure specifier `0`
+6. If not pure virtual & currtok is opening curly brace:
+    1. `parse_function_body`
+7. Otherwise:
+    1. Consume end statement
+    2. If currtok is comment : `parse_comment`
+
+## `parse_enum`
+
+1. Consume enum token
+2. Check for and consume class token
+3. `parse_attributes`
+4. If there is an identifier consume it
+5. Check for a `:`
+    1. Consume `:`
+    2. `parse_type`
+6. If there is a body parse it (Consume `{`):
+    1. Newline : ast constant
+    2. Comment : `parse_comment`
+    3. Preprocess_Define : `parse_define`
+    4. Preprocess_Conditional (if, ifdef, ifndef, elif ) : `parse_preprocess_cond`
+    5. Preprocess_Else : ast constant
+    6. Preprocess_Endif : ast constant
+    7. Preprocess_Macro : `parse_simple_preprocess`
+    8. Preprocess_Pragma : `parse_pragma`
+    9. Preprocess_Unsupported : `parse_smple_preprocess`
+    10. An actual enum entry
+        1. Consume identifier
+        2. If there is an assignment operator:
+            1. Consume operator
+            2. Consume the expression (assigned to untyped string for now)
+            3. If a macro is encountered consume it (Unreal UMETA macro support)
+        3. If there is a comma, consume it
+
+## `parse_export_body`
+
+1. `parse_global_nspace`
+
+## `parse_extern_link_body`
+
+1. `parse_global_nspace`
+
+## `parse_extern_link`
+
+1. Consume Decl_Extern_Linkage
+2. Consume the linkage identifier
+3. `parse_extern_link_body`
+
+## `parse_friend`
+
+1. Consume `friend`
+2. `parse_type`
+3. If the currok is an identifier its a function declaration or definition
+   1. `parse_function_after_name`
+4. Consume end statement so long as its not a function definion
+5. Check for inline comment, `parse_comment` if exists
+
+## `parse_function`
+
+1. Check and parse for `export`
+2. `parse_attributes`
+3. Parse specifiers
+4. `parse_type`
+5. `parse_identifier`
+6. `parse_function_after_name`
+
+## `parse_namespace`
+
+1. Consume namespace declaration
+2. Parse identifier
+3. `parse_global_namespace`
+
+## `parse_operator`
+
+1. Check for and parse export declaration
+2. `parse_attributes`
+3. Parse specifiers
+4. `parse_type`
+5. `parse_operator_after_ret_type`
+
+## `parse_operator_cast`
+
+1. Look for and parse a qualifier namespace for the cast (in-case this is defined outside the class's scope)
+2. Consume operator declaration
+3. `parse_type`
+4. Consume opening and closing parethesis
+5. Check for a const qualifiying specifier
+6. Check to see if this is a definition (`{`)
+    1. Consume `{`
+    2. Parse body to untyped string (parsing statement and expressions not supported yet)
+    3. Consume `}`
+7. Otherwise:
+    1. Consume end statement
+    2. Check for and consume comment : `parse_comment`
 
 
-## parse_type
+## `parse_struct`
 
+1. `parse_class_struct`
+
+## `parse_template`
+
+Note: This currently doesn't support templated operator casts (going to need to add support for it)
+
+1. Check for and parse export declaration
+2. Consume template declaration
+3. `parse_params`
+4. Parse for any of the following:
+   1. Decl_Class : `parse_class`
+   2. Decl_Struct : `parse_struct`
+   3. Decl_Union : `parse_union`
+   4. Decl_Using : `parse_using`
+   5. The following compound into a resolved definition or declaration:
+       1. `parse_attributes`
+       2. Parse specifiers
+       3. Attempt to parse as constructor or destructor: `parse_global_nspace_constructor_destructor`
+       4. Otherwise: `parse_operator_function_or_variable`
+
+## `parse_type`
+
+This function's implementation is awful and not done correctly. It will most likely be overhauled in the future as I plan to segement the AST_Type into several AST varaints along with sub-types to help produce robust type expressions.  
+Hopefully I won't need to make authentic type expressions as I was hopeing to avoid that...
+
+### Current Algorithim
+
+Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
+
+1. `parse_attributes`
+2. Parse specifiers
+3. If the `parse_type` was called from a template parse, check to see if class was used instead of typname and consume as name.
+4. This is where things get ugly for each of these depend on what the next token is.
+    1. If its an in-place definition of a class, enum, struct, or union:
+    2. If its a decltype (Not supported yet but draft impl there)
+    3. If its a compound native type expression (unsigned, char, short, long, int, float, dobule, etc )
+    4. Ends up being a regular type alias of an identifier
+5. Parse specifiers (postfix)
+6. We need to now look ahead to see If we're dealing with a function typename
+7. If wer're dealing with a function typename:
+    1. Shove the specifiers, and identifier code we have so far into a return type typename's Name (untyped string)
+        1. Reset the specifiers code for the top-level typeanme
+    2. Check to see if the next token is an identifier:
+        1. `parse_identifier`
+    3. Check to see if the next token is capture start and is not the last capture ("qualifier capture"):
+        1. Consume `(`
+        2. Consume expresssion between capture
+        3. Consume `)`
+    4. `parse_params`
+    5. Parse postfix specifiers
+8. Check for varaidic argument (param pack) token:
+   1. Consume varadic argument token
+
+### WIP - Alternative Algorithim
+
+Currently wrapped up via macro: `GEN_USE_NEW_TYPENAME_PARSING`
+Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
+
+1. `parse_attributes`
+2. Parse specifiers (prefix)
+3. This is where things get ugly for each of these depend on what the next token is.
+    1. If its an in-place definition of a class, enum, struct, or union:
+    2. If its a decltype (Not supported yet but draft impl there)
+    3. If its a compound native type expression (unsigned, char, short, long, int, float, dobule, etc )
+    4. Ends up being a regular type alias of an identifier
+4. Parse specifiers (postfix)
+    1. If any specifiers are found populate specifiers code with them.
+5. We need to now look ahead to see If we're dealing with a function typename
+6. If wer're dealing with a function typename:
+    1. Shove the specifiers, and identifier code we have so far into a return type typename's Name (untyped string)
+        1. Reset the specifiers code for the top-level typename
+    2. Check to see if the next token is an identifier:
+        1. `parse_identifier`
+    3. Check to see if the next token is capture start and is not the last capture ("qualifier capture"):
+        1. Consume `(`
+        2. Parse binding specifiers
+        3. `parse_identifier`
+        4. `parse_parameters` -> params_nested
+        5. Consume `)`
+        6. Construct a nested function typename definition for the qualifier `Name`
+    4. `parse_params` - > params
+    5. Parse postfix specifiers
+7. Check for varaidic argument (param pack) token:
+   1. Consume varadic argument token
+
+### **Later: Algorithim based on typename expressions**
+
+## `parse_typedef`
+
+1. Check for export module specifier
+2. typedef keyword
+3. If its a preprocess macro: Get the macro name
+4. Else:
+   1. Check to see if its a complicated definition (in-place enum, class, struct, union)
+   2. If its a complicated definition:
+       1. Perform the look ahead similar to `parse_complicated_definition`'s implementation
+       2. Check to see if its a forward declaration : `parse_forward_declaration`
+       3. If end[-1] is an identifier:
+           1. Its either an in-place, varaible type qualified identifier, or indirection type:
+              1. `parse_foward_or_definition`
+       4. else if end[-1] is a closing curly brace
+           1. Its a definition: `parse_forward_or_definition`
+       5. else if end[-1] is a closing square brace
+           2. Its an array definition: `parse_type`
+   3. Else : `parse-type`
+   4. Check for identifier : Consume the token
+   5. `parse_array_decl`
+5. Consume end statement
+6. Check for inline comment : `parse_comment`
+
+## `parse_union`
+
+1. Check for export module specifier
+2. union keyword
+3. `parse_attributes`
+4. Check for identifier
+5. Parse the body (Possible options):
+    1. Newline
+    2. Comment
+    3. Decl_Class
+    4. Decl_Enum
+    5. Decl_Struct
+    6. Decl_Union
+    7. Preprocess_Define
+    8. Preprocess_Conditional (if, ifdef, ifndef, elif, else, endif)
+    9. Preprocess_Macro
+    10. Preprocess_Pragma
+    11. Unsupported preprocess directive
+    12. Variable
+6. If its not an inplace definiton: End Statement
+
+## `parse_using`
+
+1. Check for export module specifier
+2. using keyword
+3. Check to see if its a using namespace
+4. Get the identifier
+5. If its a regular using declaration:
+    1. `parse_attributes`
+    2. `parse_type`
+    3. `parse_array_decl`
+6. End statement
+7. Check for inline comment
+
+## `parse_variable`
+
+1. Check for export module specifier
+2. `parse_attributes`
+3. `parse specifiers`
+4. `parse_type`
+5. `parse_identifier`
+6. `parse_variable_after_name`

docs/Parsing.md

@@ -2,7 +2,7 @@
 
 The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.
 
-This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around 5500 loc. I hope to keep it under 10k loc worst case.
+This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~5600 loc. I hope to keep it under 10k loc worst case.
 
 You can think of this parser of a frontend parser vs a semantic parser. Its intuitively similar to WYSIWYG. What you precerive as the syntax from the user-side before the compiler gets a hold of it, is what you get.
 
@@ -73,7 +73,7 @@ The lexing and parsing takes shortcuts from whats expected in the standard.
 * The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
   * *This includes the assignment of variables.*
 * Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
-  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function
+  * Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function or right afterthe return type.
   * Or in the usual spot for class, structs, (*right after the declaration keyword*)
   * typedefs have attributes with the type (`parse_type`)
 * Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)

docs/Readme.md

@@ -65,7 +65,7 @@ As mentioned in root readme, the user is provided Code objects by calling the co
 The AST is managed by the library and provided to the user via its interface.  
 However, the user may specifiy memory configuration.
 
-Data layout of AST struct:
+Data layout of AST struct (Subject to heavily change with upcoming redesign):
 
 ```cpp
 union {
@@ -82,6 +82,7 @@ union {
             AST*  ValueType;       // Parameter, Variable
         };
         union {
+            AST*  Macro;           // Parameters
             AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
             AST*  Params;          // Constructor, Function, Operator, Template, Typename
         };
@@ -135,7 +136,7 @@ The width dictates how much the static array can hold before it must give way to
 
 ```cpp
 constexpr static
-uw ArrSpecs_Cap =
+usize ArrSpecs_Cap =
 (
     AST_POD_Size
     - sizeof(AST*) * 3
@@ -157,7 +158,7 @@ Data Notes:
   * Most of the work is just defining the allocation procedure:
 
 ```cpp
-    void* ( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
 ```
 
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
@@ -461,6 +462,7 @@ The AST and constructors will be able to validate that the arguments provided fo
 * If return type must match a parameter
 * If number of parameters is correct
 * If added as a member symbol to a class or struct, that operator matches the requirements for the class (types match up)
+* There is no support for validating new & delete operations (yet)
 
 The user is responsible for making sure the code types provided are correct
 and have the desired specifiers assigned to them beforehand.

gencpp.10x

@@ -6,20 +6,22 @@
 		<SyncFiles>true</SyncFiles>
 		<Recursive>true</Recursive>
 		<ShowEmptyFolders>true</ShowEmptyFolders>
+		<IncludeFilesWithoutExt>false</IncludeFilesWithoutExt>
 		<IsVirtual>false</IsVirtual>
 		<IsFolder>false</IsFolder>
 		<BuildCommand>pwsh ./scripts/build.ps1 msvc debug bootstrap</BuildCommand>
 		<RebuildCommand></RebuildCommand>
 		<BuildFileCommand></BuildFileCommand>
-		<CleanCommand>psh ./scripts/clean.ps1</CleanCommand>
+		<CleanCommand>pwsh ./scripts/clean.ps1</CleanCommand>
 		<BuildWorkingDirectory></BuildWorkingDirectory>
 		<CancelBuild></CancelBuild>
-		<RunCommand>./test/gen/build/gencpp.exe</RunCommand>
-		<RunCommandWorkingDirectory></RunCommandWorkingDirectory>
+		<Exe>./test/gen/build/gencpp.exe</Exe>
+		<Args></Args>
+		<WorkingDirectory></WorkingDirectory>
 		<DebugCommand>pwsh ./scripts/build.ps1</DebugCommand>
-		<ExePathCommand>./test/gen/build/gencpp.exe</ExePathCommand>
 		<DebugSln></DebugSln>
 		<UseVisualStudioEnvBat>true</UseVisualStudioEnvBat>
+		<CaptureExeOutput>false</CaptureExeOutput>
 		<Configurations>
 			<Configuration>Debug</Configuration>
 			<Configuration>Release</Configuration>
@@ -43,6 +45,9 @@
 			<Define>GEN_TIME</Define>
 			<Define>GEN_SYSTEM_WINDOWS</Define>
 			<Define>GEN_INTELLISENSE_DIRECTIVES</Define>
+			<Define>GEN_EXECUTION_EXPRESSION_SUPPORT</Define>
+			<Define>GEN_BENCHMARK</Define>
+			<Define>GEN_COMPILER_MSVC</Define>
 		</Defines>
 		<ConfigProperties>
 			<ConfigAndPlatform>

gencpp.vcxproj

@@ -262,6 +262,7 @@
     <ClInclude Include="project\auxillary\scanner.hpp" />
     <ClInclude Include="project\components\ast.hpp" />
     <ClInclude Include="project\components\ast_types.hpp" />
+    <ClInclude Include="project\components\code_types.hpp" />
     <ClInclude Include="project\components\gen\ast_inlines.hpp" />
     <ClInclude Include="project\components\gen\ecode.hpp" />
     <ClInclude Include="project\components\gen\eoperator.hpp" />
@@ -313,11 +314,14 @@
     <ClCompile Include="project\bootstrap.cpp" />
     <ClCompile Include="project\components\ast.cpp" />
     <ClCompile Include="project\components\ast_case_macros.cpp" />
+    <ClCompile Include="project\components\code_serialization.cpp" />
     <ClCompile Include="project\components\gen\etoktype.cpp" />
     <ClCompile Include="project\components\interface.cpp" />
     <ClCompile Include="project\components\interface.parsing.cpp" />
     <ClCompile Include="project\components\interface.untyped.cpp" />
     <ClCompile Include="project\components\interface.upfront.cpp" />
+    <ClCompile Include="project\components\lexer.cpp" />
+    <ClCompile Include="project\components\parser.cpp" />
     <ClCompile Include="project\components\src_start.cpp" />
     <ClCompile Include="project\components\static_data.cpp" />
     <ClCompile Include="project\dependencies\debug.cpp" />
@@ -362,6 +366,9 @@
     <Content Include="scripts\helpers\target_arch.psm1" />
     <Content Include="scripts\refactor.ps1" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="singleheader\gen\" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

gencpp.vcxproj.filters

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

project/Readme.md

@@ -10,8 +10,7 @@ Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<depe
 
 Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
 
-**TODO : Right now the library is not finished, as such the first self-hosting iteration is still WIP**  
-Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.  
+Both libraries use *pre-generated* (self-hosting I guess) version of the library to then generate the latest version of itself.
 
 The default `gen.bootstrap.cpp` located in the project folder is meant to be produce a standard segmented library, where the components of the library  
 have relatively dedicated header and source files. Dependencies included at the top of the file and each header starting with a pragma once.  
@@ -52,7 +51,7 @@ Names or Content fields are interned strings and thus showed be cached using `ge
 
 The library has its code segmented into component files, use it to help create a derived version without needing to have to rewrite a generated file directly or build on top of the header via composition or inheritance.
 
-The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.  
+The parser is documented under `docs/Parsing.md` and `docs/Parser_Algo.md`.
 
 ## A note on compilation and runtime generation speed
 

project/auxillary/builder.cpp

@@ -7,7 +7,6 @@ Builder Builder::open( char const* path )
 	Builder result;
 
 	FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
-
 	if ( error != EFileError_NONE )
 	{
 		log_failure( "gen::File::open - Could not open file: %s", path);
@@ -28,14 +27,14 @@ void Builder::pad_lines( s32 num )
 void Builder::print( Code code )
 {
 	String   str = code->to_string();
-	// const sw len = str.length();
+	// const ssize len = str.length();
 	// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
 	Buffer.append( str );
 }
 
 void Builder::print_fmt( char const* fmt, ... )
 {
-	sw   res;
+	ssize   res;
 	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
 
 	va_list va;
@@ -49,7 +48,7 @@ void Builder::print_fmt( char const* fmt, ... )
 
 void Builder::write()
 {
-	bool result = file_write( & File, Buffer, Buffer.length() );
+	b32 result = file_write( & File, Buffer, Buffer.length() );
 
 	if ( result == false )
 		log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & File ) );

project/auxillary/scanner.cpp

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

project/auxillary/scanner.hpp

@@ -6,6 +6,7 @@
 // This is a simple file reader that reads the entire file into memory.
 // It has an extra option to skip the first few lines for undesired includes.
 // This is done so that includes can be kept in dependency and component files so that intellisense works.
+inline
 Code scan_file( char const* path )
 {
 	FileInfo file;
@@ -16,7 +17,7 @@ Code scan_file( char const* path )
 		GEN_FATAL( "scan_file: Could not open: %s", path );
 	}
 
-	sw fsize = file_size( & file );
+	ssize fsize = file_size( & file );
 	if ( fsize <= 0 )
 	{
 		GEN_FATAL("scan_file: %s is empty", path );

project/auxillary/vis_ast/build.ps1

@@ -1,106 +0,0 @@
-Clear-Host
-
-$path_root     = git rev-parse --show-toplevel
-$path_scripts  = Join-Path $path_root 'scripts'
-
-$target_arch        = Join-Path $path_scripts 'helpers/target_arch.psm1'
-$devshell           = Join-Path $path_scripts 'helpers/devshell.ps1'
-$format_cpp	        = Join-Path $path_scripts 'helpers/format_cpp.psm1'
-$incremental_checks = Join-Path $path_scripts 'helpers/incremental_checks.ps1'
-$vendor_toolchain   = Join-Path $path_scripts 'helpers/vendor_toolchain.ps1'
-
-$path_project  = Join-Path $path_root     'project'
-$path_aux      = Join-Path $path_project  'auxillary'
-$path_vis_root = Join-Path $path_aux      'vis_ast'
-$path_binaries = Join-Path $path_vis_root 'binaries'
-$path_build    = Join-Path $path_vis_root 'build'
-$path_code     = Join-Path $path_vis_root 'code'
-$path_win32    = Join-Path $path_code     'win32'
-
-Import-Module $target_arch
-Import-Module $format_cpp
-
-#region Arguments
-$vendor           = $null
-$optimize         = $null
-$debug 	          = $null
-$analysis	      = $false
-$dev              = $false
-$verbose          = $null
-$platform         = $null
-$module_specified = $false
-
-[array] $vendors = @( "clang", "msvc" )
-
-# This is a really lazy way of parsing the args, could use actual params down the line...
-
-if ( $args ) { $args | ForEach-Object {
-switch ($_){
- { $_ -in $vendors }   { $vendor    = $_; break }
- "optimize"            { $optimize  = $true }
- "debug"               { $debug     = $true }
- "analysis"            { $analysis  = $true }
- "dev"                 { $dev       = $true }
- "verbose"             { $verbose   = $true }
- "platform"            { $platform  = $true; $module_specified = $true }
-}
-}}
-#endregion Argument
-
-if ( -not $module_specified )
-{
-	$platform = $true
-}
-
-# Load up toolchain configuraion
-. $vendor_toolchain
-. $incremental_checks
-
-write-host "Building Vis AST with $vendor"
-
-if ( (Test-Path $path_build) -eq $false ) {
-	New-Item $path_build -ItemType Directory
-}
-
-if ( (Test-Path $path_binaries) -eq $false ) {
-	New-Item $path_binaries -ItemType Directory
-}
-
-$includes = @(
-	$paht_code
-)
-
-# Microsoft
-$lib_gdi32  = 'Gdi32.lib'
-$lib_xinput = 'Xinput.lib'
-$lib_user32 = 'User32.lib'
-$lib_winmm  = 'Winmm.lib'
-
-$stack_size = 1024 * 1024 * 4
-
-$compiler_args = @(
-	($flag_define + 'UNICODE'),
-	($flag_define + '_UNICODE')
-	( $flag_define + 'INTELLISENSE_DIRECTIVES=0'),
-	# ($flag_set_stack_size + $stack_size)
-	$flag_wall
-	$flag_warnings_as_errors
-	$flag_optimize_intrinsics
-)
-
-if ( $dev ) {
-	$compiler_args += ( $flag_define + 'Build_Development=1' )
-}
-else {
-	$compiler_args += ( $flag_define + 'Build_Development=0' )
-}
-
-$linker_args = @(
-	$flag_link_win_subsystem_windows,
-	$flag_link_optiiize_references
-)
-
-$unit       = join-path $path_code     'vis_ast_windows.cpp'
-$executable = join-path $path_binaries 'vis_ast.exe'
-
-$build_result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable

project/auxillary/vis_ast/code/platform/macros.hpp

@@ -1,24 +0,0 @@
-#if INTELLISENSE_DIRECTIVES
-#include "vendor/compiler.hpp"
-#endif
-
-#define global        static // Global variables
-#define internal      static // Internal linkage
-#define local_persist static // Local Persisting variables
-
-#define api_c extern "C"
-
-#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 )
-
-#define do_once()   for ( local_persist b32 once = true; once; once = false )
-#define stmt( ... ) do { __VA_ARGS__; } while ( 0 )
-
-#define array_count( array ) ( sizeof( array ) / sizeof( ( array )[0] ) )
-
-#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 ) )

project/auxillary/vis_ast/code/platform/vendor/arch.hpp

@@ -1,9 +0,0 @@
-// Platform architecture
-
-#if defined( _WIN64 ) || defined( __x86_64__ ) || defined( _M_X64 ) || defined( __64BIT__ ) || defined( __powerpc64__ ) || defined( __ppc64__ ) || defined( __aarch64__ )
-#	ifndef ARCH_64_BIT
-#		define ARCH_64_BIT 1
-#	endif
-#else
-#	error A 32-bit architecture is not supported
-#endif

project/auxillary/vis_ast/code/platform/vendor/compiler.hpp

@@ -1,21 +0,0 @@
-// Platform compiler
-
-#if defined( _MSC_VER )
-#	define Compiler_MSVC 1
-#elif defined( __clang__ )
-#	define Compiler_Clang 1
-#else
-#	error "Unknown compiler"
-#endif
-
-#if defined( __has_attribute )
-#	define HAS_ATTRIBUTE( attribute ) __has_attribute( attribute )
-#else
-#	define HAS_ATTRIBUTE( attribute ) ( 0 )
-#endif
-
-#ifdef Compiler_Clang
-#	define compiler_decorated_func_name __PRETTY_NAME__
-#elif defined(Compiler_MSVC)
-#	define compiler_decorated_func_name __FUNCDNAME__
-#endif

project/auxillary/vis_ast/code/platform/vendor/compiler_ignores.hpp

@@ -1,34 +0,0 @@
-#pragma once
-#if INTELLISENSE_DIRECTIVES
-#include "compiler.hpp"
-#endif
-
-#ifdef Compiler_MSVC
-#pragma warning( disable: 4201 ) // Support for non-standard nameless struct or union extesnion
-#pragma warning( disable: 4100 ) // Support for unreferenced formal parameters
-#pragma warning( disable: 4800 ) // Support implicit conversion to bools
-#pragma warning( disable: 4365 ) // Support for signed/unsigned mismatch auto-conversion
-#pragma warning( disable: 4189 ) // Support for unused variables
-#pragma warning( disable: 4514 ) // Support for unused inline functions
-#pragma warning( disable: 4505 ) // Support for unused static functions
-#pragma warning( disable: 5045 ) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
-#pragma warning( disable: 5264 ) // Support for 'const' variables unused
-#pragma warning( disable: 4820 ) // Support auto-adding padding to structs
-#pragma warning( disable: 4711 ) // Support automatic inline expansion
-#pragma warning( disable: 4710 ) // Support automatic inline expansion
-#pragma warning( disable: 4805 ) // Support comparisons of s32 to bool.
-#pragma warning( disable: 5246 ) // Support for initialization of subobject without braces.
-#endif
-
-#ifdef Compiler_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 "-Wunused-local-typedef"
-#pragma clang diagnostic ignored "-Wunknown-pragmas"
-#pragma clang diagnostic ignored "-Wvarargs"
-#pragma clang diagnostic ignored "-Wunused-function"
-#pragma clang diagnostic ignored "-Wunused-but-set-variable"
-#pragma clang diagnostic ignored "-Wmissing-braces"
-#endif

project/auxillary/vis_ast/code/platform/vendor/os.hpp

@@ -1,21 +0,0 @@
-// Platform OS detection
-
-#if defined( _WIN32 ) || defined( _WIN64 )
-#	ifndef System_Windows
-#		define System_Windows 1
-#	endif
-#elif defined( __APPLE__ ) && defined( __MACH__ )
-#	ifndef System_MacOS
-#		define System_MacOS 1
-#	endif
-#elif defined( __unix__ )
-#	if defined( __linux__ )
-#		ifndef System_Linux
-#			define System_linux 1
-#		endif
-#	else
-#		error This UNIX operating system is not supported
-#	endif
-#else
-#	error This operating system is not supported
-#endif

project/auxillary/vis_ast/code/platform/win32/launch.cpp

@@ -1,8 +0,0 @@
-#if INTELLISENSE_DIRECTIVES
-#include "win32.hpp"
-#endif
-
-int __stdcall WinMain( HINSTANCE instance, HINSTANCE prev_instance, char* commandline, int num_cmd_show)
-{
-	return 0;
-}

project/auxillary/vis_ast/code/platform/win32/types.hpp

@@ -1 +0,0 @@
-using HINSTANCE = void*;

project/auxillary/vis_ast/code/vis_ast_windows.cpp

@@ -1,10 +0,0 @@
-#include "platform/vendor/arch.hpp"
-#include "platform/vendor/compiler.hpp"
-#include "platform/vendor/compiler_ignores.hpp"
-#include "platform/vendor/os.hpp"
-
-#include "platform/macros.hpp"
-
-#include "platform/win32/types.hpp"
-
-#include "platform/win32/launch.cpp"

project/auxillary/vis_ast/dependencies/raylib/include/config.h

@@ -1,226 +0,0 @@
-/**********************************************************************************************
- *
- *   raylib configuration flags
- *
- *   This file defines all the configuration flags for the different raylib modules
- *
- *   LICENSE: zlib/libpng
- *
- *   Copyright (c) 2018-2023 Ahmad Fatoum & Ramon Santamaria (@raysan5)
- *
- *   This software is provided "as-is", without any express or implied warranty. In no event
- *   will the authors be held liable for any damages arising from the use of this software.
- *
- *   Permission is granted to anyone to use this software for any purpose, including commercial
- *   applications, and to alter it and redistribute it freely, subject to the following restrictions:
- *
- *     1. The origin of this software must not be misrepresented; you must not claim that you
- *     wrote the original software. If you use this software in a product, an acknowledgment
- *     in the product documentation would be appreciated but is not required.
- *
- *     2. Altered source versions must be plainly marked as such, and must not be misrepresented
- *     as being the original software.
- *
- *     3. This notice may not be removed or altered from any source distribution.
- *
- **********************************************************************************************/
-
-#ifndef CONFIG_H
-#define RL_CONFIG_H
-
-//------------------------------------------------------------------------------------
-// Module selection - Some modules could be avoided
-// Mandatory modules: rcore, rlgl, utils
-//------------------------------------------------------------------------------------
-#define RL_SUPPORT_MODULE_RSHAPES   1
-#define RL_SUPPORT_MODULE_RTEXTURES 1
-#define RL_SUPPORT_MODULE_RTEXT     1    // WARNING: It requires SUPPORT_MODULE_RTEXTURES to load sprite font textures
-#define RL_SUPPORT_MODULE_RMODELS   1
-#define RL_SUPPORT_MODULE_RAUDIO    1
-
-//------------------------------------------------------------------------------------
-// Module: rcore - Configuration Flags
-//------------------------------------------------------------------------------------
-// Camera module is included (rcamera.h) and multiple predefined cameras are available: free, 1st/3rd person, orbital
-#define RL_SUPPORT_CAMERA_SYSTEM 1
-// Gestures module is included (rgestures.h) to support gestures detection: tap, hold, swipe, drag
-#define RL_SUPPORT_GESTURES_SYSTEM 1
-// Mouse gestures are directly mapped like touches and processed by gestures system
-#define RL_SUPPORT_MOUSE_GESTURES 1
-// Reconfigure standard input to receive key inputs, works with SSH connection.
-#define RL_SUPPORT_SSH_KEYBOARD_RPI 1
-// Setting a higher resolution can improve the accuracy of time-out intervals in wait functions.
-// However, it can also reduce overall system performance, because the thread scheduler switches tasks more often.
-#define RL_SUPPORT_WINMM_HIGHRES_TIMER 1
-// Use busy wait loop for timing sync, if not defined, a high-resolution timer is set up and used
-// #define SUPPORT_BUSY_WAIT_LOOP          1
-// Use a partial-busy wait loop, in this case frame sleeps for most of the time, but then runs a busy loop at the end for accuracy
-#define RL_SUPPORT_PARTIALBUSY_WAIT_LOOP 1
-// Allow automatic screen capture of current screen pressing F12, defined in KeyCallback()
-#define RL_SUPPORT_SCREEN_CAPTURE 1
-// Allow automatic gif recording of current screen pressing CTRL+F12, defined in KeyCallback()
-#define RL_SUPPORT_GIF_RECORDING 1
-// Support CompressData() and DecompressData() functions
-#define RL_SUPPORT_COMPRESSION_API 1
-// Support automatic generated events, loading and recording of those events when required
-// #define SUPPORT_EVENTS_AUTOMATION       1
-// Support custom frame control, only for advance users
-// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
-// Enabling this flag allows manual control of the frame processes, use at your own risk
-// #define SUPPORT_CUSTOM_FRAME_CONTROL    1
-
-// rcore: Configuration values
-//------------------------------------------------------------------------------------
-#define RL_MAX_FILEPATH_CAPACITY  8192    // Maximum file paths capacity
-#define RL_MAX_FILEPATH_LENGTH    4096    // Maximum length for filepaths (Linux PATH_MAX default value)
-
-#define RL_MAX_KEYBOARD_KEYS      512    // Maximum number of keyboard keys supported
-#define RL_MAX_MOUSE_BUTTONS      8      // Maximum number of mouse buttons supported
-#define RL_MAX_GAMEPADS           4      // Maximum number of gamepads supported
-#define RL_MAX_GAMEPAD_AXIS       8      // Maximum number of axis supported (per gamepad)
-#define RL_MAX_GAMEPAD_BUTTONS    32     // Maximum number of buttons supported (per gamepad)
-#define RL_MAX_TOUCH_POINTS       8      // Maximum number of touch points supported
-#define RL_MAX_KEY_PRESSED_QUEUE  16     // Maximum number of keys in the key input queue
-#define RL_MAX_CHAR_PRESSED_QUEUE 16     // Maximum number of characters in the char input queue
-
-#define RL_MAX_DECOMPRESSION_SIZE 64    // Max size allocated for decompression in MB
-
-
-//------------------------------------------------------------------------------------
-// Module: rlgl - Configuration values
-//------------------------------------------------------------------------------------
-
-// Enable OpenGL Debug Context (only available on OpenGL 4.3)
-// #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT       1
-
-// Show OpenGL extensions and capabilities detailed logs on init
-// #define RLGL_SHOW_GL_DETAILS_INFO              1
-
-// #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS    4096    // Default internal render batch elements limits
-
-
-
-
-// Default shader vertex attribute names to set location points
-// NOTE: When a new shader is loaded, the following locations are tried to be set for convenience
-
-
-
-//------------------------------------------------------------------------------------
-// Module: rshapes - Configuration Flags
-//------------------------------------------------------------------------------------
-// Use QUADS instead of TRIANGLES for drawing when possible
-// Some lines-based shapes could still use lines
-#define RL_SUPPORT_QUADS_DRAW_MODE 1
-
-
-//------------------------------------------------------------------------------------
-// Module: rtextures - Configuration Flags
-//------------------------------------------------------------------------------------
-// Selecte desired fileformats to be supported for image data loading
-#define RL_SUPPORT_FILEFORMAT_PNG 1
-// #define SUPPORT_FILEFORMAT_BMP      1
-// #define SUPPORT_FILEFORMAT_TGA      1
-// #define SUPPORT_FILEFORMAT_JPG      1
-#define RL_SUPPORT_FILEFORMAT_GIF 1
-#define RL_SUPPORT_FILEFORMAT_QOI 1
-// #define SUPPORT_FILEFORMAT_PSD      1
-#define RL_SUPPORT_FILEFORMAT_DDS 1
-// #define SUPPORT_FILEFORMAT_HDR      1
-// #define SUPPORT_FILEFORMAT_PIC          1
-// #define SUPPORT_FILEFORMAT_KTX      1
-// #define SUPPORT_FILEFORMAT_ASTC     1
-// #define SUPPORT_FILEFORMAT_PKM      1
-// #define SUPPORT_FILEFORMAT_PVR      1
-// #define SUPPORT_FILEFORMAT_SVG      1
-
-// Support image export functionality (.png, .bmp, .tga, .jpg, .qoi)
-#define RL_SUPPORT_IMAGE_EXPORT 1
-// Support procedural image generation functionality (gradient, spot, perlin-noise, cellular)
-#define RL_SUPPORT_IMAGE_GENERATION 1
-// Support multiple image editing functions to scale, adjust colors, flip, draw on images, crop...
-// If not defined, still some functions are supported: ImageFormat(), ImageCrop(), ImageToPOT()
-#define RL_SUPPORT_IMAGE_MANIPULATION 1
-
-
-//------------------------------------------------------------------------------------
-// Module: rtext - Configuration Flags
-//------------------------------------------------------------------------------------
-// Default font is loaded on window initialization to be available for the user to render simple text
-// NOTE: If enabled, uses external module functions to load default raylib font
-#define RL_SUPPORT_DEFAULT_FONT 1
-// Selected desired font fileformats to be supported for loading
-#define RL_SUPPORT_FILEFORMAT_FNT 1
-#define RL_SUPPORT_FILEFORMAT_TTF 1
-
-// Support text management functions
-// If not defined, still some functions are supported: TextLength(), TextFormat()
-#define RL_SUPPORT_TEXT_MANIPULATION 1
-
-// On font atlas image generation [GenImageFontAtlas()], add a 3x3 pixels white rectangle
-// at the bottom-right corner of the atlas. It can be useful to for shapes drawing, to allow
-// drawing text and shapes with a single draw call [SetShapesTexture()].
-#define RL_SUPPORT_FONT_ATLAS_WHITE_REC 1
-
-// rtext: Configuration values
-//------------------------------------------------------------------------------------
-#define RL_MAX_TEXT_BUFFER_LENGTH 1024    // Size of internal static buffers used on some functions:
-// TextFormat(), TextSubtext(), TextToUpper(), TextToLower(), TextToPascal(), TextSplit()
-#define RL_MAX_TEXTSPLIT_COUNT 128    // Maximum number of substrings to split: TextSplit()
-
-
-//------------------------------------------------------------------------------------
-// Module: rmodels - Configuration Flags
-//------------------------------------------------------------------------------------
-// Selected desired model fileformats to be supported for loading
-#define RL_SUPPORT_FILEFORMAT_OBJ  1
-#define RL_SUPPORT_FILEFORMAT_MTL  1
-#define RL_SUPPORT_FILEFORMAT_IQM  1
-#define RL_SUPPORT_FILEFORMAT_GLTF 1
-#define RL_SUPPORT_FILEFORMAT_VOX  1
-#define RL_SUPPORT_FILEFORMAT_M3D  1
-// Support procedural mesh generation functions, uses external par_shapes.h library
-// NOTE: Some generated meshes DO NOT include generated texture coordinates
-#define RL_SUPPORT_MESH_GENERATION 1
-
-// rmodels: Configuration values
-//------------------------------------------------------------------------------------
-#define RL_MAX_MATERIAL_MAPS       12    // Maximum number of shader maps supported
-#define RL_MAX_MESH_VERTEX_BUFFERS 7     // Maximum vertex buffers (VBO) per mesh
-
-//------------------------------------------------------------------------------------
-// Module: raudio - Configuration Flags
-//------------------------------------------------------------------------------------
-// Desired audio fileformats to be supported for loading
-#define RL_SUPPORT_FILEFORMAT_WAV 1
-#define RL_SUPPORT_FILEFORMAT_OGG 1
-#define RL_SUPPORT_FILEFORMAT_MP3 1
-#define RL_SUPPORT_FILEFORMAT_QOA 1
-// #define SUPPORT_FILEFORMAT_FLAC         1
-#define RL_SUPPORT_FILEFORMAT_XM  1
-#define RL_SUPPORT_FILEFORMAT_MOD 1
-
-// raudio: Configuration values
-//------------------------------------------------------------------------------------
-#define RL_AUDIO_DEVICE_FORMAT            ma_format_f32    // Device output format (miniaudio: float-32bit)
-#define RL_AUDIO_DEVICE_CHANNELS          2                // Device output channels: stereo
-#define RL_AUDIO_DEVICE_SAMPLE_RATE       0                // Device sample rate (device default)
-
-#define RL_MAX_AUDIO_BUFFER_POOL_CHANNELS 16    // Maximum number of audio pool channels
-
-//------------------------------------------------------------------------------------
-// Module: utils - Configuration Flags
-//------------------------------------------------------------------------------------
-// Standard file io library (stdio.h) included
-#define RL_SUPPORT_STANDARD_FILEIO 1
-// Show TRACELOG() output messages
-// NOTE: By default LOG_DEBUG traces not shown
-#define RL_SUPPORT_TRACELOG 1
-// #define SUPPORT_TRACELOG_DEBUG          1
-
-// utils: Configuration values
-//------------------------------------------------------------------------------------
-#define RL_MAX_TRACELOG_MSG_LENGTH 256    // Max length of one trace-log message
-
-#endif
-// CONFIG_H

project/auxillary/vis_ast/dependencies/raylib/include/rcamera.h

@@ -1,595 +0,0 @@
-/*******************************************************************************************
- *
- *   rcamera - Basic camera system with support for multiple camera modes
- *
- *   CONFIGURATION:
- *       #define RCAMERA_IMPLEMENTATION
- *           Generates the implementation of the library into the included file.
- *           If not defined, the library is in header only mode and can be included in other headers
- *           or source files without problems. But only ONE file should hold the implementation.
- *
- *       #define RCAMERA_STANDALONE
- *           If defined, the library can be used as standalone as a camera system but some
- *           functions must be redefined to manage inputs accordingly.
- *
- *   CONTRIBUTORS:
- *       Ramon Santamaria:   Supervision, review, update and maintenance
- *       Christoph Wagner:   Complete redesign, using raymath (2022)
- *       Marc Palau:         Initial implementation (2014)
- *
- *
- *   LICENSE: zlib/libpng
- *
- *   Copyright (c) 2022-2023 Christoph Wagner (@Crydsch) & Ramon Santamaria (@raysan5)
- *
- *   This software is provided "as-is", without any express or implied warranty. In no event
- *   will the authors be held liable for any damages arising from the use of this software.
- *
- *   Permission is granted to anyone to use this software for any purpose, including commercial
- *   applications, and to alter it and redistribute it freely, subject to the following restrictions:
- *
- *     1. The origin of this software must not be misrepresented; you must not claim that you
- *     wrote the original software. If you use this software in a product, an acknowledgment
- *     in the product documentation would be appreciated but is not required.
- *
- *     2. Altered source versions must be plainly marked as such, and must not be misrepresented
- *     as being the original software.
- *
- *     3. This notice may not be removed or altered from any source distribution.
- *
- **********************************************************************************************/
-
-#ifndef RCAMERA_H
-#define RL_RCAMERA_H
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-// Function specifiers definition
-
-// Function specifiers in case library is build/used as a shared library (Windows)
-// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
-#if defined( _WIN32 )
-#if defined( BUILD_LIBTYPE_SHARED )
-#if defined( __TINYC__ )
-#define RL___declspec( x ) __attribute__( ( x ) )
-#endif
-#elif defined( USE_LIBTYPE_SHARED )
-#endif
-#endif
-
-#ifndef RLAPI
-#endif
-
-#if defined( RCAMERA_STANDALONE )
-#define RL_CAMERA_CULL_DISTANCE_NEAR 0.01
-#define RL_CAMERA_CULL_DISTANCE_FAR  1000.0
-#else
-#define RL_CAMERA_CULL_DISTANCE_NEAR RL_CULL_DISTANCE_NEAR
-#define RL_CAMERA_CULL_DISTANCE_FAR  RL_CULL_DISTANCE_FAR
-#endif
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-// NOTE: Below types are required for standalone usage
-//----------------------------------------------------------------------------------
-#if defined( RCAMERA_STANDALONE )
-// Vector2, 2 components
-typedef struct Vector2
-{
-	f32 x;    // Vector x component
-	f32 y;    // Vector y component
-
-} Vector2;
-
-// Vector3, 3 components
-typedef struct Vector3
-{
-	f32 x;    // Vector x component
-	f32 y;    // Vector y component
-	f32 z;    // Vector z component
-
-} Vector3;
-
-// Matrix, 4x4 components, column major, OpenGL style, right-handed
-typedef struct Matrix
-{
-	f32 m0, m4, m8, m12;     // Matrix first row (4 components)
-	f32 m1, m5, m9, m13;     // Matrix second row (4 components)
-	f32 m2, m6, m10, m14;    // Matrix third row (4 components)
-	f32 m3, m7, m11, m15;    // Matrix fourth row (4 components)
-
-} Matrix;
-
-// Camera type, defines a camera position/orientation in 3d space
-typedef struct Camera3D
-{
-	Vector3 position;      // Camera position
-	Vector3 target;        // Camera target it looks-at
-	Vector3 up;            // Camera up vector (rotation over its axis)
-	f32     fovy;          // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
-	s32     projection;    // Camera projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
-
-} Camera3D;
-
-typedef Camera3D Camera;    // Camera type fallback, defaults to Camera3D
-
-// Camera projection
-typedef enum
-{
-	Camera_Perspective = 0,    // Perspective projection
-	Camera_Orthographic        // orthographic projection
-
-} CameraProjection;
-
-// Camera system modes
-typedef enum
-{
-	Camera_Custom = 0,      // Camera custom, controlled by user (UpdateCamera() does nothing)
-	Camera_Free,            // Camera free mode
-	Camera_Orbital,         // Camera orbital, around target, zoom supported
-	Camera_First_Person,    // Camera first person
-	Camera_Third_Person     // camera third person
-
-} CameraMode;
-#endif
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-
-#if defined( __cplusplus )
-namespace raylib
-{
-	extern "C"
-	{
-// Prevents name mangling of functions
-#endif
-
-		RLAPI Vector3 get_camera_forward( Camera* camera );
-		RLAPI Vector3 get_camera_up( Camera* camera );
-		RLAPI Vector3 get_camera_right( Camera* camera );
-
-		// Camera movement
-		RLAPI void camera_move_forward( Camera* camera, f32 distance, bool moveInWorldPlane );
-		RLAPI void camera_move_up( Camera* camera, f32 distance );
-		RLAPI void camera_move_right( Camera* camera, f32 distance, bool moveInWorldPlane );
-		RLAPI void camera_move_to_target( Camera* camera, f32 delta );
-
-		// Camera rotation
-		RLAPI void camera_yaw( Camera* camera, f32 angle, bool rotateAroundTarget );
-		RLAPI void camera_pitch( Camera* camera, f32 angle, bool lockView, bool rotateAroundTarget, bool rotateUp );
-		RLAPI void camera_roll( Camera* camera, f32 angle );
-
-		RLAPI Matrix get_camera_view_matrix( Camera* camera );
-		RLAPI Matrix get_camera_projection_matrix( Camera* camera, f32 aspect );
-
-#if defined( __cplusplus )
-	}
-}
-#endif
-
-#endif
-// RCAMERA_H
-
-
-/***********************************************************************************
- *
- *   CAMERA IMPLEMENTATION
- *
- ************************************************************************************/
-
-#if defined( RCAMERA_IMPLEMENTATION )
-
-#include "raymath.h"
-// Required for vector maths:
-// Vector3Add()
-// Vector3Subtract()
-// Vector3Scale()
-// Vector3Normalize()
-// Vector3Distance()
-// Vector3CrossProduct()
-// Vector3RotateByAxisAngle()
-// Vector3Angle()
-// Vector3Negate()
-// MatrixLookAt()
-// MatrixPerspective()
-// MatrixOrtho()
-// MatrixIdentity()
-
-// raylib required functionality:
-// GetMouseDelta()
-// GetMouseWheelMove()
-// IsKeyDown()
-// IsKeyPressed()
-// GetFrameTime()
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#define RL_CAMERA_MOVE_SPEED     0.09f
-#define RL_CAMERA_ROTATION_SPEED 0.03f
-#define RL_CAMERA_PAN_SPEED      0.2f
-
-// Camera mouse movement sensitivity
-#define RL_CAMERA_MOUSE_MOVE_SENSITIVITY                  0.003f    // TODO: it should be independant of framerate
-#define RL_CAMERA_MOUSE_SCROLL_SENSITIVITY                1.5f
-
-#define RL_CAMERA_ORBITAL_SPEED                           0.5f    // Radians per second
-
-
-#define RL_CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER 8.0f
-#define RL_CAMERA_FIRST_PERSON_STEP_DIVIDER               30.0f
-#define RL_CAMERA_FIRST_PERSON_WAVING_DIVIDER             200.0f
-
-// PLAYER (used by camera)
-#define RL_PLAYER_MOVEMENT_SENSITIVITY 20.0f
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Declaration
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-// Returns the cameras forward vector (normalized)
-Vector3 get_camera_forward( Camera* camera )
-{
-	return Vector3Normalize( Vector3Subtract( camera->target, camera->position ) );
-}
-
-// Returns the cameras up vector (normalized)
-// Note: The up vector might not be perpendicular to the forward vector
-Vector3 get_camera_up( Camera* camera )
-{
-	return Vector3Normalize( camera->up );
-}
-
-// Returns the cameras right vector (normalized)
-Vector3 get_camera_right( Camera* camera )
-{
-	Vector3 forward = GetCameraForward( camera );
-	Vector3 up      = GetCameraUp( camera );
-
-	return Vector3CrossProduct( forward, up );
-}
-
-// Moves the camera in its forward direction
-void camera_move_forward( Camera* camera, f32 distance, bool moveInWorldPlane )
-{
-	Vector3 forward = GetCameraForward( camera );
-
-	if ( moveInWorldPlane )
-	{
-		// Project vector onto world plane
-		forward.y = 0;
-		forward   = Vector3Normalize( forward );
-	}
-
-	// Scale by distance
-	forward = Vector3Scale( forward, distance );
-
-	// Move position and target
-	camera->position = Vector3Add( camera->position, forward );
-	camera->target   = Vector3Add( camera->target, forward );
-}
-
-// Moves the camera in its up direction
-void camera_move_up( Camera* camera, f32 distance )
-{
-	Vector3 up = GetCameraUp( camera );
-
-	// Scale by distance
-	up = Vector3Scale( up, distance );
-
-	// Move position and target
-	camera->position = Vector3Add( camera->position, up );
-	camera->target   = Vector3Add( camera->target, up );
-}
-
-// Moves the camera target in its current right direction
-void camera_move_right( Camera* camera, f32 distance, bool moveInWorldPlane )
-{
-	Vector3 right = GetCameraRight( camera );
-
-	if ( moveInWorldPlane )
-	{
-		// Project vector onto world plane
-		right.y = 0;
-		right   = Vector3Normalize( right );
-	}
-
-	// Scale by distance
-	right = Vector3Scale( right, distance );
-
-	// Move position and target
-	camera->position = Vector3Add( camera->position, right );
-	camera->target   = Vector3Add( camera->target, right );
-}
-
-// Moves the camera position closer/farther to/from the camera target
-void camera_move_to_target( Camera* camera, f32 delta )
-{
-	float distance = Vector3Distance( camera->position, camera->target );
-
-	// Apply delta
-	distance += delta;
-
-	// Distance must be greater than 0
-	if ( distance <= 0 )
-		distance = 0.001f;
-
-	// Set new distance by moving the position along the forward vector
-	Vector3 forward  = GetCameraForward( camera );
-	camera->position = Vector3Add( camera->target, Vector3Scale( forward, -distance ) );
-}
-
-// Rotates the camera around its up vector
-// Yaw is "looking left and right"
-// If rotateAroundTarget is false, the camera rotates around its position
-// Note: angle must be provided in radians
-void camera_yaw( Camera* camera, f32 angle, bool rotateAroundTarget )
-{
-	Vector3 up = GetCameraUp( camera );
-
-	// View vector
-	Vector3 targetPosition = Vector3Subtract( camera->target, camera->position );
-
-	// Rotate view vector around up axis
-	targetPosition = Vector3RotateByAxisAngle( targetPosition, up, angle );
-
-	if ( rotateAroundTarget )
-	{
-		// Move position relative to target
-		camera->position = Vector3Subtract( camera->target, targetPosition );
-	}
-	else    // rotate around camera.position
-	{
-		// Move target relative to position
-		camera->target = Vector3Add( camera->position, targetPosition );
-	}
-}
-
-// Rotates the camera around its right vector, pitch is "looking up and down"
-//  - lockView prevents camera overrotation (aka "somersaults")
-//  - rotateAroundTarget defines if rotation is around target or around its position
-//  - rotateUp rotates the up direction as well (typically only usefull in CAMERA_FREE)
-// NOTE: angle must be provided in radians
-void camera_pitch( Camera* camera, f32 angle, bool lockView, bool rotateAroundTarget, bool rotateUp )
-{
-	Vector3 up = GetCameraUp( camera );
-
-	// View vector
-	Vector3 targetPosition = Vector3Subtract( camera->target, camera->position );
-
-	if ( lockView )
-	{
-		// In these camera modes we clamp the Pitch angle
-		// to allow only viewing straight up or down.
-
-		// Clamp view up
-		float maxAngleUp  = Vector3Angle( up, targetPosition );
-		maxAngleUp       -= 0.001f;    // avoid numerical errors
-		if ( angle > maxAngleUp )
-			angle = maxAngleUp;
-
-		// Clamp view down
-		float maxAngleDown  = Vector3Angle( Vector3Negate( up ), targetPosition );
-		maxAngleDown       *= -1.0f;     // downwards angle is negative
-		maxAngleDown       += 0.001f;    // avoid numerical errors
-		if ( angle < maxAngleDown )
-			angle = maxAngleDown;
-	}
-
-	// Rotation axis
-	Vector3 right = GetCameraRight( camera );
-
-	// Rotate view vector around right axis
-	targetPosition = Vector3RotateByAxisAngle( targetPosition, right, angle );
-
-	if ( rotateAroundTarget )
-	{
-		// Move position relative to target
-		camera->position = Vector3Subtract( camera->target, targetPosition );
-	}
-	else    // rotate around camera.position
-	{
-		// Move target relative to position
-		camera->target = Vector3Add( camera->position, targetPosition );
-	}
-
-	if ( rotateUp )
-	{
-		// Rotate up direction around right axis
-		camera->up = Vector3RotateByAxisAngle( camera->up, right, angle );
-	}
-}
-
-// Rotates the camera around its forward vector
-// Roll is "turning your head sideways to the left or right"
-// Note: angle must be provided in radians
-void camera_roll( Camera* camera, f32 angle )
-{
-	Vector3 forward = GetCameraForward( camera );
-
-	// Rotate up direction around forward axis
-	camera->up = Vector3RotateByAxisAngle( camera->up, forward, angle );
-}
-
-// Returns the camera view matrix
-Matrix get_camera_view_matrix( Camera* camera )
-{
-	return MatrixLookAt( camera->position, camera->target, camera->up );
-}
-
-// Returns the camera projection matrix
-Matrix get_camera_projection_matrix( Camera* camera, f32 aspect )
-{
-	if ( camera->projection == CAMERA_PERSPECTIVE )
-	{
-		return MatrixPerspective( camera->fovy * DEG2RAD, aspect, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR );
-	}
-	else if ( camera->projection == CAMERA_ORTHOGRAPHIC )
-	{
-		double top   = camera->fovy / 2.0;
-		double right = top * aspect;
-
-		return MatrixOrtho( -right, right, -top, top, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR );
-	}
-
-	return MatrixIdentity();
-}
-
-#if ! defined( RCAMERA_STANDALONE )
-// Update camera position for selected mode
-// Camera mode: CAMERA_FREE, CAMERA_FIRST_PERSON, CAMERA_THIRD_PERSON, CAMERA_ORBITAL or CUSTOM
-void update_camera( Camera* camera, s32 mode )
-{
-	Vector2 mousePositionDelta = GetMouseDelta();
-
-	bool moveInWorldPlane      = ( ( mode == CAMERA_FIRST_PERSON ) || ( mode == CAMERA_THIRD_PERSON ) );
-	bool rotateAroundTarget    = ( ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) );
-	bool lockView              = ( ( mode == CAMERA_FIRST_PERSON ) || ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) );
-	bool rotateUp              = false;
-
-	if ( mode == CAMERA_ORBITAL )
-	{
-		// Orbital can just orbit
-		Matrix  rotation = MatrixRotate( GetCameraUp( camera ), CAMERA_ORBITAL_SPEED * GetFrameTime() );
-		Vector3 view     = Vector3Subtract( camera->position, camera->target );
-		view             = Vector3Transform( view, rotation );
-		camera->position = Vector3Add( camera->target, view );
-	}
-	else
-	{
-		// Camera rotation
-		if ( IsKeyDown( KEY_DOWN ) )
-			CameraPitch( camera, -CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp );
-		if ( IsKeyDown( KEY_UP ) )
-			CameraPitch( camera, CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp );
-		if ( IsKeyDown( KEY_RIGHT ) )
-			CameraYaw( camera, -CAMERA_ROTATION_SPEED, rotateAroundTarget );
-		if ( IsKeyDown( KEY_LEFT ) )
-			CameraYaw( camera, CAMERA_ROTATION_SPEED, rotateAroundTarget );
-		if ( IsKeyDown( KEY_Q ) )
-			CameraRoll( camera, -CAMERA_ROTATION_SPEED );
-		if ( IsKeyDown( KEY_E ) )
-			CameraRoll( camera, CAMERA_ROTATION_SPEED );
-
-		// Camera movement
-		if ( ! IsGamepadAvailable( 0 ) )
-		{
-			// Camera pan (for CAMERA_FREE)
-			if ( ( mode == CAMERA_FREE ) && ( IsMouseButtonDown( MOUSE_BUTTON_MIDDLE ) ) )
-			{
-				const Vector2 mouseDelta = GetMouseDelta();
-				if ( mouseDelta.x > 0.0f )
-					CameraMoveRight( camera, CAMERA_PAN_SPEED, moveInWorldPlane );
-				if ( mouseDelta.x < 0.0f )
-					CameraMoveRight( camera, -CAMERA_PAN_SPEED, moveInWorldPlane );
-				if ( mouseDelta.y > 0.0f )
-					CameraMoveUp( camera, -CAMERA_PAN_SPEED );
-				if ( mouseDelta.y < 0.0f )
-					CameraMoveUp( camera, CAMERA_PAN_SPEED );
-			}
-			else
-			{
-				// Mouse support
-				CameraYaw( camera, -mousePositionDelta.x * CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget );
-				CameraPitch( camera, -mousePositionDelta.y * CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp );
-			}
-
-			// Keyboard support
-			if ( IsKeyDown( KEY_W ) )
-				CameraMoveForward( camera, CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( IsKeyDown( KEY_A ) )
-				CameraMoveRight( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( IsKeyDown( KEY_S ) )
-				CameraMoveForward( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( IsKeyDown( KEY_D ) )
-				CameraMoveRight( camera, CAMERA_MOVE_SPEED, moveInWorldPlane );
-		}
-		else
-		{
-			// Gamepad controller support
-			CameraYaw( camera, -( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_RIGHT_X ) * 2 ) * CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget );
-			CameraPitch(
-			    camera,
-			    -( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_RIGHT_Y ) * 2 ) * CAMERA_MOUSE_MOVE_SENSITIVITY,
-			    lockView,
-			    rotateAroundTarget,
-			    rotateUp
-			);
-
-			if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_Y ) <= -0.25f )
-				CameraMoveForward( camera, CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_X ) <= -0.25f )
-				CameraMoveRight( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_Y ) >= 0.25f )
-				CameraMoveForward( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane );
-			if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_X ) >= 0.25f )
-				CameraMoveRight( camera, CAMERA_MOVE_SPEED, moveInWorldPlane );
-		}
-
-		if ( mode == CAMERA_FREE )
-		{
-			if ( IsKeyDown( KEY_SPACE ) )
-				CameraMoveUp( camera, CAMERA_MOVE_SPEED );
-			if ( IsKeyDown( KEY_LEFT_CONTROL ) )
-				CameraMoveUp( camera, -CAMERA_MOVE_SPEED );
-		}
-	}
-
-	if ( ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) || ( mode == CAMERA_FREE ) )
-	{
-		// Zoom target distance
-		CameraMoveToTarget( camera, -GetMouseWheelMove() );
-		if ( IsKeyPressed( KEY_KP_SUBTRACT ) )
-			CameraMoveToTarget( camera, 2.0f );
-		if ( IsKeyPressed( KEY_KP_ADD ) )
-			CameraMoveToTarget( camera, -2.0f );
-	}
-}
-#endif
-// !RCAMERA_STANDALONE
-
-// Update camera movement, movement/rotation values should be provided by user
-void update_camera_pro( Camera* camera, Vector3 movement, Vector3 rotation, f32 zoom )
-{
-	bool lockView           = true;
-	bool rotateAroundTarget = false;
-	bool rotateUp           = false;
-	bool moveInWorldPlane   = true;
-
-	// Camera rotation
-	CameraPitch( camera, -rotation.y * DEG2RAD, lockView, rotateAroundTarget, rotateUp );
-	CameraYaw( camera, -rotation.x * DEG2RAD, rotateAroundTarget );
-	CameraRoll( camera, rotation.z * DEG2RAD );
-
-	// Camera movement
-	CameraMoveForward( camera, movement.x, moveInWorldPlane );
-	CameraMoveRight( camera, movement.y, moveInWorldPlane );
-	CameraMoveUp( camera, movement.z );
-
-	// Zoom target distance
-	CameraMoveToTarget( camera, zoom );
-}
-
-#endif
-// RCAMERA_IMPLEMENTATION

project/auxillary/vis_ast/dependencies/raylib/include/rcore.h

@@ -1,233 +0,0 @@
-/**********************************************************************************************
- *
- *   rcore - Common types and globals (all platforms)
- *
- *   LIMITATIONS:
- *       - Limitation 01
- *       - Limitation 02
- *
- *   POSSIBLE IMPROVEMENTS:
- *       - Improvement 01
- *       - Improvement 02
- *
- *
- *   LICENSE: zlib/libpng
- *
- *   Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) and contributors
- *
- *   This software is provided "as-is", without any express or implied warranty. In no event
- *   will the authors be held liable for any damages arising from the use of this software.
- *
- *   Permission is granted to anyone to use this software for any purpose, including commercial
- *   applications, and to alter it and redistribute it freely, subject to the following restrictions:
- *
- *     1. The origin of this software must not be misrepresented; you must not claim that you
- *     wrote the original software. If you use this software in a product, an acknowledgment
- *     in the product documentation would be appreciated but is not required.
- *
- *     2. Altered source versions must be plainly marked as such, and must not be misrepresented
- *     as being the original software.
- *
- *     3. This notice may not be removed or altered from any source distribution.
- *
- **********************************************************************************************/
-
-#ifndef RCORE_H
-#define RCORE_H
-
-#include "raylib.h"
-
-#include "utils.h"    // Required for: TRACELOG() macros
-
-#include "rlgl.h"    // Required for: graphics layer functionality
-
-#define RAYMATH_IMPLEMENTATION
-#include "raymath.h"    // Required for: Vector2/Vector3/Matrix functionality
-
-#include <stdlib.h>    // Required for: srand(), rand(), atexit()
-#include <stdio.h>     // Required for: sprintf() [Used in OpenURL()]
-#include <string.h>    // Required for: strrchr(), strcmp(), strlen(), memset()
-#include <time.h>      // Required for: time() [Used in InitTimer()]
-#include <math.h>      // Required for: tan() [Used in BeginMode3D()], atan2f() [Used in LoadVrStereoConfig()]
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#ifndef MAX_FILEPATH_CAPACITY
-#define MAX_FILEPATH_CAPACITY 8192    // Maximum capacity for filepath
-#endif
-#ifndef MAX_FILEPATH_LENGTH
-#define MAX_FILEPATH_LENGTH 4096    // Maximum length for filepaths (Linux PATH_MAX default value)
-#endif
-
-#ifndef MAX_KEYBOARD_KEYS
-#define MAX_KEYBOARD_KEYS 512    // Maximum number of keyboard keys supported
-#endif
-#ifndef MAX_MOUSE_BUTTONS
-#define MAX_MOUSE_BUTTONS 8    // Maximum number of mouse buttons supported
-#endif
-#ifndef MAX_GAMEPADS
-#define MAX_GAMEPADS 4    // Maximum number of gamepads supported
-#endif
-#ifndef MAX_GAMEPAD_AXIS
-#define MAX_GAMEPAD_AXIS 8    // Maximum number of axis supported (per gamepad)
-#endif
-#ifndef MAX_GAMEPAD_BUTTONS
-#define MAX_GAMEPAD_BUTTONS 32    // Maximum number of buttons supported (per gamepad)
-#endif
-#ifndef MAX_TOUCH_POINTS
-#define MAX_TOUCH_POINTS 8    // Maximum number of touch points supported
-#endif
-#ifndef MAX_KEY_PRESSED_QUEUE
-#define MAX_KEY_PRESSED_QUEUE 16    // Maximum number of keys in the key input queue
-#endif
-#ifndef MAX_CHAR_PRESSED_QUEUE
-#define MAX_CHAR_PRESSED_QUEUE 16    // Maximum number of characters in the char input queue
-#endif
-
-#ifndef MAX_DECOMPRESSION_SIZE
-#define MAX_DECOMPRESSION_SIZE 64    // Maximum size allocated for decompression in MB
-#endif
-
-// Flags operation macros
-#define FLAG_SET( n, f )    ( ( n ) |= ( f ) )
-#define FLAG_CLEAR( n, f )  ( ( n ) &= ~( f ) )
-#define FLAG_TOGGLE( n, f ) ( ( n ) ^= ( f ) )
-#define FLAG_CHECK( n, f )  ( ( n ) & ( f ) )
-
-#if ( defined( __linux__ ) || defined( PLATFORM_WEB ) ) && ( _POSIX_C_SOURCE < 199309L )
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 199309L    // Required for: CLOCK_MONOTONIC if compiled with c99 without gnu ext.
-#endif
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-typedef struct
-{
-	int x;
-	int y;
-} Point;
-
-typedef struct
-{
-	unsigned int width;
-	unsigned int height;
-} Size;
-
-// Core global state context data
-typedef struct CoreData
-{
-	struct
-	{
-		const char*  title;               // Window text title const pointer
-		unsigned int flags;               // Configuration flags (bit based), keeps window state
-		bool         ready;               // Check if window has been initialized successfully
-		bool         fullscreen;          // Check if fullscreen mode is enabled
-		bool         shouldClose;         // Check if window set for closing
-		bool         resizedLastFrame;    // Check if window has been resized last frame
-		bool         eventWaiting;        // Wait for events before ending frame
-
-		Point  position;            // Window position (required on fullscreen toggle)
-		Point  previousPosition;    // Window previous position (required on borderless windowed toggle)
-		Size   display;             // Display width and height (monitor, device-screen, LCD, ...)
-		Size   screen;              // Screen width and height (used render area)
-		Size   previousScreen;      // Screen previous width and height (required on borderless windowed toggle)
-		Size   currentFbo;          // Current render width and height (depends on active fbo)
-		Size   render;              // Framebuffer width and height (render area, including black bars if required)
-		Point  renderOffset;        // Offset from render area (must be divided by 2)
-		Size   screenMin;           // Screen minimum width and height (for resizable window)
-		Size   screenMax;           // Screen maximum width and height (for resizable window)
-		Matrix screenScale;         // Matrix to scale screen (framebuffer rendering)
-
-		char**       dropFilepaths;    // Store dropped files paths pointers (provided by GLFW)
-		unsigned int dropFileCount;    // Count dropped files strings
-
-	} Window;
-
-	struct
-	{
-		const char* basePath;    // Base path for data storage
-
-	} Storage;
-
-	struct
-	{
-		struct
-		{
-			int  exitKey;                                  // Default exit key
-			char currentKeyState[ MAX_KEYBOARD_KEYS ];     // Registers current frame key state
-			char previousKeyState[ MAX_KEYBOARD_KEYS ];    // Registers previous frame key state
-
-			// NOTE: Since key press logic involves comparing prev vs cur key state, we need to handle key repeats specially
-			char keyRepeatInFrame[ MAX_KEYBOARD_KEYS ];    // Registers key repeats for current frame.
-
-			int keyPressedQueue[ MAX_KEY_PRESSED_QUEUE ];    // Input keys queue
-			int keyPressedQueueCount;                        // Input keys queue count
-
-			int charPressedQueue[ MAX_CHAR_PRESSED_QUEUE ];    // Input characters queue (unicode)
-			int charPressedQueueCount;                         // Input characters queue count
-
-		} Keyboard;
-
-		struct
-		{
-			Vector2 offset;              // Mouse offset
-			Vector2 scale;               // Mouse scaling
-			Vector2 currentPosition;     // Mouse position on screen
-			Vector2 previousPosition;    // Previous mouse position
-
-			int  cursor;            // Tracks current mouse cursor
-			bool cursorHidden;      // Track if cursor is hidden
-			bool cursorOnScreen;    // Tracks if cursor is inside client area
-
-			char    currentButtonState[ MAX_MOUSE_BUTTONS ];     // Registers current mouse button state
-			char    previousButtonState[ MAX_MOUSE_BUTTONS ];    // Registers previous mouse button state
-			Vector2 currentWheelMove;                            // Registers current mouse wheel variation
-			Vector2 previousWheelMove;                           // Registers previous mouse wheel variation
-
-		} Mouse;
-
-		struct
-		{
-			int     pointCount;                                // Number of touch points active
-			int     pointId[ MAX_TOUCH_POINTS ];               // Point identifiers
-			Vector2 position[ MAX_TOUCH_POINTS ];              // Touch position on screen
-			char    currentTouchState[ MAX_TOUCH_POINTS ];     // Registers current touch state
-			char    previousTouchState[ MAX_TOUCH_POINTS ];    // Registers previous touch state
-
-		} Touch;
-
-		struct
-		{
-			int   lastButtonPressed;                                             // Register last gamepad button pressed
-			int   axisCount[ MAX_GAMEPADS ];                                     // Register number of available gamepad axis
-			bool  ready[ MAX_GAMEPADS ];                                         // Flag to know if gamepad is ready
-			char  name[ MAX_GAMEPADS ][ 64 ];                                    // Gamepad name holder
-			char  currentButtonState[ MAX_GAMEPADS ][ MAX_GAMEPAD_BUTTONS ];     // Current gamepad buttons state
-			char  previousButtonState[ MAX_GAMEPADS ][ MAX_GAMEPAD_BUTTONS ];    // Previous gamepad buttons state
-			float axisState[ MAX_GAMEPADS ][ MAX_GAMEPAD_AXIS ];                 // Gamepad axis state
-
-		} Gamepad;
-	} Input;
-
-	struct
-	{
-		double                 current;         // Current time measure
-		double                 previous;        // Previous time measure
-		double                 update;          // Time measure for frame update
-		double                 draw;            // Time measure for frame draw
-		double                 frame;           // Time measure for one frame
-		double                 target;          // Desired time for one frame, if 0 not applied
-		unsigned long long int base;            // Base time measure for hi-res timer (PLATFORM_ANDROID, PLATFORM_DRM)
-		unsigned int           frameCounter;    // Frame counter
-
-	} Time;
-} CoreData;
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-extern CoreData CORE;
-
-#endif

project/auxillary/vis_ast/dependencies/raylib/include/rgestures.h

@@ -1,594 +0,0 @@
-/**********************************************************************************************
- *
- *   rgestures - Gestures system, gestures processing based on input events (touch/mouse)
- *
- *   CONFIGURATION:
- *       #define RGESTURES_IMPLEMENTATION
- *           Generates the implementation of the library into the included file.
- *           If not defined, the library is in header only mode and can be included in other headers
- *           or source files without problems. But only ONE file should hold the implementation.
- *
- *       #define RGESTURES_STANDALONE
- *           If defined, the library can be used as standalone to process gesture events with
- *           no external dependencies.
- *
- *   CONTRIBUTORS:
- *       Marc Palau:         Initial implementation (2014)
- *       Albert Martos:      Complete redesign and testing (2015)
- *       Ian Eito:           Complete redesign and testing (2015)
- *       Ramon Santamaria:   Supervision, review, update and maintenance
- *
- *
- *   LICENSE: zlib/libpng
- *
- *   Copyright (c) 2014-2023 Ramon Santamaria (@raysan5)
- *
- *   This software is provided "as-is", without any express or implied warranty. In no event
- *   will the authors be held liable for any damages arising from the use of this software.
- *
- *   Permission is granted to anyone to use this software for any purpose, including commercial
- *   applications, and to alter it and redistribute it freely, subject to the following restrictions:
- *
- *     1. The origin of this software must not be misrepresented; you must not claim that you
- *     wrote the original software. If you use this software in a product, an acknowledgment
- *     in the product documentation would be appreciated but is not required.
- *
- *     2. Altered source versions must be plainly marked as such, and must not be misrepresented
- *     as being the original software.
- *
- *     3. This notice may not be removed or altered from any source distribution.
- *
- **********************************************************************************************/
-
-#ifndef RGESTURES_H
-#define RGESTURES_H
-
-#ifndef PI
-#define PI 3.14159265358979323846
-#endif
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#ifndef MAX_TOUCH_POINTS
-#define MAX_TOUCH_POINTS 8    // Maximum number of touch points supported
-#endif
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-// NOTE: Below types are required for standalone usage
-//----------------------------------------------------------------------------------
-// Boolean type
-#if ( defined( __STDC__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( _MSC_VER ) && _MSC_VER >= 1800 )
-#include <stdbool.h>
-#elif ! defined( __cplusplus ) && ! defined( bool ) && ! defined( RL_BOOL_TYPE )
-typedef enum bool
-{
-	false = 0,
-	true  = ! false
-} bool;
-#endif
-
-#if ! defined( RL_VECTOR2_TYPE )
-// Vector2 type
-typedef struct Vector2
-{
-	float x;
-	float y;
-} Vector2;
-#endif
-
-#if defined( RGESTURES_STANDALONE )
-// Gestures type
-// NOTE: It could be used as flags to enable only some gestures
-typedef enum
-{
-	GESTURE_NONE        = 0,
-	GESTURE_TAP         = 1,
-	GESTURE_DOUBLETAP   = 2,
-	GESTURE_HOLD        = 4,
-	GESTURE_DRAG        = 8,
-	GESTURE_SWIPE_RIGHT = 16,
-	GESTURE_SWIPE_LEFT  = 32,
-	GESTURE_SWIPE_UP    = 64,
-	GESTURE_SWIPE_DOWN  = 128,
-	GESTURE_PINCH_IN    = 256,
-	GESTURE_PINCH_OUT   = 512
-} Gesture;
-#endif
-
-typedef enum
-{
-	TOUCH_ACTION_UP = 0,
-	TOUCH_ACTION_DOWN,
-	TOUCH_ACTION_MOVE,
-	TOUCH_ACTION_CANCEL
-} TouchAction;
-
-// Gesture event
-typedef struct
-{
-	int     touchAction;
-	int     pointCount;
-	int     pointId[ MAX_TOUCH_POINTS ];
-	Vector2 position[ MAX_TOUCH_POINTS ];
-} GestureEvent;
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-
-#if defined( __cplusplus )
-extern "C"
-{    // Prevents name mangling of functions
-#endif
-
-	void ProcessGestureEvent( GestureEvent event );    // Process gesture event and translate it into gestures
-	void UpdateGestures( void );                       // Update gestures detected (must be called every frame)
-
-#if defined( RGESTURES_STANDALONE )
-	void SetGesturesEnabled( unsigned int flags );    // Enable a set of gestures using flags
-	bool IsGestureDetected( int gesture );            // Check if a gesture have been detected
-	int  GetGestureDetected( void );                  // Get latest detected gesture
-
-	float   GetGestureHoldDuration( void );    // Get gesture hold time in seconds
-	Vector2 GetGestureDragVector( void );      // Get gesture drag vector
-	float   GetGestureDragAngle( void );       // Get gesture drag angle
-	Vector2 GetGesturePinchVector( void );     // Get gesture pinch delta
-	float   GetGesturePinchAngle( void );      // Get gesture pinch angle
-#endif
-
-#if defined( __cplusplus )
-}
-#endif
-
-#endif    // RGESTURES_H
-
-/***********************************************************************************
- *
- *   RGESTURES IMPLEMENTATION
- *
- ************************************************************************************/
-
-#if defined( RGESTURES_IMPLEMENTATION )
-
-#if defined( RGESTURES_STANDALONE )
-#if defined( _WIN32 )
-#if defined( __cplusplus )
-extern "C"
-{    // Prevents name mangling of functions
-#endif
-	// Functions required to query time on Windows
-	int __stdcall QueryPerformanceCounter( unsigned long long int* lpPerformanceCount );
-	int __stdcall QueryPerformanceFrequency( unsigned long long int* lpFrequency );
-#if defined( __cplusplus )
-}
-#endif
-#elif defined( __linux__ )
-#if _POSIX_C_SOURCE < 199309L
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 199309L    // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
-#endif
-#include <sys/time.h>    // Required for: timespec
-#include <time.h>        // Required for: clock_gettime()
-
-#include <math.h>    // Required for: sqrtf(), atan2f()
-#endif
-#if defined( __APPLE__ )    // macOS also defines __MACH__
-#include <mach/clock.h>     // Required for: clock_get_time()
-#include <mach/mach.h>      // Required for: mach_timespec_t
-#endif
-#endif
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#define FORCE_TO_SWIPE  0.2f      // Swipe force, measured in normalized screen units/time
-#define MINIMUM_DRAG    0.015f    // Drag minimum force, measured in normalized screen units (0.0f to 1.0f)
-#define DRAG_TIMEOUT    0.3f      // Drag minimum time for web, measured in seconds
-#define MINIMUM_PINCH   0.005f    // Pinch minimum force, measured in normalized screen units (0.0f to 1.0f)
-#define TAP_TIMEOUT     0.3f      // Tap minimum time, measured in seconds
-#define PINCH_TIMEOUT   0.3f      // Pinch minimum time, measured in seconds
-#define DOUBLETAP_RANGE 0.03f     // DoubleTap range, measured in normalized screen units (0.0f to 1.0f)
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-
-// Gestures module state context [136 bytes]
-typedef struct
-{
-	unsigned int current;         // Current detected gesture
-	unsigned int enabledFlags;    // Enabled gestures flags
-
-	struct
-	{
-		int     firstId;              // Touch id for first touch point
-		int     pointCount;           // Touch points counter
-		double  eventTime;            // Time stamp when an event happened
-		Vector2 upPosition;           // Touch up position
-		Vector2 downPositionA;        // First touch down position
-		Vector2 downPositionB;        // Second touch down position
-		Vector2 downDragPosition;     // Touch drag position
-		Vector2 moveDownPositionA;    // First touch down position on move
-		Vector2 moveDownPositionB;    // Second touch down position on move
-		Vector2 previousPositionA;    // Previous position A to compare for pinch gestures
-		Vector2 previousPositionB;    // Previous position B to compare for pinch gestures
-		int     tapCounter;           // TAP counter (one tap implies TOUCH_ACTION_DOWN and TOUCH_ACTION_UP actions)
-	} Touch;
-
-	struct
-	{
-		bool   resetRequired;    // HOLD reset to get first touch point again
-		double timeDuration;     // HOLD duration in seconds
-	} Hold;
-
-	struct
-	{
-		Vector2 vector;       // DRAG vector (between initial and current position)
-		float   angle;        // DRAG angle (relative to x-axis)
-		float   distance;     // DRAG distance (from initial touch point to final) (normalized [0..1])
-		float   intensity;    // DRAG intensity, how far why did the DRAG (pixels per frame)
-	} Drag;
-
-	struct
-	{
-		double startTime;    // SWIPE start time to calculate drag intensity
-	} Swipe;
-
-	struct
-	{
-		Vector2 vector;      // PINCH vector (between first and second touch points)
-		float   angle;       // PINCH angle (relative to x-axis)
-		float   distance;    // PINCH displacement distance (normalized [0..1])
-	} Pinch;
-} GesturesData;
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-static GesturesData GESTURES = {
-	.Touch.firstId = -1,
-	.current       = GESTURE_NONE,         // No current gesture detected
-	.enabledFlags  = 0b0000001111111111    // All gestures supported by default
-};
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Declaration
-//----------------------------------------------------------------------------------
-static float  rgVector2Angle( Vector2 initialPosition, Vector2 finalPosition );
-static float  rgVector2Distance( Vector2 v1, Vector2 v2 );
-static double rgGetCurrentTime( void );
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-
-// Enable only desired gestures to be detected
-void SetGesturesEnabled( unsigned int flags )
-{
-	GESTURES.enabledFlags = flags;
-}
-
-// Check if a gesture have been detected
-bool IsGestureDetected( unsigned int gesture )
-{
-	if ( ( GESTURES.enabledFlags & GESTURES.current ) == gesture )
-		return true;
-	else
-		return false;
-}
-
-// Process gesture event and translate it into gestures
-void ProcessGestureEvent( GestureEvent event )
-{
-	// Reset required variables
-	GESTURES.Touch.pointCount = event.pointCount;    // Required on UpdateGestures()
-
-	if ( GESTURES.Touch.pointCount == 1 )    // One touch point
-	{
-		if ( event.touchAction == TOUCH_ACTION_DOWN )
-		{
-			GESTURES.Touch.tapCounter++;    // Tap counter
-
-			// Detect GESTURE_DOUBLE_TAP
-			if ( ( GESTURES.current == GESTURE_NONE ) && ( GESTURES.Touch.tapCounter >= 2 )
-			     && ( ( rgGetCurrentTime() - GESTURES.Touch.eventTime ) < TAP_TIMEOUT )
-			     && ( rgVector2Distance( GESTURES.Touch.downPositionA, event.position[ 0 ] ) < DOUBLETAP_RANGE ) )
-			{
-				GESTURES.current          = GESTURE_DOUBLETAP;
-				GESTURES.Touch.tapCounter = 0;
-			}
-			else    // Detect GESTURE_TAP
-			{
-				GESTURES.Touch.tapCounter = 1;
-				GESTURES.current          = GESTURE_TAP;
-			}
-
-			GESTURES.Touch.downPositionA    = event.position[ 0 ];
-			GESTURES.Touch.downDragPosition = event.position[ 0 ];
-
-			GESTURES.Touch.upPosition       = GESTURES.Touch.downPositionA;
-			GESTURES.Touch.eventTime        = rgGetCurrentTime();
-
-			GESTURES.Swipe.startTime        = rgGetCurrentTime();
-
-			GESTURES.Drag.vector            = ( Vector2 ) { 0.0f, 0.0f };
-		}
-		else if ( event.touchAction == TOUCH_ACTION_UP )
-		{
-			// A swipe can happen while the current gesture is drag, but (specially for web) also hold, so set upPosition for both cases
-			if ( GESTURES.current == GESTURE_DRAG || GESTURES.current == GESTURE_HOLD )
-				GESTURES.Touch.upPosition = event.position[ 0 ];
-
-			// NOTE: GESTURES.Drag.intensity dependent on the resolution of the screen
-			GESTURES.Drag.distance  = rgVector2Distance( GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition );
-			GESTURES.Drag.intensity = GESTURES.Drag.distance / ( float )( ( rgGetCurrentTime() - GESTURES.Swipe.startTime ) );
-
-			// Detect GESTURE_SWIPE
-			if ( ( GESTURES.Drag.intensity > FORCE_TO_SWIPE ) && ( GESTURES.current != GESTURE_DRAG ) )
-			{
-				// NOTE: Angle should be inverted in Y
-				GESTURES.Drag.angle = 360.0f - rgVector2Angle( GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition );
-
-				if ( ( GESTURES.Drag.angle < 30 ) || ( GESTURES.Drag.angle > 330 ) )
-					GESTURES.current = GESTURE_SWIPE_RIGHT;    // Right
-				else if ( ( GESTURES.Drag.angle >= 30 ) && ( GESTURES.Drag.angle <= 150 ) )
-					GESTURES.current = GESTURE_SWIPE_UP;    // Up
-				else if ( ( GESTURES.Drag.angle > 150 ) && ( GESTURES.Drag.angle < 210 ) )
-					GESTURES.current = GESTURE_SWIPE_LEFT;    // Left
-				else if ( ( GESTURES.Drag.angle >= 210 ) && ( GESTURES.Drag.angle <= 330 ) )
-					GESTURES.current = GESTURE_SWIPE_DOWN;    // Down
-				else
-					GESTURES.current = GESTURE_NONE;
-			}
-			else
-			{
-				GESTURES.Drag.distance  = 0.0f;
-				GESTURES.Drag.intensity = 0.0f;
-				GESTURES.Drag.angle     = 0.0f;
-
-				GESTURES.current        = GESTURE_NONE;
-			}
-
-			GESTURES.Touch.downDragPosition = ( Vector2 ) { 0.0f, 0.0f };
-			GESTURES.Touch.pointCount       = 0;
-		}
-		else if ( event.touchAction == TOUCH_ACTION_MOVE )
-		{
-			GESTURES.Touch.moveDownPositionA = event.position[ 0 ];
-
-			if ( GESTURES.current == GESTURE_HOLD )
-			{
-				if ( GESTURES.Hold.resetRequired )
-					GESTURES.Touch.downPositionA = event.position[ 0 ];
-
-				GESTURES.Hold.resetRequired = false;
-
-				// Detect GESTURE_DRAG
-				if ( ( rgGetCurrentTime() - GESTURES.Touch.eventTime ) > DRAG_TIMEOUT )
-				{
-					GESTURES.Touch.eventTime = rgGetCurrentTime();
-					GESTURES.current         = GESTURE_DRAG;
-				}
-			}
-
-			GESTURES.Drag.vector.x = GESTURES.Touch.moveDownPositionA.x - GESTURES.Touch.downDragPosition.x;
-			GESTURES.Drag.vector.y = GESTURES.Touch.moveDownPositionA.y - GESTURES.Touch.downDragPosition.y;
-		}
-	}
-	else if ( GESTURES.Touch.pointCount == 2 )    // Two touch points
-	{
-		if ( event.touchAction == TOUCH_ACTION_DOWN )
-		{
-			GESTURES.Touch.downPositionA     = event.position[ 0 ];
-			GESTURES.Touch.downPositionB     = event.position[ 1 ];
-
-			GESTURES.Touch.previousPositionA = GESTURES.Touch.downPositionA;
-			GESTURES.Touch.previousPositionB = GESTURES.Touch.downPositionB;
-
-			// GESTURES.Pinch.distance = rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.downPositionB);
-
-			GESTURES.Pinch.vector.x    = GESTURES.Touch.downPositionB.x - GESTURES.Touch.downPositionA.x;
-			GESTURES.Pinch.vector.y    = GESTURES.Touch.downPositionB.y - GESTURES.Touch.downPositionA.y;
-
-			GESTURES.current           = GESTURE_HOLD;
-			GESTURES.Hold.timeDuration = rgGetCurrentTime();
-		}
-		else if ( event.touchAction == TOUCH_ACTION_MOVE )
-		{
-			GESTURES.Pinch.distance          = rgVector2Distance( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB );
-
-			GESTURES.Touch.moveDownPositionA = event.position[ 0 ];
-			GESTURES.Touch.moveDownPositionB = event.position[ 1 ];
-
-			GESTURES.Pinch.vector.x          = GESTURES.Touch.moveDownPositionB.x - GESTURES.Touch.moveDownPositionA.x;
-			GESTURES.Pinch.vector.y          = GESTURES.Touch.moveDownPositionB.y - GESTURES.Touch.moveDownPositionA.y;
-
-			if ( ( rgVector2Distance( GESTURES.Touch.previousPositionA, GESTURES.Touch.moveDownPositionA ) >= MINIMUM_PINCH )
-			     || ( rgVector2Distance( GESTURES.Touch.previousPositionB, GESTURES.Touch.moveDownPositionB ) >= MINIMUM_PINCH ) )
-			{
-				if ( rgVector2Distance( GESTURES.Touch.previousPositionA, GESTURES.Touch.previousPositionB )
-				     > rgVector2Distance( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB ) )
-					GESTURES.current = GESTURE_PINCH_IN;
-				else
-					GESTURES.current = GESTURE_PINCH_OUT;
-			}
-			else
-			{
-				GESTURES.current           = GESTURE_HOLD;
-				GESTURES.Hold.timeDuration = rgGetCurrentTime();
-			}
-
-			// NOTE: Angle should be inverted in Y
-			GESTURES.Pinch.angle = 360.0f - rgVector2Angle( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB );
-		}
-		else if ( event.touchAction == TOUCH_ACTION_UP )
-		{
-			GESTURES.Pinch.distance   = 0.0f;
-			GESTURES.Pinch.angle      = 0.0f;
-			GESTURES.Pinch.vector     = ( Vector2 ) { 0.0f, 0.0f };
-			GESTURES.Touch.pointCount = 0;
-
-			GESTURES.current          = GESTURE_NONE;
-		}
-	}
-	else if ( GESTURES.Touch.pointCount > 2 )    // More than two touch points
-	{
-		// TODO: Process gesture events for more than two points
-	}
-}
-
-// Update gestures detected (must be called every frame)
-void UpdateGestures( void )
-{
-	// NOTE: Gestures are processed through system callbacks on touch events
-
-	// Detect GESTURE_HOLD
-	if ( ( ( GESTURES.current == GESTURE_TAP ) || ( GESTURES.current == GESTURE_DOUBLETAP ) ) && ( GESTURES.Touch.pointCount < 2 ) )
-	{
-		GESTURES.current           = GESTURE_HOLD;
-		GESTURES.Hold.timeDuration = rgGetCurrentTime();
-	}
-
-	// Detect GESTURE_NONE
-	if ( ( GESTURES.current == GESTURE_SWIPE_RIGHT ) || ( GESTURES.current == GESTURE_SWIPE_UP ) || ( GESTURES.current == GESTURE_SWIPE_LEFT )
-	     || ( GESTURES.current == GESTURE_SWIPE_DOWN ) )
-	{
-		GESTURES.current = GESTURE_NONE;
-	}
-}
-
-// Get latest detected gesture
-int GetGestureDetected( void )
-{
-	// Get current gesture only if enabled
-	return ( GESTURES.enabledFlags & GESTURES.current );
-}
-
-// Hold time measured in ms
-float GetGestureHoldDuration( void )
-{
-	// NOTE: time is calculated on current gesture HOLD
-
-	double time = 0.0;
-
-	if ( GESTURES.current == GESTURE_HOLD )
-		time = rgGetCurrentTime() - GESTURES.Hold.timeDuration;
-
-	return ( float )time;
-}
-
-// Get drag vector (between initial touch point to current)
-Vector2 GetGestureDragVector( void )
-{
-	// NOTE: drag vector is calculated on one touch points TOUCH_ACTION_MOVE
-
-	return GESTURES.Drag.vector;
-}
-
-// Get drag angle
-// NOTE: Angle in degrees, horizontal-right is 0, counterclockwise
-float GetGestureDragAngle( void )
-{
-	// NOTE: drag angle is calculated on one touch points TOUCH_ACTION_UP
-
-	return GESTURES.Drag.angle;
-}
-
-// Get distance between two pinch points
-Vector2 GetGesturePinchVector( void )
-{
-	// NOTE: Pinch distance is calculated on two touch points TOUCH_ACTION_MOVE
-
-	return GESTURES.Pinch.vector;
-}
-
-// Get angle between two pinch points
-// NOTE: Angle in degrees, horizontal-right is 0, counterclockwise
-float GetGesturePinchAngle( void )
-{
-	// NOTE: pinch angle is calculated on two touch points TOUCH_ACTION_MOVE
-
-	return GESTURES.Pinch.angle;
-}
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Definition
-//----------------------------------------------------------------------------------
-// Get angle from two-points vector with X-axis
-static float rgVector2Angle( Vector2 v1, Vector2 v2 )
-{
-	float angle = atan2f( v2.y - v1.y, v2.x - v1.x ) * ( 180.0f / PI );
-
-	if ( angle < 0 )
-		angle += 360.0f;
-
-	return angle;
-}
-
-// Calculate distance between two Vector2
-static float rgVector2Distance( Vector2 v1, Vector2 v2 )
-{
-	float result;
-
-	float dx = v2.x - v1.x;
-	float dy = v2.y - v1.y;
-
-	result   = ( float )sqrt( dx * dx + dy * dy );
-
-	return result;
-}
-
-// Time measure returned are seconds
-static double rgGetCurrentTime( void )
-{
-	double time = 0;
-
-#if ! defined( RGESTURES_STANDALONE )
-	time = GetTime();
-#else
-#if defined( _WIN32 )
-	unsigned long long int clockFrequency, currentTime;
-
-	QueryPerformanceFrequency( &clockFrequency );    // BE CAREFUL: Costly operation!
-	QueryPerformanceCounter( &currentTime );
-
-	time = ( double )currentTime / clockFrequency;    // Time in seconds
-#endif
-
-#if defined( __linux__ )
-	// NOTE: Only for Linux-based systems
-	struct timespec now;
-	clock_gettime( CLOCK_MONOTONIC, &now );
-	unsigned long long int nowTime = ( unsigned long long int )now.tv_sec * 1000000000LLU + ( unsigned long long int )now.tv_nsec;    // Time in nanoseconds
-
-	time                           = ( ( double )nowTime * 1e-9 );    // Time in seconds
-#endif
-
-#if defined( __APPLE__ )
-	// #define CLOCK_REALTIME  CALENDAR_CLOCK    // returns UTC time since 1970-01-01
-	// #define CLOCK_MONOTONIC SYSTEM_CLOCK      // returns the time since boot time
-
-	clock_serv_t    cclock;
-	mach_timespec_t now;
-	host_get_clock_service( mach_host_self(), SYSTEM_CLOCK, &cclock );
-
-	// NOTE: OS X does not have clock_gettime(), using clock_get_time()
-	clock_get_time( cclock, &now );
-	mach_port_deallocate( mach_task_self(), cclock );
-	unsigned long long int nowTime = ( unsigned long long int )now.tv_sec * 1000000000LLU + ( unsigned long long int )now.tv_nsec;    // Time in nanoseconds
-
-	time                           = ( ( double )nowTime * 1e-9 );    // Time in seconds
-#endif
-#endif
-
-	return time;
-}
-
-#endif    // RGESTURES_IMPLEMENTATION

project/auxillary/vis_ast/dependencies/raylib/include/utils.h

@@ -1,82 +0,0 @@
-/**********************************************************************************************
- *
- *   raylib.utils - Some common utility functions
- *
- *
- *   LICENSE: zlib/libpng
- *
- *   Copyright (c) 2014-2023 Ramon Santamaria (@raysan5)
- *
- *   This software is provided "as-is", without any express or implied warranty. In no event
- *   will the authors be held liable for any damages arising from the use of this software.
- *
- *   Permission is granted to anyone to use this software for any purpose, including commercial
- *   applications, and to alter it and redistribute it freely, subject to the following restrictions:
- *
- *     1. The origin of this software must not be misrepresented; you must not claim that you
- *     wrote the original software. If you use this software in a product, an acknowledgment
- *     in the product documentation would be appreciated but is not required.
- *
- *     2. Altered source versions must be plainly marked as such, and must not be misrepresented
- *     as being the original software.
- *
- *     3. This notice may not be removed or altered from any source distribution.
- *
- **********************************************************************************************/
-
-#ifndef UTILS_H
-#define UTILS_H
-
-#if defined( PLATFORM_ANDROID )
-#include <stdio.h>                    // Required for: FILE
-#include <android/asset_manager.h>    // Required for: AAssetManager
-#endif
-
-#if defined( SUPPORT_TRACELOG )
-#define TRACELOG( level, ... ) TraceLog( level, __VA_ARGS__ )
-
-#if defined( SUPPORT_TRACELOG_DEBUG )
-#define TRACELOGD( ... ) TraceLog( LOG_DEBUG, __VA_ARGS__ )
-#else
-#define TRACELOGD( ... ) ( void )0
-#endif
-#else
-#define TRACELOG( level, ... ) ( void )0
-#define TRACELOGD( ... )       ( void )0
-#endif
-
-//----------------------------------------------------------------------------------
-// Some basic Defines
-//----------------------------------------------------------------------------------
-#if defined( PLATFORM_ANDROID )
-#define fopen( name, mode ) android_fopen( name, mode )
-#endif
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-// Nop...
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-#if defined( __cplusplus )
-extern "C"
-{    // Prevents name mangling of functions
-#endif
-
-#if defined( PLATFORM_ANDROID )
-	void  InitAssetManager( AAssetManager* manager, const char* dataPath );    // Initialize asset manager from android app
-	FILE* android_fopen( const char* fileName, const char* mode );             // Replacement for fopen() -> Read-only!
-#endif
-
-#if defined( __cplusplus )
-}
-#endif
-
-#endif    // UTILS_H

project/auxillary/vis_ast/dependencies/raylib/raylib.c

@@ -1,8 +0,0 @@
-#include "raudio.c"
-#include "rcore.c"
-#include "rglfw.c"
-#include "rmodels.c"
-#include "rshapes.c"
-#include "rtext.c"
-#include "rtextures.c"
-#include "rutils.c"

project/auxillary/vis_ast/dependencies/raylib/raylib.refactor

@@ -1,9 +0,0 @@
- __VERSION 1
-
-
-word SUPPORT_MODULE_RSHAPES,   RL_SUPPORT_MODULE_RSHAPES
-word SUPPORT_MODULE_RTEXTURES, RL_SUPPORT_MODULE_RTEXTURES
-word SUPPORT_MODULE_RTEXT,     RL_SUPPORT_MODULE_RTEXT
-word SUPPORT_MODULE_RMODELS,   RL_SUPPORT_MODULE_RMODELS
-word SUPPORT_MODULE_RAUDIO,    RL_SUPPORT_MODULE_RAUDIO
-

project/auxillary/vis_ast/dependencies/raylib/raylib_refactor.cpp

@@ -1,290 +0,0 @@
-#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
-#define GEN_BENCHMARK
-#define GEN_ENFORCE_STRONG_CODE_TYPES
-// #define GEN_IMPLEMENTATION
-#include "gen.cpp"
-#include "gen.builder.cpp"
-
-
-constexpr char const* path_config    = "config.h";
-constexpr char const* path_raylib    = "raylib.h";
-constexpr char const* path_raymath   = "raymath.h";
-constexpr char const* path_rcamera   = "rcamera.h";
-constexpr char const* path_rcore     = "rcore.h";
-constexpr char const* path_rgestures = "rgestures.h";
-constexpr char const* path_rgl       = "rgl.h";
-constexpr char const* path_rtext     = "rtext.h";
-
-
-using namespace gen;
-
-StringCached upper_snake_to_mixed_snake(StringCached str)
-{
-    local_persist String scratch = String::make_reserve(GlobalAllocator, kilobytes(1));
-    scratch.clear();
-
-    bool capitalizeNext = true;
-
-    for (s32 index = 0; index < str.length(); ++index)
-    {
-        char c = str[index];
-
-        if (c == '_')
-        {
-            scratch.append(c);
-            capitalizeNext = true;
-        }
-        else if (capitalizeNext)
-        {
-            if (c >= 'a' && c <= 'z')
-            {
-                scratch.append(c - 32); // Convert to uppercase
-            }
-            else
-            {
-                scratch.append(c);
-            }
-            capitalizeNext = false;
-        }
-        else
-        {
-            if (c >= 'A' && c <= 'Z')
-            {
-                scratch.append(c + 32); // Convert to lowercase
-            }
-            else
-            {
-                scratch.append(c);
-            }
-        }
-    }
-
-    StringCached result = get_cached_string(scratch);
-    return result;
-}
-
-StringCached pascal_to_lower_snake(StringCached str)
-{
-    local_persist String scratch = String::make_reserve(GlobalAllocator, kilobytes(1));
-    scratch.clear();
-
-    for (s32 index = 0; index < str.length(); ++index)
-    {
-        char c = str[index];
-        char next = (index + 1 < str.length()) ? str[index + 1] : '\0'; // Ensure we don't go out of bounds
-
-        // Whitelist check for "2D" and "3D"
-        if ((c == '2' || c == '3' | c == '4') && (next == 'D' || next == 'd'))
-        {
-            if (index > 0) // If it's not the start of the string, append an underscore
-            {
-                char* prev = str.Data + index - 1;
-                if (*prev != '_') // Avoid double underscores
-                {
-                    scratch.append('_');
-                }
-            }
-            scratch.append(c);
-            scratch.append('d'); // Convert to lowercase
-            index++; // Skip the next character since we've already processed it
-            continue;
-        }
-
-        if (c >= 'A' && c <= 'Z')
-        {
-            char* prev = (index > 0) ? str.Data + index - 1 : nullptr;
-
-            if ((index > 0 && prev && *prev >= 'a' && *prev <= 'z') || 
-                (prev && char_is_digit(*prev) && (next >= 'A' && next <= 'Z')))
-            {
-                scratch.append('_');
-            }
-
-            scratch.append(c + 32);
-        }
-        else if (char_is_digit(c) && (next >= 'A' && next <= 'Z')) // Check for a number followed by an uppercase letter
-        {
-            scratch.append(c);
-            scratch.append('_');
-        }
-        else
-        {
-            scratch.append(c);
-        }
-    }
-
-    StringCached result = get_cached_string(scratch);
-    return result;
-}
-
-void refactor_enum( CodeEnum& code )
-{
-	for ( Code elem : code->Body )
-	{
-		if ( elem->Type == ECode::Untyped )
-		{
-			elem->Content = upper_snake_to_mixed_snake( elem->Content );
-		}
-	}
-}
-
-void refactor_typename( CodeType& type )
-{
-	local_persist CodeType t_unsigned_char      = parse_type( code(unsigned char) );
-	local_persist CodeType t_unsigned_char_ptr  = parse_type( code(unsigned char*) );
-	local_persist CodeType t_unsigned_short_ptr	= parse_type( code(unsigned short*) );
-	local_persist CodeType t_int                = parse_type( code(int) );
-	local_persist CodeType t_int_ptr 		    = parse_type( code(int*) );
-	local_persist CodeType t_unsigned_int       = parse_type( code(unsigned int) );
-	local_persist CodeType t_float 	            = parse_type( code(float) );
-	local_persist CodeType t_float_ptr          = parse_type( code(float*) );
-
-	local_persist CodeType t_f32_ptr = parse_type( code(f32*) );
-	local_persist CodeType t_u8_ptr  = parse_type( code(u8*) );
-	local_persist CodeType t_s32_ptr = parse_type( code(s32*) );
-
-	String type_str = type.to_string();
-
-	if ( str_compare( type_str, t_unsigned_char.to_string() ) == 0 )
-	{
-		type.ast = t_u8.ast;
-	}
-	if ( str_compare( type_str, t_unsigned_char_ptr.to_string() ) == 0 )
-	{
-		type.ast = t_u8_ptr.ast;
-	}
-	if ( str_compare( type_str, t_unsigned_short_ptr.to_string() ) == 0 )
-	{
-		type.ast = t_u8_ptr.ast;
-	}
-	if ( str_compare( type_str, t_int.to_string() ) == 0 )
-	{
-		type.ast = t_s32.ast;
-	}
-	if ( str_compare( type_str, t_int_ptr.to_string() ) == 0 )
-	{
-		type.ast = t_s32_ptr.ast;
-	}
-	if ( str_compare( type_str, t_unsigned_int.to_string() ) == 0 )
-	{
-		type.ast = t_u32.ast;
-	}
-	if ( str_compare( type_str, t_float.to_string() ) == 0 )
-	{
-		type.ast = t_f32.ast;
-	}
-	if ( str_compare( type_str, t_float_ptr.to_string() ) == 0 )
-	{
-		type.ast = t_f32_ptr.ast;
-	}
-}
-
-void refactor_fn( CodeFn& fn )
-{
-	fn->Name = pascal_to_lower_snake( fn->Name );
-
-	for ( CodeParam param : fn->Params )
-	{
-		refactor_typename( param->ValueType );
-	}
-}
-
-void refactor_struct( CodeStruct& code )
-{
-	for ( Code field : code->Body )
-	{
-		if ( field->Type == ECode::Variable )
-		{
-			CodeVar var = field.cast<CodeVar>();
-			refactor_typename( var->ValueType );
-		}
-	}
-}
-
-void refactor_file( char const* path )
-{
-	FileContents contents = file_read_contents( GlobalAllocator, true, path );
-	CodeBody     code     = parse_global_body( { contents.size, rcast(char const*, contents.data) } );
-
-	String name_scratch = String::make_reserve( GlobalAllocator, kilobytes(1) );
-
-	// CodeBody includes 
-	// CodeBody nspace_body = def_body( ECode::Namespace );
-	CodeBody new_code = def_body( ECode::Global_Body );
-
-	for ( Code elem : code )
-	{
-		if ( elem->Type == ECode::Preprocess_Define )
-		{
-			if ( str_compare( elem->Name, txt("RL"), 2 ) == 0 || str_compare( elem->Name, txt("RAYLIB"), 6 ) == 0 )
-				continue;
-
-			name_scratch.append_fmt( "%RL_%S", elem->Name );
-			elem->Name = get_cached_string( name_scratch );
-			name_scratch.clear();
-		}
-
-		if ( elem->Type == ECode::Enum )
-		{
-			refactor_enum( elem.cast<CodeEnum>() );
-		}
-
-		if ( elem->Type == ECode::Typedef )
-		{
-			CodeTypedef td = elem.cast<CodeTypedef>();
-			if ( td->UnderlyingType->Type == ECode::Enum )
-			{
-				CodeEnum code = td->UnderlyingType.cast<CodeEnum>();
-				refactor_enum( code );
-			}
-			if ( td->UnderlyingType->Type == ECode::Struct )
-			{
-				CodeStruct code = td->UnderlyingType.cast<CodeStruct>();
-				refactor_struct( code );
-			}
-		}
-
-		if ( elem->Type == ECode::Struct )
-		{
-			refactor_struct( elem.cast<CodeStruct>() );
-		}
-
-		if ( elem->Type == ECode::Function || elem->Type == ECode::Function_Fwd )
-		{
-			refactor_fn( elem.cast<CodeFn>() );
-		}
-
-		if ( elem->Type == ECode::Extern_Linkage )
-		{
-			CodeBody body = elem.cast<CodeExtern>()->Body;
-			for ( Code elem : body )
-			{
-				if ( elem->Type == ECode::Function || elem->Type == ECode::Function_Fwd )
-				{
-					refactor_fn( elem.cast<CodeFn>() );
-				}
-			}
-
-			Code nspace = def_namespace( txt("raylib"), def_namespace_body( args(elem) ) );
-			elem = nspace;
-		}
-
-		new_code.append( elem );
-	}
-
-	Builder builder = Builder::open( path );
-	builder.print( new_code );
-	builder.write();
-}
-
-int gen_main()
-{
-	gen::init();
-
-	refactor_file( path_config );
-	refactor_file( path_raylib );
-	refactor_file( path_raymath );
-	refactor_file( path_rcamera );
-
-	return 0;
-}

project/auxillary/vis_ast/readme.md

@@ -1,10 +0,0 @@
-# Vis AST
-
-AST visualizer for gencpp
-
-This is a early start to creating frontend tooling for c/c++ using gencpp as a core component.  
-I'll be exploring creating an AST explorer for this library with raylib as the graphical & general platform vendor for dependencies that go beyond the scope of gencpp.
-
-For now I'll have its build script in this file, however it will heavily rely on gencpp's helper scripts.
-
-Whatever sort of UX tooling I setup for this will be reused for the other tools I'll be creating for gencpp.

project/auxillary/vis_ast/update_deps.ps1

@@ -1,178 +0,0 @@
-Clear-Host
-
-$path_root     = git rev-parse --show-toplevel
-$path_scripts  = Join-Path $path_root 'scripts'
-
-$target_arch        = Join-Path $path_scripts 'helpers/target_arch.psm1'
-$devshell           = Join-Path $path_scripts 'helpers/devshell.ps1'
-$format_cpp	        = Join-Path $path_scripts 'helpers/format_cpp.psm1'
-$incremental_checks = Join-Path $path_scripts 'helpers/incremental_checks.ps1'
-$vendor_toolchain   = Join-Path $path_scripts 'helpers/vendor_toolchain.ps1'
-
-$path_project  = Join-Path $path_root     'project'
-$path_aux      = Join-Path $path_project  'auxillary'
-$path_vis_root = Join-Path $path_aux      'vis_ast'
-$path_binaries = Join-Path $path_vis_root 'binaries'
-
-$path_deps = Join-Path $path_vis_root 'dependencies'
-$path_temp = Join-Path $path_deps     'temp'
-
-Import-Module $target_arch
-Import-Module $format_cpp
-
-#region Arguments
-$vendor           = $null
-$optimize         = $null
-$debug 	          = $null
-$analysis	      = $false
-$dev              = $false
-$verbose          = $null
-
-[array] $vendors = @( "clang", "msvc" )
-
-# This is a really lazy way of parsing the args, could use actual params down the line...
-
-if ( $args ) { $args | ForEach-Object {
-switch ($_){
- { $_ -in $vendors }   { $vendor    = $_; break }
- "optimize"            { $optimize  = $true }
- "debug"               { $debug     = $true }
- "analysis"            { $analysis  = $true }
- "dev"                 { $dev       = $true }
- "verbose"             { $verbose   = $true }
-}
-}}
-#endregion Argument
-
-# Load up toolchain configuraion
-. $vendor_toolchain
-. $incremental_checks
-
-# Clear out the current content first
-# remove-item $path_temp -Recurse
-# New-Item -ItemType Directory -Path $path_temp
-
-if ( -not (Test-Path $path_binaries) ) {
-	New-Item -ItemType Directory -Path $path_binaries
-}
-
-function setup-raylib {
-	$path_raylib     = join-path $path_deps   'raylib'
-	$path_raylib_inc = join-path $path_raylib 'include'
-	$path_raylib_lib = join-path $path_raylib 'lib'
-	if ( test-path $path_raylib_inc ) {
-		remove-item $path_raylib_inc -recurse
-		remove-item $path_raylib_lib -recurse
-	}
-	new-item -path $path_raylib_inc -ItemType Directory
-	new-item -path $path_raylib_lib -ItemType Directory
-
-	$url_raylib_zip  = 'https://github.com/raysan5/raylib/archive/refs/heads/master.zip'
-	$path_raylib_zip = join-path $path_temp 'raylib.zip'
-
-	$path_raylib_master      = join-path $path_temp          'raylib-master'
-	$path_raylib_src         = join-path $path_raylib_master 'src'
-	$path_raylib_glfw_inc    = join-path $path_raylib_src    'external/glfw/include'
-
-	remove-item $path_raylib_master -Recurse
-	# invoke-webrequest -uri $url_raylib_zip   -outfile $path_raylib_zip
-	expand-archive    -path $path_raylib_zip -destinationpath $path_temp
-
-	write-host "Building raylib with $vendor"
-
-	$path_build = Join-Path $path_raylib 'build'
-	if ( (Test-Path $path_build) -eq $false ) {
-		New-Item $path_build -ItemType Directory
-	}
-
-	$raylib_headers = Get-ChildItem -Path $path_raylib_src -Filter "*.h" -File
-	$raylib_modules = get-childitem -path $path_raylib_src -filter "*.c" -file
-
-	# Refactor raylib
-	if ( $true ) {
-	# if ( $false ) {
-		$path_gencpp = join-path $path_root 'project/gen'
-
-		$includes = @(
-			$path_gencpp
-		)
-
-		$compiler_args = @(
-			($flag_define + 'GEN_TIME')
-		)
-
-		$linker_args = @(
-
-		)
-
-		$unit       = join-path $path_raylib 'raylib_refactor.cpp'
-		$executable = join-path $path_build  'raylib_refactor.exe'
-
-		$build_result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
-		Push-Location $path_raylib_src
-			if ( Test-Path( $executable ) ) {
-				Measure-Command { & $executable
-						| ForEach-Object {
-							write-host `t $_ -ForegroundColor Green
-						}
-					}
-			}
-		Pop-Location
-
-		push-location $path_scripts
-		# Time to format
-		$fmt_includes = @()
-		foreach ( $header in $raylib_headers ) {
-			$fmt_includes +=  split-path $header -leaf
-		}
-		foreach ( $module in $raylib_modules ) {
-			$fmt_includes +=  split-path $module -leaf
-		}
-		format-cpp $path_raylib_src $fmt_includes $null
-		pop-location
-	}
-
-	# Build raylib
-	if ( $false ) {
-		# Microsoft
-		$lib_gdi32   = 'Gdi32.lib'
-		$lib_shell32 = 'Shell32.lib'
-		$lib_xinput  = 'Xinput.lib'
-		$lib_user32  = 'User32.lib'
-		$lib_winmm   = 'Winmm.lib'
-
-		$includes = @(
-			$path_raylib_src,
-			$path_raylib_glfw_inc
-		)
-		foreach ($include in $includes) {
-			write-host $include
-		}
-
-		$compiler_args = @(
-			($flag_define + 'PLATFORM_DESKTOP'),
-			($flag_define + 'BUILD_LIBTYPE_SHARED')
-		)
-		$linker_args   = @(
-			$flag_link_dll,
-
-			# $lib_xinput,
-			$lib_gdi32,
-			$lib_shell32,
-			$lib_user32,
-			$lib_winmm
-		)
-
-		# $unit = join-path $path_raylib     'raylib.c'
-		$dll  = join-path $path_raylib_lib 'raylib.dll'
-		# $build_result = build-simple $path_build $includes $compiler_args $linker_args $unit $dll
-
-		$build_result = build $path_build $includes $compiler_args $linker_args $raylib_modules $dll
-	}
-
-	# Move headers to used include
-	foreach ($header in $raylib_headers) {
-		Copy-Item -Path $header -Destination (join-path $path_raylib_inc (split-path $header -Leaf))
-	}
-}
-setup-raylib

project/bootstrap.cpp

@@ -20,6 +20,44 @@ constexpr char const* generation_notice =
 "// This file was generated automatially by gencpp's bootstrap.cpp "
 "(See: https://github.com/Ed94/gencpp)\n\n";
 
+#include <cstdlib>   // for system()
+
+void format_file( char const* path )
+{
+	String resolved_path = String::make(GlobalAllocator, to_str(path));
+
+	String style_arg = String::make(GlobalAllocator, txt("-style=file:"));
+	style_arg.append("../scripts/.clang-format ");
+
+	// Need to execute clang format on the generated file to get it to match the original.
+	#define clang_format      "clang-format "
+	#define cf_format_inplace "-i "
+	#define cf_verbose        "-verbose "
+	String command = String::make( GlobalAllocator, clang_format );
+	command.append( cf_format_inplace );
+	command.append( cf_verbose );
+	command.append( style_arg );
+	command.append( resolved_path );
+		log_fmt("\tRunning clang-format on file:\n");
+		system( command );
+		log_fmt("\tclang-format finished reformatting.\n");
+	#undef cf_cmd
+	#undef cf_format_inplace
+	#undef cf_style
+	#undef cf_verbse
+}
+
+Code dump_to_scratch_and_retireve( Code code )
+{
+	Builder ecode_file_temp = Builder::open("gen/scratch.hpp");
+	ecode_file_temp.print(code);
+	ecode_file_temp.write();
+	format_file("gen/scratch.hpp");
+	Code result = scan_file( "gen/scratch.hpp" );
+	remove("gen/scratch.hpp");
+	return result;
+}
+
 int gen_main()
 {
 	gen::init();
@@ -29,7 +67,7 @@ int gen_main()
 
 	// gen_dep.hpp
 	{
-		Code header_start = scan_file( "dependencies/header_start.hpp" );
+		Code platform     = scan_file( "dependencies/platform.hpp" );
 		Code macros 	  = scan_file( "dependencies/macros.hpp" );
 		Code basic_types  = scan_file( "dependencies/basic_types.hpp" );
 		Code debug        = scan_file( "dependencies/debug.hpp" );
@@ -45,8 +83,8 @@ int gen_main()
 		Builder
 		header = Builder::open("gen/gen.dep.hpp");
 		header.print_fmt( generation_notice );
-		header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n\n" );
-		header.print( header_start );
+		header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n" );
+		header.print( platform );
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 
 		header.print( macros );
@@ -80,7 +118,7 @@ int gen_main()
 		Builder
 		src = Builder::open( "gen/gen.dep.cpp" );
 		src.print_fmt( generation_notice );
-		src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n\n" );
+		src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
 		src.print( src_start );
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
 
@@ -112,6 +150,7 @@ int gen_main()
 		Code types        = scan_file( "components/types.hpp" );
 		Code ast          = scan_file( "components/ast.hpp" );
 		Code ast_types    = scan_file( "components/ast_types.hpp" );
+		Code code_types   = scan_file( "components/code_types.hpp" );
 		Code interface    = scan_file( "components/interface.hpp" );
 		Code inlines      = scan_file( "components/inlines.hpp" );
 		Code header_end   = scan_file( "components/header_end.hpp" );
@@ -131,13 +170,18 @@ int gen_main()
 
 		header.print_fmt( "#pragma region Types\n" );
 		header.print( types );
-		header.print( ecode );
-		header.print( eoperator );
-		header.print( especifier );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(ecode) );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(eoperator) );
+		header.print( fmt_newline);
+		header.print( dump_to_scratch_and_retireve(especifier) );
+		header.print( fmt_newline);
 		header.print_fmt( "#pragma endregion Types\n\n" );
 
 		header.print_fmt( "#pragma region AST\n" );
 		header.print( ast );
+		header.print( code_types );
 		header.print( ast_types );
 		header.print_fmt( "\n#pragma endregion AST\n" );
 
@@ -146,7 +190,8 @@ int gen_main()
 		header.print_fmt( "\n#pragma region Inlines\n" );
 		header.print( inlines );
 		header.print( fmt_newline );
-		header.print( ast_inlines );
+		header.print( dump_to_scratch_and_retireve(ast_inlines) );
+		header.print( fmt_newline );
 		header.print_fmt( "#pragma endregion Inlines\n" );
 
 		header.print( header_end );
@@ -181,38 +226,44 @@ int gen_main()
 
 	// gen.cpp
 	{
-		Code        src_start       = scan_file( "components/src_start.cpp" );
-		Code        static_data 	= scan_file( "components/static_data.cpp" );
-		Code        ast_case_macros = scan_file( "components/ast_case_macros.cpp" );
-		Code        ast			    = scan_file( "components/ast.cpp" );
-		Code        interface	    = scan_file( "components/interface.cpp" );
-		Code        upfront 	    = scan_file( "components/interface.upfront.cpp" );
-		Code 	    parsing 	    = scan_file( "components/interface.parsing.cpp" );
-		Code        untyped 	    = scan_file( "components/interface.untyped.cpp" );
+		Code        src_start          = scan_file( "components/src_start.cpp" );
+		Code        static_data 	   = scan_file( "components/static_data.cpp" );
+		Code        ast_case_macros    = scan_file( "components/ast_case_macros.cpp" );
+		Code        ast			       = scan_file( "components/ast.cpp" );
+		Code        code_serialization = scan_file( "components/code_serialization.cpp" );
+		Code        interface	       = scan_file( "components/interface.cpp" );
+		Code        upfront 	       = scan_file( "components/interface.upfront.cpp" );
+		Code        lexer              = scan_file( "components/lexer.cpp" );
+		Code        parser             = scan_file( "components/parser.cpp" );
+		Code 	    parsing_interface  = scan_file( "components/interface.parsing.cpp" );
+		Code        untyped 	       = scan_file( "components/interface.untyped.cpp" );
 
 		CodeBody etoktype         = gen_etoktype( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
-		CodeNS   nspaced_etoktype = def_namespace( name(Parser), def_namespace_body( args(etoktype)) );
+		CodeNS   nspaced_etoktype = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
 
 		Builder
 		src = Builder::open( "gen/gen.cpp" );
 		src.print_fmt( generation_notice );
 		src.print( push_ignores );
 		src.print( src_start );
-		src.print_fmt( "GEN_NS_BEGIN\n");
+		src.print_fmt( "\nGEN_NS_BEGIN\n");
 
 		src.print( static_data );
 
 		src.print_fmt( "\n#pragma region AST\n\n" );
 		src.print( ast_case_macros );
 		src.print( ast );
+		src.print( code_serialization );
 		src.print_fmt( "\n#pragma endregion AST\n" );
 
 		src.print_fmt( "\n#pragma region Interface\n" );
 		src.print( interface );
 		src.print( upfront );
 		src.print_fmt( "\n#pragma region Parsing\n\n" );
-		src.print( nspaced_etoktype );
-		src.print( parsing );
+		src.print( dump_to_scratch_and_retireve(nspaced_etoktype) );
+		src.print( lexer );
+		src.print( parser );
+		src.print( parsing_interface );
 		src.print( untyped );
 		src.print_fmt( "\n#pragma endregion Parsing\n\n" );
 		src.print_fmt( "#pragma endregion Interface\n\n" );
@@ -270,7 +321,7 @@ int gen_main()
 		header.print_fmt( "\nGEN_NS_BEGIN\n" );
 		header.print( parsing );
 		header.print( scanner );
-		header.print_fmt( "GEN_NS_END\n" );
+		header.print_fmt( "\nGEN_NS_END\n" );
 		header.write();
 	}
 
@@ -285,7 +336,7 @@ int gen_main()
 		src.print( def_include( txt("gen.scanner.hpp") ) );
 		src.print_fmt( "\nGEN_NS_BEGIN\n" );
 		src.print( parsing );
-		src.print( scanner );
+		// src.print( scanner );
 		src.print_fmt( "GEN_NS_END\n" );
 		src.write();
 	}

project/components/ast.hpp

@@ -11,6 +11,7 @@ struct AST_Body;
 struct AST_Attributes;
 struct AST_Comment;
 struct AST_Constructor;
+// struct AST_BaseClass;
 struct AST_Class;
 struct AST_Define;
 struct AST_Destructor;
@@ -28,6 +29,42 @@ struct AST_Param;
 struct AST_Pragma;
 struct AST_PreprocessCond;
 struct AST_Specifiers;
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct AST_Expr;
+struct AST_Expr_Assign;
+struct AST_Expr_Alignof;
+struct AST_Expr_Binary;
+struct AST_Expr_CStyleCast;
+struct AST_Expr_FunctionalCast;
+struct AST_Expr_CppCast;
+struct AST_Expr_ProcCall;
+struct AST_Expr_Decltype;
+struct AST_Expr_Comma;  // TODO(Ed) : This is a binary op not sure if it needs its own AST...
+struct AST_Expr_AMS;    // Access Member Symbol
+struct AST_Expr_Sizeof;
+struct AST_Expr_Subscript;
+struct AST_Expr_Ternary;
+struct AST_Expr_UnaryPrefix;
+struct AST_Expr_UnaryPostfix;
+struct AST_Expr_Element;
+
+struct AST_Stmt;
+struct AST_Stmt_Break;
+struct AST_Stmt_Case;
+struct AST_Stmt_Continue;
+struct AST_Stmt_Decl;
+struct AST_Stmt_Do;
+struct AST_Stmt_Expr;  // TODO(Ed) : Is this distinction needed? (Should it be a flag instead?)
+struct AST_Stmt_Else;
+struct AST_Stmt_If;
+struct AST_Stmt_For;
+struct AST_Stmt_Goto;
+struct AST_Stmt_Label;
+struct AST_Stmt_Switch;
+struct AST_Stmt_While;
+#endif
+
 struct AST_Struct;
 struct AST_Template;
 struct AST_Type;
@@ -40,6 +77,7 @@ struct Code;
 struct CodeBody;
 // These are to offer ease of use and optionally strong type safety for the AST.
 struct CodeAttributes;
+// struct CodeBaseClass;
 struct CodeComment;
 struct CodeClass;
 struct CodeConstructor;
@@ -59,6 +97,42 @@ struct CodeParam;
 struct CodePreprocessCond;
 struct CodePragma;
 struct CodeSpecifiers;
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct CodeExpr;
+struct CodeExpr_Assign;
+struct CodeExpr_Alignof;
+struct CodeExpr_Binary;
+struct CodeExpr_CStyleCast;
+struct CodeExpr_FunctionalCast;
+struct CodeExpr_CppCast;
+struct CodeExpr_Element;
+struct CodeExpr_ProcCall;
+struct CodeExpr_Decltype;
+struct CodeExpr_Comma;
+struct CodeExpr_AMS; // Access Member Symbol
+struct CodeExpr_Sizeof;
+struct CodeExpr_Subscript;
+struct CodeExpr_Ternary;
+struct CodeExpr_UnaryPrefix;
+struct CodeExpr_UnaryPostfix;
+
+struct CodeStmt;
+struct CodeStmt_Break;
+struct CodeStmt_Case;
+struct CodeStmt_Continue;
+struct CodeStmt_Decl;
+struct CodeStmt_Do;
+struct CodeStmt_Expr;
+struct CodeStmt_Else;
+struct CodeStmt_If;
+struct CodeStmt_For;
+struct CodeStmt_Goto;
+struct CodeStmt_Label;
+struct CodeStmt_Switch;
+struct CodeStmt_While;
+#endif
+
 struct CodeStruct;
 struct CodeTemplate;
 struct CodeType;
@@ -67,7 +141,7 @@ struct CodeUnion;
 struct CodeUsing;
 struct CodeVar;
 
-namespace Parser
+namespace parser
 {
 	struct Token;
 }
@@ -103,7 +177,7 @@ struct Code
 	Using_Code( Code );
 
 	template< class Type >
-	Type cast()
+	forceinline Type cast()
 	{
 		return * rcast( Type*, this );
 	}
@@ -113,8 +187,16 @@ struct Code
 		return ast;
 	}
 	Code& operator ++();
+
+	// TODO(Ed) : Remove this overload.
 	auto& operator*()
 	{
+		local_persist thread_local
+		Code NullRef = { nullptr };
+
+		if ( ast == nullptr )
+			return NullRef;
+
 		return *this;
 	}
 
@@ -123,12 +205,14 @@ struct Code
 #ifdef GEN_ENFORCE_STRONG_CODE_TYPES
 #	define operator explicit operator
 #endif
+	operator CodeBody() const;
 	operator CodeAttributes() const;
+	// operator CodeBaseClass() const;
 	operator CodeComment() const;
-	operator CodeConstructor() const;
-	operator CodeDestructor() const;
 	operator CodeClass() const;
+	operator CodeConstructor() const;
 	operator CodeDefine() const;
+	operator CodeDestructor() const;
 	operator CodeExec() const;
 	operator CodeEnum() const;
 	operator CodeExtern() const;
@@ -150,7 +234,6 @@ struct Code
 	operator CodeUnion() const;
 	operator CodeUsing() const;
 	operator CodeVar() const;
-	operator CodeBody() const;
 	#undef operator
 };
 
@@ -179,10 +262,13 @@ struct AST
 	char const* type_str();
 	bool        validate_body();
 
-	neverinline String to_string();
+	String to_string();
+
+	neverinline
+	void to_string( String& result );
 
 	template< class Type >
-	Type cast()
+	forceinline Type cast()
 	{
 		return * this;
 	}
@@ -190,6 +276,7 @@ struct AST
 	operator Code();
 	operator CodeBody();
 	operator CodeAttributes();
+	// operator CodeBaseClass();
 	operator CodeComment();
 	operator CodeConstructor();
 	operator CodeDestructor();
@@ -223,7 +310,7 @@ struct AST
 	(
 			AST_POD_Size
 			- sizeof(AST*) * 3
-			- sizeof(Parser::Token*)
+			- sizeof(parser::Token*)
 			- sizeof(AST*)
 			- sizeof(StringCached)
 			- sizeof(CodeT)
@@ -246,24 +333,26 @@ struct AST
 				AST*  ValueType;       // Parameter, Variable
 			};
 			union {
+				AST*  Macro;           // Parameter
 				AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
 				AST*  Params;          // Constructor, Function, Operator, Template, Typename
 			};
 			union {
 				AST*  ArrExpr;          // Typename
-				AST*  Body;             // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+				AST*  Body;             // Class, Constructor, Destructor, Enum, Friend, Function, Namespace, Struct, Union
 				AST*  Declaration;      // Friend, Template
 				AST*  Value;            // Parameter, Variable
 			};
 			union {
 				AST*  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
 				AST*  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
+				AST*  PostNameMacro;     // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
 			};
 		};
 		StringCached  Content;          // Attributes, Comment, Execution, Include
 		struct {
 			SpecifierT ArrSpecs[ArrSpecs_Cap]; // Specifiers
-			AST*       NextSpecs;                   // Specifiers; If ArrSpecs is full, then NextSpecs is used.
+			AST*       NextSpecs;              // Specifiers; If ArrSpecs is full, then NextSpecs is used.
 		};
 	};
 	union {
@@ -275,10 +364,11 @@ struct AST
 		AST* Next;
 		AST* Back;
 	};
-	Parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
+	parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
 	AST*              Parent;
 	StringCached      Name;
 	CodeT             Type;
+//	CodeFlag          CodeFlags;
 	ModuleFlag        ModuleFlags;
 	union {
 		b32           IsFunction;  // Used by typedef to not serialize the name field.
@@ -286,6 +376,7 @@ struct AST
 		OperatorT     Op;
 		AccessSpec    ParentAccess;
 		s32           NumEntries;
+		s32           VarConstructorInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
 	};
 };
 
@@ -305,18 +396,20 @@ struct AST_POD
 				AST*  ValueType;       // Parameter, Variable
 			};
 			union {
+				AST*  Macro;           // Parameter
 				AST*  BitfieldSize;    // Variable (Class/Struct Data Member)
 				AST*  Params;          // Constructor, Function, Operator, Template, Typename
 			};
 			union {
 				AST*  ArrExpr;          // Typename
-				AST*  Body;             // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
+				AST*  Body;             // Class, Constructr, Destructor, Enum, Friend, Function, Namespace, Struct, Union
 				AST*  Declaration;      // Friend, Template
 				AST*  Value;            // Parameter, Variable
 			};
 			union {
 				AST*  NextVar;          // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
 				AST*  SuffixSpecs;      // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
+				AST*  PostNameMacro;    // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
 			};
 		};
 		StringCached  Content;          // Attributes, Comment, Execution, Include
@@ -334,10 +427,11 @@ struct AST_POD
 		AST* Next;
 		AST* Back;
 	};
-	Parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
+	parser::Token*    Token; // Reference to starting token, only avaialble if it was derived from parsing.
 	AST*              Parent;
 	StringCached      Name;
 	CodeT             Type;
+	CodeFlag          CodeFlags;
 	ModuleFlag        ModuleFlags;
 	union {
 		b32           IsFunction;  // Used by typedef to not serialize the name field.
@@ -345,12 +439,13 @@ struct AST_POD
 		OperatorT     Op;
 		AccessSpec    ParentAccess;
 		s32           NumEntries;
+		s32           VarConstructorInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
 	};
 };
 
 struct test {
 	SpecifierT ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
-	AST* NextSpecs;                   // Specifiers; If ArrSpecs is full, then NextSpecs is used.
+	AST* NextSpecs;                         // Specifiers; If ArrSpecs is full, then NextSpecs is used.
 };
 
 constexpr int pls = sizeof(test);
@@ -363,258 +458,3 @@ static_assert( sizeof(AST_POD) == AST_POD_Size,    "ERROR: AST POD is not size o
 // Used when the its desired when omission is allowed in a definition.
 #define NoCode      { nullptr }
 #define CodeInvalid (* Code::Invalid.ast) // Uses an implicitly overloaded cast from the AST to the desired code type.
-
-#pragma region Code Types
-
-struct CodeBody
-{
-	Using_Code( CodeBody );
-
-	void append( Code other )
-	{
-		raw()->append( other.ast );
-	}
-	void append( CodeBody body )
-	{
-		for ( Code entry : body )
-		{
-			append( entry );
-		}
-	}
-	bool has_entries()
-	{
-		return rcast( AST*, ast )->has_entries();
-	}
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Body* operator->()
-	{
-		return ast;
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-#pragma region Iterator
-	Code begin()
-	{
-		if ( ast )
-			return { rcast( AST*, ast)->Front };
-
-		return { nullptr };
-	}
-	Code end()
-	{
-		return { rcast(AST*, ast)->Back->Next };
-	}
-#pragma endregion Iterator
-
-	AST_Body* ast;
-};
-
-struct CodeClass
-{
-	Using_Code( CodeClass );
-
-	void add_interface( CodeType interface );
-
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-	AST_Class* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr");
-			return nullptr;
-		}
-		return ast;
-	}
-	AST_Class* ast;
-};
-
-struct CodeParam
-{
-	Using_Code( CodeParam );
-
-	void append( CodeParam other );
-
-	CodeParam get( s32 idx );
-	bool has_entries();
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Param* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr!");
-			return nullptr;
-		}
-		return ast;
-	}
-	operator Code()
-	{
-		return { (AST*)ast };
-	}
-#pragma region Iterator
-	CodeParam begin()
-	{
-		if ( ast )
-			return { ast };
-
-		return { nullptr };
-	}
-	CodeParam end()
-	{
-		// return { (AST_Param*) rcast( AST*, ast)->Last };
-		return { nullptr };
-	}
-	CodeParam& operator++();
-	CodeParam operator*()
-	{
-		return * this;
-	}
-#pragma endregion Iterator
-
-	AST_Param* ast;
-};
-
-struct CodeSpecifiers
-{
-	Using_Code( CodeSpecifiers );
-
-	bool append( SpecifierT spec )
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
-			return false;
-		}
-
-		if ( raw()->NumEntries == AST::ArrSpecs_Cap )
-		{
-			log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST::ArrSpecs_Cap );
-			return false;
-		}
-
-		raw()->ArrSpecs[ raw()->NumEntries ] = spec;
-		raw()->NumEntries++;
-		return true;
-	}
-	s32 has( SpecifierT spec )
-	{
-		for ( s32 idx = 0; idx < raw()->NumEntries; idx++ )
-		{
-			if ( raw()->ArrSpecs[ raw()->NumEntries ] == spec )
-				return idx;
-		}
-
-		return -1;
-	}
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	AST_Specifiers* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr!");
-			return nullptr;
-		}
-		return ast;
-	}
-	operator Code()
-	{
-		return { (AST*) ast };
-	}
-#pragma region Iterator
-	SpecifierT* begin()
-	{
-		if ( ast )
-			return & raw()->ArrSpecs[0];
-
-		return nullptr;
-	}
-	SpecifierT* end()
-	{
-		return raw()->ArrSpecs + raw()->NumEntries;
-	}
-#pragma endregion Iterator
-
-	AST_Specifiers* ast;
-};
-
-struct CodeStruct
-{
-	Using_Code( CodeStruct );
-
-	void add_interface( CodeType interface );
-
-	AST* raw()
-	{
-		return rcast( AST*, ast );
-	}
-	operator Code()
-	{
-		return * rcast( Code*, this );
-	}
-	AST_Struct* operator->()
-	{
-		if ( ast == nullptr )
-		{
-			log_failure("Attempt to dereference a nullptr");
-			return nullptr;
-		}
-		return ast;
-	}
-	AST_Struct* ast;
-};
-
-#define Define_CodeType( Typename )     \
-	struct Code##Typename               \
-	{                                   \
-		Using_Code( Code ## Typename ); \
-		AST*            raw();          \
-		operator        Code();         \
-		AST_##Typename* operator->();   \
-		AST_##Typename* ast;            \
-	}
-
-Define_CodeType( Attributes );
-Define_CodeType( Comment );
-Define_CodeType( Constructor );
-Define_CodeType( Define );
-Define_CodeType( Destructor );
-Define_CodeType( Enum );
-Define_CodeType( Exec );
-Define_CodeType( Extern );
-Define_CodeType( Include );
-Define_CodeType( Friend );
-Define_CodeType( Fn );
-Define_CodeType( Module );
-Define_CodeType( NS );
-Define_CodeType( Operator );
-Define_CodeType( OpCast );
-Define_CodeType( Pragma );
-Define_CodeType( PreprocessCond );
-Define_CodeType( Template );
-Define_CodeType( Type );
-Define_CodeType( Typedef );
-Define_CodeType( Union );
-Define_CodeType( Using );
-Define_CodeType( Var );
-
-#undef Define_CodeType
-#undef Using_Code
-
-#pragma endregion Code Types

project/components/ast_types.hpp

@@ -1,6 +1,6 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "ast.hpp"
+#	include "code_types.hpp"
 #endif
 
 #pragma region AST Types
@@ -15,7 +15,7 @@ struct AST_Body
 	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
 	Code              Front;
 	Code              Back;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -32,7 +32,7 @@ struct AST_Attributes
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -40,6 +40,23 @@ struct AST_Attributes
 };
 static_assert( sizeof(AST_Attributes) == sizeof(AST), "ERROR: AST_Attributes is not the same size as AST");
 
+#if 0
+struct AST_BaseClass
+{
+	union {
+		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	Code              Prev;
+	Code              Next;
+	parser::Token*    Tok;
+	Code              Parent;
+	StringCached      Name;
+	CodeT             Type;
+	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_BaseClass) == sizeof(AST), "ERROR: AST_BaseClass is not the same size as AST");
+#endif
+
 struct AST_Comment
 {
 	union {
@@ -48,7 +65,7 @@ struct AST_Comment
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -73,7 +90,7 @@ struct AST_Class
 	};
 	CodeType                Prev;
 	CodeType                Next;
-	Parser::Token*          Token;
+	parser::Token*          Tok;
 	Code                    Parent;
 	StringCached            Name;
 	CodeT                   Type;
@@ -99,9 +116,9 @@ struct AST_Constructor
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
-	char              _PAD_NAME_[ sizeof(StringCached) ];
+	StringCached      Name;
 	CodeT             Type;
 	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
@@ -115,7 +132,7 @@ struct AST_Define
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -139,9 +156,9 @@ struct AST_Destructor
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
-	char                   _PAD_NAME_[ sizeof(StringCached) ];
+	StringCached           Name;
 	CodeT                  Type;
 	char                   _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
 };
@@ -164,7 +181,7 @@ struct AST_Enum
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -181,7 +198,7 @@ struct AST_Exec
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -189,6 +206,263 @@ struct AST_Exec
 };
 static_assert( sizeof(AST_Exec) == sizeof(AST), "ERROR: AST_Exec is not the same size as AST");
 
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct AST_Expr
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr) == sizeof(AST), "ERROR: AST_Expr is not the same size as AST");
+
+struct AST_Expr_Assign
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Assign) == sizeof(AST), "ERROR: AST_Expr_Assign is not the same size as AST");
+
+struct AST_Expr_Alignof
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Alignof) == sizeof(AST), "ERROR: AST_Expr_Alignof is not the same size as AST");
+
+struct AST_Expr_Binary
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Binary) == sizeof(AST), "ERROR: AST_Expr_Binary is not the same size as AST");
+
+struct AST_Expr_CStyleCast
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_CStyleCast) == sizeof(AST), "ERROR: AST_Expr_CStyleCast is not the same size as AST");
+
+struct AST_Expr_FunctionalCast
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_FunctionalCast) == sizeof(AST), "ERROR: AST_Expr_FunctionalCast is not the same size as AST");
+
+struct AST_Expr_CppCast
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_CppCast) == sizeof(AST), "ERROR: AST_Expr_CppCast is not the same size as AST");
+
+struct AST_Expr_ProcCall
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_ProcCall) == sizeof(AST), "ERROR: AST_Expr_Identifier is not the same size as AST");
+
+struct AST_Expr_Decltype
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Decltype) == sizeof(AST), "ERROR: AST_Expr_Decltype is not the same size as AST");
+
+struct AST_Expr_Comma
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Comma) == sizeof(AST), "ERROR: AST_Expr_Comma is not the same size as AST");
+
+struct AST_Expr_AMS
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_AMS) == sizeof(AST), "ERROR: AST_Expr_AMS is not the same size as AST");
+
+struct AST_Expr_Sizeof
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Sizeof) == sizeof(AST), "ERROR: AST_Expr_Sizeof is not the same size as AST");
+
+struct AST_Expr_Subscript
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Subscript) == sizeof(AST), "ERROR: AST_Expr_Subscript is not the same size as AST");
+
+struct AST_Expr_Ternary
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Ternary) == sizeof(AST), "ERROR: AST_Expr_Ternary is not the same size as AST");
+
+struct AST_Expr_UnaryPrefix
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_UnaryPrefix) == sizeof(AST), "ERROR: AST_Expr_UnaryPrefix is not the same size as AST");
+
+struct AST_Expr_UnaryPostfix
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_UnaryPostfix) == sizeof(AST), "ERROR: AST_Expr_UnaryPostfix is not the same size as AST");
+
+struct AST_Expr_Element
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Expr_Element) == sizeof(AST), "ERROR: AST_Expr_Element is not the same size as AST");
+#endif
+
 struct AST_Extern
 {
 	union {
@@ -202,7 +476,7 @@ struct AST_Extern
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -218,7 +492,7 @@ struct AST_Include
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -240,7 +514,7 @@ struct AST_Friend
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -265,7 +539,7 @@ struct AST_Fn
 	};
 	Code                    Prev;
 	Code                    Next;
-	Parser::Token*          Token;
+	parser::Token*          Tok;
 	Code                    Parent;
 	StringCached            Name;
 	CodeT                   Type;
@@ -279,7 +553,7 @@ struct AST_Module
 	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -300,7 +574,7 @@ struct AST_NS
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -326,7 +600,7 @@ struct AST_Operator
 	};
 	Code           Prev;
 	Code           Next;
-	Parser::Token* Token;
+	parser::Token* Tok;
 	Code           Parent;
 	StringCached   Name;
 	CodeT          Type;
@@ -352,7 +626,7 @@ struct AST_OpCast
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -368,14 +642,15 @@ struct AST_Param
 		{
 			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
 			CodeType  ValueType;
-			char 	  _PAD_PROPERTIES_[ sizeof(AST*) ];
+			Code      Macro;
 			Code      Value;
-			char 	  _PAD_PROPERTIES_3_[ sizeof(AST*) ];
+			Code     PostNameMacro; // Thanks Unreal
+			// char     _PAD_PROPERTIES_3_[sizeof( AST* )];
 		};
 	};
 	CodeParam         Last;
 	CodeParam         Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -392,7 +667,7 @@ struct AST_Pragma
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -408,7 +683,7 @@ struct AST_PreprocessCond
 	};
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
@@ -422,14 +697,226 @@ struct AST_Specifiers
 	CodeSpecifiers    NextSpecs;
 	Code              Prev;
 	Code              Next;
-	Parser::Token*    Token;
+	parser::Token*    Tok;
 	Code              Parent;
 	StringCached      Name;
 	CodeT             Type;
 	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
 	s32               NumEntries;
 };
-	static_assert( sizeof(AST_Specifiers) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");
+static_assert( sizeof(AST_Specifiers) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct AST_Stmt
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt) == sizeof(AST), "ERROR: AST_Stmt is not the same size as AST");
+
+struct AST_Stmt_Break
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Break) == sizeof(AST), "ERROR: AST_Stmt_Break is not the same size as AST");
+
+struct AST_Stmt_Case
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Case) == sizeof(AST), "ERROR: AST_Stmt_Case is not the same size as AST");
+
+struct AST_Stmt_Continue
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Continue) == sizeof(AST), "ERROR: AST_Stmt_Continue is not the same size as AST");
+
+struct AST_Stmt_Decl
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Decl) == sizeof(AST), "ERROR: AST_Stmt_Decl is not the same size as AST");
+
+struct AST_Stmt_Do
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Do) == sizeof(AST), "ERROR: AST_Stmt_Do is not the same size as AST");
+
+struct AST_Stmt_Expr
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Expr) == sizeof(AST), "ERROR: AST_Stmt_Expr is not the same size as AST");
+
+struct AST_Stmt_Else
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Else) == sizeof(AST), "ERROR: AST_Stmt_Else is not the same size as AST");
+
+struct AST_Stmt_If
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_If) == sizeof(AST), "ERROR: AST_Stmt_If is not the same size as AST");
+
+struct AST_Stmt_For
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_For) == sizeof(AST), "ERROR: AST_Stmt_For is not the same size as AST");
+
+struct AST_Stmt_Goto
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Goto) == sizeof(AST), "ERROR: AST_Stmt_Goto is not the same size as AST");
+
+struct AST_Stmt_Label
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Label) == sizeof(AST), "ERROR: AST_Stmt_Label is not the same size as AST");
+
+struct AST_Stmt_Switch
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_Switch) == sizeof(AST), "ERROR: AST_Stmt_Switch is not the same size as AST");
+
+struct AST_Stmt_While
+{
+	union {
+		char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+	};
+	CodeExpr       Prev;
+	CodeExpr       Next;
+	parser::Token* Tok;
+	Code           Parent;
+	StringCached   Name;
+	CodeT          Type;
+	char           _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
+};
+static_assert( sizeof(AST_Stmt_While) == sizeof(AST), "ERROR: AST_Stmt_While is not the same size as AST");
+#endif
 
 struct AST_Struct
 {
@@ -448,7 +935,7 @@ struct AST_Struct
 	};
 	CodeType               Prev;
 	CodeType               Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -471,7 +958,7 @@ struct AST_Template
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -480,6 +967,36 @@ struct AST_Template
 };
 static_assert( sizeof(AST_Template) == sizeof(AST), "ERROR: AST_Template is not the same size as AST");
 
+#if 0
+// WIP... The type ast is going to become more advanced and lead to a major change to AST design.
+struct AST_Type
+{
+	union {
+		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap + sizeof(AST*) ];
+		struct
+		{
+			char           _PAD_INLINE_CMT_[ sizeof(AST*) ];
+			CodeAttributes Attributes;
+			CodeSpecifiers Specs;
+			Code           QualifierID;
+			// CodeType       ReturnType;      // Only used for function signatures
+			// CodeParam      Params;          // Only used for function signatures
+			Code           ArrExpr;
+			// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
+		};
+	};
+	Code                   Prev;
+	Code                   Next;
+	parser::Token*         Tok;
+	Code                   Parent;
+	StringCached           Name;
+	CodeT                  Type;
+	char 			       _PAD_UNUSED_[ sizeof(ModuleFlag) ];
+	b32                    IsParamPack;
+};
+static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same size as AST");
+#endif
+
 struct AST_Type
 {
 	union {
@@ -497,7 +1014,7 @@ struct AST_Type
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -520,7 +1037,7 @@ struct AST_Typedef
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -544,7 +1061,7 @@ struct AST_Union
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
@@ -568,7 +1085,7 @@ struct AST_Using
 	};
 	Code                    Prev;
 	Code                    Next;
-	Parser::Token*          Token;
+	parser::Token*          Tok;
 	Code                    Parent;
 	StringCached            Name;
 	CodeT                   Type;
@@ -594,12 +1111,12 @@ struct AST_Var
 	};
 	Code                   Prev;
 	Code                   Next;
-	Parser::Token*         Token;
+	parser::Token*         Tok;
 	Code                   Parent;
 	StringCached           Name;
 	CodeT                  Type;
 	ModuleFlag             ModuleFlags;
-	char 			       _PAD_UNUSED_[ sizeof(u32) ];
+	s32                    VarConstructorInit;
 };
 static_assert( sizeof(AST_Var) == sizeof(AST), "ERROR: AST_Var is not the same size as AST");
 

project/components/code_types.hpp

@@ -0,0 +1,881 @@
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#pragma once
+#include "ast.hpp"
+#endif
+
+#pragma region Code Types
+
+struct CodeBody
+{
+	Using_Code( CodeBody );
+
+	void append( Code other )
+	{
+		raw()->append( other.ast );
+	}
+	void append( CodeBody body )
+	{
+		for ( Code entry : body )
+		{
+			append( entry );
+		}
+	}
+	bool has_entries()
+	{
+		return rcast( AST*, ast )->has_entries();
+	}
+	void to_string( String& result );
+	void to_string_export( String& result );
+	AST* raw()
+	{
+		return rcast( AST*, ast );
+	}
+	AST_Body* operator->()
+	{
+		return ast;
+	}
+	operator Code()
+	{
+		return * rcast( Code*, this );
+	}
+#pragma region Iterator
+	Code begin()
+	{
+		if ( ast )
+			return { rcast( AST*, ast)->Front };
+
+		return { nullptr };
+	}
+	Code end()
+	{
+		return { rcast(AST*, ast)->Back->Next };
+	}
+#pragma endregion Iterator
+
+	AST_Body* ast;
+};
+
+struct CodeClass
+{
+	Using_Code( CodeClass );
+
+	void add_interface( CodeType interface );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST* raw()
+	{
+		return rcast( AST*, ast );
+	}
+	operator Code()
+	{
+		return * rcast( Code*, this );
+	}
+	AST_Class* operator->()
+	{
+		if ( ast == nullptr )
+		{
+			log_failure("Attempt to dereference a nullptr");
+			return nullptr;
+		}
+		return ast;
+	}
+	AST_Class* ast;
+};
+
+struct CodeParam
+{
+	Using_Code( CodeParam );
+
+	void append( CodeParam other );
+
+	CodeParam get( s32 idx );
+	bool has_entries();
+	void to_string( String& result );
+	AST* raw()
+	{
+		return rcast( AST*, ast );
+	}
+	AST_Param* operator->()
+	{
+		if ( ast == nullptr )
+		{
+			log_failure("Attempt to dereference a nullptr!");
+			return nullptr;
+		}
+		return ast;
+	}
+	operator Code()
+	{
+		return { (AST*)ast };
+	}
+#pragma region Iterator
+	CodeParam begin()
+	{
+		if ( ast )
+			return { ast };
+
+		return { nullptr };
+	}
+	CodeParam end()
+	{
+		// return { (AST_Param*) rcast( AST*, ast)->Last };
+		return { nullptr };
+	}
+	CodeParam& operator++();
+	CodeParam operator*()
+	{
+		return * this;
+	}
+#pragma endregion Iterator
+
+	AST_Param* ast;
+};
+
+struct CodeSpecifiers
+{
+	Using_Code( CodeSpecifiers );
+
+	bool append( SpecifierT spec )
+	{
+		if ( ast == nullptr )
+		{
+			log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
+			return false;
+		}
+
+		if ( raw()->NumEntries == AST::ArrSpecs_Cap )
+		{
+			log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST::ArrSpecs_Cap );
+			return false;
+		}
+
+		raw()->ArrSpecs[ raw()->NumEntries ] = spec;
+		raw()->NumEntries++;
+		return true;
+	}
+	s32 has( SpecifierT spec )
+	{
+		for ( s32 idx = 0; idx < raw()->NumEntries; idx++ )
+		{
+			if ( raw()->ArrSpecs[ idx ] == spec )
+				return idx;
+		}
+
+		return -1;
+	}
+	void to_string( String& result );
+	AST* raw()
+	{
+		return rcast( AST*, ast );
+	}
+	AST_Specifiers* operator->()
+	{
+		if ( ast == nullptr )
+		{
+			log_failure("Attempt to dereference a nullptr!");
+			return nullptr;
+		}
+		return ast;
+	}
+	operator Code()
+	{
+		return { (AST*) ast };
+	}
+#pragma region Iterator
+	SpecifierT* begin()
+	{
+		if ( ast )
+			return & raw()->ArrSpecs[0];
+
+		return nullptr;
+	}
+	SpecifierT* end()
+	{
+		return raw()->ArrSpecs + raw()->NumEntries;
+	}
+#pragma endregion Iterator
+
+	AST_Specifiers* ast;
+};
+
+struct CodeStruct
+{
+	Using_Code( CodeStruct );
+
+	void add_interface( CodeType interface );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST* raw()
+	{
+		return rcast( AST*, ast );
+	}
+	operator Code()
+	{
+		return * rcast( Code*, this );
+	}
+	AST_Struct* operator->()
+	{
+		if ( ast == nullptr )
+		{
+			log_failure("Attempt to dereference a nullptr");
+			return nullptr;
+		}
+		return ast;
+	}
+	AST_Struct* ast;
+};
+
+#define Define_CodeType( Typename )     \
+	struct Code##Typename               \
+	{                                   \
+		Using_Code( Code ## Typename ); \
+		AST*            raw();          \
+		operator        Code();         \
+		AST_##Typename* operator->();   \
+		AST_##Typename* ast;            \
+	}
+
+Define_CodeType( Attributes );
+// Define_CodeType( BaseClass );
+Define_CodeType( Comment );
+
+struct CodeConstructor
+{
+	Using_Code( CodeConstructor );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST*             raw();
+	operator         Code();
+	AST_Constructor* operator->();
+	AST_Constructor* ast;
+};
+
+struct CodeDefine
+{
+	Using_Code( CodeDefine );
+
+	void to_string( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_Define* operator->();
+	AST_Define* ast;
+};
+
+struct CodeDestructor
+{
+	Using_Code( CodeDestructor );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST*             raw();
+	operator         Code();
+	AST_Destructor* operator->();
+	AST_Destructor* ast;
+};
+
+struct CodeEnum
+{
+	Using_Code( CodeEnum );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+	void to_string_class_def( String& result );
+	void to_string_class_fwd( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Enum* operator->();
+	AST_Enum* ast;
+};
+
+Define_CodeType( Exec );
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct CodeExpr
+{
+	Using_Code( CodeExpr );
+
+	void to_string( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Expr* operator->();
+	AST_Expr* ast;
+};
+
+struct CodeExpr_Assign
+{
+	Using_Code( CodeExpr_Assign );
+
+	void to_string( String& result );
+
+	AST*             raw();
+	operator         Code();
+	AST_Expr_Assign* operator->();
+	AST_Expr_Assign* ast;
+};
+
+struct CodeExpr_Alignof
+{
+	Using_Code( CodeExpr_Alignof );
+
+	void to_string( String& result );
+
+	AST*              raw();
+	operator          Code();
+	AST_Expr_Alignof* operator->();
+	AST_Expr_Alignof* ast;
+};
+
+struct CodeExpr_Binary
+{
+	Using_Code( CodeExpr_Binary );
+
+	void to_string( String& result );
+
+	AST*             raw();
+	operator         Code();
+	AST_Expr_Binary* operator->();
+	AST_Expr_Binary* ast;
+};
+
+struct CodeExpr_CStyleCast
+{
+	Using_Code( CodeExpr_CStyleCast );
+
+	void to_string( String& result );
+
+	AST*                 raw();
+	operator             Code();
+	AST_Expr_CStyleCast* operator->();
+	AST_Expr_CStyleCast* ast;
+};
+
+struct CodeExpr_FunctionalCast
+{
+	Using_Code( CodeExpr_FunctionalCast );
+
+	void to_string( String& result );
+
+	AST*                     raw();
+	operator                 Code();
+	AST_Expr_FunctionalCast* operator->();
+	AST_Expr_FunctionalCast* ast;
+};
+
+struct CodeExpr_CppCast
+{
+	Using_Code( CodeExpr_CppCast );
+
+	void to_string( String& result );
+
+	AST*              raw();
+	operator          Code();
+	AST_Expr_CppCast* operator->();
+	AST_Expr_CppCast* ast;
+};
+
+struct CodeExpr_Element
+{
+	Using_Code( CodeExpr_Element );
+
+	void to_string( String& result );
+
+	AST*              raw();
+	operator          Code();
+	AST_Expr_Element* operator->();
+	AST_Expr_Element* ast;
+};
+
+struct CodeExpr_ProcCall
+{
+	Using_Code( CodeExpr_ProcCall );
+
+	void to_string( String& result );
+
+	AST*               raw();
+	operator           Code();
+	AST_Expr_ProcCall* operator->();
+	AST_Expr_ProcCall* ast;
+};
+
+struct CodeExpr_Decltype
+{
+	Using_Code( CodeExpr_Decltype );
+
+	void to_string( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Expr_Decltype* operator->();
+	AST_Expr_Decltype* ast;
+};
+
+struct CodeExpr_Comma
+{
+	Using_Code( CodeExpr_Comma );
+
+	void to_string( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Expr_Comma* operator->();
+	AST_Expr_Comma* ast;
+};
+
+struct CodeExpr_AMS
+{
+	Using_Code( CodeExpr_AMS );
+
+	void to_string( String& result );
+
+	AST*          raw();
+	operator      Code();
+	AST_Expr_AMS* operator->();
+	AST_Expr_AMS* ast;
+};
+
+struct CodeExpr_Sizeof
+{
+	Using_Code( CodeExpr_Sizeof );
+
+	void to_string( String& result );
+
+	AST*             raw();
+	operator         Code();
+	AST_Expr_Sizeof* operator->();
+	AST_Expr_Sizeof* ast;
+};
+
+struct CodeExpr_Subscript
+{
+	Using_Code( CodeExpr_Subscript );
+
+	void to_string( String& result );
+
+	AST*                raw();
+	operator            Code();
+	AST_Expr_Subscript* operator->();
+	AST_Expr_Subscript* ast;
+};
+
+struct CodeExpr_Ternary
+{
+	Using_Code( CodeExpr_Ternary );
+
+	void to_string( String& result );
+
+	AST*              raw();
+	operator          Code();
+	AST_Expr_Ternary* operator->();
+	AST_Expr_Ternary* ast;
+};
+
+struct CodeExpr_UnaryPrefix
+{
+	Using_Code( CodeExpr_UnaryPrefix );
+
+	void to_string( String& result );
+
+	AST*                  raw();
+	operator              Code();
+	AST_Expr_UnaryPrefix* operator->();
+	AST_Expr_UnaryPrefix* ast;
+};
+
+struct CodeExpr_UnaryPostfix
+{
+	Using_Code( CodeExpr_UnaryPostfix );
+
+	void to_string( String& result );
+
+	AST*                   raw();
+	operator               Code();
+	AST_Expr_UnaryPostfix* operator->();
+	AST_Expr_UnaryPostfix* ast;
+};
+#endif
+
+struct CodeExtern
+{
+	Using_Code( CodeExtern );
+
+	void to_string( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_Extern* operator->();
+	AST_Extern* ast;
+};
+
+struct CodeInclude
+{
+	Using_Code( CodeInclude );
+
+	void to_string( String& result );
+
+	AST*         raw();
+	operator     Code();
+	AST_Include* operator->();
+	AST_Include* ast;
+};
+
+struct CodeFriend
+{
+	Using_Code( CodeFriend );
+
+	void to_string( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_Friend* operator->();
+	AST_Friend* ast;
+};
+
+struct CodeFn
+{
+	Using_Code( CodeFn );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST*     raw();
+	operator Code();
+	AST_Fn*  operator->();
+	AST_Fn*  ast;
+};
+
+struct CodeModule
+{
+	Using_Code( CodeModule );
+
+	void to_string( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_Module* operator->();
+	AST_Module* ast;
+};
+
+struct CodeNS
+{
+	Using_Code( CodeNS );
+
+	void to_string( String& result );
+
+	AST*     raw();
+	operator Code();
+	AST_NS*  operator->();
+	AST_NS*  ast;
+};
+
+struct CodeOperator
+{
+	Using_Code( CodeOperator );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST*          raw();
+	operator      Code();
+	AST_Operator* operator->();
+	AST_Operator* ast;
+};
+
+struct CodeOpCast
+{
+	Using_Code( CodeOpCast );
+
+	void to_string_def( String& result );
+	void to_string_fwd( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_OpCast* operator->();
+	AST_OpCast* ast;
+};
+
+struct CodePragma
+{
+	Using_Code( CodePragma );
+
+	void to_string( String& result );
+
+	AST*        raw();
+	operator    Code();
+	AST_Pragma* operator->();
+	AST_Pragma* ast;
+};
+
+struct CodePreprocessCond
+{
+	Using_Code( CodePreprocessCond );
+
+	void to_string_if( String& result );
+	void to_string_ifdef( String& result );
+	void to_string_ifndef( String& result );
+	void to_string_elif( String& result );
+	void to_string_else( String& result );
+	void to_string_endif( String& result );
+
+	AST*                raw();
+	operator            Code();
+	AST_PreprocessCond* operator->();
+	AST_PreprocessCond* ast;
+};
+
+#if GEN_EXECUTION_EXPRESSION_SUPPORT
+struct CodeStmt
+{
+	Using_Code( CodeStmt );
+
+	void to_string( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Stmt* operator->();
+	AST_Stmt* ast;
+};
+
+struct CodeStmt_Break
+{
+	Using_Code( CodeStmt_Break );
+
+	void to_string( String& result );
+
+	AST*            raw();
+	operator        Code();
+	AST_Stmt_Break* operator->();
+	AST_Stmt_Break* ast;
+};
+
+struct CodeStmt_Case
+{
+	Using_Code( CodeStmt_Case );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Case* operator->();
+	AST_Stmt_Case* ast;
+};
+
+struct CodeStmt_Continue
+{
+	Using_Code( CodeStmt_Continue );
+
+	void to_string( String& result );
+
+	AST*               raw();
+	operator           Code();
+	AST_Stmt_Continue* operator->();
+	AST_Stmt_Continue* ast;
+};
+
+struct CodeStmt_Decl
+{
+	Using_Code( CodeStmt_Decl );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Decl* operator->();
+	AST_Stmt_Decl* ast;
+};
+
+struct CodeStmt_Do
+{
+	Using_Code( CodeStmt_Do );
+
+	void to_string( String& result );
+
+	AST*         raw();
+	operator     Code();
+	AST_Stmt_Do* operator->();
+	AST_Stmt_Do* ast;
+};
+
+struct CodeStmt_Expr
+{
+	Using_Code( CodeStmt_Expr );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Expr* operator->();
+	AST_Stmt_Expr* ast;
+};
+
+struct CodeStmt_Else
+{
+	Using_Code( CodeStmt_Else );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Else* operator->();
+	AST_Stmt_Else* ast;
+};
+
+struct CodeStmt_If
+{
+	Using_Code( CodeStmt_If );
+
+	void to_string( String& result );
+
+	AST*         raw();
+	operator     Code();
+	AST_Stmt_If* operator->();
+	AST_Stmt_If* ast;
+};
+
+struct CodeStmt_For
+{
+	Using_Code( CodeStmt_For );
+
+	void to_string( String& result );
+
+	AST*          raw();
+	operator      Code();
+	AST_Stmt_For* operator->();
+	AST_Stmt_For* ast;
+};
+
+struct CodeStmt_Goto
+{
+	Using_Code( CodeStmt_Goto );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Goto* operator->();
+	AST_Stmt_Goto* ast;
+};
+
+struct CodeStmt_Label
+{
+	Using_Code( CodeStmt_Label );
+
+	void to_string( String& result );
+
+	AST*            raw();
+	operator        Code();
+	AST_Stmt_Label* operator->();
+	AST_Stmt_Label* ast;
+};
+
+struct CodeStmt_Switch
+{
+	Using_Code( CodeStmt_Switch );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_Switch* operator->();
+	AST_Stmt_Switch* ast;
+};
+
+struct CodeStmt_While
+{
+	Using_Code( CodeStmt_While );
+
+	void to_string( String& result );
+
+	AST*           raw();
+	operator       Code();
+	AST_Stmt_While* operator->();
+	AST_Stmt_While* ast;
+};
+#endif
+
+struct CodeTemplate
+{
+	Using_Code( CodeTemplate );
+
+	void to_string( String& result );
+
+	AST*          raw();
+	operator      Code();
+	AST_Template* operator->();
+	AST_Template* ast;
+};
+
+struct CodeType
+{
+	Using_Code( CodeType );
+
+	void to_string( String& result );
+
+	AST*      raw();
+	operator  Code();
+	AST_Type* operator->();
+	AST_Type* ast;
+};
+
+struct CodeTypedef
+{
+	Using_Code( CodeTypedef );
+
+	void to_string( String& result );
+
+	AST*         raw();
+	operator     Code();
+	AST_Typedef* operator->();
+	AST_Typedef* ast;
+};
+
+struct CodeUnion
+{
+	Using_Code( CodeUnion );
+
+	void to_string( String& result );
+
+	AST*       raw();
+	operator   Code();
+	AST_Union* operator->();
+	AST_Union* ast;
+};
+
+struct CodeUsing
+{
+	Using_Code( CodeUsing );
+
+	void to_string( String& result );
+	void to_string_ns( String& result );
+
+	AST*       raw();
+	operator   Code();
+	AST_Using* operator->();
+	AST_Using* ast;
+};
+
+struct CodeVar
+{
+	Using_Code( CodeVar );
+
+	void to_string( String& result );
+
+	AST*     raw();
+	operator Code();
+	AST_Var* operator->();
+	AST_Var* ast;
+};
+
+#undef Define_CodeType
+#undef Using_Code
+
+#pragma endregion Code Types

project/components/gen/ecode.hpp

@@ -72,71 +72,71 @@ namespace ECode
 		NumTypes
 	};
 
-	StrC to_str( Type type )
+	inline StrC to_str( Type type )
 	{
 		local_persist StrC lookup[] {
-			{sizeof( "Invalid" ),              "Invalid"            },
-			{ sizeof( "Untyped" ),             "Untyped"            },
-			{ sizeof( "NewLine" ),             "NewLine"            },
-			{ sizeof( "Comment" ),             "Comment"            },
-			{ sizeof( "Access_Private" ),      "Access_Private"     },
-			{ sizeof( "Access_Protected" ),    "Access_Protected"   },
-			{ sizeof( "Access_Public" ),       "Access_Public"      },
-			{ sizeof( "PlatformAttributes" ),  "PlatformAttributes" },
-			{ sizeof( "Class" ),               "Class"              },
-			{ sizeof( "Class_Fwd" ),           "Class_Fwd"          },
-			{ sizeof( "Class_Body" ),          "Class_Body"         },
-			{ sizeof( "Constructor" ),         "Constructor"        },
-			{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"    },
-			{ sizeof( "Destructor" ),          "Destructor"         },
-			{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"     },
-			{ sizeof( "Enum" ),                "Enum"               },
-			{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"           },
-			{ sizeof( "Enum_Body" ),           "Enum_Body"          },
-			{ sizeof( "Enum_Class" ),          "Enum_Class"         },
-			{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"     },
-			{ sizeof( "Execution" ),           "Execution"          },
-			{ sizeof( "Export_Body" ),         "Export_Body"        },
-			{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"     },
-			{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body"},
-			{ sizeof( "Friend" ),              "Friend"             },
-			{ sizeof( "Function" ),            "Function"           },
-			{ sizeof( "Function_Fwd" ),        "Function_Fwd"       },
-			{ sizeof( "Function_Body" ),       "Function_Body"      },
-			{ sizeof( "Global_Body" ),         "Global_Body"        },
-			{ sizeof( "Module" ),              "Module"             },
-			{ sizeof( "Namespace" ),           "Namespace"          },
-			{ sizeof( "Namespace_Body" ),      "Namespace_Body"     },
-			{ sizeof( "Operator" ),            "Operator"           },
-			{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"       },
-			{ sizeof( "Operator_Member" ),     "Operator_Member"    },
-			{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd"},
-			{ sizeof( "Operator_Cast" ),       "Operator_Cast"      },
-			{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"  },
-			{ sizeof( "Parameters" ),          "Parameters"         },
-			{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"  },
-			{ sizeof( "Preprocess_Include" ),  "Preprocess_Include" },
-			{ sizeof( "Preprocess_If" ),       "Preprocess_If"      },
-			{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"   },
-			{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef"},
-			{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"    },
-			{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"    },
-			{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"   },
-			{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"  },
-			{ sizeof( "Specifiers" ),          "Specifiers"         },
-			{ sizeof( "Struct" ),              "Struct"             },
-			{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"         },
-			{ sizeof( "Struct_Body" ),         "Struct_Body"        },
-			{ sizeof( "Template" ),            "Template"           },
-			{ sizeof( "Typedef" ),             "Typedef"            },
-			{ sizeof( "Typename" ),            "Typename"           },
-			{ sizeof( "Union" ),               "Union"              },
-			{ sizeof( "Union_Body" ),          "Union_Body"         },
-			{ sizeof( "Using" ),               "Using"              },
-			{ sizeof( "Using_Namespace" ),     "Using_Namespace"    },
-			{ sizeof( "Variable" ),            "Variable"           },
+			{ sizeof( "Invalid" ),             "Invalid"             },
+			{ sizeof( "Untyped" ),             "Untyped"             },
+			{ sizeof( "NewLine" ),             "NewLine"             },
+			{ sizeof( "Comment" ),             "Comment"             },
+			{ sizeof( "Access_Private" ),      "Access_Private"      },
+			{ sizeof( "Access_Protected" ),    "Access_Protected"    },
+			{ sizeof( "Access_Public" ),       "Access_Public"       },
+			{ sizeof( "PlatformAttributes" ),  "PlatformAttributes"  },
+			{ sizeof( "Class" ),               "Class"               },
+			{ sizeof( "Class_Fwd" ),           "Class_Fwd"           },
+			{ sizeof( "Class_Body" ),          "Class_Body"          },
+			{ sizeof( "Constructor" ),         "Constructor"         },
+			{ sizeof( "Constructor_Fwd" ),     "Constructor_Fwd"     },
+			{ sizeof( "Destructor" ),          "Destructor"          },
+			{ sizeof( "Destructor_Fwd" ),      "Destructor_Fwd"      },
+			{ sizeof( "Enum" ),                "Enum"                },
+			{ sizeof( "Enum_Fwd" ),            "Enum_Fwd"            },
+			{ sizeof( "Enum_Body" ),           "Enum_Body"           },
+			{ sizeof( "Enum_Class" ),          "Enum_Class"          },
+			{ sizeof( "Enum_Class_Fwd" ),      "Enum_Class_Fwd"      },
+			{ sizeof( "Execution" ),           "Execution"           },
+			{ sizeof( "Export_Body" ),         "Export_Body"         },
+			{ sizeof( "Extern_Linkage" ),      "Extern_Linkage"      },
+			{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
+			{ sizeof( "Friend" ),              "Friend"              },
+			{ sizeof( "Function" ),            "Function"            },
+			{ sizeof( "Function_Fwd" ),        "Function_Fwd"        },
+			{ sizeof( "Function_Body" ),       "Function_Body"       },
+			{ sizeof( "Global_Body" ),         "Global_Body"         },
+			{ sizeof( "Module" ),              "Module"              },
+			{ sizeof( "Namespace" ),           "Namespace"           },
+			{ sizeof( "Namespace_Body" ),      "Namespace_Body"      },
+			{ sizeof( "Operator" ),            "Operator"            },
+			{ sizeof( "Operator_Fwd" ),        "Operator_Fwd"        },
+			{ sizeof( "Operator_Member" ),     "Operator_Member"     },
+			{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
+			{ sizeof( "Operator_Cast" ),       "Operator_Cast"       },
+			{ sizeof( "Operator_Cast_Fwd" ),   "Operator_Cast_Fwd"   },
+			{ sizeof( "Parameters" ),          "Parameters"          },
+			{ sizeof( "Preprocess_Define" ),   "Preprocess_Define"   },
+			{ sizeof( "Preprocess_Include" ),  "Preprocess_Include"  },
+			{ sizeof( "Preprocess_If" ),       "Preprocess_If"       },
+			{ sizeof( "Preprocess_IfDef" ),    "Preprocess_IfDef"    },
+			{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
+			{ sizeof( "Preprocess_ElIf" ),     "Preprocess_ElIf"     },
+			{ sizeof( "Preprocess_Else" ),     "Preprocess_Else"     },
+			{ sizeof( "Preprocess_EndIf" ),    "Preprocess_EndIf"    },
+			{ sizeof( "Preprocess_Pragma" ),   "Preprocess_Pragma"   },
+			{ sizeof( "Specifiers" ),          "Specifiers"          },
+			{ sizeof( "Struct" ),              "Struct"              },
+			{ sizeof( "Struct_Fwd" ),          "Struct_Fwd"          },
+			{ sizeof( "Struct_Body" ),         "Struct_Body"         },
+			{ sizeof( "Template" ),            "Template"            },
+			{ sizeof( "Typedef" ),             "Typedef"             },
+			{ sizeof( "Typename" ),            "Typename"            },
+			{ sizeof( "Union" ),               "Union"               },
+			{ sizeof( "Union_Body" ),          "Union_Body"          },
+			{ sizeof( "Using" ),               "Using"               },
+			{ sizeof( "Using_Namespace" ),     "Using_Namespace"     },
+			{ sizeof( "Variable" ),            "Variable"            },
 		};
-		return lookup[ type ];
+		return lookup[type];
 	}
 
 }    // namespace ECode

project/components/gen/eoperator.hpp

@@ -52,57 +52,65 @@ namespace EOperator
 		PtrToMemOfPtr,
 		FunctionCall,
 		Comma,
+		New,
+		NewArray,
+		Delete,
+		DeleteArray,
 		NumOps
 	};
 
-	StrC to_str( Type op )
+	inline StrC to_str( Type op )
 	{
 		local_persist StrC lookup[] {
-			{sizeof( "INVALID" ), "INVALID"},
-			{ sizeof( "=" ),      "="      },
-			{ sizeof( "+=" ),     "+="     },
-			{ sizeof( "-=" ),     "-="     },
-			{ sizeof( "*=" ),     "*="     },
-			{ sizeof( "/=" ),     "/="     },
-			{ sizeof( "%=" ),     "%="     },
-			{ sizeof( "&=" ),     "&="     },
-			{ sizeof( "|=" ),     "|="     },
-			{ sizeof( "^=" ),     "^="     },
-			{ sizeof( "<<=" ),    "<<="    },
-			{ sizeof( ">>=" ),    ">>="    },
-			{ sizeof( "++" ),     "++"     },
-			{ sizeof( "--" ),     "--"     },
-			{ sizeof( "+" ),      "+"      },
-			{ sizeof( "-" ),      "-"      },
-			{ sizeof( "!" ),      "!"      },
-			{ sizeof( "+" ),      "+"      },
-			{ sizeof( "-" ),      "-"      },
-			{ sizeof( "*" ),      "*"      },
-			{ sizeof( "/" ),      "/"      },
-			{ sizeof( "%" ),      "%"      },
-			{ sizeof( "~" ),      "~"      },
-			{ sizeof( "&" ),      "&"      },
-			{ sizeof( "|" ),      "|"      },
-			{ sizeof( "^" ),      "^"      },
-			{ sizeof( "<<" ),     "<<"     },
-			{ sizeof( ">>" ),     ">>"     },
-			{ sizeof( "&&" ),     "&&"     },
-			{ sizeof( "||" ),     "||"     },
-			{ sizeof( "==" ),     "=="     },
-			{ sizeof( "!=" ),     "!="     },
-			{ sizeof( "<" ),      "<"      },
-			{ sizeof( ">" ),      ">"      },
-			{ sizeof( "<=" ),     "<="     },
-			{ sizeof( ">=" ),     ">="     },
-			{ sizeof( "[]" ),     "[]"     },
-			{ sizeof( "*" ),      "*"      },
-			{ sizeof( "&" ),      "&"      },
-			{ sizeof( "->" ),     "->"     },
-			{ sizeof( "->*" ),    "->*"    },
-			{ sizeof( "()" ),     "()"     },
-			{ sizeof( "," ),      ","      },
+			{ sizeof( "INVALID" ),  "INVALID"  },
+			{ sizeof( "=" ),        "="        },
+			{ sizeof( "+=" ),       "+="       },
+			{ sizeof( "-=" ),       "-="       },
+			{ sizeof( "*=" ),       "*="       },
+			{ sizeof( "/=" ),       "/="       },
+			{ sizeof( "%=" ),       "%="       },
+			{ sizeof( "&=" ),       "&="       },
+			{ sizeof( "|=" ),       "|="       },
+			{ sizeof( "^=" ),       "^="       },
+			{ sizeof( "<<=" ),      "<<="      },
+			{ sizeof( ">>=" ),      ">>="      },
+			{ sizeof( "++" ),       "++"       },
+			{ sizeof( "--" ),       "--"       },
+			{ sizeof( "+" ),        "+"        },
+			{ sizeof( "-" ),        "-"        },
+			{ sizeof( "!" ),        "!"        },
+			{ sizeof( "+" ),        "+"        },
+			{ sizeof( "-" ),        "-"        },
+			{ sizeof( "*" ),        "*"        },
+			{ sizeof( "/" ),        "/"        },
+			{ sizeof( "%" ),        "%"        },
+			{ sizeof( "~" ),        "~"        },
+			{ sizeof( "&" ),        "&"        },
+			{ sizeof( "|" ),        "|"        },
+			{ sizeof( "^" ),        "^"        },
+			{ sizeof( "<<" ),       "<<"       },
+			{ sizeof( ">>" ),       ">>"       },
+			{ sizeof( "&&" ),       "&&"       },
+			{ sizeof( "||" ),       "||"       },
+			{ sizeof( "==" ),       "=="       },
+			{ sizeof( "!=" ),       "!="       },
+			{ sizeof( "<" ),        "<"        },
+			{ sizeof( ">" ),        ">"        },
+			{ sizeof( "<=" ),       "<="       },
+			{ sizeof( ">=" ),       ">="       },
+			{ sizeof( "[]" ),       "[]"       },
+			{ sizeof( "*" ),        "*"        },
+			{ sizeof( "&" ),        "&"        },
+			{ sizeof( "->" ),       "->"       },
+			{ sizeof( "->*" ),      "->*"      },
+			{ sizeof( "()" ),       "()"       },
+			{ sizeof( "," ),        ","        },
+			{ sizeof( "new" ),      "new"      },
+			{ sizeof( "new[]" ),    "new[]"    },
+			{ sizeof( "delete" ),   "delete"   },
+			{ sizeof( "delete[]" ), "delete[]" },
 		};
-		return lookup[ op ];
+		return lookup[op];
 	}
 
 }    // namespace EOperator

project/components/gen/especifier.hpp

@@ -28,67 +28,67 @@ namespace ESpecifier
 		RValue,
 		Static,
 		Thread_Local,
-		Volatile,
 		Virtual,
 		Const,
 		Final,
 		NoExceptions,
 		Override,
 		Pure,
+		Volatile,
 		NumSpecifiers
 	};
 
-	bool is_trailing( Type specifier )
+	inline bool is_trailing( Type specifier )
 	{
 		return specifier > Virtual;
 	}
 
-	StrC to_str( Type type )
+	inline StrC to_str( Type type )
 	{
 		local_persist StrC lookup[] {
-			{sizeof( "INVALID" ),        "INVALID"      },
-			{ sizeof( "consteval" ),     "consteval"    },
-			{ sizeof( "constexpr" ),     "constexpr"    },
-			{ sizeof( "constinit" ),     "constinit"    },
-			{ sizeof( "explicit" ),      "explicit"     },
-			{ sizeof( "extern" ),        "extern"       },
-			{ sizeof( "forceinline" ),   "forceinline"  },
-			{ sizeof( "global" ),        "global"       },
-			{ sizeof( "inline" ),        "inline"       },
-			{ sizeof( "internal" ),      "internal"     },
-			{ sizeof( "local_persist" ), "local_persist"},
-			{ sizeof( "mutable" ),       "mutable"      },
-			{ sizeof( "neverinline" ),   "neverinline"  },
-			{ sizeof( "*" ),             "*"            },
-			{ sizeof( "&" ),             "&"            },
-			{ sizeof( "register" ),      "register"     },
-			{ sizeof( "&&" ),            "&&"           },
-			{ sizeof( "static" ),        "static"       },
-			{ sizeof( "thread_local" ),  "thread_local" },
-			{ sizeof( "volatile" ),      "volatile"     },
-			{ sizeof( "virtual" ),       "virtual"      },
-			{ sizeof( "const" ),         "const"        },
-			{ sizeof( "final" ),         "final"        },
-			{ sizeof( "noexcept" ),      "noexcept"     },
-			{ sizeof( "override" ),      "override"     },
-			{ sizeof( "= 0" ),           "= 0"          },
+			{ sizeof( "INVALID" ),       "INVALID"       },
+			{ sizeof( "consteval" ),     "consteval"     },
+			{ sizeof( "constexpr" ),     "constexpr"     },
+			{ sizeof( "constinit" ),     "constinit"     },
+			{ sizeof( "explicit" ),      "explicit"      },
+			{ sizeof( "extern" ),        "extern"        },
+			{ sizeof( "forceinline" ),   "forceinline"   },
+			{ sizeof( "global" ),        "global"        },
+			{ sizeof( "inline" ),        "inline"        },
+			{ sizeof( "internal" ),      "internal"      },
+			{ sizeof( "local_persist" ), "local_persist" },
+			{ sizeof( "mutable" ),       "mutable"       },
+			{ sizeof( "neverinline" ),   "neverinline"   },
+			{ sizeof( "*" ),             "*"             },
+			{ sizeof( "&" ),             "&"             },
+			{ sizeof( "register" ),      "register"      },
+			{ sizeof( "&&" ),            "&&"            },
+			{ sizeof( "static" ),        "static"        },
+			{ sizeof( "thread_local" ),  "thread_local"  },
+			{ sizeof( "virtual" ),       "virtual"       },
+			{ sizeof( "const" ),         "const"         },
+			{ sizeof( "final" ),         "final"         },
+			{ sizeof( "noexcept" ),      "noexcept"      },
+			{ sizeof( "override" ),      "override"      },
+			{ sizeof( "= 0" ),           "= 0"           },
+			{ sizeof( "volatile" ),      "volatile"      },
 		};
-		return lookup[ type ];
+		return lookup[type];
 	}
 
-	Type to_type( StrC str )
+	inline Type to_type( StrC str )
 	{
-		local_persist u32 keymap[ NumSpecifiers ];
+		local_persist u32 keymap[NumSpecifiers];
 		do_once_start for ( u32 index = 0; index < NumSpecifiers; index++ )
 		{
-			StrC enum_str   = to_str( ( Type )index );
-			keymap[ index ] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+			StrC enum_str = to_str( (Type)index );
+			keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
 		}
 		do_once_end u32 hash = crc32( str.Ptr, str.Len );
 		for ( u32 index = 0; index < NumSpecifiers; index++ )
 		{
-			if ( keymap[ index ] == hash )
-				return ( Type )index;
+			if ( keymap[index] == hash )
+				return (Type)index;
 		}
 		return Invalid;
 	}

project/components/gen/etoktype.cpp

@@ -5,11 +5,11 @@
 
 // This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
 
-namespace Parser
+namespace parser
 {
 	namespace ETokType
 	{
-#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( API_Export, GEN_API_Export_Code ) Entry( API_Import, GEN_API_Import_Code )
+#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Attribute_API_Import, "GEN_API_Import_Code" )
 
 		enum Type : u32
 		{
@@ -92,10 +92,12 @@ namespace Parser
 			Statement_End,
 			StaticAssert,
 			String,
+			Type_Typename,
 			Type_Unsigned,
 			Type_Signed,
 			Type_Short,
 			Type_Long,
+			Type_bool,
 			Type_char,
 			Type_int,
 			Type_double,
@@ -106,126 +108,128 @@ namespace Parser
 			Type_MS_W64,
 			Varadic_Argument,
 			__Attributes_Start,
-			API_Export,
-			API_Import,
+			Attribute_API_Export,
+			Attribute_API_Import,
 			NumTokens
 		};
 
-		StrC to_str( Type type )
+		inline StrC to_str( Type type )
 		{
 			local_persist StrC lookup[] {
-				{sizeof( "__invalid__" ),          "__invalid__"        },
-				{ sizeof( "private" ),             "private"            },
-				{ sizeof( "protected" ),           "protected"          },
-				{ sizeof( "public" ),              "public"             },
-				{ sizeof( "." ),                   "."                  },
-				{ sizeof( "::" ),                  "::"                 },
-				{ sizeof( "&" ),                   "&"                  },
-				{ sizeof( "&&" ),                  "&&"                 },
-				{ sizeof( ":" ),                   ":"                  },
-				{ sizeof( "[[" ),                  "[["                 },
-				{ sizeof( "]]" ),                  "]]"                 },
-				{ sizeof( "{" ),                   "{"                  },
-				{ sizeof( "}" ),                   "}"                  },
-				{ sizeof( "[" ),                   "["                  },
-				{ sizeof( "]" ),                   "]"                  },
-				{ sizeof( "(" ),                   "("                  },
-				{ sizeof( ")" ),                   ")"                  },
-				{ sizeof( "__comment__" ),         "__comment__"        },
-				{ sizeof( "__comment_end__" ),     "__comment_end__"    },
-				{ sizeof( "__comment_start__" ),   "__comment_start__"  },
-				{ sizeof( "__character__" ),       "__character__"      },
-				{ sizeof( "," ),                   ","                  },
-				{ sizeof( "class" ),               "class"              },
-				{ sizeof( "__attribute__" ),       "__attribute__"      },
-				{ sizeof( "__declspec" ),          "__declspec"         },
-				{ sizeof( "enum" ),                "enum"               },
-				{ sizeof( "extern" ),              "extern"             },
-				{ sizeof( "friend" ),              "friend"             },
-				{ sizeof( "module" ),              "module"             },
-				{ sizeof( "namespace" ),           "namespace"          },
-				{ sizeof( "operator" ),            "operator"           },
-				{ sizeof( "struct" ),              "struct"             },
-				{ sizeof( "template" ),            "template"           },
-				{ sizeof( "typedef" ),             "typedef"            },
-				{ sizeof( "using" ),               "using"              },
-				{ sizeof( "union" ),               "union"              },
-				{ sizeof( "__identifier__" ),      "__identifier__"     },
-				{ sizeof( "import" ),              "import"             },
-				{ sizeof( "export" ),              "export"             },
-				{ sizeof( "__new_line__" ),        "__new_line__"       },
-				{ sizeof( "__number__" ),          "__number__"         },
-				{ sizeof( "__operator__" ),        "__operator__"       },
-				{ sizeof( "#" ),                   "#"                  },
-				{ sizeof( "define" ),              "define"             },
-				{ sizeof( "if" ),                  "if"                 },
-				{ sizeof( "ifdef" ),               "ifdef"              },
-				{ sizeof( "ifndef" ),              "ifndef"             },
-				{ sizeof( "elif" ),                "elif"               },
-				{ sizeof( "else" ),                "else"               },
-				{ sizeof( "endif" ),               "endif"              },
-				{ sizeof( "include" ),             "include"            },
-				{ sizeof( "pragma" ),              "pragma"             },
-				{ sizeof( "__macro_content__" ),   "__macro_content__"  },
-				{ sizeof( "__macro__" ),           "__macro__"          },
-				{ sizeof( "__unsupported__" ),     "__unsupported__"    },
-				{ sizeof( "alignas" ),             "alignas"            },
-				{ sizeof( "const" ),               "const"              },
-				{ sizeof( "consteval" ),           "consteval"          },
-				{ sizeof( "constexpr" ),           "constexpr"          },
-				{ sizeof( "constinit" ),           "constinit"          },
-				{ sizeof( "explicit" ),            "explicit"           },
-				{ sizeof( "extern" ),              "extern"             },
-				{ sizeof( "final" ),               "final"              },
-				{ sizeof( "forceinline" ),         "forceinline"        },
-				{ sizeof( "global" ),              "global"             },
-				{ sizeof( "inline" ),              "inline"             },
-				{ sizeof( "internal" ),            "internal"           },
-				{ sizeof( "local_persist" ),       "local_persist"      },
-				{ sizeof( "mutable" ),             "mutable"            },
-				{ sizeof( "neverinline" ),         "neverinline"        },
-				{ sizeof( "override" ),            "override"           },
-				{ sizeof( "static" ),              "static"             },
-				{ sizeof( "thread_local" ),        "thread_local"       },
-				{ sizeof( "volatile" ),            "volatile"           },
-				{ sizeof( "virtual" ),             "virtual"            },
-				{ sizeof( "*" ),                   "*"                  },
-				{ sizeof( ";" ),                   ";"                  },
-				{ sizeof( "static_assert" ),       "static_assert"      },
-				{ sizeof( "__string__" ),          "__string__"         },
-				{ sizeof( "unsigned" ),            "unsigned"           },
-				{ sizeof( "signed" ),              "signed"             },
-				{ sizeof( "short" ),               "short"              },
-				{ sizeof( "long" ),                "long"               },
-				{ sizeof( "char" ),                "char"               },
-				{ sizeof( "int" ),                 "int"                },
-				{ sizeof( "double" ),              "double"             },
-				{ sizeof( "__int8" ),              "__int8"             },
-				{ sizeof( "__int16" ),             "__int16"            },
-				{ sizeof( "__int32" ),             "__int32"            },
-				{ sizeof( "__int64" ),             "__int64"            },
-				{ sizeof( "_W64" ),                "_W64"               },
-				{ sizeof( "..." ),                 "..."                },
-				{ sizeof( "__attrib_start__" ),    "__attrib_start__"   },
-				{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code"},
-				{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code"},
+				{ sizeof( "__invalid__" ),         "__invalid__"         },
+				{ sizeof( "private" ),             "private"             },
+				{ sizeof( "protected" ),           "protected"           },
+				{ sizeof( "public" ),              "public"              },
+				{ sizeof( "." ),                   "."                   },
+				{ sizeof( "::" ),                  "::"                  },
+				{ sizeof( "&" ),                   "&"                   },
+				{ sizeof( "&&" ),                  "&&"                  },
+				{ sizeof( ":" ),                   ":"                   },
+				{ sizeof( "[[" ),                  "[["                  },
+				{ sizeof( "]]" ),                  "]]"                  },
+				{ sizeof( "{" ),                   "{"                   },
+				{ sizeof( "}" ),                   "}"                   },
+				{ sizeof( "[" ),                   "["                   },
+				{ sizeof( "]" ),                   "]"                   },
+				{ sizeof( "(" ),                   "("                   },
+				{ sizeof( ")" ),                   ")"                   },
+				{ sizeof( "__comment__" ),         "__comment__"         },
+				{ sizeof( "__comment_end__" ),     "__comment_end__"     },
+				{ sizeof( "__comment_start__" ),   "__comment_start__"   },
+				{ sizeof( "__character__" ),       "__character__"       },
+				{ sizeof( "," ),                   ","                   },
+				{ sizeof( "class" ),               "class"               },
+				{ sizeof( "__attribute__" ),       "__attribute__"       },
+				{ sizeof( "__declspec" ),          "__declspec"          },
+				{ sizeof( "enum" ),                "enum"                },
+				{ sizeof( "extern" ),              "extern"              },
+				{ sizeof( "friend" ),              "friend"              },
+				{ sizeof( "module" ),              "module"              },
+				{ sizeof( "namespace" ),           "namespace"           },
+				{ sizeof( "operator" ),            "operator"            },
+				{ sizeof( "struct" ),              "struct"              },
+				{ sizeof( "template" ),            "template"            },
+				{ sizeof( "typedef" ),             "typedef"             },
+				{ sizeof( "using" ),               "using"               },
+				{ sizeof( "union" ),               "union"               },
+				{ sizeof( "__identifier__" ),      "__identifier__"      },
+				{ sizeof( "import" ),              "import"              },
+				{ sizeof( "export" ),              "export"              },
+				{ sizeof( "__new_line__" ),        "__new_line__"        },
+				{ sizeof( "__number__" ),          "__number__"          },
+				{ sizeof( "__operator__" ),        "__operator__"        },
+				{ sizeof( "#" ),                   "#"                   },
+				{ sizeof( "define" ),              "define"              },
+				{ sizeof( "if" ),                  "if"                  },
+				{ sizeof( "ifdef" ),               "ifdef"               },
+				{ sizeof( "ifndef" ),              "ifndef"              },
+				{ sizeof( "elif" ),                "elif"                },
+				{ sizeof( "else" ),                "else"                },
+				{ sizeof( "endif" ),               "endif"               },
+				{ sizeof( "include" ),             "include"             },
+				{ sizeof( "pragma" ),              "pragma"              },
+				{ sizeof( "__macro_content__" ),   "__macro_content__"   },
+				{ sizeof( "__macro__" ),           "__macro__"           },
+				{ sizeof( "__unsupported__" ),     "__unsupported__"     },
+				{ sizeof( "alignas" ),             "alignas"             },
+				{ sizeof( "const" ),               "const"               },
+				{ sizeof( "consteval" ),           "consteval"           },
+				{ sizeof( "constexpr" ),           "constexpr"           },
+				{ sizeof( "constinit" ),           "constinit"           },
+				{ sizeof( "explicit" ),            "explicit"            },
+				{ sizeof( "extern" ),              "extern"              },
+				{ sizeof( "final" ),               "final"               },
+				{ sizeof( "forceinline" ),         "forceinline"         },
+				{ sizeof( "global" ),              "global"              },
+				{ sizeof( "inline" ),              "inline"              },
+				{ sizeof( "internal" ),            "internal"            },
+				{ sizeof( "local_persist" ),       "local_persist"       },
+				{ sizeof( "mutable" ),             "mutable"             },
+				{ sizeof( "neverinline" ),         "neverinline"         },
+				{ sizeof( "override" ),            "override"            },
+				{ sizeof( "static" ),              "static"              },
+				{ sizeof( "thread_local" ),        "thread_local"        },
+				{ sizeof( "volatile" ),            "volatile"            },
+				{ sizeof( "virtual" ),             "virtual"             },
+				{ sizeof( "*" ),                   "*"                   },
+				{ sizeof( ";" ),                   ";"                   },
+				{ sizeof( "static_assert" ),       "static_assert"       },
+				{ sizeof( "__string__" ),          "__string__"          },
+				{ sizeof( "typename" ),            "typename"            },
+				{ sizeof( "unsigned" ),            "unsigned"            },
+				{ sizeof( "signed" ),              "signed"              },
+				{ sizeof( "short" ),               "short"               },
+				{ sizeof( "long" ),                "long"                },
+				{ sizeof( "bool" ),                "bool"                },
+				{ sizeof( "char" ),                "char"                },
+				{ sizeof( "int" ),                 "int"                 },
+				{ sizeof( "double" ),              "double"              },
+				{ sizeof( "__int8" ),              "__int8"              },
+				{ sizeof( "__int16" ),             "__int16"             },
+				{ sizeof( "__int32" ),             "__int32"             },
+				{ sizeof( "__int64" ),             "__int64"             },
+				{ sizeof( "_W64" ),                "_W64"                },
+				{ sizeof( "..." ),                 "..."                 },
+				{ sizeof( "__attrib_start__" ),    "__attrib_start__"    },
+				{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
+				{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
 			};
-			return lookup[ type ];
+			return lookup[type];
 		}
 
-		Type to_type( StrC str )
+		inline Type to_type( StrC str )
 		{
-			local_persist u32 keymap[ NumTokens ];
+			local_persist u32 keymap[NumTokens];
 			do_once_start for ( u32 index = 0; index < NumTokens; index++ )
 			{
-				StrC enum_str   = to_str( ( Type )index );
-				keymap[ index ] = crc32( enum_str.Ptr, enum_str.Len - 1 );
+				StrC enum_str = to_str( (Type)index );
+				keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
 			}
 			do_once_end u32 hash = crc32( str.Ptr, str.Len );
 			for ( u32 index = 0; index < NumTokens; index++ )
 			{
-				if ( keymap[ index ] == hash )
-					return ( Type )index;
+				if ( keymap[index] == hash )
+					return (Type)index;
 			}
 			return Invalid;
 		}
@@ -234,4 +238,4 @@ namespace Parser
 
 	using TokType = ETokType::Type;
 
-}    // namespace Parser
+}    // namespace parser

project/components/header_end.hpp

@@ -42,7 +42,7 @@ constexpr s32 InitSize_DataArrays = 16;
 
 // NOTE: This limits the maximum size of an allocation
 // If you are generating a string larger than this, increase the size of the bucket here.
-constexpr uw  Global_BucketSize         = GEN_GLOBAL_BUCKET_SIZE;
+constexpr usize  Global_BucketSize         = GEN_GLOBAL_BUCKET_SIZE;
 constexpr s32 CodePool_NumBlocks        = GEN_CODEPOOL_NUM_BLOCKS;
 constexpr s32 SizePer_StringArena       = GEN_SIZE_PER_STRING_ARENA;
 
@@ -63,7 +63,6 @@ extern CodeAttributes attrib_api_import;
 extern Code module_global_fragment;
 extern Code module_private_fragment;
 
-// Exposed, but this is really used for parsing.
 extern Code fmt_newline;
 
 extern CodePragma pragma_once;
@@ -123,8 +122,8 @@ extern CodeType t_typename;
 	extern CodeType t_u32;
 	extern CodeType t_u64;
 
-	extern CodeType t_sw;
-	extern CodeType t_uw;
+	extern CodeType t_ssize;
+	extern CodeType t_usize;
 
 	extern CodeType t_f32;
 	extern CodeType t_f64;
@@ -155,6 +154,11 @@ extern CodeType t_typename;
 
 #pragma endregion Macros
 
+// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
+// Populate with strings via gen::get_cached_string.
+// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
+extern Array< StringCached > PreprocessorDefines;
+
 #ifdef GEN_EXPOSE_BACKEND
 
 	// Global allocator used for data with process lifetime.

project/components/inlines.hpp

@@ -3,6 +3,7 @@
 #include "interface.hpp"
 #endif
 
+inline
 void AST::append( AST* other )
 {
 	if ( other->Parent )
@@ -27,6 +28,7 @@ void AST::append( AST* other )
 	NumEntries++;
 }
 
+inline
 Code& AST::entry( u32 idx )
 {
 	AST** current = & Front;
@@ -42,21 +44,25 @@ Code& AST::entry( u32 idx )
 	return * rcast( Code*, current);
 }
 
+inline
 bool AST::has_entries()
 {
-	return NumEntries;
+	return NumEntries > 0;
 }
 
+inline
 char const* AST::type_str()
 {
 	return ECode::to_str( Type );
 }
 
+inline
 AST::operator Code()
 {
 	return { this };
 }
 
+inline
 Code& Code::operator ++()
 {
 	if ( ast )
@@ -65,6 +71,7 @@ Code& Code::operator ++()
 	return *this;
 }
 
+inline
 void CodeClass::add_interface( CodeType type )
 {
 	CodeType possible_slot = ast->ParentType;
@@ -84,6 +91,7 @@ void CodeClass::add_interface( CodeType type )
 	possible_slot.ast = type.ast;
 }
 
+inline
 void CodeParam::append( CodeParam other )
 {
 	AST* self  = (AST*) ast;
@@ -107,6 +115,7 @@ void CodeParam::append( CodeParam other )
 	self->NumEntries++;
 }
 
+inline
 CodeParam CodeParam::get( s32 idx )
 {
 	CodeParam param = *this;
@@ -115,24 +124,27 @@ CodeParam CodeParam::get( s32 idx )
 		if ( ! ++ param )
 			return { nullptr };
 
-		return { (AST_Param*) param.raw()->Next };
+		param = { (AST_Param*) param.raw()->Next };
 	}
 	while ( --idx );
 
-	return { nullptr };
+	return param;
 }
 
+inline
 bool CodeParam::has_entries()
 {
 	return ast->NumEntries > 0;
 }
 
+inline
 CodeParam& CodeParam::operator ++()
 {
 	ast = ast->Next.ast;
 	return * this;
 }
 
+inline
 void CodeStruct::add_interface( CodeType type )
 {
 	CodeType possible_slot = ast->ParentType;
@@ -152,6 +164,7 @@ void CodeStruct::add_interface( CodeType type )
 	possible_slot.ast = type.ast;
 }
 
+inline
 CodeBody def_body( CodeT type )
 {
 	switch ( type )
@@ -179,7 +192,8 @@ CodeBody def_body( CodeT type )
 	return (CodeBody)result;
 }
 
-StrC token_fmt_impl( sw num, ... )
+inline
+StrC token_fmt_impl( ssize num, ... )
 {
 	local_persist thread_local
 	char buf[GEN_PRINTF_MAXLEN] = { 0 };
@@ -187,7 +201,7 @@ StrC token_fmt_impl( sw num, ... )
 
 	va_list va;
 	va_start(va, num );
-	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
+	ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
 	va_end(va);
 
 	return { result, buf };

project/components/interface.cpp

@@ -1,13 +1,15 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
 #pragma once
-#include "ast.cpp"
+#include "code_serialization.cpp"
 #endif
 
-internal void init_parser();
-internal void deinit_parser();
+namespace parser {
+internal void init();
+internal void deinit();
+}
 
 internal
-void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
+void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
 {
 	Arena* last = & Global_AllocatorBuckets.back();
 
@@ -86,17 +88,17 @@ void define_constants()
 
 	access_private       = make_code();
 	access_private->Type = ECode::Access_Private;
-	access_private->Name = get_cached_string( txt("private:") );
+	access_private->Name = get_cached_string( txt("private:\n") );
 	access_private.set_global();
 
 	access_protected       = make_code();
 	access_protected->Type = ECode::Access_Protected;
-	access_protected->Name = get_cached_string( txt("protected:") );
+	access_protected->Name = get_cached_string( txt("protected:\n") );
 	access_protected.set_global();
 
 	access_public       = make_code();
 	access_public->Type = ECode::Access_Public;
-	access_public->Name = get_cached_string( txt("public:") );
+	access_public->Name = get_cached_string( txt("public:\n") );
 	access_public.set_global();
 
 	attrib_api_export = def_attributes( code(GEN_API_Export_Code));
@@ -167,8 +169,8 @@ void define_constants()
 	def_constant_code_type( u32 );
 	def_constant_code_type( u64 );
 
-	def_constant_code_type( sw );
-	def_constant_code_type( uw );
+	def_constant_code_type( ssize );
+	def_constant_code_type( usize );
 
 	def_constant_code_type( f32 );
 	def_constant_code_type( f64 );
@@ -287,14 +289,17 @@ void init()
 			GEN_FATAL( "gen::init: Failed to initialize the StringCache");
 	}
 
+	// Preprocessor Defines
+	PreprocessorDefines = Array<StringCached>::init_reserve( GlobalAllocator, kilobytes(1) );
+
 	define_constants();
-	init_parser();
+	parser::init();
 }
 
 void deinit()
 {
-	uw index = 0;
-	uw left  = CodePools.num();
+	usize index = 0;
+	usize left  = CodePools.num();
 	do
 	{
 		Pool* code_pool = & CodePools[index];
@@ -320,6 +325,8 @@ void deinit()
 
 	LexArena.free();
 
+	PreprocessorDefines.free();
+
 	index = 0;
 	left  = Global_AllocatorBuckets.num();
 	do
@@ -331,7 +338,7 @@ void deinit()
 	while ( left--, left );
 
 	Global_AllocatorBuckets.free();
-	deinit_parser();
+	parser::deinit();
 }
 
 void reset()
@@ -365,9 +372,9 @@ AllocatorInfo get_string_allocator( s32 str_length )
 {
 	Arena* last = & StringArenas.back();
 
-	uw size_req = str_length + sizeof(String::Header) + sizeof(char*);
+	usize size_req = str_length + sizeof(String::Header) + sizeof(char*);
 
-	if ( last->TotalUsed + size_req > last->TotalSize )
+	if ( last->TotalUsed + ssize(size_req) > last->TotalSize )
 	{
 		Arena new_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
 
@@ -416,18 +423,18 @@ Code make_code()
 	}
 
 	Code result { rcast( AST*, alloc( * allocator, sizeof(AST) )) };
-	// mem_set( result.ast, 0, sizeof(AST) );
-	result->Type = ECode::Invalid;
+	mem_set( result.ast, 0, sizeof(AST) );
+	// result->Type = ECode::Invalid;
 
-	result->Content     = { nullptr };
-	result->Prev        = { nullptr };
-	result->Next        = { nullptr };
-	result->Token		= nullptr;
-	result->Parent      = { nullptr };
-	result->Name        = { nullptr };
-	result->Type        = ECode::Invalid;
-	result->ModuleFlags = ModuleFlag::Invalid;
-	result->NumEntries  = 0;
+	// result->Content     = { nullptr };
+	// result->Prev        = { nullptr };
+	// result->Next        = { nullptr };
+	// result->Token		= nullptr;
+	// result->Parent      = { nullptr };
+	// result->Name        = { nullptr };
+	// result->Type        = ECode::Invalid;
+	// result->ModuleFlags = ModuleFlag::Invalid;
+	// result->NumEntries  = 0;
 
 	return result;
 }

project/components/interface.hpp

@@ -29,7 +29,6 @@ StringCached get_cached_string( StrC str );
 Code make_code();
 
 // Set these before calling gen's init() procedure.
-// Data
 
 void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
 void set_allocator_code_pool   ( AllocatorInfo pool_allocator );
@@ -145,6 +144,42 @@ CodeBody       def_union_body      ( s32 num, Code* codes );
 
 #pragma region Parsing
 
+// TODO(Ed) : Implmeent the new parser API design.
+
+#if 0
+namespace parser {
+	struct StackNode
+	{
+		StackNode* Prev;
+
+		Token Start;
+		Token Name;       // The name of the AST node (if parsed)
+		StrC  FailedProc; // The name of the procedure that failed
+	};
+	// Stack nodes are allocated the error's allocator
+
+	struct Error
+	{
+		String     message;
+		StackNode* context_stack;
+	};
+}
+
+struct ParseInfo
+{
+	Arena FileMem;
+	Arena TokMem;
+	Arena CodeMem;
+
+	FileContents         FileContent;
+	Array<parser::Token> Tokens;
+	Array<parser::Error> Errors;
+	// Errors are allocated to a dedicated general arena.
+};
+
+CodeBody parse_file( StrC path );
+#endif
+
 CodeClass       parse_class        ( StrC class_def       );
 CodeConstructor parse_constructor  ( StrC constructor_def );
 CodeDestructor  parse_destructor   ( StrC destructor_def  );
@@ -169,9 +204,9 @@ CodeVar         parse_variable     ( StrC var_def         );
 
 #pragma region Untyped text
 
-sw   token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
+ssize   token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
 //! Do not use directly. Use the token_fmt macro instead.
-StrC token_fmt_impl( sw, ... );
+StrC token_fmt_impl( ssize, ... );
 
 Code untyped_str      ( StrC content);
 Code untyped_fmt      ( char const* fmt, ... );

project/components/interface.untyped.cpp

@@ -3,10 +3,10 @@
 #include "interface.parsing.cpp"
 #endif
 
-sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
+ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
 {
 	char const* buf_begin = buf;
-	sw          remaining = buf_size;
+	ssize          remaining = buf_size;
 
 	local_persist
 	Arena tok_map_arena;
@@ -37,7 +37,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 
 	while ( current )
 	{
-		sw len = 0;
+		ssize len = 0;
 
 		while ( current && current != '<' && remaining )
 		{
@@ -68,7 +68,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 
 			if ( value )
 			{
-				sw          left = value->Len;
+				ssize          left = value->Len;
 				char const* str  = value->Ptr;
 
 				while ( left-- )
@@ -97,7 +97,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
 	tok_map.clear();
 	tok_map_arena.free();
 
-	sw result = buf_size - remaining;
+	ssize result = buf_size - remaining;
 
 	return result;
 }
@@ -138,7 +138,7 @@ Code untyped_fmt( char const* fmt, ...)
 
 	va_list va;
 	va_start(va, fmt);
-	sw length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
+	ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
 	va_end(va);
 
 	Code
@@ -169,7 +169,7 @@ Code untyped_token_fmt( s32 num_tokens, ... )
 
 	va_list va;
 	va_start(va, num_tokens);
-	sw length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
+	ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
 	va_end(va);
 
 	Code

project/components/interface.upfront.cpp

@@ -159,7 +159,6 @@ OpValidateResult operator__validate( OperatorT op, CodeParam params_code, CodeTy
 
 		case Unary_Plus:
 		case Unary_Minus:
-		case BNot:
 			if ( ! params_code )
 				is_member_symbol = true;
 
@@ -194,6 +193,41 @@ OpValidateResult operator__validate( OperatorT op, CodeParam params_code, CodeTy
 			}
 			break;
 
+		case BNot:
+		{
+			// Some compilers let you do this...
+		#if 0
+			if ( ! ret_type.is_equal( t_bool) )
+			{
+				log_failure( "gen::def_operator: return type is not a boolean - %s", params_code.debug_str() );
+				return OpValidateResult::Fail;
+			}
+		#endif
+
+			if ( ! params_code )
+				is_member_symbol = true;
+
+			else
+			{
+				if ( params_code->Type != ECode::Parameters )
+				{
+					log_failure( "gen::def_operator: params is not of Parameters type - %s", params_code.debug_str() );
+					return OpValidateResult::Fail;
+				}
+
+				if ( params_code->NumEntries > 1 )
+				{
+					log_failure(
+					    "gen::def_operator: operator%s may not have more than one parameter - param count: %d",
+					    to_str( op ),
+					    params_code->NumEntries
+					);
+					return OpValidateResult::Fail;
+				}
+			}
+			break;
+		}
+
 		case Add:
 		case Subtract:
 		case Multiply:
@@ -325,6 +359,11 @@ OpValidateResult operator__validate( OperatorT op, CodeParam params_code, CodeTy
 		case Comma:
 			check_params();
 			break;
+
+		case New:
+		case Delete:
+			// This library doesn't support validating new and delete yet.
+			break;
 #	undef specs
 	}
 
@@ -520,7 +559,7 @@ CodeClass def_class( StrC name
 		return CodeInvalid;
 	}
 
-	if ( parent && (parent->Type != Class || parent->Type != Struct || parent->Type != Typename || parent->Type != Untyped) )
+	if ( parent && ( parent->Type != Class && parent->Type != Struct && parent->Type != Typename && parent->Type != Untyped ) )
 	{
 		log_failure( "gen::def_class: parent provided is not type 'Class', 'Struct', 'Typeanme', or 'Untyped': %s", parent.debug_str() );
 		return CodeInvalid;
@@ -546,6 +585,7 @@ CodeClass def_class( StrC name
 
 		result->Type = Class;
 		result->Body = body;
+		result->Body->Parent = result; // TODO(Ed): Review this?
 	}
 	else
 	{
@@ -578,17 +618,25 @@ CodeDefine def_define( StrC name, StrC content )
 
 	name_check( def_define, name );
 
+	// Defines can be empty definitions
+#if 0
 	if ( content.Len <= 0 || content.Ptr == nullptr )
 	{
 		log_failure( "gen::def_define: Invalid value provided" );
 		return CodeInvalid;
 	}
+#endif
 
 	CodeDefine
 	result          = (CodeDefine) make_code();
 	result->Type    = Preprocess_Define;
 	result->Name    = get_cached_string( name );
-	result->Content = get_cached_string( content );
+	if ( content.Len <= 0 || content.Ptr == nullptr )
+	{
+		result->Content = get_cached_string( txt("") );
+	}
+	else
+		result->Content = get_cached_string( content );
 
 	return result;
 }

project/components/src_start.cpp

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

project/components/static_data.cpp

@@ -9,6 +9,7 @@
 global AllocatorInfo  GlobalAllocator;
 global Array<Arena>   Global_AllocatorBuckets;
 
+// TODO(Ed) : Make the code pool a dynamic arena
 global Array< Pool >  CodePools         = { nullptr };
 global Array< Arena > StringArenas      = { nullptr };
 
@@ -81,6 +82,8 @@ global CodeType t_wchar_t;
 global CodeType t_class;
 global CodeType t_typename;
 
+global Array< StringCached > PreprocessorDefines;
+
 #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
 global CodeType t_b32;
 
@@ -94,8 +97,8 @@ global CodeType t_u16;
 global CodeType t_u32;
 global CodeType t_u64;
 
-global CodeType t_sw;
-global CodeType t_uw;
+global CodeType t_ssize;
+global CodeType t_usize;
 
 global CodeType t_f32;
 global CodeType t_f64;

project/components/types.hpp

@@ -3,7 +3,7 @@
 #include "header_start.hpp"
 #endif
 
-using LogFailType = sw(*)(char const*, ...);
+using LogFailType = ssize(*)(char const*, ...);
 
 // By default this library will either crash or exit if an error is detected while generating codes.
 // Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
@@ -16,9 +16,9 @@ using LogFailType = sw(*)(char const*, ...);
 enum class AccessSpec : u32
 {
 	Default,
-	Public,
-	Protected,
 	Private,
+	Protected,
+	Public,
 
 	Num_AccessSpec,
 	Invalid,
@@ -30,9 +30,9 @@ char const* to_str( AccessSpec type )
 	local_persist
 	char const* lookup[ (u32)AccessSpec::Num_AccessSpec ] = {
 		"",
-		"public",
-		"protected",
 		"private",
+		"protected",
+		"public",
 	};
 
 	if ( type > AccessSpec::Public )
@@ -44,6 +44,7 @@ char const* to_str( AccessSpec type )
 
 enum CodeFlag : u32
 {
+	None          = 0,
 	FunctionType  = bit(0),
 	ParamPack     = bit(1),
 	Module_Export = bit(2),
@@ -70,6 +71,7 @@ enum class ModuleFlag : u32
 	Invalid,
 };
 
+inline
 StrC to_str( ModuleFlag flag )
 {
 	local_persist
@@ -85,6 +87,7 @@ StrC to_str( ModuleFlag flag )
 	return lookup[ (u32)flag ];
 }
 
+inline
 ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
 {
 	return (ModuleFlag)( (u32)A | (u32)B );

project/dependencies/basic_types.hpp

@@ -47,21 +47,21 @@
 #if defined( GEN_COMPILER_MSVC )
 #	if _MSC_VER < 1300
 typedef unsigned char  u8;
-typedef signed char    s8;
+typedef signed   char  s8;
 typedef unsigned short u16;
-typedef signed short   s16;
+typedef signed   short s16;
 typedef unsigned int   u32;
-typedef signed int     s32;
+typedef signed   int   s32;
 #    else
 typedef unsigned __int8  u8;
-typedef signed __int8    s8;
+typedef signed   __int8  s8;
 typedef unsigned __int16 u16;
-typedef signed __int16   s16;
+typedef signed   __int16 s16;
 typedef unsigned __int32 u32;
-typedef signed __int32   s32;
+typedef signed   __int32 s32;
 #    endif
 typedef unsigned __int64 u64;
-typedef signed __int64   s64;
+typedef signed   __int64 s64;
 #else
 #	include <stdint.h>
 
@@ -85,10 +85,10 @@ static_assert( sizeof( u16 ) == 2, "sizeof(u16) != 2" );
 static_assert( sizeof( u32 ) == 4, "sizeof(u32) != 4" );
 static_assert( sizeof( u64 ) == 8, "sizeof(u64) != 8" );
 
-typedef size_t    uw;
-typedef ptrdiff_t sw;
+typedef size_t    usize;
+typedef ptrdiff_t ssize;
 
-static_assert( sizeof( uw ) == sizeof( sw ), "sizeof(uw) != sizeof(sw)" );
+static_assert( sizeof( usize ) == sizeof( ssize ), "sizeof(usize) != sizeof(ssize)" );
 
 // NOTE: (u)zpl_intptr is only here for semantic reasons really as this library will only support 32/64 bit OSes.
 #if defined( _WIN64 )
@@ -122,4 +122,13 @@ typedef s8  b8;
 typedef s16 b16;
 typedef s32 b32;
 
+using mem_ptr       = void*;
+using mem_ptr_const = void const*;
+
+template<typename Type> uptr to_uptr( Type* ptr ) { return (uptr)ptr; }
+template<typename Type> sptr to_sptr( Type* ptr ) { return (sptr)ptr; }
+
+template<typename Type> mem_ptr       to_mem_ptr      ( Type ptr ) { return (mem_ptr)      ptr; }
+template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem_ptr_const)ptr; }
+
 #pragma endregion Basic Types

project/dependencies/containers.hpp

@@ -5,14 +5,22 @@
 
 #pragma region Containers
 
+template<class TType>             struct RemoveConst                    { typedef TType Type;       };
+template<class TType>             struct RemoveConst<const TType>       { typedef TType Type;       };
+template<class TType>             struct RemoveConst<const TType[]>     { typedef TType Type[];     };
+template<class TType, usize Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
+
+template<class TType>
+using TRemoveConst = typename RemoveConst<TType>::Type;
+
 template<class Type>
 struct Array
 {
 	struct Header
 	{
 		AllocatorInfo Allocator;
-		uw            Capacity;
-		uw            Num;
+		usize            Capacity;
+		usize            Num;
 	};
 
 	static
@@ -22,7 +30,7 @@ struct Array
 	}
 
 	static
-	Array init_reserve( AllocatorInfo allocator, sw capacity )
+	Array init_reserve( AllocatorInfo allocator, ssize capacity )
 	{
 		Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) * capacity ));
 
@@ -37,11 +45,16 @@ struct Array
 	}
 
 	static
-	uw grow_formula( uw value )
+	usize grow_formula( usize value )
 	{
 		return 2 * value + 8;
 	}
 
+	bool append( Array other )
+	{
+		return append( other, other.num() );
+	}
+
 	bool append( Type value )
 	{
 		Header* header = get_header();
@@ -60,7 +73,7 @@ struct Array
 		return true;
 	}
 
-	bool append( Type* items, uw item_num )
+	bool append( Type* items, usize item_num )
 	{
 		Header* header = get_header();
 
@@ -78,7 +91,7 @@ struct Array
 		return true;
 	}
 
-	bool append_at( Type item, uw idx )
+	bool append_at( Type item, usize idx )
 	{
 		Header* header = get_header();
 
@@ -104,7 +117,7 @@ struct Array
 		return true;
 	}
 
-	bool append_at( Type* items, uw item_num, uw idx )
+	bool append_at( Type* items, usize item_num, usize idx )
 	{
 		Header* header = get_header();
 
@@ -143,14 +156,14 @@ struct Array
 		header.Num     = 0;
 	}
 
-	bool fill( uw begin, uw end, Type value )
+	bool fill( usize begin, usize end, Type value )
 	{
 		Header& header = * get_header();
 
-		if ( begin < 0 || end >= header.Num )
+		if ( begin < 0 || end > header.Num )
 			return false;
 
-		for ( sw idx = begin; idx < end; idx++ )
+		for ( ssize idx = ssize(begin); idx < ssize(end); idx++ )
 		{
 			Data[ idx ] = value;
 		}
@@ -167,13 +180,14 @@ struct Array
 
 	Header* get_header( void )
 	{
-		return rcast( Header*, Data ) - 1 ;
+		using NonConstType = TRemoveConst< Type >;
+		return rcast( Header*, const_cast<NonConstType*>(Data) ) - 1 ;
 	}
 
-	bool grow( uw min_capacity )
+	bool grow( usize min_capacity )
 	{
 		Header& header       = * get_header();
-		uw      new_capacity = grow_formula( header.Capacity );
+		usize      new_capacity = grow_formula( header.Capacity );
 
 		if ( new_capacity < min_capacity )
 			new_capacity = min_capacity;
@@ -181,12 +195,12 @@ struct Array
 		return set_capacity( new_capacity );
 	}
 
-	uw num( void )
+	usize num( void )
 	{
 		return get_header()->Num;
 	}
 
-	bool pop( void )
+	void pop( void )
 	{
 		Header& header = * get_header();
 
@@ -194,7 +208,7 @@ struct Array
 		header.Num--;
 	}
 
-	void remove_at( uw idx )
+	void remove_at( usize idx )
 	{
 		Header* header = get_header();
 		GEN_ASSERT( idx < header->Num );
@@ -203,7 +217,7 @@ struct Array
 		header->Num--;
 	}
 
-	bool reserve( uw new_capacity )
+	bool reserve( usize new_capacity )
 	{
 		Header& header = * get_header();
 
@@ -213,7 +227,7 @@ struct Array
 		return true;
 	}
 
-	bool resize( uw num )
+	bool resize( usize num )
 	{
 		Header* header = get_header();
 
@@ -229,7 +243,7 @@ struct Array
 		return true;
 	}
 
-	bool set_capacity( uw new_capacity )
+	bool set_capacity( usize new_capacity )
 	{
 		Header& header = * get_header();
 
@@ -237,9 +251,13 @@ struct Array
 			return true;
 
 		if ( new_capacity < header.Num )
+		{
+			// Already have the memory, mine as well keep it.
 			header.Num = new_capacity;
+			return true;
+		}
 
-		sw      size       = sizeof( Header ) + sizeof( Type ) * new_capacity;
+		ssize      size       = sizeof( Header ) + sizeof( Type ) * new_capacity;
 		Header* new_header = rcast( Header*, alloc( header.Allocator, size ) );
 
 		if ( new_header == nullptr )
@@ -280,54 +298,52 @@ struct Array
 	}
 };
 
+// TODO(Ed) : This thing needs ALOT of work.
+
 template<typename Type>
 struct HashTable
 {
 	struct FindResult
 	{
-		sw HashIndex;
-		sw PrevIndex;
-		sw EntryIndex;
+		ssize HashIndex;
+		ssize PrevIndex;
+		ssize EntryIndex;
 	};
 
 	struct Entry
 	{
 		u64  Key;
-		sw   Next;
+		ssize   Next;
 		Type Value;
 	};
 
+	static constexpr f32 CriticalLoadScale = 0.7f;
+
 	static
 	HashTable init( AllocatorInfo allocator )
 	{
-		HashTable<Type> result = { { nullptr }, { nullptr } };
-
-		result.Hashes  = Array<sw>::init( allocator );
-		result.Entries = Array<Entry>::init( allocator );
-
+		HashTable<Type> result = init_reserve(allocator, 8);
 		return result;
 	}
 
 	static
-	HashTable init_reserve( AllocatorInfo allocator, uw num )
+	HashTable init_reserve( AllocatorInfo allocator, usize num )
 	{
 		HashTable<Type> result = { { nullptr }, { nullptr } };
 
-		result.Hashes  = Array<sw>::init_reserve( allocator, num );
+		result.Hashes  = Array<ssize>::init_reserve( allocator, num );
 		result.Hashes.get_header()->Num = num;
+		result.Hashes.resize( num );
+		result.Hashes.fill( 0, num, -1);
 
 		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();
+		Hashes.fill( 0, Hashes.num(), -1);
 	}
 
 	void destroy( void )
@@ -341,7 +357,7 @@ struct HashTable
 
 	Type* get( u64 key )
 	{
-		sw idx = find( key ).EntryIndex;
+		ssize idx = find( key ).EntryIndex;
 		if ( idx >= 0 )
 			return & Entries[ idx ].Value;
 
@@ -354,7 +370,7 @@ struct HashTable
 	{
 		GEN_ASSERT_NOT_NULL( map_proc );
 
-		for ( sw idx = 0; idx < Entries.num(); idx++ )
+		for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
 		{
 			map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
 		}
@@ -366,7 +382,7 @@ struct HashTable
 	{
 		GEN_ASSERT_NOT_NULL( map_proc );
 
-		for ( sw idx = 0; idx < Entries.num(); idx++ )
+		for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
 		{
 			map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
 		}
@@ -374,38 +390,25 @@ struct HashTable
 
 	void grow()
 	{
-		sw new_num = Array<Entry>::grow_formula( Entries.num() );
+		ssize new_num = Array<Entry>::grow_formula( Entries.num() );
 		rehash( new_num );
 	}
 
-	void rehash( sw new_num )
+	void rehash( ssize new_num )
 	{
-		sw idx;
-		sw last_added_index;
+		ssize 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 )
+		for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
 		{
-			Entry& entry = Entries[ idx ];
-
 			FindResult find_result;
 
-			if ( new_ht.Hashes.num() == 0 )
-				new_ht.grow();
-
-			entry            = Entries[ idx ];
+			Entry& 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;
 
@@ -419,15 +422,15 @@ struct HashTable
 
 	void rehash_fast()
 	{
-		sw idx;
+		ssize idx;
 
-		for ( idx = 0; idx < Entries.num(); idx++ )
+		for ( idx = 0; idx < ssize(Entries.num()); idx++ )
 			Entries[ idx ].Next = -1;
 
-		for ( idx = 0; idx < Hashes.num(); idx++ )
+		for ( idx = 0; idx < ssize(Hashes.num()); idx++ )
 			Hashes[ idx ] = -1;
 
-		for ( idx = 0; idx < Entries.num(); idx++ )
+		for ( idx = 0; idx < ssize(Entries.num()); idx++ )
 		{
 			Entry*     entry;
 			FindResult find_result;
@@ -453,21 +456,20 @@ struct HashTable
 		}
 	}
 
-	void remove_entry( sw idx )
+	void remove_entry( ssize idx )
 	{
 		Entries.remove_at( idx );
 	}
 
 	void set( u64 key, Type value )
 	{
-		sw idx;
+		ssize idx;
 		FindResult find_result;
 
-		if ( Hashes.num() == 0 )
+		if ( full() )
 			grow();
 
 		find_result = find( key );
-
 		if ( find_result.EntryIndex >= 0 )
 		{
 			idx = find_result.EntryIndex;
@@ -492,23 +494,23 @@ struct HashTable
 			grow();
 	}
 
-	sw slot( u64 key )
+	ssize slot( u64 key )
 	{
-		for ( sw idx = 0; idx < Hashes.num(); ++idx )
+		for ( ssize idx = 0; idx < ssize(Hashes.num()); ++idx )
 			if ( Hashes[ idx ] == key )
 				return idx;
 
 		return -1;
 	}
 
-	Array< sw>    Hashes;
+	Array< ssize>    Hashes;
 	Array< Entry> Entries;
 
 protected:
 
-	sw add_entry( u64 key )
+	ssize add_entry( u64 key )
 	{
-		sw idx;
+		ssize idx;
 		Entry entry = { key, -1 };
 
 		idx = Entries.num();
@@ -540,7 +542,9 @@ protected:
 
 	b32 full()
 	{
-		return 0.75f * Hashes.num() < Entries.num();
+		usize critical_load = usize( CriticalLoadScale * f32(Hashes.num()) );
+		b32 result = Entries.num() > critical_load;
+		return result;
 	}
 };
 

project/dependencies/debug.hpp

@@ -24,7 +24,7 @@
 	{                                                                                        \
 		if ( ! ( cond ) )                                                                    \
 		{                                                                                    \
-			assert_handler( #cond, __FILE__, zpl_cast( s64 ) __LINE__, msg, ##__VA_ARGS__ ); \
+			assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
 			GEN_DEBUG_TRAP();                                                                \
 		}                                                                                    \
 	} while ( 0 )
@@ -34,18 +34,14 @@
 // NOTE: Things that shouldn't happen with a message!
 #define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
 
-void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
-s32  assert_crash( char const* condition );
-void process_exit( u32 code );
-
 #if Build_Debug
 	#define GEN_FATAL( ... )                               \
 	do                                                     \
 	{                                                      \
 		local_persist thread_local                         \
 		char buf[GEN_PRINTF_MAXLEN] = { 0 };               \
-													       \
-		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \
+		                                                   \
+		str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__);      \
 		GEN_PANIC(buf);                                    \
 	}                                                      \
 	while (0)
@@ -53,11 +49,15 @@ void process_exit( u32 code );
 
 #	define GEN_FATAL( ... )                  \
 	do                                       \
-	{										 \
+	{                                        \
 		str_fmt_out_err( __VA_ARGS__ );      \
 		process_exit(1);                     \
-	}             					         \
+	}                                        \
 	while (0)
 #endif
 
+void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
+s32  assert_crash( char const* condition );
+void process_exit( u32 code );
+
 #pragma endregion Debug

project/dependencies/filesystem.cpp

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

project/dependencies/filesystem.hpp

@@ -48,8 +48,8 @@ union FileDescriptor
 typedef struct FileOperations FileOperations;
 
 #define GEN_FILE_OPEN_PROC( name )     FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
-#define GEN_FILE_READ_AT_PROC( name )  b32 name( FileDescriptor fd, void* buffer, sw size, s64 offset, sw* bytes_read, b32 stop_at_newline )
-#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, sw size, s64 offset, sw* bytes_written )
+#define GEN_FILE_READ_AT_PROC( name )  b32 name( FileDescriptor fd, void* buffer, ssize size, s64 offset, ssize* bytes_read, b32 stop_at_newline )
+#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
 #define GEN_FILE_SEEK_PROC( name )     b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset )
 #define GEN_FILE_CLOSE_PROC( name )    void name( FileDescriptor fd )
 
@@ -161,7 +161,7 @@ FileError file_open_mode( FileInfo* file, FileMode mode, char const* filename );
 	* @param  buffer Buffer to read to
 	* @param  size   Size to read
 	*/
-GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
+b32 file_read( FileInfo* file, void* buffer, ssize size );
 
 /**
 	* Reads file at a specific offset
@@ -171,7 +171,7 @@ GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
 	* @param  offset     Offset to read from
 	* @param  bytes_read How much data we've actually read
 	*/
-GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offset );
+b32 file_read_at( FileInfo* file, void* buffer, ssize size, s64 offset );
 
 /**
 	* Reads file safely
@@ -181,13 +181,13 @@ GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offs
 	* @param  offset     Offset to read from
 	* @param  bytes_read How much data we've actually read
 	*/
-GEN_DEF_INLINE b32 file_read_at_check( FileInfo* file, void* buffer, sw size, s64 offset, sw* bytes_read );
+b32 file_read_at_check( FileInfo* file, void* buffer, ssize size, s64 offset, ssize* bytes_read );
 
 struct FileContents
 {
 	AllocatorInfo allocator;
 	void*         data;
-	sw            size;
+	ssize            size;
 };
 
 constexpr b32 zero_terminate    = true;
@@ -214,20 +214,20 @@ s64 file_size( FileInfo* file );
 	* @param  file
 	* @param  offset Offset to seek to
 	*/
-GEN_DEF_INLINE s64 file_seek( FileInfo* file, s64 offset );
+s64 file_seek( FileInfo* file, s64 offset );
 
 /**
 	* Seeks the file cursor to the end of the file
 	* @param  file
 	*/
-GEN_DEF_INLINE s64 file_seek_to_end( FileInfo* file );
+s64 file_seek_to_end( FileInfo* file );
 
 /**
 	* Returns the length from the beginning of the file we've read so far
 	* @param  file
 	* @return      Our current position in file
 	*/
-GEN_DEF_INLINE s64 file_tell( FileInfo* file );
+s64 file_tell( FileInfo* file );
 
 /**
 	* Writes to a file
@@ -235,7 +235,7 @@ GEN_DEF_INLINE s64 file_tell( FileInfo* file );
 	* @param  buffer Buffer to read from
 	* @param  size   Size to read
 	*/
-GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
+b32 file_write( FileInfo* file, void const* buffer, ssize size );
 
 /**
 	* Writes to file at a specific offset
@@ -245,7 +245,7 @@ GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
 	* @param  offset        Offset to write to
 	* @param  bytes_written How much data we've actually written
 	*/
-GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s64 offset );
+b32 file_write_at( FileInfo* file, void const* buffer, ssize size, s64 offset );
 
 /**
 	* Writes to file safely
@@ -255,88 +255,7 @@ GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s
 	* @param  offset        Offset to write to
 	* @param  bytes_written How much data we've actually written
 	*/
-GEN_DEF_INLINE b32 file_write_at_check( FileInfo* file, void const* buffer, sw size, s64 offset, sw* bytes_written );
-
-GEN_IMPL_INLINE s64 file_seek( FileInfo* f, s64 offset )
-{
-	s64 new_offset = 0;
-
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-
-	f->ops.seek( f->fd, offset, ESeekWhence_BEGIN, &new_offset );
-
-	return new_offset;
-}
-
-GEN_IMPL_INLINE s64 file_seek_to_end( FileInfo* f )
-{
-	s64 new_offset = 0;
-
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-
-	f->ops.seek( f->fd, 0, ESeekWhence_END, &new_offset );
-
-	return new_offset;
-}
-
-GEN_IMPL_INLINE s64 file_tell( FileInfo* f )
-{
-	s64 new_offset = 0;
-
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-
-	f->ops.seek( f->fd, 0, ESeekWhence_CURRENT, &new_offset );
-
-	return new_offset;
-}
-
-GEN_IMPL_INLINE b32 file_read( FileInfo* f, void* buffer, sw size )
-{
-	s64 cur_offset = file_tell( f );
-	b32 result     = file_read_at( f, buffer, size, file_tell( f ) );
-	file_seek( f, cur_offset + size );
-	return result;
-}
-
-GEN_IMPL_INLINE b32 file_read_at( FileInfo* f, void* buffer, sw size, s64 offset )
-{
-	return file_read_at_check( f, buffer, size, offset, NULL );
-}
-
-GEN_IMPL_INLINE b32 file_read_at_check( FileInfo* f, void* buffer, sw size, s64 offset, sw* bytes_read )
-{
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-	return f->ops.read_at( f->fd, buffer, size, offset, bytes_read, false );
-}
-
-GEN_IMPL_INLINE b32 file_write( FileInfo* f, void const* buffer, sw size )
-{
-	s64 cur_offset = file_tell( f );
-	b32 result     = file_write_at( f, buffer, size, file_tell( f ) );
-
-	file_seek( f, cur_offset + size );
-
-	return result;
-}
-
-GEN_IMPL_INLINE b32 file_write_at( FileInfo* f, void const* buffer, sw size, s64 offset )
-{
-	return file_write_at_check( f, buffer, size, offset, NULL );
-}
-
-GEN_IMPL_INLINE b32 file_write_at_check( FileInfo* f, void const* buffer, sw size, s64 offset, sw* bytes_written )
-{
-	if ( ! f->ops.read_at )
-		f->ops = default_file_operations;
-
-	return f->ops.write_at( f->fd, buffer, size, offset, bytes_written );
-}
-
-
+b32 file_write_at_check( FileInfo* file, void const* buffer, ssize size, s64 offset, ssize* bytes_written );
 
 enum FileStreamFlags : u32
 {
@@ -363,15 +282,103 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator );
 	* @param  size     Buffer's size
 	* @param  flags
 	*/
-b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw size, FileStreamFlags flags );
+b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize size, FileStreamFlags flags );
 
 /**
 	* Retrieves the stream's underlying buffer and buffer size.
 	* @param file memory stream
 	* @param size (Optional) buffer size
 	*/
-u8* file_stream_buf( FileInfo* file, sw* size );
+u8* file_stream_buf( FileInfo* file, ssize* size );
 
 extern FileOperations const memory_file_operations;
 
+inline
+s64 file_seek( FileInfo* f, s64 offset )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, offset, ESeekWhence_BEGIN, &new_offset );
+
+	return new_offset;
+}
+
+inline
+s64 file_seek_to_end( FileInfo* f )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, 0, ESeekWhence_END, &new_offset );
+
+	return new_offset;
+}
+
+inline
+s64 file_tell( FileInfo* f )
+{
+	s64 new_offset = 0;
+
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	f->ops.seek( f->fd, 0, ESeekWhence_CURRENT, &new_offset );
+
+	return new_offset;
+}
+
+inline
+b32 file_read( FileInfo* f, void* buffer, ssize size )
+{
+	s64 cur_offset = file_tell( f );
+	b32 result     = file_read_at( f, buffer, size, file_tell( f ) );
+	file_seek( f, cur_offset + size );
+	return result;
+}
+
+inline
+b32 file_read_at( FileInfo* f, void* buffer, ssize size, s64 offset )
+{
+	return file_read_at_check( f, buffer, size, offset, NULL );
+}
+
+inline
+b32 file_read_at_check( FileInfo* f, void* buffer, ssize size, s64 offset, ssize* bytes_read )
+{
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+	return f->ops.read_at( f->fd, buffer, size, offset, bytes_read, false );
+}
+
+inline
+b32 file_write( FileInfo* f, void const* buffer, ssize size )
+{
+	s64 cur_offset = file_tell( f );
+	b32 result     = file_write_at( f, buffer, size, file_tell( f ) );
+
+	file_seek( f, cur_offset + size );
+
+	return result;
+}
+
+inline
+b32 file_write_at( FileInfo* f, void const* buffer, ssize size, s64 offset )
+{
+	return file_write_at_check( f, buffer, size, offset, NULL );
+}
+
+inline
+b32 file_write_at_check( FileInfo* f, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
+{
+	if ( ! f->ops.read_at )
+		f->ops = default_file_operations;
+
+	return f->ops.write_at( f->fd, buffer, size, offset, bytes_written );
+}
+
 #pragma endregion File Handling

project/dependencies/hashing.cpp

@@ -27,11 +27,11 @@ global u32 const _crc32_table[ 256 ] = {
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
 
-u32 crc32( void const* data, sw len )
+u32 crc32( void const* data, ssize len )
 {
-	sw        remaining;
-	u32       result = ~( zpl_cast( u32 ) 0 );
-	u8 const* c      = zpl_cast( u8 const* ) data;
+	ssize        remaining;
+	u32       result = ~( scast( u32, 0) );
+	u8 const* c      = rcast( u8 const*, data);
 	for ( remaining = len; remaining--; c++ )
 		result = ( result >> 8 ) ^ ( _crc32_table[ ( result ^ *c ) & 0xff ] );
 	return ~result;
@@ -77,11 +77,11 @@ global u64 const _crc64_table[ 256 ] = {
 	0xa6df411fbfb21ca3ull, 0xdc0731d78f8795daull, 0x536fa08fdfd90e51ull, 0x29b7d047efec8728ull,
 };
 
-u64 crc64( void const* data, sw len )
+u64 crc64( void const* data, ssize len )
 {
-	sw        remaining;
-	u64       result = ( zpl_cast( u64 ) 0 );
-	u8 const* c      = zpl_cast( u8 const* ) data;
+	ssize        remaining;
+	u64       result = ( scast( u64, 0) );
+	u8 const* c      = rcast( u8 const*, data);
 	for ( remaining = len; remaining--; c++ )
 		result = ( result >> 8 ) ^ ( _crc64_table[ ( result ^ *c ) & 0xff ] );
 	return result;

project/dependencies/hashing.hpp

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

project/dependencies/macros.hpp

@@ -1,52 +1,77 @@
 #ifdef GEN_INTELLISENSE_DIRECTIVES
-#	pragma once
-#	include "header_start.hpp"
+#   pragma once
 #endif
 
 #pragma region Macros
 
-#define zpl_cast( Type ) ( Type )
-
-// Keywords
-
+#ifndef global
 #define global        static    // Global variables
+#endif
+#ifndef internal
 #define internal      static    // Internal linkage
+#endif
+#ifndef local_persist
 #define local_persist static    // Local Persisting variables
-
-#ifdef GEN_COMPILER_MSVC
-#	define forceinline __forceinline
-#	define neverinline __declspec( noinline )
-#elif defined(GEN_COMPILER_GCC)
-#	define forceinline inline __attribute__((__always_inline__))
-#	define neverinline __attribute__( ( __noinline__ ) )
-#elif defined(GEN_COMPILER_CLANG)
-#if __has_attribute(__always_inline__)
-#	define forceinline inline __attribute__((__always_inline__))
-#	define neverinline __attribute__( ( __noinline__ ) )
-#else
-#	define forceinline
-#	define neverinline
-#endif
-#else
-#	define forceinline
-#	define neverinline
 #endif
 
-// Bits
+#ifndef api_c
+#define api_c extern "C"
+#endif
 
+#ifndef bit
 #define bit( Value )                             ( 1 << Value )
 #define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
+#endif
 
-// Casting
+#ifndef ccast
+#define ccast( type, value ) ( const_cast< type >( (value) ) )
+#endif
+#ifndef pcast
+#define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
+#endif
+#ifndef rcast
+#define rcast( type, value ) reinterpret_cast< type >( value )
+#endif
+#ifndef scast
+#define scast( type, value ) static_cast< type >( value )
+#endif
 
-#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 )
+#ifndef stringize
+#define stringize_va( ... ) #__VA_ARGS__
+#define stringize( ... )    stringize_va( __VA_ARGS__ )
+#endif
 
-// Num Arguments (Varadics)
-// #if defined(__GNUC__) || defined(__clang__)
-// Supports 0-50 arguments
+#ifndef do_once
+#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
+
+#define do_once_start      \
+	do                     \
+	{                      \
+		local_persist      \
+		bool done = false; \
+		if ( done )        \
+			break;         \
+		done = true;
+
+#define do_once_end        \
+	}                      \
+	while(0);
+#endif
+
+#ifndef labeled_scope_start
+#define labeled_scope_start if ( false ) {
+#define labeled_scope_end   }
+#endif
+
+#ifndef         compiler_decorated_func_name
+#   ifdef COMPILER_CLANG
+#       define  compiler_decorated_func_name __PRETTY_NAME__
+#   elif defined(COMPILER_MSVC)
+#   	define compiler_decorated_func_name __FUNCDNAME__
+#   endif
+#endif
+
+#ifndef num_args_impl
 #define num_args_impl( _0,                                 \
 		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,   \
 		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20,  \
@@ -61,7 +86,7 @@
 		N, ...                                             \
 	) N
 
-	// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
+// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
 #define num_args(...)                            \
 	num_args_impl(_, ## __VA_ARGS__,             \
 		100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
@@ -76,93 +101,69 @@
 		 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, \
 		 0                                       \
 	)
+#endif
 
-// #else
-// This doesn't work on latest msvc so I had to use /Zc:preprocessor flag.
-
-// Supports 1-50 arguments
-// #define num_args_impl(                                  \
-// 		_1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10,   \
-// 		_11, _12, _13, _14, _15, _16, _17, _18, _19, _20,  \
-// 		_21, _22, _23, _24, _25, _26, _27, _28, _29, _30,  \
-// 		_31, _32, _33, _34, _35, _36, _37, _38, _39, _40,  \
-// 		_41, _42, _43, _44, _45, _46, _47, _48, _49, _50,  \
-// 		_51, _52, _53, _54, _55, _56, _57, _58, _59, _60,  \
-// 		_61, _62, _63, _64, _65, _66, _67, _68, _69, _70,  \
-// 		_71, _72, _73, _74, _75, _76, _77, _78, _79, _80,  \
-// 		_81, _82, _83, _84, _85, _86, _87, _88, _89, _90,  \
-// 		_91, _92, _93, _94, _95, _96, _97, _98, _99, _100, \
-// 		N, ...                                             \
-// 	) N
-
-// #define num_args(...)                         \
-// 	num_args_impl( __VA_ARGS__,                  \
-// 		100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
-// 		 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, \
-// 		 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, \
-// 		 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
-// 		 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
-// 		 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
-// 		 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
-// 		 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
-// 		 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
-// 		 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
-// 		 10,  9,  8,  7,  6,  5,  4,  3,  2,  1  \
-// 	)
-// #endif
-
-// Stringizing
-#define stringize_va( ... ) #__VA_ARGS__
-#define stringize( ... )    stringize_va( __VA_ARGS__ )
-
-// Function do once
-
-#define do_once()          \
-	do                     \
-	{                      \
-		static             \
-		bool Done = false; \
-		if ( Done )        \
-			return;        \
-		Done = true;       \
-	}                      \
-	while(0)
-
-#define do_once_start      \
-	do                     \
-	{                      \
-		static             \
-		bool Done = false; \
-		if ( Done )        \
-			break;         \
-		Done = true;
-
-#define do_once_end        \
-	}                      \
-	while(0);
-
-#define labeled_scope_start if ( false ) {
-#define labeled_scope_end   }
-
+#ifndef clamp
 #define clamp( x, lower, upper )      min( max( ( x ), ( lower ) ), ( upper ) )
-#define count_of( x )                 ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( sw )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
+#endif
+#ifndef count_of
+#define count_of( x )                 ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( ssize )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
+#endif
+#ifndef is_between
 #define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
-#define max( a, b )                   ( ( a ) > ( b ) ? ( a ) : ( b ) )
-#define min( a, b )                   ( ( a ) < ( b ) ? ( a ) : ( b ) )
-#define size_of( x )                  ( sw )( sizeof( x ) )
+#endif
+#ifndef size_of
+#define size_of( x )                  ( ssize )( sizeof( x ) )
+#endif
+
+#ifndef max
+#define max( a, b ) ( (a > b) ? (a) : (b) )
+#endif
+#ifndef min
+#define min( a, b ) ( (a < b) ? (a) : (b) )
+#endif
 
 #if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
-#	define offset_of( Type, element ) ( ( GEN_NS( gen_sw ) ) & ( ( ( Type* )0 )->element ) )
+#	define offset_of( Type, element ) ( ( GEN_NS( ssize ) ) & ( ( ( Type* )0 )->element ) )
 #else
 #	define offset_of( Type, element ) __builtin_offsetof( Type, element )
 #endif
 
-template< class Type >
-void swap( Type& a, Type& b )
-{
-	Type tmp = a;
-	a = b;
-	b = tmp;
-}
+#ifndef        forceinline
+#	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
+#endif
+
+#ifndef        neverinline
+#	ifdef GEN_COMPILER_MSVC
+#		define neverinline __declspec( noinline )
+#	elif defined(GEN_COMPILER_GCC)
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	elif defined(GEN_COMPILER_CLANG)
+#	if __has_attribute(__always_inline__)
+#		define neverinline __attribute__( ( __noinline__ ) )
+#	else
+#		define neverinline
+#	endif
+#	else
+#		define neverinline
+#	endif
+#endif
 
 #pragma endregion Macros

project/dependencies/memory.cpp

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

project/dependencies/memory.hpp

@@ -10,43 +10,51 @@
 #define gigabytes( x ) ( megabytes( x ) * ( s64 )( 1024 ) )
 #define terabytes( x ) ( gigabytes( x ) * ( s64 )( 1024 ) )
 
-#define GEN__ONES          ( zpl_cast( uw ) - 1 / GEN_U8_MAX )
+#define GEN__ONES          ( scast( GEN_NS usize, - 1) / GEN_U8_MAX )
 #define GEN__HIGHS         ( GEN__ONES * ( GEN_U8_MAX / 2 + 1 ) )
-#define GEN__HAS_ZERO( x ) ( ( ( x )-GEN__ONES ) & ~( x )&GEN__HIGHS )
+#define GEN__HAS_ZERO( x ) ( ( ( x ) - GEN__ONES ) & ~( x ) & GEN__HIGHS )
+
+template< class Type >
+void swap( Type& a, Type& b )
+{
+	Type tmp = a;
+	a = b;
+	b = tmp;
+}
 
 //! Checks if value is power of 2.
-GEN_DEF_INLINE b32 is_power_of_two( sw x );
+b32 is_power_of_two( ssize x );
 
 //! Aligns address to specified alignment.
-GEN_DEF_INLINE void* align_forward( void* ptr, sw alignment );
+void* align_forward( void* ptr, ssize alignment );
 
 //! Aligns value to a specified alignment.
-GEN_DEF_INLINE s64 align_forward_i64( s64 value, sw alignment );
+s64 align_forward_i64( s64 value, ssize alignment );
 
 //! Moves pointer forward by bytes.
-GEN_DEF_INLINE void* pointer_add( void* ptr, sw bytes );
+void* pointer_add( void* ptr, ssize bytes );
 
 //! Moves pointer forward by bytes.
-GEN_DEF_INLINE void const* pointer_add_const( void const* ptr, sw bytes );
+void const* pointer_add_const( void const* ptr, ssize bytes );
 
 //! Calculates difference between two addresses.
-GEN_DEF_INLINE sw pointer_diff( void const* begin, void const* end );
+ssize pointer_diff( void const* begin, void const* end );
 
 //! Copy non-overlapping memory from source to destination.
-void* mem_copy( void* dest, void const* source, sw size );
+void* mem_copy( void* dest, void const* source, ssize size );
 
 //! Search for a constant value within the size limit at memory location.
-void const* mem_find( void const* data, u8 byte_value, sw size );
+void const* mem_find( void const* data, u8 byte_value, ssize size );
 
 //! Copy memory from source to destination.
-GEN_DEF_INLINE void* mem_move( void* dest, void const* source, sw size );
+void* mem_move( void* dest, void const* source, ssize size );
 
 //! Set constant value at memory location with specified size.
-GEN_DEF_INLINE void* mem_set( void* data, u8 byte_value, sw size );
+void* mem_set( void* data, u8 byte_value, ssize size );
 
 //! @param ptr Memory location to clear up.
 //! @param size The size to clear up with.
-GEN_DEF_INLINE void zero_size( void* ptr, sw size );
+void zero_size( void* ptr, ssize size );
 
 //! Clears up an item.
 #define zero_item( t ) zero_size( ( t ), size_of( *( t ) ) )    // NOTE: Pass pointer of struct
@@ -63,8 +71,8 @@ enum AllocType : u8
 };
 
 using AllocatorProc = void* ( void* allocator_data, AllocType type
-	, sw size, sw alignment
-	, void* old_memory, sw old_size
+	, ssize size, ssize alignment
+	, void* old_memory, ssize old_size
 	, u64 flags );
 
 struct AllocatorInfo
@@ -87,22 +95,22 @@ enum AllocFlag
 #endif
 
 //! Allocate memory with default alignment.
-GEN_DEF_INLINE void* alloc( AllocatorInfo a, sw size );
+void* alloc( AllocatorInfo a, ssize size );
 
 //! Allocate memory with specified alignment.
-GEN_DEF_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment );
+void* alloc_align( AllocatorInfo a, ssize size, ssize alignment );
 
 //! Free allocated memory.
-GEN_DEF_INLINE void free( AllocatorInfo a, void* ptr );
+void free( AllocatorInfo a, void* ptr );
 
 //! Free all memory allocated by an allocator.
-GEN_DEF_INLINE void free_all( AllocatorInfo a );
+void free_all( AllocatorInfo a );
 
 //! Resize an allocated memory.
-GEN_DEF_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size );
+void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size );
 
 //! Resize an allocated memory with specified alignment.
-GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
+void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
 
 //! Allocate memory for an item.
 #define alloc_item( allocator_, Type ) ( Type* )alloc( allocator_, size_of( Type ) )
@@ -114,17 +122,17 @@ GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw n
 /* define GEN_HEAP_ANALYSIS to enable this feature */
 /* call zpl_heap_stats_init at the beginning of the entry point */
 /* you can call zpl_heap_stats_check near the end of the execution to validate any possible leaks */
-void heap_stats_init( void );
-sw   heap_stats_used_memory( void );
-sw   heap_stats_alloc_count( void );
-void heap_stats_check( void );
+void  heap_stats_init( void );
+ssize heap_stats_used_memory( void );
+ssize heap_stats_alloc_count( void );
+void  heap_stats_check( void );
 
 //! Allocate/Resize memory using default options.
 
 //! Use this if you don't need a "fancy" resize allocation
-GEN_DEF_INLINE void* default_resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
+void* default_resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
 
-void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
 
 //! The heap allocator backed by operating system's memory manager.
 constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr }; }
@@ -135,270 +143,40 @@ constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr };
 //! Helper to free memory allocated by heap allocator.
 #define mfree( ptr ) free( heap(), ptr )
 
-GEN_IMPL_INLINE b32 is_power_of_two( sw x )
-{
-	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 VirtualMemory
 {
 	void*  data;
-	sw size;
+	ssize size;
 };
 
 //! Initialize virtual memory from existing data.
-VirtualMemory vm_from_memory( void* data, sw size );
+VirtualMemory vm_from_memory( void* data, ssize size );
 
 //! Allocate virtual memory at address with size.
 
 //! @param addr The starting address of the region to reserve. If NULL, it lets operating system to decide where to allocate it.
 //! @param size The size to serve.
-VirtualMemory vm_alloc( void* addr, sw size );
+VirtualMemory vm_alloc( void* addr, ssize size );
 
 //! Release the virtual memory.
 b32 vm_free( VirtualMemory vm );
 
 //! Trim virtual memory.
-VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size );
+VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size );
 
 //! Purge virtual memory.
 b32 gen_vm_purge( VirtualMemory vm );
 
 //! Retrieve VM's page size and alignment.
-sw gen_virtual_memory_page_size( sw* alignment_out );
+ssize gen_virtual_memory_page_size( ssize* alignment_out );
 
 struct Arena
 {
 	static
-	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+	void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
 
 	static
-	Arena init_from_memory( void* start, sw size )
+	Arena init_from_memory( void* start, ssize size )
 	{
 		return
 		{
@@ -411,7 +189,7 @@ struct Arena
 	}
 
 	static
-	Arena init_from_allocator( AllocatorInfo backing, sw size )
+	Arena init_from_allocator( AllocatorInfo backing, ssize size )
 	{
 		Arena result =
 		{
@@ -425,18 +203,18 @@ struct Arena
 	}
 
 	static
-	Arena init_sub( Arena& parent, sw size )
+	Arena init_sub( Arena& parent, ssize size )
 	{
 		return init_from_allocator( parent.Backing, size );
 	}
 
-	sw alignment_of( sw alignment )
+	ssize alignment_of( ssize alignment )
 	{
-		sw alignment_offset, result_pointer, mask;
+		ssize alignment_offset, result_pointer, mask;
 		GEN_ASSERT( is_power_of_two( alignment ) );
 
 		alignment_offset = 0;
-		result_pointer   = (sw) PhysicalStart + TotalUsed;
+		result_pointer   = (ssize) PhysicalStart + TotalUsed;
 		mask             = alignment - 1;
 
 		if ( result_pointer & mask )
@@ -445,10 +223,14 @@ struct Arena
 		return alignment_offset;
 	}
 
+// This id is defined by Unreal for asserts
+#pragma push_macro("check")
+#undef check
 	void check()
 	{
 		GEN_ASSERT( TempCount == 0 );
 	}
+#pragma pop_macro("check")
 
 	void free()
 	{
@@ -459,17 +241,17 @@ struct Arena
 		}
 	}
 
-	sw size_remaining( sw alignment )
+	ssize size_remaining( ssize alignment )
 	{
-		sw result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
+		ssize result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
 		return result;
 	}
 
 	AllocatorInfo Backing;
 	void*         PhysicalStart;
-	sw            TotalSize;
-	sw            TotalUsed;
-	sw            TempCount;
+	ssize            TotalSize;
+	ssize            TotalUsed;
+	ssize            TempCount;
 
 	operator AllocatorInfo()
 	{
@@ -489,7 +271,7 @@ struct FixedArena
 		return result;
 	}
 
-	sw size_remaining( sw alignment )
+	ssize size_remaining( ssize alignment )
 	{
 		return arena.size_remaining( alignment );
 	}
@@ -519,16 +301,16 @@ using Arena_4MB   = FixedArena< megabytes( 4 ) >;
 struct Pool
 {
 	static
-	void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
+	void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
 
 	static
-	Pool init( AllocatorInfo backing, sw num_blocks, sw block_size )
+	Pool init( AllocatorInfo backing, ssize num_blocks, ssize 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 );
+	Pool init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align );
 
 	void clear();
 
@@ -543,10 +325,10 @@ struct Pool
 	AllocatorInfo Backing;
 	void*         PhysicalStart;
 	void*         FreeList;
-	sw            BlockSize;
-	sw            BlockAlign;
-	sw            TotalSize;
-	sw            NumBlocks;
+	ssize         BlockSize;
+	ssize         BlockAlign;
+	ssize         TotalSize;
+	ssize         NumBlocks;
 
 	operator AllocatorInfo()
 	{
@@ -554,4 +336,236 @@ struct Pool
 	}
 };
 
+
+inline
+b32 is_power_of_two( ssize x ) {
+	if ( x <= 0 )
+		return false;
+	return ! ( x & ( x - 1 ) );
+}
+
+inline
+mem_ptr align_forward( void* ptr, ssize alignment )
+{
+	GEN_ASSERT( is_power_of_two( alignment ) );
+	uptr p       = to_uptr(ptr);
+	uptr forward = (p + ( alignment - 1 ) ) & ~( alignment - 1 );
+
+	return to_mem_ptr(forward);
+}
+
+inline s64 align_forward_i64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; }
+
+inline void*       pointer_add      ( void*       ptr, ssize bytes ) { return rcast(void*,       rcast( u8*,        ptr) + bytes ); }
+inline void const* pointer_add_const( void const* ptr, ssize bytes ) { return rcast(void const*, rcast( u8 const*,  ptr) + bytes ); }
+
+inline sptr pointer_diff( mem_ptr_const begin, mem_ptr_const end ) {
+	return scast( ssize, rcast( u8 const*, end) - rcast(u8 const*, begin) );
+}
+
+inline
+void* mem_move( void* destination, void const* source, ssize byte_count )
+{
+	if ( destination == NULL )
+	{
+		return NULL;
+	}
+
+	u8*       dest_ptr = rcast( u8*, destination);
+	u8 const* src_ptr  = rcast( u8 const*, source);
+
+	if ( dest_ptr == src_ptr )
+		return dest_ptr;
+
+	if ( src_ptr + byte_count <= dest_ptr || dest_ptr + byte_count <= src_ptr )    // NOTE: Non-overlapping
+		return mem_copy( dest_ptr, src_ptr, byte_count );
+
+	if ( dest_ptr < src_ptr )
+	{
+		if ( to_uptr(src_ptr) % size_of( ssize ) == to_uptr(dest_ptr) % size_of( ssize ) )
+		{
+			while ( pcast( uptr, dest_ptr) % size_of( ssize ) )
+			{
+				if ( ! byte_count-- )
+					return destination;
+
+				*dest_ptr++ = *src_ptr++;
+			}
+			while ( byte_count >= size_of( ssize ) )
+			{
+				* rcast(ssize*, dest_ptr)  = * rcast(ssize const*, src_ptr);
+				byte_count -= size_of( ssize );
+				dest_ptr   += size_of( ssize );
+				src_ptr    += size_of( ssize );
+			}
+		}
+		for ( ; byte_count; byte_count-- )
+			*dest_ptr++ = *src_ptr++;
+	}
+	else
+	{
+		if ( ( to_uptr(src_ptr) % size_of( ssize ) ) == ( to_uptr(dest_ptr) % size_of( ssize ) ) )
+		{
+			while ( to_uptr( dest_ptr + byte_count ) % size_of( ssize ) )
+			{
+				if ( ! byte_count-- )
+					return destination;
+
+				dest_ptr[ byte_count ] = src_ptr[ byte_count ];
+			}
+			while ( byte_count >= size_of( ssize ) )
+			{
+				byte_count                              -= size_of( ssize );
+				* rcast(ssize*, dest_ptr + byte_count )  = * rcast( ssize const*, src_ptr + byte_count );
+			}
+		}
+		while ( byte_count )
+			byte_count--, dest_ptr[ byte_count ] = src_ptr[ byte_count ];
+	}
+
+	return destination;
+}
+
+inline
+void* mem_set( void* destination, u8 fill_byte, ssize byte_count )
+{
+	if ( destination == NULL )
+	{
+		return NULL;
+	}
+
+	ssize align_offset;
+	u8*   dest_ptr  = rcast( u8*, destination);
+	u32   fill_word = ( ( u32 )-1 ) / 255 * fill_byte;
+
+	if ( byte_count == 0 )
+		return destination;
+
+	dest_ptr[ 0 ] = dest_ptr[ byte_count - 1 ] = fill_byte;
+	if ( byte_count < 3 )
+		return destination;
+
+	dest_ptr[ 1 ] = dest_ptr[ byte_count - 2 ] = fill_byte;
+	dest_ptr[ 2 ] = dest_ptr[ byte_count - 3 ] = fill_byte;
+	if ( byte_count < 7 )
+		return destination;
+
+	dest_ptr[ 3 ] = dest_ptr[ byte_count - 4 ] = fill_byte;
+	if ( byte_count < 9 )
+		return destination;
+
+	align_offset  = -to_sptr( dest_ptr ) & 3;
+	dest_ptr     += align_offset;
+	byte_count   -= align_offset;
+	byte_count   &= -4;
+
+	* rcast( u32*, ( dest_ptr + 0              ) ) = fill_word;
+	* rcast( u32*, ( dest_ptr + byte_count - 4 ) ) = fill_word;
+	if ( byte_count < 9 )
+		return destination;
+
+	* rcast( u32*, dest_ptr + 4 )               = fill_word;
+	* rcast( u32*, dest_ptr + 8 )               = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 12 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 8 )  = fill_word;
+	if ( byte_count < 25 )
+		return destination;
+
+	* rcast( u32*, dest_ptr + 12 )              = fill_word;
+	* rcast( u32*, dest_ptr + 16 )              = fill_word;
+	* rcast( u32*, dest_ptr + 20 )              = fill_word;
+	* rcast( u32*, dest_ptr + 24 )              = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 28 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 24 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 20 ) = fill_word;
+	* rcast( u32*, dest_ptr + byte_count - 16 ) = fill_word;
+
+	align_offset  = 24 + to_uptr( dest_ptr ) & 4;
+	dest_ptr     += align_offset;
+	byte_count   -= align_offset;
+
+	{
+		u64 fill_doubleword = ( scast( u64, fill_word) << 32 ) | fill_word;
+		while ( byte_count > 31 )
+		{
+			* rcast( u64*, dest_ptr + 0 )  = fill_doubleword;
+			* rcast( u64*, dest_ptr + 8 )  = fill_doubleword;
+			* rcast( u64*, dest_ptr + 16 ) = fill_doubleword;
+			* rcast( u64*, dest_ptr + 24 ) = fill_doubleword;
+
+			byte_count -= 32;
+			dest_ptr += 32;
+		}
+	}
+
+	return destination;
+}
+
+inline
+void* alloc_align( AllocatorInfo a, ssize size, ssize alignment ) {
+	return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* alloc( AllocatorInfo a, ssize size ) {
+	return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+inline
+void free( AllocatorInfo a, void* ptr ) {
+	if ( ptr != nullptr )
+		a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void free_all( AllocatorInfo a ) {
+	a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size ) {
+	return resize_align( a, ptr, old_size, new_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
+}
+
+inline
+void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment ) {
+	return a.Proc( a.Data, EAllocation_RESIZE, new_size, alignment, ptr, old_size, GEN_DEFAULT_ALLOCATOR_FLAGS );
+}
+
+inline
+void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, ssize new_size, ssize alignment )
+{
+	if ( ! old_memory )
+		return alloc_align( a, new_size, alignment );
+
+	if ( new_size == 0 )
+	{
+		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;
+	}
+}
+
+inline
+void zero_size( void* ptr, ssize size ) {
+	mem_set( ptr, 0, size );
+}
+
 #pragma endregion Memory

project/dependencies/parsing.cpp

@@ -36,7 +36,7 @@ u8 adt_destroy_branch( ADT_Node* node )
 	GEN_ASSERT_NOT_NULL( node );
 	if ( ( node->type == EADT_TYPE_OBJECT || node->type == EADT_TYPE_ARRAY ) && node->nodes )
 	{
-		for ( sw i = 0; i < node->nodes.num(); ++i )
+		for ( ssize i = 0; i < scast(ssize, node->nodes.num()); ++i )
 		{
 			adt_destroy_branch( node->nodes + i );
 		}
@@ -66,7 +66,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
 		return NULL;
 	}
 
-	for ( sw i = 0; i < node->nodes.num(); i++ )
+	for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
 	{
 		if ( ! str_compare( node->nodes[ i ].name, name ) )
 		{
@@ -76,7 +76,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
 
 	if ( deep_search )
 	{
-		for ( sw i = 0; i < node->nodes.num(); i++ )
+		for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
 		{
 			ADT_Node* res = adt_find( node->nodes + i, name, deep_search );
 
@@ -111,7 +111,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 				file_stream_open( &tmp, heap(), ( u8* )back, size_of( back ), EFileStream_WRITABLE );
 				adt_print_number( &tmp, node );
 
-				sw  fsize = 0;
+				ssize  fsize = 0;
 				u8* buf   = file_stream_buf( &tmp, &fsize );
 
 				if ( ! str_compare( ( char const* )buf, value ) )
@@ -132,7 +132,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
 
 internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
 {
-	for ( sw i = 0; i < node->nodes.num(); i++ )
+	for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
 	{
 		if ( ! str_compare( node->nodes[ i ].name, name ) )
 		{
@@ -207,7 +207,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 			/* run a value comparison against any child that is an object node */
 			else if ( node->type == EADT_TYPE_ARRAY )
 			{
-				for ( sw i = 0; i < node->nodes.num(); i++ )
+				for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
 				{
 					ADT_Node* child = &node->nodes[ i ];
 					if ( child->type != EADT_TYPE_OBJECT )
@@ -225,7 +225,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 		/* [value] */
 		else
 		{
-			for ( sw i = 0; i < node->nodes.num(); i++ )
+			for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
 			{
 				ADT_Node* child = &node->nodes[ i ];
 				if ( _adt_get_value( child, l_b2 ) )
@@ -256,8 +256,8 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	/* handle array index lookup */
 	else
 	{
-		sw idx = ( sw )str_to_i64( buf, NULL, 10 );
-		if ( idx >= 0 && idx < node->nodes.num() )
+		ssize idx = ( ssize )str_to_i64( buf, NULL, 10 );
+		if ( idx >= 0 && idx < scast(ssize, node->nodes.num()) )
 		{
 			found_node = &node->nodes[ idx ];
 
@@ -272,7 +272,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
 	return found_node;
 }
 
-ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
+ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index )
 {
 	if ( ! parent || ( parent->type != EADT_TYPE_OBJECT && parent->type != EADT_TYPE_ARRAY ) )
 	{
@@ -282,7 +282,7 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
 	if ( ! parent->nodes )
 		return NULL;
 
-	if ( index < 0 || index > parent->nodes.num() )
+	if ( index < 0 || index > scast(ssize, parent->nodes.num()) )
 		return NULL;
 
 	ADT_Node o = { 0 };
@@ -337,7 +337,7 @@ b8 adt_set_int( ADT_Node* obj, char const* name, s64 value )
 	return true;
 }
 
-ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index )
+ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index )
 {
 	GEN_ASSERT_NOT_NULL( node );
 	GEN_ASSERT_NOT_NULL( new_parent );
@@ -366,8 +366,8 @@ void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node )
 	GEN_ASSERT_NOT_NULL( other_node );
 	ADT_Node* parent                     = node->parent;
 	ADT_Node* other_parent               = other_node->parent;
-	sw        index                      = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
-	sw        index2                     = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
+	ssize        index                      = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
+	ssize        index2                     = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
 	ADT_Node  temp                       = parent->nodes[ index ];
 	temp.parent                          = other_parent;
 	other_parent->nodes[ index2 ].parent = parent;
@@ -380,7 +380,7 @@ void adt_remove_node( ADT_Node* node )
 	GEN_ASSERT_NOT_NULL( node );
 	GEN_ASSERT_NOT_NULL( node->parent );
 	ADT_Node* parent = node->parent;
-	sw        index  = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
+	ssize        index  = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
 	parent->nodes.remove_at( index );
 }
 
@@ -484,7 +484,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 	node_type = EADT_TYPE_INTEGER;
 	neg_zero  = false;
 
-	sw   ib        = 0;
+	ssize   ib        = 0;
 	char buf[ 48 ] = { 0 };
 
 	if ( *e == '+' )
@@ -550,7 +550,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 
 	f32  eb          = 10;
 	char expbuf[ 6 ] = { 0 };
-	sw   expi        = 0;
+	ssize   expi        = 0;
 
 	if ( *e && ! ! str_find( "eE", *e ) )
 	{
@@ -595,7 +595,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
 
 #ifndef GEN_PARSER_DISABLE_ANALYSIS
 		char *q = buf, *base_string = q, *base_string2 = q;
-		base_string           = zpl_cast( char* ) str_skip( base_string, '.' );
+		base_string           = ccast( char*, str_skip( base_string, '.' ));
 		*base_string          = '\0';
 		base_string2          = base_string + 1;
 		char* base_string_off = base_string2;
@@ -816,13 +816,13 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	char* beginChar;
 	char* endChar;
 
-	sw columnIndex       = 0;
-	sw totalColumnIndex = 0;
+	ssize columnIndex       = 0;
+	ssize totalColumnIndex = 0;
 
 	do
 	{
 		char delimiter = 0;
-		currentChar = zpl_cast( char* ) str_trim( currentChar, false );
+		currentChar = ccast( char*, str_trim( currentChar, false ));
 
 		if ( *currentChar == 0 )
 			break;
@@ -846,7 +846,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 		#endif
 			do
 			{
-				endChar = zpl_cast( char* ) str_skip( endChar, '"' );
+				endChar = ccast( char*, str_skip( endChar, '"' ));
 
 				if ( *endChar && *( endChar + 1 ) == '"' )
 				{
@@ -865,7 +865,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			}
 
 			*endChar    = 0;
-			currentChar = zpl_cast( char* ) str_trim( endChar + 1, true );
+			currentChar = ccast( char*, str_trim( endChar + 1, true ));
 			delimiter   = * currentChar;
 
 			/* unescape escaped quotes (so that unescaped text escapes :) */
@@ -902,7 +902,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 
 			if ( * endChar )
 			{
-				currentChar = zpl_cast( char* ) str_trim( endChar, true );
+				currentChar = ccast( char*, str_trim( endChar, true ));
 
 				while ( char_is_space( *( endChar - 1 ) ) )
 				{
@@ -946,7 +946,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 			}
 		}
 
-		if ( columnIndex >= root->nodes.num() )
+		if ( columnIndex >= scast(ssize, root->nodes.num()) )
 		{
 			adt_append_arr( root, NULL );
 		}
@@ -989,7 +989,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
 	/* consider first row as a header. */
 	if ( has_header )
 	{
-		for ( sw i = 0; i < root->nodes.num(); i++ )
+		for ( ssize i = 0; i < scast(ssize, root->nodes.num()); i++ )
 		{
 			CSV_Object* col = root->nodes + i;
 			CSV_Object* hdr = col->nodes;
@@ -1057,11 +1057,11 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 	GEN_ASSERT_NOT_NULL( file );
 	GEN_ASSERT_NOT_NULL( obj );
 	GEN_ASSERT( obj->nodes );
-	sw cols = obj->nodes.num();
+	ssize cols = obj->nodes.num();
 	if ( cols == 0 )
 		return;
 
-	sw rows = obj->nodes[ 0 ].nodes.num();
+	ssize rows = obj->nodes[ 0 ].nodes.num();
 	if ( rows == 0 )
 		return;
 
@@ -1069,7 +1069,7 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 
 	if ( has_headers )
 	{
-		for ( sw i = 0; i < cols; i++ )
+		for ( ssize i = 0; i < cols; i++ )
 		{
 			_csv_write_header( file, &obj->nodes[ i ] );
 			if ( i + 1 != cols )
@@ -1080,9 +1080,9 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
 		str_fmt_file( file, "\n" );
 	}
 
-	for ( sw r = 0; r < rows; r++ )
+	for ( ssize r = 0; r < rows; r++ )
 	{
-		for ( sw i = 0; i < cols; i++ )
+		for ( ssize i = 0; i < cols; i++ )
 		{
 			_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
 			if ( i + 1 != cols )
@@ -1099,7 +1099,8 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
 	FileInfo tmp;
 	file_stream_new( &tmp, a );
 	csv_write_delimiter( &tmp, obj, delimiter );
-	sw     fsize;
+	
+	ssize  fsize;
 	u8*    buf    = file_stream_buf( &tmp, &fsize );
 	String output = String::make_length( a, ( char* )buf, fsize );
 	file_close( &tmp );

project/dependencies/parsing.hpp

@@ -178,7 +178,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search );
 	* @param index
 	* @return zpl_adt_node * node
 	*/
-ADT_Node* adt_alloc_at( ADT_Node* parent, sw index );
+ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index );
 
 /**
 	* @brief Allocate an unitialised node within a container.
@@ -196,7 +196,7 @@ ADT_Node* adt_alloc( ADT_Node* parent );
 	* @param index
 	* @return zpl_adt_node * node
 	*/
-ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index );
+ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index );
 
 /**
 	* @brief Move an existing node to a new container.
@@ -400,31 +400,33 @@ enum CSV_Error : u32
 
 typedef ADT_Node CSV_Object;
 
-GEN_DEF_INLINE u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header );
-u8                csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim );
-void              csv_free( CSV_Object* obj );
+u8   csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header );
+u8   csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim );
+void csv_free( CSV_Object* obj );
 
-GEN_DEF_INLINE void   csv_write( FileInfo* file, CSV_Object* obj );
-GEN_DEF_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* obj );
-void                  csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
-String                csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
+void   csv_write( FileInfo* file, CSV_Object* obj );
+String csv_write_string( AllocatorInfo a, CSV_Object* obj );
+void   csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
+String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
 
 /* inline */
 
-GEN_IMPL_INLINE u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
+inline
+u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
 {
 	return csv_parse_delimiter( root, text, allocator, has_header, ',' );
 }
 
-GEN_IMPL_INLINE void csv_write( FileInfo* file, CSV_Object* obj )
+inline
+void csv_write( FileInfo* file, CSV_Object* obj )
 {
 	csv_write_delimiter( file, obj, ',' );
 }
 
-GEN_IMPL_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* obj )
+inline
+String csv_write_string( AllocatorInfo a, CSV_Object* obj )
 {
 	return csv_write_string_delimiter( a, obj, ',' );
 }
 
 #pragma endregion CSV
-

project/dependencies/platform.hpp

@@ -1,4 +1,6 @@
-#pragma once
+#ifdef GEN_INTELLISENSE_DIRECTIVES
+#	pragma once
+#endif
 
 #pragma region Platform Detection
 
@@ -99,9 +101,6 @@
 #  define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
 #endif
 
-#define GEN_DEF_INLINE  static
-#define GEN_IMPL_INLINE static inline
-
 #pragma endregion Platform Detection
 
 #pragma region Mandatory Includes

project/dependencies/printing.cpp

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

project/dependencies/printing.hpp

@@ -12,23 +12,23 @@ struct FileInfo;
 #endif
 
 // NOTE: A locally persisting buffer is used internally
-char* str_fmt_buf       ( char const* fmt, ... );
-char* str_fmt_buf_va    ( char const* fmt, va_list va );
-sw    str_fmt           ( char* str, sw n, char const* fmt, ... );
-sw    str_fmt_va        ( char* str, sw n, char const* fmt, va_list va );
-sw    str_fmt_out_va    ( char const* fmt, va_list va );
-sw    str_fmt_out_err   ( char const* fmt, ... );
-sw    str_fmt_out_err_va( char const* fmt, va_list va );
-sw    str_fmt_file      ( FileInfo* f, char const* fmt, ... );
-sw    str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
+char*  str_fmt_buf       ( char const* fmt, ... );
+char*  str_fmt_buf_va    ( char const* fmt, va_list va );
+ssize  str_fmt           ( char* str, ssize n, char const* fmt, ... );
+ssize  str_fmt_va        ( char* str, ssize n, char const* fmt, va_list va );
+ssize  str_fmt_out_va    ( char const* fmt, va_list va );
+ssize  str_fmt_out_err   ( char const* fmt, ... );
+ssize  str_fmt_out_err_va( char const* fmt, va_list va );
+ssize  str_fmt_file      ( FileInfo* f, char const* fmt, ... );
+ssize  str_fmt_file_va   ( FileInfo* f, char const* fmt, va_list va );
 
 constexpr
 char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
 
 inline
-sw log_fmt(char const* fmt, ...)
+ssize log_fmt(char const* fmt, ...)
 {
-	sw res;
+	ssize res;
 	va_list va;
 
 	va_start(va, fmt);

project/dependencies/string_ops.cpp

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

project/dependencies/string_ops.hpp

@@ -5,41 +5,42 @@
 
 #pragma region String Ops
 
-GEN_DEF_INLINE const char* char_first_occurence( const char* str, char c );
+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 );
+b32   char_is_alpha( char c );
+b32   char_is_alphanumeric( char c );
+b32   char_is_digit( char c );
+b32   char_is_hex_digit( char c );
+b32   char_is_space( char c );
+char  char_to_lower( char c );
+char  char_to_upper( char c );
 
-GEN_DEF_INLINE s32  digit_to_int( char c );
-GEN_DEF_INLINE s32  hex_digit_to_int( char c );
+s32  digit_to_int( char c );
+s32  hex_digit_to_int( char c );
 
-GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2 );
-GEN_DEF_INLINE s32         str_compare( const char* s1, const char* s2, sw len );
-GEN_DEF_INLINE char*       str_copy( char* dest, const char* source, sw len );
-GEN_DEF_INLINE sw          str_copy_nulpad( char* dest, const char* source, sw len );
-GEN_DEF_INLINE sw          str_len( const char* str );
-GEN_DEF_INLINE sw          str_len( const char* str, sw max_len );
-GEN_DEF_INLINE char*       str_reverse( char* str );    // NOTE: ASCII only
-GEN_DEF_INLINE char const* str_skip( char const* str, char c );
-GEN_DEF_INLINE char const* str_skip_any( char const* str, char const* char_list );
-GEN_DEF_INLINE char const* str_trim( char const* str, b32 catch_newline );
+s32         str_compare( const char* s1, const char* s2 );
+s32         str_compare( const char* s1, const char* s2, ssize len );
+char*       str_copy( char* dest, const char* source, ssize len );
+ssize       str_copy_nulpad( char* dest, const char* source, ssize len );
+ssize       str_len( const char* str );
+ssize       str_len( const char* str, ssize max_len );
+char*       str_reverse( char* str );    // NOTE: ASCII only
+char const* str_skip( char const* str, char c );
+char const* str_skip_any( char const* str, char const* char_list );
+char const* str_trim( char const* str, b32 catch_newline );
 
 // NOTE: ASCII only
-GEN_DEF_INLINE void str_to_lower( char* str );
-GEN_DEF_INLINE void str_to_upper( char* str );
+void str_to_lower( char* str );
+void str_to_upper( char* str );
 
 s64  str_to_i64( const char* str, char** end_ptr, s32 base );
 void i64_to_str( s64 value, char* string, s32 base );
 void u64_to_str( u64 value, char* string, s32 base );
 f64  str_to_f64( const char* str, char** end_ptr );
 
-GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
+inline
+const char* char_first_occurence( const char* s, char c )
 {
 	char ch = c;
 	for ( ; *s != ch; s++ )
@@ -50,59 +51,67 @@ GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
 	return s;
 }
 
-GEN_IMPL_INLINE b32 char_is_alpha( char c )
+inline
+b32 char_is_alpha( char c )
 {
 	if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE b32 char_is_alphanumeric( char c )
+inline
+b32 char_is_alphanumeric( char c )
 {
 	return char_is_alpha( c ) || char_is_digit( c );
 }
 
-GEN_IMPL_INLINE b32 char_is_digit( char c )
+inline
+b32 char_is_digit( char c )
 {
 	if ( c >= '0' && c <= '9' )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE b32 char_is_hex_digit( char c )
+inline
+b32 char_is_hex_digit( char c )
 {
 	if ( char_is_digit( c ) || ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE b32 char_is_space( char c )
+inline
+b32 char_is_space( char c )
 {
 	if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
 		return true;
 	return false;
 }
 
-GEN_IMPL_INLINE char char_to_lower( char c )
+inline
+char char_to_lower( char c )
 {
 	if ( c >= 'A' && c <= 'Z' )
 		return 'a' + ( c - 'A' );
 	return c;
 }
 
-GEN_IMPL_INLINE char char_to_upper( char c )
+inline char char_to_upper( char c )
 {
 	if ( c >= 'a' && c <= 'z' )
 		return 'A' + ( c - 'a' );
 	return c;
 }
 
-GEN_IMPL_INLINE s32 digit_to_int( char c )
+inline
+s32 digit_to_int( char c )
 {
 	return char_is_digit( c ) ? c - '0' : c - 'W';
 }
 
-GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
+inline
+s32 hex_digit_to_int( char c )
 {
 	if ( char_is_digit( c ) )
 		return digit_to_int( c );
@@ -113,7 +122,8 @@ GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
 	return -1;
 }
 
-GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
+inline
+s32 str_compare( const char* s1, const char* s2 )
 {
 	while ( *s1 && ( *s1 == *s2 ) )
 	{
@@ -122,7 +132,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
 	return *( u8* )s1 - *( u8* )s2;
 }
 
-GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
+inline
+s32 str_compare( const char* s1, const char* s2, ssize len )
 {
 	for ( ; len > 0; s1++, s2++, len-- )
 	{
@@ -134,7 +145,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
 	return 0;
 }
 
-GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
+inline
+char* str_copy( char* dest, const char* source, ssize len )
 {
 	GEN_ASSERT_NOT_NULL( dest );
 	if ( source )
@@ -154,9 +166,10 @@ GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
 	return dest;
 }
 
-GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
+inline
+ssize str_copy_nulpad( char* dest, const char* source, ssize len )
 {
-	sw result = 0;
+	ssize result = 0;
 	GEN_ASSERT_NOT_NULL( dest );
 	if ( source )
 	{
@@ -178,7 +191,8 @@ GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
 	return result;
 }
 
-GEN_IMPL_INLINE sw str_len( const char* str )
+inline
+ssize str_len( const char* str )
 {
 	if ( str == NULL )
 	{
@@ -190,17 +204,19 @@ GEN_IMPL_INLINE sw str_len( const char* str )
 	return str - p;
 }
 
-GEN_IMPL_INLINE sw str_len( const char* str, sw max_len )
+inline
+ssize str_len( const char* str, ssize max_len )
 {
-	const char* end = zpl_cast( const char* ) mem_find( str, 0, max_len );
+	const char* end = rcast(const char*, mem_find( str, 0, max_len ));
 	if ( end )
 		return end - str;
 	return max_len;
 }
 
-GEN_IMPL_INLINE char* str_reverse( char* str )
+inline
+char* str_reverse( char* str )
 {
-	sw    len  = str_len( str );
+	ssize    len  = str_len( str );
 	char* a    = str + 0;
 	char* b    = str + len - 1;
 	len       /= 2;
@@ -212,7 +228,8 @@ GEN_IMPL_INLINE char* str_reverse( char* str )
 	return str;
 }
 
-GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
+inline
+char const* str_skip( char const* str, char c )
 {
 	while ( *str && *str != c )
 	{
@@ -221,11 +238,12 @@ GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
 	return str;
 }
 
-GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list )
+inline
+char const* str_skip_any( char const* str, char const* char_list )
 {
-	char const* closest_ptr     = zpl_cast( char const* ) pointer_add( ( void* )str, str_len( str ) );
-	sw          char_list_count = str_len( char_list );
-	for ( sw i = 0; i < char_list_count; i++ )
+	char const* closest_ptr     = rcast( char const*, pointer_add_const( rcast(void const*, str), str_len( str ) ));
+	ssize       char_list_count = str_len( char_list );
+	for ( ssize i = 0; i < char_list_count; i++ )
 	{
 		char const* p = str_skip( str, char_list[ i ] );
 		closest_ptr   = min( closest_ptr, p );
@@ -233,7 +251,8 @@ GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list
 	return closest_ptr;
 }
 
-GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
+inline
+char const* str_trim( char const* str, b32 catch_newline )
 {
 	while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
 	{
@@ -242,7 +261,8 @@ GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
 	return str;
 }
 
-GEN_IMPL_INLINE void str_to_lower( char* str )
+inline
+void str_to_lower( char* str )
 {
 	if ( ! str )
 		return;
@@ -253,7 +273,8 @@ GEN_IMPL_INLINE void str_to_lower( char* str )
 	}
 }
 
-GEN_IMPL_INLINE void str_to_upper( char* str )
+inline
+void str_to_upper( char* str )
 {
 	if ( ! str )
 		return;

project/dependencies/strings.cpp

@@ -5,7 +5,7 @@
 
 #pragma region String
 
-String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
+String String::fmt( AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ... )
 {
 	va_list va;
 	va_start( va, fmt );
@@ -15,9 +15,9 @@ String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const*
 	return make( allocator, buf );
 }
 
-String String::make_length( AllocatorInfo allocator, char const* str, sw length )
+String String::make_length( AllocatorInfo allocator, char const* str, ssize length )
 {
-	constexpr sw header_size = sizeof( Header );
+	constexpr ssize header_size = sizeof( Header );
 
 	s32   alloc_size = header_size + length + 1;
 	void* allocation = alloc( allocator, alloc_size );
@@ -41,9 +41,9 @@ String String::make_length( AllocatorInfo allocator, char const* str, sw length
 	return result;
 }
 
-String String::make_reserve( AllocatorInfo allocator, sw capacity )
+String String::make_reserve( AllocatorInfo allocator, ssize capacity )
 {
-	constexpr sw header_size = sizeof( Header );
+	constexpr ssize header_size = sizeof( Header );
 
 	s32   alloc_size = header_size + capacity + 1;
 	void* allocation = alloc( allocator, alloc_size );
@@ -78,7 +78,7 @@ String String::fmt_buf( AllocatorInfo allocator, char const* fmt, ... )
 
 bool String::append_fmt( char const* fmt, ... )
 {
-	sw   res;
+	ssize   res;
 	char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
 
 	va_list va;
@@ -89,9 +89,9 @@ bool String::append_fmt( char const* fmt, ... )
 	return append( buf, res );
 }
 
-bool String::make_space_for( char const* str, sw add_len )
+bool String::make_space_for( char const* str, ssize add_len )
 {
-	sw available = avail_space();
+	ssize available = avail_space();
 
 	// NOTE: Return if there is enough space left
 	if ( available >= add_len )
@@ -100,7 +100,7 @@ bool String::make_space_for( char const* str, sw add_len )
 	}
 	else
 	{
-		sw new_len, old_size, new_size;
+		ssize new_len, old_size, new_size;
 
 		void* ptr;
 		void* new_ptr;
@@ -118,13 +118,13 @@ bool String::make_space_for( char const* str, sw add_len )
 		if ( new_ptr == nullptr )
 			return false;
 
-		header            = zpl_cast( Header* ) new_ptr;
+		header            = rcast( Header*, new_ptr);
 		header->Allocator = allocator;
 		header->Capacity  = new_len;
 
 		Data = rcast( char*, header + 1 );
 
-		return str;
+		return true;
 	}
 }
 #pragma endregion String

project/dependencies/strings.hpp

@@ -8,18 +8,17 @@
 // Constant string with length.
 struct StrC
 {
-	sw          Len;
+	ssize          Len;
 	char const* Ptr;
 
-	operator char const* () const
-	{
-		return Ptr;
-	}
+	operator char const* ()               const { return Ptr; }
+	char const& operator[]( ssize index ) const { return Ptr[index]; }
 };
 
-#define cast_to_strc( str ) * rcast( StrC*, str - sizeof(sw) )
-#define txt( text ) StrC { sizeof( text ) - 1, text }
+#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
+#define txt( text )         StrC { sizeof( text ) - 1, ( text ) }
 
+inline
 StrC to_str( char const* str )
 {
 	return { str_len( str ), str };
@@ -34,12 +33,12 @@ struct String
 	struct Header
 	{
 		AllocatorInfo Allocator;
-		sw            Capacity;
-		sw            Length;
+		ssize            Capacity;
+		ssize            Length;
 	};
 
 	static
-	uw grow_formula( uw value )
+	usize grow_formula( usize value )
 	{
 		// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
 		return 4 * value + 8;
@@ -48,7 +47,7 @@ struct String
 	static
 	String make( AllocatorInfo allocator, char const* str )
 	{
-		sw length = str ? str_len( str ) : 0;
+		ssize length = str ? str_len( str ) : 0;
 		return make_length( allocator, str, length );
 	}
 
@@ -59,23 +58,23 @@ struct String
 	}
 
 	static
-	String make_reserve( AllocatorInfo allocator, sw capacity );
+	String make_reserve( AllocatorInfo allocator, ssize capacity );
 
 	static
-	String make_length( AllocatorInfo allocator, char const* str, sw length );
+	String make_length( AllocatorInfo allocator, char const* str, ssize length );
 
 	static
-	String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
+	String fmt( AllocatorInfo allocator, char* buf, ssize 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 join( AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue )
 	{
 		String result = make( allocator, "" );
 
-		for ( sw idx = 0; idx < num_parts; ++idx )
+		for ( ssize idx = 0; idx < num_parts; ++idx )
 		{
 			result.append( parts[ idx ] );
 
@@ -92,14 +91,27 @@ struct String
 		if ( lhs.length() != rhs.length() )
 			return false;
 
-		for ( sw idx = 0; idx < lhs.length(); ++idx )
+		for ( ssize 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 );
+	static
+	bool are_equal( String lhs, StrC rhs )
+	{
+		if ( lhs.length() != (rhs.Len) )
+			return false;
+
+		for ( ssize idx = 0; idx < lhs.length(); ++idx )
+			if ( lhs[idx] != rhs[idx] )
+				return false;
+
+		return true;
+	}
+
+	bool make_space_for( char const* str, ssize add_len );
 
 	bool append( char c )
 	{
@@ -111,11 +123,11 @@ struct String
 		return append( str, str_len( str ) );
 	}
 
-	bool append( char const* str, sw length )
+	bool append( char const* str, ssize length )
 	{
 		if ( sptr(str) > 0 )
 		{
-			sw curr_len = this->length();
+			ssize curr_len = this->length();
 
 			if ( ! make_space_for( str, length ) )
 				return false;
@@ -128,7 +140,7 @@ struct String
 
 			header.Length = curr_len + length;
 		}
-		return str;
+		return str != nullptr;
 	}
 
 	bool append( StrC str)
@@ -143,7 +155,7 @@ struct String
 
 	bool append_fmt( char const* fmt, ... );
 
-	sw avail_space() const
+	ssize avail_space() const
 	{
 		Header const&
 		header = * rcast( Header const*, Data - sizeof( Header ));
@@ -156,7 +168,7 @@ struct String
 		return Data[ length() - 1 ];
 	}
 
-	sw capacity() const
+	ssize capacity() const
 	{
 		Header const&
 		header = * rcast( Header const*, Data - sizeof( Header ));
@@ -169,7 +181,7 @@ struct String
 		get_header().Length = 0;
 	}
 
-	String duplicate( AllocatorInfo allocator )
+	String duplicate( AllocatorInfo allocator ) const
 	{
 		return make_length( allocator, Data, length() );
 	}
@@ -189,7 +201,7 @@ struct String
 		return *(Header*)(Data - sizeof(Header));
 	}
 
-	sw length() const
+	ssize length() const
 	{
 		Header const&
 		header = * rcast( Header const*, Data - sizeof( Header ));
@@ -197,6 +209,24 @@ struct String
 		return header.Length;
 	}
 
+	b32 starts_with( StrC substring ) const
+	{
+		if (substring.Len > length())
+			return false;
+
+		b32 result = str_compare(Data, substring.Ptr, substring.Len ) == 0;
+		return result;
+	}
+
+	b32 starts_with( String substring ) const
+	{
+		if (substring.length() > length())
+			return false;
+
+		b32 result = str_compare(Data, substring, substring.length() - 1 ) == 0;
+		return result;
+	}
+
 	void skip_line()
 	{
 	#define current (*scanner)
@@ -243,7 +273,7 @@ struct String
 
 	void trim( char const* cut_set )
 	{
-		sw len = 0;
+		ssize len = 0;
 
 		char* start_pos = Data;
 		char* end_pos   = Data + length() - 1;
@@ -254,7 +284,7 @@ struct String
 		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 ) );
+		len = scast( ssize, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
 
 		if ( Data != start_pos )
 			mem_move( Data, start_pos, len );
@@ -324,7 +354,7 @@ struct String
 
 	operator bool()
 	{
-		return Data;
+		return Data != nullptr;
 	}
 
 	operator char* ()
@@ -349,19 +379,19 @@ struct String
 		if ( this == & other )
 			return *this;
 
-		String& this_ = ccast( String, *this );
+		String*
+		this_ = ccast(String*, this);
+		this_->Data = other.Data;
 
-		this_.Data = other.Data;
-
-		return this_;
+		return *this;
 	}
 
-	char& operator [] ( sw index )
+	char& operator [] ( ssize index )
 	{
 		return Data[ index ];
 	}
 
-	char const& operator [] ( sw index ) const
+	char const& operator [] ( ssize index ) const
 	{
 		return Data[ index ];
 	}

project/dependencies/timing.cpp

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

project/enums/ECode_ExecutionSupport.csv

@@ -0,0 +1,144 @@
+Invalid
+Untyped
+NewLine
+Comment
+Access_Private
+Access_Protected
+Access_Public
+PlatformAttributes
+Class
+Class_Fwd
+Class_Body
+Constructor
+Constructor_Fwd
+Destructor
+Destructor_Fwd
+Enum
+Enum_Fwd
+Enum_Body
+Enum_Class
+Enum_Class_Fwd
+Execution
+
+Expression
+
+Expr_Identifier
+Expr_NumericLiteral
+Expr_StringLiteral
+
+Expr_Alignof
+Expr_ProcCall
+
+Expr_Assign_Add
+Expr_Assign_Subtract
+Expr_Assign_Multiply
+Expr_Assign_Divide
+Expr_Assign_Modulo
+Expr_Assign_Bitwise_And
+Expr_Assign_Bitwise_Or
+Expr_Assign_Bitwise_XOr
+Expr_Assign_LeftShift
+Expr_Assign_RightShift
+
+Expr_CStyleCast
+Expr_FunctionalCast
+Expr_ConstCast
+Expr_DynamicCast
+Expr_ReinterpretCast
+Expr_StaticCast
+
+Expr_Unary_Add
+Expr_Unary_Minus
+Expr_Unary_Not
+Expr_Unary_Increment
+Expr_Unary_Decrement
+Expr_Indirection
+Expr_AddressOf,
+
+Expr_UnaryPost_Increment
+Expr_UnaryPost_Decrement
+Expr_Subscript
+
+Expr_Binary_Add
+Expr_Binary_Subtract
+Expr_Binary_Multiply
+Expr_Binary_Divide
+Expr_Binary_Modulo
+Expr_Binary_Bitwise_And
+Expr_Binary_Bitwise_Or
+Expr_Binary_Bitwise_XOr
+Expr_Binary_Bitwise_LeftShift
+Expr_Binary_Bitwise_RightShift
+Expr_Binary_Logical_Not
+Expr_Binary_Logical_And
+Expr_Binary_Logical_Or
+Expr_Binary_Equal
+Expr_Binary_NotEqual
+Expr_Binary_Lesser
+Expr_Binary_Greater
+Expr_Binary_LesserEqual
+Expr_Binary_GreaterEqual
+Expr_MemberOfObject,
+Expr_MemberOfPointer,
+Expr_PointerToMemberOfObject,
+Expr_PointerToMemberOfPointer,
+Expr_Comma,
+Expr_Tenary,
+
+Export_Body
+Extern_Linkage
+Extern_Linkage_Body
+Friend
+Function
+Function_Fwd
+Function_Body
+Global_Body
+
+Module
+Namespace
+Namespace_Body
+Operator
+Operator_Fwd
+Operator_Member
+Operator_Member_Fwd
+Operator_Cast
+Operator_Cast_Fwd
+Parameters
+Preprocess_Define
+Preprocess_Include
+Preprocess_If
+Preprocess_IfDef
+Preprocess_IfNotDef
+Preprocess_ElIf
+Preprocess_Else
+Preprocess_EndIf
+Preprocess_Pragma
+Specifiers
+
+Statement
+Stmt_Break
+Stmt_Case
+Stmt_Continue
+Stmt_Declaration
+Stmt_Do
+Stmt_Expr
+Stmt_Else
+Stmt_If
+Stmt_For
+Stmt_Goto
+Stmt_Label
+Stmt_Switch
+Stmt_Switch
+Stmt_While
+
+Struct
+Struct_Fwd
+Struct_Body
+Template
+Typedef
+Typename
+Union
+Union_Body
+Using
+Using_Namespace
+Variable

project/enums/EOperator.csv

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

project/enums/ESpecifier.csv

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

project/enums/ETokType.csv

@@ -77,10 +77,12 @@ Star,                   "*"
 Statement_End,          ";"
 StaticAssert,           "static_assert"
 String,                 "__string__"
+Type_Typename,          "typename"
 Type_Unsigned,          "unsigned"
 Type_Signed,            "signed"
 Type_Short,             "short"
 Type_Long,              "long"
+Type_bool,              "bool"
 Type_char,              "char"
 Type_int,               "int"
 Type_double,            "double"

project/enums/ETokType_New.csv

@@ -0,0 +1,183 @@
+Invalid,                "__invalid__"
+Access_Private,         "private"
+Access_Protected,       "protected"
+Access_Public,          "public"
+Access_MemberSymbol,    "."
+Access_StaticSymbol,    "::"
+Ampersand,              "&"
+Ampersand_DBL,          "&&"
+Assign_Classifer,       ":"
+Attribute_Open,         "[["
+Attribute_Close,        "]]"
+BraceCurly_Open,        "{"
+BraceCurly_Close,       "}"
+BraceSquare_Open,       "["
+BraceSquare_Close,      "]"
+Capture_Start,          "("
+Capture_End,            ")"
+Comment,                "__comment__"
+Comment_End,            "__comment_end__"
+Comment_Start,          "__comment_start__"
+Char,                   "__character__"
+Comma,                  ","
+
+Decl_Class,             "class"
+Decl_Default            "default"
+Decl_GNU_Attribute,     "__attribute__"
+Decl_MSVC_Attribute,    "__declspec"
+Decl_Enum,              "enum"
+Decl_Extern_Linkage,    "extern"
+Decl_Friend,            "friend"
+Decl_Module,            "module"
+Decl_Namespace,         "namespace"
+Decl_Operator,          "operator"
+Decl_Struct,            "struct"
+Decl_Template,          "template"
+
+Decl_Type,              "decltype"
+
+Decl_Typedef,           "typedef"
+Decl_Using,             "using"
+Decl_Union,             "union"
+
+Expr_AlignOf,           "alignof"
+
+
+Identifier,             "__identifier__"
+
+Module_Import,          "import"
+Module_Export,          "export"
+
+NewLine,                "__new_line__"
+
+Number,                 "__number__"
+
+Operator,               "__operator__"
+
+Op_Assign,                    "="
+Op_Assign_Add,                "+="
+Op_Assign_Subtract,           "-="
+Op_Assign_Multiply,           "*="
+Op_Assign_Divide,             "/="
+Op_Assign_Modulo,             "%="
+Op_Assign_Bitwise_And,        "&="
+Op_Assign_Bitwise_Or,         "|="
+Op_Assign_Bitwise_XOr,        "^="
+Op_Assign_Bitwise_LeftShift,  "<<="
+Op_Assign_Bitwise_RightShift, ">>="
+
+Op_Increment, "++"
+Op_Decrement, "--"
+
+Op_Add,                 "+"
+Op_Subtract,            "-"
+Op_Multiply,            "*"
+Op_Divide,              "/"
+Op_Modulo,              "%"
+
+Op_Bitwise_And,         "&"
+Op_Bitwise_Or,          "|"
+Op_Bitwise_XOr,         "^"
+Op_Bitwise_LeftShitf,   "<<"
+Op_Bitwise_RightShift,  ">>"
+
+Op_UnaryAdd,            "+"
+Op_UnaryMinus,          "-"
+Op_UnaryNot,            "~"
+
+Op_Logical_Not,         "!"
+Op_Logical_And,         "&&"
+Op_Logical_Or,          "||"
+
+Op_Equal,               "=="
+Op_NotEqual,            "!="
+Op_Lesser,              "<"
+Op_Greater,             ">"
+Op_LesserEqual,         "<="
+Op_GreaterEqual",       ">=
+
+Op_Subscript,                "[]"
+Op_Indirection,              "*"
+Op_AddressOf,                "&"
+Op_MemberOfObject,           "."
+Op_MemberOfPointer",         "->"
+Op_PointerToMemberOfObject,  ".*"
+Op_PointerToMemberOfPointer, "->*"
+
+Op_Comma,                    ","
+Op_Ternary,                  "?"
+
+Preprocess_Hash,        "#"
+Preprocess_Define,      "define"
+Preprocess_If,          "if"
+Preprocess_IfDef,       "ifdef"
+Preprocess_IfNotDef,    "ifndef"
+Preprocess_ElIf,        "elif"
+Preprocess_Else,        "else"
+Preprocess_EndIf,       "endif"
+Preprocess_Include,     "include"
+Preprocess_Pragma,      "pragma"
+Preprocess_Content,	    "__macro_content__"
+Preprocess_Macro,       "__macro__"
+Preprocess_Generic,     "_Generic"
+Preprocess_Unsupported, "__unsupported__"
+
+Spec_Alignof,           "alignof"
+Spec_Const,             "const"
+Spec_Consteval,         "consteval"
+Spec_Constexpr,         "constexpr"
+Spec_Constinit,         "constinit"
+Spec_Explicit,          "explicit"
+Spec_Extern,            "extern"
+Spec_Final,             "final"
+Spec_ForceInline,	    "forceinline"
+Spec_Global,            "global"
+Spec_Inline,            "inline"
+Spec_Internal_Linkage,  "internal"
+Spec_LocalPersist,      "local_persist"
+Spec_Mutable,           "mutable"
+Spec_NeverInline,       "neverinline"
+Spec_Override,          "override"
+Spec_Static,            "static"
+Spec_ThreadLocal,       "thread_local"
+Spec_Volatile,          "volatile"
+Spec_Virtual,           "virtual"
+
+Star,                   "*"
+
+Stmt_Break,             "break"
+Stmt_Case,              "case"
+Stmt_Continue,          "continue"
+Stmt_Default,           "default"
+Stmt_Do,                "do"
+Stmt_Else,              "else"
+Stmt_End,               ";"
+Stmt_If,                "if"
+Stmt_For,               "for"
+Stmt_Goto,              "goto"
+Stmt_Return,            "return"
+Stmt_Switch,            "switch"
+Stmt_While,             "while"
+
+StaticAssert,           "static_assert"
+String,                 "__string__"
+
+Type_Auto,              "auto"
+Type_Unsigned,          "unsigned"
+Type_Signed,            "signed"
+Type_Short,             "short"
+Type_Long,              "long"
+Type_bool,              "bool"
+Type_char,              "char"
+Type_int,               "int"
+Type_float,             "float"
+Type_double,            "double"
+Type_MS_int8,           "__int8"
+Type_MS_int16,          "__int16"
+Type_MS_int32,          "__int32"
+Type_MS_int64,          "__int64"
+Type_MS_W64,            "_W64"
+
+Varadic_Argument,       "..."
+
+__Attributes_Start,     "__attrib_start__"

project/gen.cpp

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

project/gen.dep.hpp

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

project/gen.hpp

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

project/helpers/helper.hpp

@@ -35,6 +35,7 @@ CodeBody gen_ecode( char const* path )
 #pragma push_macro("local_persist")
 #undef local_persist
 	CodeFn to_str = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
 		StrC to_str( Type type )
 		{
 			local_persist
@@ -69,7 +70,7 @@ CodeBody gen_eoperator( char const* path )
 	String enum_entries   = String::make_reserve( GlobalAllocator, kilobytes(1) );
 	String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
 
-	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	for (usize idx = 0; idx < enum_strs.num(); idx++)
 	{
 		char const* enum_str     = enum_strs[idx].string;
 		char const* entry_to_str = str_strs [idx].string;
@@ -89,6 +90,7 @@ CodeBody gen_eoperator( char const* path )
 #pragma push_macro("local_persist")
 #undef local_persist
 	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		inline
 		StrC to_str( Type op )
 		{
 			local_persist
@@ -124,7 +126,7 @@ CodeBody gen_especifier( char const* path )
 	String enum_entries   = String::make_reserve( GlobalAllocator, kilobytes(1) );
 	String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
 
-	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	for (usize idx = 0; idx < enum_strs.num(); idx++)
 	{
 		char const* enum_str     = enum_strs[idx].string;
 		char const* entry_to_str = str_strs [idx].string;
@@ -142,6 +144,7 @@ CodeBody gen_especifier( char const* path )
 	)));
 
 	CodeFn is_trailing = parse_function(token_fmt("specifier", (StrC)to_str_entries, stringize(
+		inline
 		bool is_trailing( Type specifier )
 		{
 			return specifier > Virtual;
@@ -159,6 +162,7 @@ CodeBody gen_especifier( char const* path )
 #undef forceinline
 #undef neverinline
 	CodeFn to_str = parse_function(token_fmt("entries", (StrC)to_str_entries, stringize(
+		inline
 		StrC to_str( Type type )
 		{
 			local_persist
@@ -171,6 +175,7 @@ CodeBody gen_especifier( char const* path )
 	)));
 
 	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
 		Type to_type( StrC str )
 		{
 			local_persist
@@ -236,7 +241,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 	String to_str_attributes        = String::make_reserve( GlobalAllocator, kilobytes(4) );
 	String attribute_define_entries = String::make_reserve( GlobalAllocator, kilobytes(4) );
 
-	for (uw idx = 0; idx < enum_strs.num(); idx++)
+	for (usize idx = 0; idx < enum_strs.num(); idx++)
 	{
 		char const* enum_str     = enum_strs[idx].string;
 		char const* entry_to_str = enum_str_strs [idx].string;
@@ -245,14 +250,14 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 		to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
 	}
 
-	for ( uw idx = 0; idx < attribute_strs.num(); idx++ )
+	for ( usize 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 );
+		attribute_entries.append_fmt( "Attribute_%s,\n", attribute_str );
 		to_str_attributes.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
-		attribute_define_entries.append_fmt( "Entry( %s, %s )", attribute_str, entry_to_str );
+		attribute_define_entries.append_fmt( "Entry( Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
 
 		if ( idx < attribute_strs.num() - 1 )
 			attribute_define_entries.append( " \\\n");
@@ -265,6 +270,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 	CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), attribute_define_entries  );
 #pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
 
+	// We cannot parse this enum, it has Attribute names as enums
 	CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, "attribute_toks", (StrC)attribute_entries, stringize(
 		enum Type : u32
 		{
@@ -281,6 +287,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 #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(
+		inline
 		StrC to_str( Type type )
 		{
 			local_persist
@@ -294,6 +301,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
 	)));
 
 	CodeFn to_type = parse_function( token_fmt( "entries", (StrC)to_str_entries, stringize(
+		inline
 		Type to_type( StrC str )
 		{
 			local_persist
@@ -338,6 +346,7 @@ CodeBody gen_ast_inlines()
 #undef log_failure
 	char const* code_impl_tmpl = stringize(
 		\n
+		inline
 		char const* <typename>::debug_str()
 		{
 			if ( ast == nullptr )
@@ -345,6 +354,7 @@ CodeBody gen_ast_inlines()
 
 			return rcast(AST*, ast)->debug_str();
 		}
+		inline
 		Code <typename>::duplicate()
 		{
 			if ( ast == nullptr )
@@ -355,20 +365,23 @@ CodeBody gen_ast_inlines()
 
 			return { rcast(AST*, ast)->duplicate() };
 		}
+		inline
 		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;
+				// Just check if they're both null.
+				// log_failure( "Code::is_equal: Cannot compare code, AST is null!" );
+				return ast == nullptr && other.ast == nullptr;
 			}
-
 			return rcast(AST*, ast)->is_equal( other.ast );
 		}
+		inline
 		bool <typename>::is_valid()
 		{
 			return (AST*) ast != nullptr && rcast( AST*, ast)->Type != CodeT::Invalid;
 		}
+		inline
 		void <typename>::set_global()
 		{
 			if ( ast == nullptr )
@@ -379,16 +392,7 @@ CodeBody gen_ast_inlines()
 
 			rcast(AST*, ast)->Parent = Code::Global.ast;
 		}
-		String <typename>::to_string()
-		{
-			if ( ast == nullptr )
-			{
-			log_failure("Code::to_string: Cannot convert code to string, AST is null!");
-			return { nullptr };
-			}
-
-			return rcast(AST*, ast)->to_string();
-		}
+		inline
 		<typename>& <typename>::operator =( Code other )
 		{
 			if ( other.ast && other->Parent )
@@ -400,14 +404,17 @@ CodeBody gen_ast_inlines()
 			ast = rcast( decltype(ast), other.ast );
 			return *this;
 		}
+		inline
 		bool <typename>::operator ==( Code other )
 		{
 			return (AST*) ast == other.ast;
 		}
+		inline
 		bool <typename>::operator !=( Code other )
 		{
 			return (AST*) ast != other.ast;
 		}
+		inline
 		<typename>::operator bool()
 		{
 			return ast != nullptr;
@@ -415,14 +422,17 @@ CodeBody gen_ast_inlines()
 	);
 
 	char const* codetype_impl_tmpl = stringize(
+		inline
 		AST* Code<typename>::raw()
 		{
 			return rcast( AST*, ast );
 		}
+		inline
 		Code<typename>::operator Code()
 		{
 			return *rcast( Code*, this );
 		}
+		inline
 		AST_<typename>* Code<typename>::operator->()
 		{
 			if ( ast == nullptr )
@@ -490,12 +500,11 @@ CodeBody gen_ast_inlines()
 	impl_code_var.     append( parse_global_body( token_fmt( "typename", StrC name(Var),            codetype_impl_tmpl )));
 
 	char const* cast_tmpl = stringize(
-		AST::operator Code<typename>()
+		inline	AST::operator Code<typename>()
 		{
 			return { rcast( AST_<typename>*, this ) };
 		}
-
-		Code::operator Code<typename>() const
+		inline Code::operator Code<typename>() const
 		{
 			return { (AST_<typename>*) ast };
 		}

project/helpers/pop_ignores.inline.hpp

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

project/helpers/push_ignores.inline.hpp

@@ -1,6 +1,7 @@
-#if __clang__
+#ifdef __clang__
 #	pragma clang diagnostic push
 #	pragma clang diagnostic ignored "-Wunused-const-variable"
+#	pragma clang diagnostic ignored "-Wunused-but-set-variable"
 #	pragma clang diagnostic ignored "-Wswitch"
 #	pragma clang diagnostic ignored "-Wunused-variable"
 #   pragma clang diagnostic ignored "-Wunknown-pragmas"
@@ -8,7 +9,7 @@
 #	pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
-#if __GNUC__
+#ifdef __GNUC__
 #	pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wunknown-pragmas"
 #	pragma GCC diagnostic ignored "-Wcomment"

project/helpers/undef.macros.hpp

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

scripts/.clang-format

@@ -151,17 +151,17 @@ SpaceBeforeRangeBasedForLoopColon: true
 SpaceBeforeSquareBrackets: false
 SpacesBeforeTrailingComments: 4
 
-SpaceInEmptyBlock: true
+SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
-SpacesInAngles: true
-SpacesInCStyleCastParentheses: true
-SpacesInConditionalStatement: true
-SpacesInContainerLiterals: true
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
 SpacesInLineCommentPrefix:
   Minimum: 1
   Maximum: 20
 SpacesInParentheses: true
-SpacesInSquareBrackets: true
+SpacesInSquareBrackets: false
 
 Standard: c++17
 

scripts/build.ci.ps1

@@ -2,14 +2,36 @@
 # It will most likely need a partial rewrite to segment the build process into separate script invocations based on the OS.
 # That or just rewrite it in an sh script and call it a day.
 
-Import-Module ./helpers/target_arch.psm1
 $target_arch        = Join-Path $PSScriptRoot 'helpers/target_arch.psm1'
 $devshell           = Join-Path $PSScriptRoot 'helpers/devshell.ps1'
 $format_cpp	        = Join-Path $PSScriptRoot 'helpers/format_cpp.psm1'
+$refactor_unreal    = Join-Path $PSScriptRoot 'refactor_unreal.ps1'
 $incremental_checks = Join-Path $PSScriptRoot 'helpers/incremental_checks.ps1'
 $vendor_toolchain   = Join-Path $PSScriptRoot 'helpers/vendor_toolchain.ps1'
 
-$path_root = git rev-parse --show-toplevel
+Import-Module $target_arch
+
+function Get-ScriptRepoRoot {
+    $currentPath = $PSScriptRoot
+    while ($currentPath -ne $null -and $currentPath -ne "")
+	{
+        if (Test-Path (Join-Path $currentPath ".git")) {
+            return $currentPath
+        }
+        # Also check for .git file which indicates a submodule
+        $gitFile = Join-Path $currentPath ".git"
+        if (Test-Path $gitFile -PathType Leaf)
+		{
+            $gitContent = Get-Content $gitFile
+            if ($gitContent -match "gitdir: (.+)") {
+                return $currentPath
+            }
+        }
+        $currentPath = Split-Path $currentPath -Parent
+    }
+    throw "Unable to find repository root"
+}
+$path_root = Get-ScriptRepoRoot
 
 Import-Module $target_arch
 Import-Module $format_cpp
@@ -22,6 +44,7 @@ Push-Location $path_root
 	   $verbose      = $false
 [bool] $bootstrap    = $false
 [bool] $singleheader = $false
+[bool] $unreal       = $false
 [bool] $test         = $false
 
 [array] $vendors = @( "clang", "msvc" )
@@ -36,6 +59,7 @@ if ( $args ) { $args | ForEach-Object {
 		"debug"               { $release      = $false }
 		"bootstrap"           { $bootstrap    = $true }
 		"singleheader"        { $singleheader = $true }
+		"unreal"              { $unreal       = $true }
 		"test"                { $test         = $true }
 	}
 }}
@@ -61,10 +85,10 @@ elseif ( $release -eq $false ) {
 	$debug = $true
 }
 else {
-	$optimize = treu
+	$optimize = $true
 }
 
-if ( $bootstrap -eq $false -and $singleheader -eq $false -and $test -eq $false ) {
+if ( $bootstrap -eq $false -and $singleheader -eq $false -and $unreal -eq $false -and $test -eq $false ) {
 	throw "No build target specified. One must be specified, this script will not assume one"
 }
 
@@ -80,6 +104,7 @@ $path_build        = Join-Path $path_root build
 $path_project      = Join-Path $path_root project
 $path_scripts      = Join-Path $path_root scripts
 $path_singleheader = Join-Path $path_root singleheader
+$path_unreal       = Join-Path $path_root unreal_engine
 $path_test         = Join-Path $path_root test
 
 if ( $bootstrap )
@@ -162,11 +187,55 @@ if ( $singleheader )
 	Pop-Location
 }
 
+if ( $unreal )
+{
+	$path_build = join-path $path_unreal build
+	$path_gen   = join-path $path_unreal gen
+
+	if ( -not(Test-Path($path_build) )) {
+		New-Item -ItemType Directory -Path $path_build
+	}
+	if ( -not(Test-Path($path_gen) )) {
+		New-Item -ItemType Directory -Path $path_gen
+	}
+
+	$includes    = @( $path_project )
+	$unit       = join-path $path_unreal "unreal.cpp"
+	$executable = join-path $path_build  "unreal.exe"
+
+	$compiler_args = @()
+	$compiler_args += ( $flag_define + 'GEN_TIME' )
+
+	$linker_args   = @(
+		$flag_link_win_subsystem_console
+	)
+
+	build-simple $path_build $includes $compiler_args $linker_args $unit $executable
+
+	Push-Location $path_unreal
+		if ( Test-Path( $executable ) ) {
+			write-host "`nRunning unreal variant generator"
+			$time_taken = Measure-Command { & $executable
+					| ForEach-Object {
+						write-host `t $_ -ForegroundColor Green
+					}
+				}
+			write-host "`n Unreal variant generator completed in $($time_taken.TotalMilliseconds) ms"
+		}
+	Pop-Location
+
+	. $refactor_unreal
+}
+
 if ( $test )
 {
-	$path_gen       = join-path $path_test gen
-	$path_gen_build = join-path $path_gen  build
-	$path_build     = join-path $path_test build
+	$path_gen          = join-path $path_test gen
+	$path_gen_build    = join-path $path_gen  build
+	$path_build        = join-path $path_test build
+	$path_original     = join-path $path_gen  original
+	$path_components   = join-path $path_original components
+	$path_dependencies = join-path $path_original dependencies
+	$path_helpers      = join-path $path_original helpers
 
 	if ( -not(Test-Path($path_build) )) {
 		New-Item -ItemType Directory -Path $path_build
@@ -177,6 +246,18 @@ if ( $test )
 	if ( -not(Test-Path($path_gen_build) ))  {
 		New-Item -ItemType Directory -Path $path_gen_build
 	}
+	if ( -not(test-path $path_original)) {
+		new-item -ItemType Directory -Path $path_original
+	}
+	if ( -not(test-path $path_components)) {
+		new-item -ItemType Directory -Path $path_components
+	}
+	if ( -not(test-path $path_dependencies)) {
+		new-item -ItemType Directory -Path $path_dependencies
+	}
+	if ( -not(test-path $path_helpers)) {
+		new-item -ItemType Directory -Path $path_helpers
+	}
 
 	$path_bootstrap = join-path $path_project gen
 
@@ -210,10 +291,9 @@ if ( $test )
 
 #region Formatting
 push-location $path_scripts
-if ( $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
+if ( $true -and $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
 {
 	$path_gen      = join-path $path_project gen
-	$path_comp_gen = join-path $path_project components/gen
 	$include  = @(
 		'gen.hpp', 'gen.cpp',
 		'gen.dep.hpp', 'gen.dep.cpp',
@@ -221,12 +301,12 @@ if ( $bootstrap -and (Test-Path (Join-Path $path_project "gen/gen.hpp")) )
 		'gen.scanner.hpp', 'gen.scanner.cpp'
 	)
 	$exclude  = $null
-	format-cpp $path_gen $include $exclude
+	# format-cpp $path_gen $include $exclude
 	format-cpp $path_comp_gen @( 'ast_inlines.hpp', 'ecode.hpp', 'especifier.hpp', 'eoperator.hpp', 'etoktype.cpp' ) $null
 
 }
 
-if ( $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp")) )
+if ( $false -and $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp")) )
 {
 	$path_gen = join-path $path_singleheader gen
 	$include  = @(
@@ -236,6 +316,19 @@ if ( $singleheader -and (Test-Path (Join-Path $path_singleheader "gen/gen.hpp"))
 	format-cpp $path_gen $include $exclude
 }
 
+if ( $false -and $unreal -and (Test-Path( Join-Path $path_unreal "gen/gen.hpp")) )
+{
+	$path_gen = join-path $path_unreal gen
+	$include  = @(
+		'gen.hpp', 'gen.cpp',
+		'gen.dep.hpp', 'gen.dep.cpp',
+		'gen.builder.hpp', 'gen.builder.cpp'
+		'gen.scanner.hpp', 'gen.scanner.cpp'
+	)
+	$exclude  = $null
+	format-cpp $path_gen $include $exclude
+}
+
 if ( $test -and $false )
 {
 	$path_gen = join-path $path_test gen

scripts/gencpp.natvis

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

scripts/gencpp.refactor

@@ -43,9 +43,6 @@
 // word GEN_COMPILER_MINGW, new_name
 // word GEN_COMPILER_MSVC,  new_name
 
-    // General
-// word zpl_cast, new_name
-
 // word global,        new_name
 // word internal,      new_name
 // word local_persist, new_name
@@ -150,8 +147,8 @@
 // word u16,  new_name
 // word u32,  new_name
 // word u64,  new_name
-// word uw,   new_name
-// word sw,   new_name
+// word usize,   new_name
+// word ssize,   new_name
 // word sptr, new_name
 // word uptr, new_name
 // word f32,  new_name