gencpp/docs/AST_Types.md

# AST Types Documentation

While the Readme for docs covers the data layout per AST, this will focus on the AST types avaialble, and their nuances.

## Body

These are containers representing a scope body of a definition that can be of the following `ECode` type:

* Class_Body
* Enum_Body
* Export_Body
* Extern_Linkage_Body
* Function_Body
* Global_Body
* Namespace_Body
* Struct_Body
* Union_Body

Fields:

```cpp
Code           Front;
Code           Back;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
s32            NumEntries;
```

The `Front` member represents the start of the link list and `Back` the end.
NumEntries is the number of entries in the body.

Parent should have a compatible ECode type for the type of defintion used.

Serialization:

Will output only the entries, the braces are handled by the parent.

```cpp
<Front>...
<Back>
```

## Attributes

Represent standard or vendor specific C/C++ attributes.

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
<Content>
```

While the parser supports the `__declspec` and `__attribute__` syntax, the upfront constructor ( def_attributes ) must have the user specify the entire attribute, including the `[[]]`, `__declspec` or `__attribute__` parts.

## Comment

Stores a comment.

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
<Content>
```

The parser will perserve comments found if residing with a body or in accepted inline-to-definition locations.
Otherwise they will be skipped by the TokArray::__eat and TokArray::current( skip foramtting enabled ) functions.

The upfront constructor: `def_comment` expects to recieve a comment without the `//` or `/* */` parts. It will add them during construction.

## Class & Struct

Fields:

```cpp
CodeComment    InlineCmt;  // Only supported by forward declarations
CodeAttributes Attributes;
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;
ModuleFlag     ModuleFlags;
AccessSpec     ParentAccess;
```

Serialization:

```cpp
// Class_Fwd
<ModuleFlags> <class/struct> <Name>; <InlineCmt>

// Class
<ModuleFlags> <class/struct> <Attributes> <Name> : <ParentAccess> <ParentType>, public <ParentType->Next>, ... <InlineCmt>
{
    <Body>
};
```

You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest must be done through interfaces.

## Constructor

Fields:

```cpp
CodeComment    InlineCmt;  // Only supported by forward declarations
Code           InitializerList;
CodeParam      Params;
Code           Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
// Constructor_Fwd
<Specs> <Parent->Name>( <Params> ); <InlineCmt>

// Constructor
<Specs> <Parent->Name>( <Params> ) <InlineCmt>
    : <InitializerList>
{
    <Body>
}

// Constructor Source Implementation
<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
{
    <Body>
}
```

## Define

Represents a preprocessor define

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
#define <Name> <Content>
```

## Destructor

Fields:

```cpp
CodeComment    InlineCmt;
CodeSpecifiers Specs;
Code           Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
// Destructor_Fwd
<Specs> ~<Parent->Name>( <Params> ) <Specs>; <InlineCmt>

// Destructor
<Specs> ~<Parent->Name>( <Params> ) <Specs>
{
    <Body>
}

// Destructor Source Implementation
<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>
{
    <Body>
}
```

## Enum

Fields:

```cpp
CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeType       UnderlyingType;
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
// Enum_Fwd
<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>

// Enum
<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>
{
    <Body>
};
```

## Execution

Just represents an execution body. Equivalent to an untyped body.
Will be obsolute when function body parsing is implemented.

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
<Content>
```

## External Linkage

Fields:

```cpp
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
extern "<Name>"
{
    <Body>
}
```

## Include

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
Code           Parent;
parser::Token* Tok;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
#include <Content>
```

## Friend

This library (until its necessary become some third-party library to do otherwise) does not support friend declarations with in-statment function definitions.

Fields:

```cpp
CodeComment    InlineCmt;
Code           Declaration;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
friend <Declaration>; <InlineCmt>
```

## Function

Fields:

```cpp
CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ReturnType;
CodeParam      Params;
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
// Function_Fwd
<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>; <InlineCmt>

