latest gencpp

Project/Source/GasaEditor/GasaGen/GasaGen.cpp

@@ -128,8 +128,8 @@ void Execute_GasaModule_Codegen()
 		generate_AttributeSets();
 		generate_DevOptionsCache();
 		// generate_HostWidgetController();
-		change_SBlueprintActionMenu_Construct();
+		// change_SBlueprintActionMenu_Construct();
-		change_EditorContentList();
+		// change_EditorContentList();
 		
 		gen::deinit( & gen_ctx);
 	});

Project/Source/GasaEditor/GasaGen/gencpp/AST_Design.md

@@ -53,6 +53,7 @@ StrBuilder <prefix>_to_strbuilder(Code code);
 
 Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator.
 
-Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`.  
+Serialization of for the AST is defined for `Code` in [`ast.cpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`.  
 Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp).  
+
 Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

Project/Source/GasaEditor/GasaGen/gencpp/AST_Types.md

@@ -30,7 +30,7 @@ Code           Front;
 Code      Back;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 s32       NumEntries;
 ```
 
@@ -62,7 +62,7 @@ Code           Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -86,7 +86,7 @@ Code           Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -114,7 +114,7 @@ CodeType       Prev;
 CodeType       Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 AccessSpec     ParentAccess;
 ```
@@ -148,7 +148,7 @@ Code           Prev;
 Code        Next;
 Token*      Tok;
 Code        Parent;
-CodeT          Type;
+CodeType    Type;
 ```
 
 Serialization:
@@ -178,13 +178,14 @@ Represents a preprocessor define
 Fields:
 
 ```cpp
-StrCached   Content;
+CodeDefineParams Params;
+Code             Body;
 StrCached        Name;
 Code             Prev;
 Code             Next;
 Token*           Tok;
 Code             Parent;
-CodeT          Type;
+CodeType         Type;
 ```
 
 Serialization:
@@ -193,6 +194,28 @@ Serialization:
 #define <Name> <Content>
 ```
 
+## DefineParams
+
+Preprocessor define's parameters.
+
+Fields:
+
+```cpp
+StrCached Name;
+Code      Last;
+Code      Next;
+Token*    Tok;
+Code      Parent;
+CodeType  Type;
+s32       NumEntries;
+```
+
+Serialization:
+
+```cpp
+<Name>, <Next> ...
+```
+
 ## Destructor
 
 Fields:
@@ -206,7 +229,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ```
 
 Serialization:
@@ -243,7 +266,7 @@ Code           Next;
 Token*         Tok;
 Code           Parent;
 StrCached      Name;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -277,7 +300,7 @@ Code           Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -286,7 +309,7 @@ Serialization:
 <Content>
 ```
 
-## External Linkage
+## External Linkage (Extern)
 
 Fields:
 
@@ -297,7 +320,7 @@ Code           Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -320,7 +343,7 @@ Code           Prev;
 Code      Next;
 Code      Parent;
 Token*    Tok;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -343,7 +366,7 @@ Code           Prev;
 Code        Next;
 Token*      Tok;
 Code        Parent;
-CodeT          Type;
+CodeType    Type;
 ```
 
 Serialization:
@@ -368,7 +391,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -395,7 +418,7 @@ Code           Prev;
 Code       Next;
 Token*     Tok;
 Code       Parent;
-CodeT          Type;
+CodeType   Type;
 ModuleFlag ModuleFlags;
 ```
 
@@ -416,7 +439,7 @@ Code           Prev;
 Code       Next;
 Token*     Tok;
 Code       Parent;
-CodeT          Type;
+CodeType   Type;
 ModuleFlag ModuleFlags;
 ```
 
@@ -445,7 +468,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 OperatorT      Op;
 ```
@@ -477,7 +500,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ```
 
 Serialization:
@@ -507,7 +530,7 @@ CodeParams     Last;
 CodeParams Next;
 Token*     Tok;
 Code       Parent;
-CodeT          Type;
+CodeType   Type;
 s32        NumEntries;
 ```
 
@@ -530,7 +553,7 @@ Code           Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT          Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -550,7 +573,7 @@ Code          Prev;
 Code      Next;
 Token*    Tok;
 Code      Parent;
-CodeT         Type;
+CodeType  Type;
 ```
 
 Serialization:
@@ -571,7 +594,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 s32            NumEntries;
 ```
 
@@ -593,7 +616,7 @@ Code           Prev;
 Code        Next;
 Token*      Tok;
 Code        Parent;
-CodeT          Type;
+CodeType    Type;
 ModuleFlag  ModuleFlags;
 ```
 
@@ -622,7 +645,7 @@ Code           Next;
 Token*         Tok;
 Code           Parent;
 StrCached      Name;
-CodeT          Type;
+CodeType       Type;
 b32            IsParamPack;
 ETypenameTag   TypeTag;
 ```
@@ -654,7 +677,7 @@ Code          Prev;
 Code        Next;
 Token*      Tok
 Code        Parent;
-CodeT         Type;
+CodeType    Type;
 ModuleFlag  ModuleFlags;
 b32         IsFunction;
 ```
@@ -687,7 +710,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -713,7 +736,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 ```
 
@@ -746,7 +769,7 @@ Code           Prev;
 Code           Next;
 Token*         Tok;
 Code           Parent;
-CodeT          Type;
+CodeType       Type;
 ModuleFlag     ModuleFlags;
 s32            VarParenthesizedInit;
 ```

Project/Source/GasaEditor/GasaGen/gencpp/LICENSE

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

Project/Source/GasaEditor/GasaGen/gencpp/Parsing.md

@@ -6,9 +6,9 @@
 
 # Parsing
 
-The library features a naive single-pass parser tailored for only what the library needs to construct the supported syntax of C++ into its AST for *"front-end"* meta-programming purposes.
+The library features a naive single-pass parser, tailored for only what the library needs; for construction of C++ code into gencpp's AST for *"front-end"* meta-programming purposes.
 
-This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~7000 loc. I hope to keep it under 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 ~7000 loc. I hope to keep it under 10-15k loc worst case.
 
 You can think of this parser as *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.
 
@@ -17,6 +17,7 @@ User exposed interface:
 ```cpp
 CodeClass       parse_class        ( Str class_def       );
 CodeConstructor parse_constructor  ( Str constructor_def );
+CodeDefine      parse_define       ( Str define_def      );
 CodeDestructor  parse_destructor   ( Str destructor_def  );
 CodeEnum        parse_enum         ( Str enum_def        );
 CodeBody        parse_export_body  ( Str export_def      );
@@ -53,38 +54,98 @@ The keywords supported for the preprocessor are:
 * endif
 * pragma
 
-Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. 
+Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST node.
 If a directive is used with an unsupported keyword its will be processed as an untyped AST.
 
-The preprocessor lines are stored as members of their associated scope they are parsed within. ( Global, Namespace, Class/Struct )  
+The preprocessor lines are stored as members of their associated scope they are parsed within ( Global, Namespace, Class/Struct ).
-***Again (Its not standard): These ASTs will be considered members or entries of braced scope they reside within***
+***Again: These ASTs will be considered members or entries of braced scope they reside within***
 
 Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).  
 Exceptions:
 
-* function signatures are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
+* varaible definitions are allowed for a preprocessed macro `extern MACRO();`
+* function definitions are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES`
 * typedefs allow for a preprocessed macro: `typedef MACRO();`
   * Disable with: `#define GEN_PARSER_DISABLE_MACRO_TYPEDEF`
 * Macros can behave as typenames