// Function
<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>
{
    <Body>
}
```

## Module

Fields:

```cpp
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
<ModuleFlags> module <Name>;
```

## Namespace

Fields:

```cpp
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
<ModuleFlags> namespace <Name>
{
    <Body>
}
```

## Operator Overload

Fields:

```cpp
CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ReturnType;
CodeParam      Params;
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
OperatorT      Op;
```

Serialization:

```cpp
// Operator_Fwd
<ModuleFlags> <Attributes> <Specs> <ReturnType> operator <Op>( <Params> ) <Specs>; <InlineCmt>

// Operator
<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>operator <Op>( <Params> ) <Specs>
{
    <Body>
}
```

## Operator Cast Overload ( User-Defined Type Conversion )

Fields:

```cpp
CodeComment    InlineCmt;
CodeSpecifiers Specs;
CodeType       ValueType;
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
// Operator_Cast_Fwd
<Specs> operator <ValueType>() <Specs>; <InlineCmt>

// Operator_Cast
<Specs> <Name>operator <ValueType>() <Specs>
{
    <Body>
}
```

## Parameters (AST_Param)

Fields:

```cpp
CodeType       ValueType;
Code           Macro;
Code           Value;
CodeParam      Last;
CodeParam      Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
s32            NumEntries;
```

Serialization:

```cpp
<Macro>, <Next> ... <Last>

<Macro> <ValueType> <Name>, <Next>... <Last>
```

## Pragma

Fields:

```cpp
StringCached   Content;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
```

Serialization:

```cpp
#pragma <Content>
```

## Preprocessor Conditional

Fields:

```cpp
StringCached  Content;
Code          Prev;
Code          Next;
paser::Token* Tok;
Code          Parent;
StringCached  Name;
CodeT         Type;
```

Serialization:

```cpp
#<based off Type> <Content>
```

## Specifiers

Fields:

```cpp
SpecifierT     ArrSpecs[ AST::ArrSpecs_Cap ];
CodeSpecifiers NextSpecs;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
s32            NumEntries;
```

Serialization:

```cpp
<Spec>, ...
```

## Template

Fields:

```cpp
CodeParam      Params;
Code           Declaration;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
<ModuleFlags>
template< <Params> >
<Declaration>
```

## Typename

Typenames represent the type "symbol".

Fields:

```cpp
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeReturnType ReturnType;
CodeParam      Params;
Code           ArrExpr;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
b32            IsParamPack;
```

Serialization:

```cpp
<Attributes> <Name> <Specs> <IsParamPack ?: ...>
```

## Typedef

Behave as usual except function or macro typedefs.  
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;
parse::Token* Tok
Code          Parent;
StringCached  Name;
CodeT         Type;
ModuleFlag    ModuleFlags;
b32           IsFunction;
```

Serialization:

```cpp
// Regular
<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>

// Functions
<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
```

## Union

Fields:

```cpp
CodeAttributes Attributes;
CodeBody       Body;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
<ModuleFlags> union <Attributes> <Name>
{
    <Body>
}
```

## Using

Fields:

```cpp
CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeType       UnderlyingType;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
// Regular
<ModuleFlags> using <Attributes> <Name> = <UnderlyingType>; <InlineCmt>

// Namespace
<ModuleFlags> using namespace <Name>; <InlineCmt>
```

## Variable

[Algo](./Parser_Algo.md:)

Fields:

```cpp
CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ValueType;
Code           BitfieldSize;
Code           Value;
CodeVar        NextVar;
Code           Prev;
Code           Next;
parser::Token* Tok;
Code           Parent;
StringCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;
```

Serialization:

```cpp
// Regular
<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> = <Value>, NextVar ...; <InlineCmt>

// Bitfield
<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
```
WIP : Various changes to project before small hiatus. (Broken) I need to manually review these as the changes have various errors that are difficult to diagnose why. I took a break to do handmade hero and now a bit rusty. 2023-09-25 09:12:11 -07:00			`# AST Types Documentation`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00
			`While the Readme for docs covers the data layout per AST, this will focus on the AST types avaialble, and their nuances.`

			`## Body`

			These are containers representing a scope body of a definition that can be of the following `ECode` type:

			`* Class_Body`
			`* Enum_Body`
			`* Export_Body`
			`* Extern_Linkage_Body`
			`* Function_Body`
			`* Global_Body`
			`* Namespace_Body`
			`* Struct_Body`
			`* Union_Body`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`Code Front;`
			`Code Back;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`s32 NumEntries;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			The `Front` member represents the start of the link list and `Back` the end.
			`NumEntries is the number of entries in the body.`

			`Parent should have a compatible ECode type for the type of defintion used.`

			`Serialization:`

			`Will output only the entries, the braces are handled by the parent.`

			```cpp
			`<Front>...`
			`<Back>`
			```

			`## Attributes`

			`Represent standard or vendor specific C/C++ attributes.`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<Content>`
			```

			While the parser supports the `__declspec` and `__attribute__` syntax, the upfront constructor ( def_attributes ) must have the user specify the entire attribute, including the `[[]]`, `__declspec` or `__attribute__` parts.

			`## Comment`

			`Stores a comment.`

			`Fields:`

			```cpp
Progress on parser documentation 2023-11-21 20:36:56 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<Content>`
			```

			`The parser will perserve comments found if residing with a body or in accepted inline-to-definition locations.`
			`Otherwise they will be skipped by the TokArray::__eat and TokArray::current( skip foramtting enabled ) functions.`

			The upfront constructor: `def_comment` expects to recieve a comment without the `//` or `/* */` parts. It will add them during construction.

			`## Class & Struct`

			`Fields:`

			```cpp
WIP : Various changes to project before small hiatus. (Broken) I need to manually review these as the changes have various errors that are difficult to diagnose why. I took a break to do handmade hero and now a bit rusty. 2023-09-25 09:12:11 -07:00			`CodeComment InlineCmt; // Only supported by forward declarations`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`CodeAttributes Attributes;`
			`CodeType ParentType;`
			`CodeBody Body;`
WIP : Various changes to project before small hiatus. (Broken) I need to manually review these as the changes have various errors that are difficult to diagnose why. I took a break to do handmade hero and now a bit rusty. 2023-09-25 09:12:11 -07:00			`CodeType Prev; // Used to store references to interfaces`
			`CodeType Next; // Used to store references to interfaces`
Progress on parser documentation 2023-11-21 20:36:56 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			`AccessSpec ParentAccess;`
			```

			`Serialization:`

			```cpp
			`// Class_Fwd`
			`<ModuleFlags> <class/struct> <Name>; <InlineCmt>`

			`// Class`
WIP : Various changes to project before small hiatus. (Broken) I need to manually review these as the changes have various errors that are difficult to diagnose why. I took a break to do handmade hero and now a bit rusty. 2023-09-25 09:12:11 -07:00			`<ModuleFlags> <class/struct> <Attributes> <Name> : <ParentAccess> <ParentType>, public <ParentType->Next>, ... <InlineCmt>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`{`
			`<Body>`
			`};`
			```

			`You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest must be done through interfaces.`

			`## Constructor`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeComment InlineCmt; // Only supported by forward declarations`
			`Code InitializerList;`
			`CodeParam Params;`
			`Code Body;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
Updated docs 2024-04-17 15:29:30 -07:00			`StringCached Name;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`// Constructor_Fwd`
			`<Specs> <Parent->Name>( <Params> ); <InlineCmt>`

			`// Constructor`
WIP : Various changes to project before small hiatus. (Broken) I need to manually review these as the changes have various errors that are difficult to diagnose why. I took a break to do handmade hero and now a bit rusty. 2023-09-25 09:12:11 -07:00			`<Specs> <Parent->Name>( <Params> ) <InlineCmt>`
			`: <InitializerList>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`{`
			`<Body>`
			`}`
Updated docs 2024-04-17 15:29:30 -07:00
			`// Constructor Source Implementation`
			`<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>`
			`{`
			`<Body>`
			`}`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`## Define`

			`Represents a preprocessor define`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`#define <Name> <Content>`
			```

			`## Destructor`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeSpecifiers Specs;`
			`Code Body;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
Updated docs 2024-04-17 15:29:30 -07:00			`StringCached Name;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`CodeT Type;`
			```

			`Serialization:`

			```cpp
			`// Destructor_Fwd`
			`<Specs> ~<Parent->Name>( <Params> ) <Specs>; <InlineCmt>`

			`// Destructor`
			`<Specs> ~<Parent->Name>( <Params> ) <Specs>`
			`{`
			`<Body>`
			`}`
Updated docs 2024-04-17 15:29:30 -07:00
			`// Destructor Source Implementation`
			`<Specs> <Parent>::~<Parent->Name>( <Params> ) <Specs>`
			`{`
			`<Body>`
			`}`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`## Enum`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeAttributes Attributes;`
			`CodeType UnderlyingType;`
			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			```

			`Serialization:`

			```cpp
			`// Enum_Fwd`
			`<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>`

			`// Enum`
			`<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>`
			`{`
			`<Body>`
			`};`
			```

			`## Execution`

			`Just represents an execution body. Equivalent to an untyped body.`
			`Will be obsolute when function body parsing is implemented.`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<Content>`
			```

			`## External Linkage`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`extern "<Name>"`
			`{`
			`<Body>`
			`}`
			```

			`## Include`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`Code Parent;`
			`parser::Token* Tok;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`#include <Content>`
			```

			`## Friend`

			`This library (until its necessary become some third-party library to do otherwise) does not support friend declarations with in-statment function definitions.`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeComment InlineCmt;`
			`Code Declaration;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`friend <Declaration>; <InlineCmt>`
			```

			`## Function`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeAttributes Attributes;`
			`CodeSpecifiers Specs;`
			`CodeType ReturnType;`
			`CodeParam Params;`
			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
			`Code Parent;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			```

			`Serialization:`

			```cpp
			`// Function_Fwd`
			`<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>; <InlineCmt>`

			`// Function`
			`<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>( <Params> ) <Specs>`
			`{`
			`<Body>`
			`}`
			```

			`## Module`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<ModuleFlags> module <Name>;`
			```

			`## Namespace`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<ModuleFlags> namespace <Name>`
			`{`
			`<Body>`
			`}`
			```

			`## Operator Overload`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeAttributes Attributes;`
			`CodeSpecifiers Specs;`
			`CodeType ReturnType;`
			`CodeParam Params;`
			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			`OperatorT Op;`
			```

			`Serialization:`

			```cpp
			`// Operator_Fwd`
			`<ModuleFlags> <Attributes> <Specs> <ReturnType> operator <Op>( <Params> ) <Specs>; <InlineCmt>`

			`// Operator`
			`<ModuleFlags> <Attributes> <Specs> <ReturnType> <Name>operator <Op>( <Params> ) <Specs>`
			`{`
			`<Body>`
			`}`
			```

			`## Operator Cast Overload ( User-Defined Type Conversion )`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeSpecifiers Specs;`
			`CodeType ValueType;`
			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			```

			`Serialization:`

			```cpp
			`// Operator_Cast_Fwd`
			`<Specs> operator <ValueType>() <Specs>; <InlineCmt>`

			`// Operator_Cast`
			`<Specs> <Name>operator <ValueType>() <Specs>`
			`{`
			`<Body>`
			`}`
			```

Updated docs 2024-04-17 15:29:30 -07:00			`## Parameters (AST_Param)`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00
			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeType ValueType;`
Updated docs 2024-04-17 15:29:30 -07:00			`Code Macro;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`Code Value;`
			`CodeParam Last;`
			`CodeParam Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`s32 NumEntries;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