-* There is some macro support in paramters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
+* There is some macro support in parameters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
 
 *(Exceptions are added on an on-demand basis)*
 *(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
 
 Adding your own exceptions is possible by simply modifying the parser to allow for the syntax you need.
 
-*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase some some egregious preprocessor abuse.*
+*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase contains some egregious preprocessor abuse.*
 
-If a macro is not defined withint e scope of parsing a set of files, it can be defined beforehand by:
+Macros used within a file should be registered by the user before parsing. This can be done two ways:
 
-* Appending the [`PreprocessorDefines`](https://github.com/Ed94/gencpp/blob/a18b5b97aa5cfd20242065cbf53462a623cd18fa/base/components/header_end.hpp#L137) array.
+1. The register macro interface within [interface.hpp](../base/components/interface.hpp).
-  * For functional macros a "(" just needs to be added after the name like: `<name>(` so that it will tokenize its arguments as part of the token during lexing.
+2. Using `def_define` to create a CodeDefine and making sure to not set `opts.dont_register_to_preprocess_macros` to `true`.
-* Defining a CodeDefine using `def_define`. The definition will be processed by the interface for user into `PreprocessorDefines`.
-  * This can be prevented by setting the optional prameter `dont_append_preprocess_defines`.
 
-The lexing and parsing takes shortcuts from whats expected in the standard.
+## Registering macros
 
+While the registeration of macros in the meta-program's side for parsing can be considered tedius, its necessary for the parser to accurately resolve the macros intent in one pass (and it provides some hygenics by verifying that they are used as intended).
+
+The following can be used to register a macro:
+
+```c
+GEN_API void register_macro( Macro macro );
+GEN_API void register_macros( s32 num, ... );
+GEN_API void register_macros_arr( s32 num, Macro* macros );
+```
+
+The Macro typename is defined with the following in [parser_types.hpp](../base/components/parser_types.hpp):
+
+```c
+struct Macro
+{
+    StrCached  Name;
+    MacroType  Type;
+    MacroFlags Flags;
+};
+```
+
+The macro can be designated one of the following types:
+
+* `MT_Expression`: Intended to resolve to an expression expansion.
+* `MT_Statement`: Intended to resolve an statement expansion.
+* `MT_Typename`: Intended to resolve to a typename.
+
+Additioonally tthe following flags may be set:
+
+* `MF_Functional`: The macro intended to be passed arguments are at least have the calling `()` as part of its usage.
+* `MF_Expects_Body`: The parser should expect a braced-body `{ ... }` after the macro signature `<name> <params>`
+* `MF_Allow_As_Identifier`: Will allow the macro to be an acceptable token/s when an `Tok_Identifier` is expected.
+* `MF_Allow_As_Attribute`: Will allow the macro to be an acceptable token/s when an attribute token/s is expected.
+* `MF_Allow_As_Definition`: Will allow the macro be an acceptable token/s when the parser expects a declartion or definition to resolve after attributes or specifiers have been identified beforehand.
+  * This flag requires that the macro is of type `MT_Statement` to make any sense of usage.
+
+If a macro is not defined the following warning will be issued if `GEN_BUILD_DEBUG=1` during lexing within [lexer.cpp](../base/components/lexer.cpp) - `lex_preprocessor_define`:
+
+```c
+log_fmt("Warning: '%S' was not registered before the lexer processed its #define directive, it will be registered as a expression macro\n"
+    , name.Text 
+);
+```
+
+Further within the same scope, the lexer will issue a warning if it detects a macro was not flagged as function but has an open parenthesis `(` token right after is name with no whitespace:
+
+```c
+log_fmt("Warning: %S registered macro is not flagged as functional yet the definition detects opening parenthesis '(' for arguments\n"
+    , name.Text
+);
+```
+
+Macros are tracked using a `MacroTable Macros;` defined as a member of the library's `Context`.
+
+```c
+typedef HashTable(Macro) MacroTable;
+```
+
+## Notes
+
+* Empty lines used throughout the file are preserved for formatting purposes during ast serialization (they have a dedicated Token: `Tok_NewLine`).
 * Numeric literals are not checked for validity.
 * The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs. (There is a [todo](https://github.com/Ed94/gencpp/issues/49) to add support)
   * *This includes the assignment of variables.*
@@ -95,4 +156,4 @@ The lexing and parsing takes shortcuts from whats expected in the standard.
 * Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
   * This is useful for example: parsing Unreal `Module_API` macros.
 
-Empty lines used throughout the file are preserved for formatting purposes during ast serialization.
+**The lexer & parser do not gracefully attempt to continue when it comes across incorrect code, and doesn't properly track errors into a listing (yet).**

Project/Source/GasaEditor/GasaGen/gencpp/Readme.md

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

Project/Source/GasaEditor/GasaGen/gencpp/Readme_Docs.md

@@ -26,7 +26,7 @@ This means that the typename entry for the parameter AST would be either:
 ***Concepts and Constraints are not supported***  
 Its a [todo](https://github.com/Ed94/gencpp/issues/21)
 
-### Feature Macros:
+### Feature Macros
 
 * `GEN_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing.
   * This can be generated using base.cpp.
@@ -36,10 +36,41 @@ Its a [todo](https://github.com/Ed94/gencpp/issues/21)
 * `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
 * `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
 * `GEN_DONT_ALLOW_INVALID_CODE` (Not implemented yet) : Will fail when an invalid code is constructed, parsed, or serialized.
-* `GEN_C_LIKE_PP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
+* `GEN_C_LIKE_CPP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
 
 ### The Data & Interface
 
+The library's persistent state is managed tracked by a context struct: `global Context* _ctx;` defined within [static_data.cpp](../base/components/static_data.cpp)
+
+https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/interface.hpp#L39-L97
+
+The interface for the context:
+
+* `init`: Initializtion
+* `deinit`: De-initialization.
+* `reset`: Clears the allocations, but doesn't free the memoery, then calls `init()` on `_ctx` again.
+* `get_context`: Retreive the currently tracked context.
+* `set_context`: Swap out the current tracked context.
+
+
+#### Allocato usage
+
+* `Allocator_DyanmicContainers`: Growing arrays, hash tables. (Unbounded sized containers)
+* `Allocator_Pool`: Fixed-sized object allocations (ASTs, etc)
+* `Allocator_StrCache`: StrCached allocations
+* `Allocator_Temp`: Temporary alloations mostly intended for StrBuilder usage. Manually cleared by the user by their own discretion.
+
+The allocator definitions used are exposed to the user incase they want to dictate memory usage
+
+* Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
+* Most of the work is just defining the allocation procedure:
+
+```cpp
+    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
+```
+
+For any allocator above that the user does not define before `init`, a fallback allocator will be assigned that utiizes the `fallback_allocator_proc` wtihin [interface.cpp](../base/components/interface.cpp).
+
 As mentioned in root readme, the user is provided Code objects by calling the constructor's functions to generate them or find existing matches.
 
 The AST is managed by the library and provided to the user via its interface.  
@@ -47,14 +78,14 @@ However, the user may specifiy memory configuration.
 
 [Data layout of AST struct (Subject to heavily change with upcoming todos)](../base/components/ast.hpp#L396-461)  
 
-https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
+https://github.com/Ed94/gencpp/blob/967a044637f1615c709cb723dc61118fcc08dcdb/base/components/ast.hpp#L369-L435
 
 *`StringCahced` is a typedef for `Str` (a string slice), to denote it is an interned string*  
 *`CodeType` is enum taggin the type of code. Has an underlying type of `u32`*  
 *`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*  
-*`StrBuilder` is the dynamically allocated string type for the library*  
+*`StrBuilder` is the dynamically allocating string builder type for the library*  
 
-AST widths are setup to be AST_POD_Size.  
+AST widths are setup to be AST_POD_Size (128 bytes by default).
 The width dictates how much the static array can hold before it must give way to using an allocated array:
 
 ```cpp
@@ -73,41 +104,16 @@ int AST_ArrSpecs_Cap =
 )
 / sizeof(Specifier) - 1;
 ```
-
-*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
-
 Data Notes:
 
-* The allocator definitions used are exposed to the user incase they want to dictate memory usage
-  * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_strbuilder_allocator`, `cache_str`, `make_code`.
-  * Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
-  * Most of the work is just defining the allocation procedure:
-
-```cpp
-    void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
-```
-
 * ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
 * Code types have member symbols but their data layout is enforced to be POD types.
 * This library treats memory failures as fatal.
 * Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
-  * `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
 * Strings used for serialization and file buffers are not contained by those used for cached strings.
-  * They are currently using `FallbackAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
+  * `_ctx->Allocator_Temp` is used.
-  * Memory within the buckets is not reused, so its inherently wasteful.
-  * I will be augmenting the default allocator with virtual memory & a slab allocator in the [future](https://github.com/Ed94/gencpp/issues/12)
-* Intrusive linked lists used children nodes on bodies, and parameters.
 * Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
-* Allocations can be tuned by defining the folloiwng macros (will be moved to runtime configuration in the future):
+  * Any modifcations to an existing AST should be to just construct another with the modifications done on-demand while traversing the AST (non-destructive).
-  * `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
-  * `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
-  * `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
-  * `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
-  * `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
-  * `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
-  * `TokenMap_FixedArena` : token_fmt_va uses local_persit memory of this arena type for the hashtable.
-  * `GEN_LEX_ALLOCATOR_SIZE`
-  * `GEN_BUILDER_STR_BUFFER_RESERVE`
 
 The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
 
@@ -117,6 +123,7 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeClass
 * CodeConstructor
 * CodeDefine
+* CodeDefineParams
 * CodeDestructor
 * CodeEnum
 * CodeExec
@@ -127,7 +134,7 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeModule
 * CodeNS
 * CodeOperator
-* CodeOpCast
+* CodeOpCast : User defined member operator conversion
 * CodeParams : Has support for `for : range` iterating across parameters.
 * CodePreprocessCond
 * CodePragma
@@ -140,11 +147,15 @@ The following CodeTypes are used which the user may optionally use strong typing
 * CodeUsing
 * CodeVar
 
-Each Code boy has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
+Each `struct Code<Name>` has an associated "filtered AST" with the naming convention: `AST_<CodeName>`
 Unrelated fields of the AST for that node type are omitted and only necessary padding members are defined otherwise.
-Retrieving a raw version of the ast can be done using the `raw()` function defined in each AST.
 
-## There are three sets of interfaces for Code AST generation the library provides
+For the interface related to these code types see:
+
+* [ast.hpp](../base/components/ast.hpp): Under the region pragma `Code C-Interface`
+* [code_types.hpp](../base/components/code_types.hpp): Under the region pragma `Code C-Interface`. Additional functionlity for c++ will be within the struct definitions or at the end of the file.
+
+## There are three categories of interfaces for Code AST generation & reflection
 
 * Upfront
 * Parsing
@@ -164,6 +175,7 @@ Interface :``
 * def_class
 * def_constructor
 * def_define
+* def_define_params
 * def_destructor
 * def_enum
 * def_execution
@@ -218,6 +230,27 @@ Code <name>
 
 ```
 
+All optional parmeters are defined within `struct Opts_def_<functon name>`. This was done to setup a [macro trick](https://x.com/vkrajacic/status/1749816169736073295) for default optional parameers in the C library:
+
+```cpp
+struct gen_Opts_def_struct
+{
+	gen_CodeBody       body;
+	gen_CodeTypename   parent;
+	gen_AccessSpec     parent_access;
+	gen_CodeAttributes attributes;
+	gen_CodeTypename*  interfaces;
+	gen_s32            num_interfaces;
+	gen_ModuleFlag     mflags;
+};
+typedef struct gen_Opts_def_struct gen_Opts_def_struct;
+
+GEN_API gen_CodeClass gen_def__struct( gen_Str name, gen_Opts_def_struct opts GEN_PARAM_DEFAULT );
+#define gen_def_struct( name, ... ) gen_def__struct( name, ( gen_Opts_def_struct ) { __VA_ARGS__ } )
+```
+
+In the C++ library, the `def_<funtion name>` is not wrapped in a macro.
+
 When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
 
 ```cpp
@@ -228,7 +261,7 @@ def_global_body( 3, ht_entry, array_ht_entry, hashtable );
 ```
 
 If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.
-When the members have been populated use: `AST::validate_body` to verify that the members are valid entires for that type.
+When the members have been populated use: `code_validate_body` to verify that the members are valid entires for that type.
 
 ### Parse construction
 
@@ -238,12 +271,12 @@ Interface :
 
 * parse_class
 * parse_constructor
+* parse_define
 * parse_destructor
 * parse_enum
 * parse_export_body
 * parse_extern_link
 * parse_friend
-  * Purposefully are only support forward declares with this constructor.
 * parse_function
 * parse_global_body
 * parse_namespace
@@ -322,6 +355,7 @@ Code        <name>       = parse_<function name>( gen_code_str );
 
 The following are provided predefined by the library as they are commonly used:
 
+* `enum_underlying_macro`
 * `access_public`
 * `access_protected`
 * `access_private`

Project/Source/GasaEditor/GasaGen/gencpp/gen.dep.hpp

@@ -271,10 +271,10 @@ GEN_NS_BEGIN
 
 #ifndef do_once
 #define do_once()                                           \
-	static int __do_once_counter_##src_line_str = 0; \
+	local_persist int __do_once_counter_##src_line_str = 0; \
 	for ( ; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 )
 #define do_once_defer( expression )                         \
-	static int __do_once_counter_##src_line_str = 0; \
+	local_persist int __do_once_counter_##src_line_str = 0; \
 	for ( ; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1, ( expression ) )
 #define do_once_start                    \
 	do                                   \
@@ -852,10 +852,10 @@ template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem
 #if GEN_BUILD_DEBUG
 #	if defined( GEN_COMPILER_MSVC )
 #		if _MSC_VER < 1300
-#pragma message("GEN_BUILD_DEBUG: __asm int 3")
+// #pragma message("GEN_BUILD_DEBUG: __asm int 3")
 #			define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
 #		else
-#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
+// #pragma message("GEN_BUILD_DEBUG: __debugbreak()")
 #			define GEN_DEBUG_TRAP() __debugbreak()
 #		endif
 #	elif defined( GEN_COMPILER_TINYC )
@@ -864,7 +864,7 @@ template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem
 #		define GEN_DEBUG_TRAP() __builtin_trap()
 #	endif
 #else
-#pragma message("GEN_BUILD_DEBUG: omitted")
+// #pragma message("GEN_BUILD_DEBUG: omitted")
 #	define GEN_DEBUG_TRAP()
 #endif
 
@@ -2184,8 +2184,7 @@ bool array_fill(Array<Type> array, usize begin, usize end, Type value)
 	if (begin < 0 || end > header->Num)
 		return false;
 
-	for (ssize idx = ssize(begin); idx < ssize(end); idx++)
+	for (ssize idx = ssize(begin); idx < ssize(end); idx++) {
-	{
 		array[idx] = value;
 	}
 

Project/Source/GasaEditor/GasaGen/gencpp/gen.hpp

@@ -42,7 +42,7 @@
 	|  \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l                       |
 	|  Unreal Engine         | |   | |                      __} |                                  |
 	|                        l_l   l_l                     {___/                                   |
-	! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
+	! ----------------------------------------------------------------------- VERSION: v0.23-Alpha |
 	! ============================================================================================ |
 	! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION                 |
 	! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
@@ -605,7 +605,18 @@ inline Str spec_to_str( Specifier type )
 
 inline bool spec_is_trailing( Specifier specifier )
 {
-	return specifier > Spec_Virtual;
+	switch ( specifier )
+	{
+		case Spec_Const :
+		case Spec_Final :
+		case Spec_NoExceptions :
+		case Spec_Override :
+		case Spec_Pure :
+		case Spec_Volatile :
+			return true;
+		default :
+			return false;
+	}
 }
 
 inline Specifier str_to_specifier( Str str )
@@ -663,8 +674,8 @@ enum TokType : u32
 	Tok_BraceCurly_Close,
 	Tok_BraceSquare_Open,
 	Tok_BraceSquare_Close,
-	Tok_Capture_Start,
+	Tok_Paren_Open,
-	Tok_Capture_End,
+	Tok_Paren_Close,
 	Tok_Comment,
 	Tok_Comment_End,
 	Tok_Comment_Start,
@@ -923,11 +934,6 @@ AccessSpec tok_to_access_specifier(Token tok) {
 	return scast(AccessSpec, tok.Type);
 }
 
-FORCEINLINE
-Str tok_to_str(Token tok) {
-	return tok.Text;
-}
-
 FORCEINLINE
 bool tok_is_valid( Token tok ) {
 	return tok.Text.Ptr && tok.Text.Len && tok.Type != Tok_Invalid;
@@ -1012,8 +1018,6 @@ enum MacroType : u16
 	MT_Expression,     // A macro is assumed to be a expression if not resolved.
 	MT_Statement,      
 	MT_Typename,
-	MT_Attribute,      // More of a note to the parser than anythign else (attributes should be defined in the user attribues def).
-	MT_Specifier,      // More of a note to the parser than anythign else (specifiers should be defined in the user attribues def).
 	MT_Block_Start,    // Not Supported yet
 	MT_Block_End,      // Not Supported yet
 	MT_Case_Statement, // Not Supported yet
@@ -1040,8 +1044,6 @@ Str macrotype_to_str( MacroType type )
 		{ "Statement",        sizeof("Statement")        - 1 },
 		{ "Expression",       sizeof("Expression")       - 1 },
 		{ "Typename",         sizeof("Typename")         - 1 },
-		{ "Attribute(Macro)", sizeof("Attribute(Macro)") - 1 },
-		{ "Specifier(Macro)", sizeof("Specifier(Macro)") - 1 },
 		{ "Block_Start",      sizeof("Block_Start")      - 1 },
 		{ "Block_End",        sizeof("Block_End")        - 1 },
 		{ "Case_Statement",   sizeof("Case_Statement")   - 1 },
@@ -1144,7 +1146,7 @@ struct AST_Pragma;
 struct AST_PreprocessCond;
 struct AST_Specifiers;
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct AST_Expr;
 struct AST_Expr_Assign;
 struct AST_Expr_Alignof;
@@ -1241,7 +1243,7 @@ struct CodePragma;
 struct CodeSpecifiers;
 #endif
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 
 #if GEN_COMPILER_C
 typedef AST_Expr*                CodeExpr;
@@ -1916,7 +1918,7 @@ struct CodeExec
 	AST_Exec *ast;
 };
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct CodeExpr
 {
 #if ! GEN_C_LIKE_CPP
@@ -2243,7 +2245,7 @@ struct CodePreprocessCond
 	AST_PreprocessCond* ast;
 };
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct CodeStmt
 {
 #if ! GEN_C_LIKE_CPP
@@ -2968,7 +2970,7 @@ 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
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct AST_Expr
 {
 	union {
@@ -3471,7 +3473,7 @@ struct AST_Specifiers
 };
 static_assert( sizeof(AST_Specifiers) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");
 
-#if GEN_EXECUTION_EXPRESSION_SUPPORT
+#ifdef GEN_EXECUTION_EXPRESSION_SUPPORT
 struct AST_Stmt
 {
 	union {
@@ -3982,6 +3984,9 @@ struct Context
 
 	// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
 	ParseContext parser;
+
+	// TODO(Ed): Formatting - This will eventually be in a separate struct when in the process of serialization of the builder.
+	s32 temp_serialize_indent;
 };
 
 // Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that
@@ -4010,7 +4015,11 @@ GEN_API void register_macro( Macro macro );
 
 // Ease of use batch registration
 GEN_API void register_macros( s32 num, ... );
-GEN_API void register_macros( s32 num,  Macro* macros );
+GEN_API void register_macros_arr( s32 num, Macro* macros );
+
+#if GEN_COMPILER_CPP
+FORCEINLINE void register_macros( s32 num, Macro* macros ) { return register_macros_arr(num, macros); }
+#endif
 
 // Used internally to retrive or make string allocations.
 // Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
@@ -4166,36 +4175,49 @@ GEN_API CodeBody def_body( CodeType type );
 /// or provide as an array of Code objects.
 
 GEN_API CodeBody         def_class_body           ( s32 num, ... );
-GEN_API CodeBody         def_class_body      ( s32 num, Code* codes );
+GEN_API CodeBody         def_class_body_arr       ( s32 num, Code* codes );
 GEN_API CodeDefineParams def_define_params        ( s32 num, ... );
-GEN_API CodeDefineParams def_define_params   ( s32 num, CodeDefineParams* codes );
+GEN_API CodeDefineParams def_define_params_arr    ( s32 num, CodeDefineParams* codes );
 GEN_API CodeBody         def_enum_body            ( s32 num, ... );
-GEN_API CodeBody         def_enum_body       ( s32 num, Code* codes );
+GEN_API CodeBody         def_enum_body_arr        ( s32 num, Code* codes );
 GEN_API CodeBody         def_export_body          ( s32 num, ... );
-GEN_API CodeBody         def_export_body     ( s32 num, Code* codes);
+GEN_API CodeBody         def_export_body_arr      ( s32 num, Code* codes);
 GEN_API CodeBody         def_extern_link_body     ( s32 num, ... );
-GEN_API CodeBody         def_extern_link_body( s32 num, Code* codes );
+GEN_API CodeBody         def_extern_link_body_arr ( s32 num, Code* codes );
 GEN_API CodeBody         def_function_body        ( s32 num, ... );
-GEN_API CodeBody         def_function_body   ( s32 num, Code* codes );
+GEN_API CodeBody         def_function_body_arr    ( s32 num, Code* codes );
 GEN_API CodeBody         def_global_body          ( s32 num, ... );
-GEN_API CodeBody         def_global_body     ( s32 num, Code* codes );
+GEN_API CodeBody         def_global_body_arr      ( s32 num, Code* codes );
 GEN_API CodeBody         def_namespace_body       ( s32 num, ... );
-GEN_API CodeBody         def_namespace_body  ( s32 num, Code* codes );
+GEN_API CodeBody         def_namespace_body_arr   ( s32 num, Code* codes );
 GEN_API CodeParams       def_params               ( s32 num, ... );
-GEN_API CodeParams       def_params          ( s32 num, CodeParams* params );
+GEN_API CodeParams       def_params_arr           ( s32 num, CodeParams* params );
 GEN_API CodeSpecifiers   def_specifiers           ( s32 num, ... );
-GEN_API CodeSpecifiers   def_specifiers      ( s32 num, Specifier* specs );
+GEN_API CodeSpecifiers   def_specifiers_arr       ( s32 num, Specifier* specs );
 GEN_API CodeBody         def_struct_body          ( s32 num, ... );
-GEN_API CodeBody         def_struct_body     ( s32 num, Code* codes );
+GEN_API CodeBody         def_struct_body_arr      ( s32 num, Code* codes );
 GEN_API CodeBody         def_union_body           ( s32 num, ... );
-GEN_API CodeBody         def_union_body      ( s32 num, Code* codes );
+GEN_API CodeBody         def_union_body_arr       ( s32 num, Code* codes );
+
+#if GEN_COMPILER_CPP
+FORCEINLINE CodeBody         def_class_body      ( s32 num, Code* codes )             { return def_class_body_arr(num, codes); }
+FORCEINLINE CodeDefineParams def_define_params   ( s32 num, CodeDefineParams* codes ) { return def_define_params_arr(num, codes); }
+FORCEINLINE CodeBody         def_enum_body       ( s32 num, Code* codes )             { return def_enum_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_export_body     ( s32 num, Code* codes)              { return def_export_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_extern_link_body( s32 num, Code* codes )             { return def_extern_link_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_function_body   ( s32 num, Code* codes )             { return def_function_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_global_body     ( s32 num, Code* codes )             { return def_global_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_namespace_body  ( s32 num, Code* codes )             { return def_namespace_body_arr(num, codes); }
+FORCEINLINE CodeParams       def_params          ( s32 num, CodeParams* params )      { return def_params_arr(num, params); }
+FORCEINLINE CodeSpecifiers   def_specifiers      ( s32 num, Specifier* specs )        { return def_specifiers_arr(num, specs); }
+FORCEINLINE CodeBody         def_struct_body     ( s32 num, Code* codes )             { return def_struct_body_arr(num, codes); }
+FORCEINLINE CodeBody         def_union_body      ( s32 num, Code* codes )             { return def_union_body_arr(num, codes); }
+#endif
 
 #pragma endregion Upfront
 
 #pragma region Parsing
 
-// TODO(Ed) : Implmeent the new parser API design.
-
 #if 0
 struct StackNode
 {