Updated docs 2024-04-17 15:29:30 -07:00			`<Macro>, <Next> ... <Last>`

			`<Macro> <ValueType> <Name>, <Next>... <Last>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`## Pragma`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`#pragma <Content>`
			```

			`## Preprocessor Conditional`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`StringCached Content;`
			`Code Prev;`
			`Code Next;`
			`paser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`#<based off Type> <Content>`
			```

			`## Specifiers`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`SpecifierT ArrSpecs[ AST::ArrSpecs_Cap ];`
			`CodeSpecifiers NextSpecs;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`s32 NumEntries;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<Spec>, ...`
			```

			`## Template`

			`Fields:`

			```cpp
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`CodeParam Params;`
			`Code Declaration;`
			`Code Prev;`
			`Code Next;`
			`parser::Token* Tok;`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`<ModuleFlags>`
			`template< <Params> >`
			`<Declaration>`
			```

			`## Typename`

			`Typenames represent the type "symbol".`

			`Fields:`

			```cpp
			`CodeAttributes Attributes;`
			`CodeSpecifiers Specs;`
Reorganization of parser, refactor of parse_type( bool* ) and progression of parser docs Wanted to make parser implementation easier to sift through, so I emphasized alphabetical order more. Since I couldn't just strip whitespace from typenames I decided to make the parse_type more aware of the typename's components if it was a function signature. This ofc lead to the dark & damp hell that is parsing typenames. Also made initial implementation to support parsing decltype within a typename signature.. The test failure for the singleheader is still a thing, these changes have not addressed that. 2023-09-04 22:44:04 -07:00			`CodeReturnType ReturnType;`
			`CodeParam Params;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code ArrExpr;`
			`Code Prev;`
			`Code Next;`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
doc update for parampack typename 2023-08-23 10:17:30 -07:00			`b32 IsParamPack;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
doc update for parampack typename 2023-08-23 10:17:30 -07:00			`<Attributes> <Name> <Specs> <IsParamPack ?: ...>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`## Typedef`

			`Behave as usual except function or macro typedefs.`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`Those (macros) don't use the underlying type field as everything was serialized under the Name field.`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00
			`Fields:`

			```cpp
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`CodeComment InlineCmt;`
			`Code UnderlyingType;`
			`Code Prev;`
			`Code Next;`
			`parse::Token* Tok`
			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			`b32 IsFunction;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`Serialization:`

			```cpp
			`// Regular`
			`<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>`

			`// Functions`
Updated AST_Types.md doc 2023-11-22 12:03:24 -08:00			`<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>`
			`<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```

			`## Union`

			`Fields:`

			```cpp
			`CodeAttributes Attributes;`
			`CodeBody Body;`
			`Code Prev;`
			`Code Next;`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			```

			`Serialization:`

			```cpp
			`<ModuleFlags> union <Attributes> <Name>`
			`{`
			`<Body>`
			`}`
			```

			`## Using`

			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeAttributes Attributes;`
			`CodeType UnderlyingType;`
			`Code Prev;`
			`Code Next;`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			```

			`Serialization:`

			```cpp
			`// Regular`
			`<ModuleFlags> using <Attributes> <Name> = <UnderlyingType>; <InlineCmt>`

			`// Namespace`
			`<ModuleFlags> using namespace <Name>; <InlineCmt>`
			```

			`## Variable`

WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`[Algo](./Parser_Algo.md:)`

Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Fields:`

			```cpp
			`CodeComment InlineCmt;`
			`CodeAttributes Attributes;`
			`CodeSpecifiers Specs;`
			`CodeType ValueType;`
			`Code BitfieldSize;`
			`Code Value;`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`CodeVar NextVar;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Prev;`
			`Code Next;`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`parser::Token* Tok;`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			`Code Parent;`
			`StringCached Name;`
			`CodeT Type;`
			`ModuleFlag ModuleFlags;`
			```

			`Serialization:`

			```cpp
			`// Regular`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> = <Value>, NextVar ...; <InlineCmt>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00
			`// Bitfield`
WIP: Improvements to parser, updated docs Trying to get support for typename keyword soon 2023-11-21 18:27:33 -08:00			`<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>`
Cleanup and doc updates 2023-08-22 23:17:47 -07:00			```