2023-09-25 09:12:11 -07:00
# AST Types Documentation
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
2023-11-22 12:03:24 -08:00
Code Front;
Code Back;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
s32 NumEntries;
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
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
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
2023-11-21 20:36:56 -08:00
StringCached Content;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
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
2023-09-25 09:12:11 -07:00
CodeComment InlineCmt; // Only supported by forward declarations
2023-08-22 23:17:47 -07:00
CodeAttributes Attributes;
CodeType ParentType;
CodeBody Body;
2023-09-25 09:12:11 -07:00
CodeType Prev; // Used to store references to interfaces
CodeType Next; // Used to store references to interfaces
2023-11-21 20:36:56 -08:00
parser::Token* Tok;
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
2023-09-25 09:12:11 -07:00
< ModuleFlags > < class / struct > < Attributes > < Name > : < ParentAccess > < ParentType > , public < ParentType- > Next>, ... < InlineCmt >
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
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;
CodeT Type;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
// Constructor_Fwd
< Specs > < Parent- > Name>( < Params > ); < InlineCmt >
// Constructor
2023-09-25 09:12:11 -07:00
< Specs > < Parent- > Name>( < Params > ) < InlineCmt >
: < InitializerList >
2023-08-22 23:17:47 -07:00
{
< Body >
}
```
## Define
Represents a preprocessor define
Fields:
```cpp
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
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;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
2023-08-22 23:17:47 -07:00
Code Parent;
CodeT Type;
```
Serialization:
```cpp
// Destructor_Fwd
< Specs > ~< Parent- > Name>( < Params > ) < Specs > ; < InlineCmt >
// Destructor
< Specs > ~< Parent- > Name>( < Params > ) < Specs >
{
< Body >
}
```
## Enum
Fields:
```cpp
CodeComment InlineCmt;
CodeAttributes Attributes;
CodeType UnderlyingType;
CodeBody Body;
Code Prev;
Code Next;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
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
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
< Content >
```
## External Linkage
Fields:
```cpp
2023-11-22 12:03:24 -08:00
CodeBody Body;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
extern "< Name > "
{
< Body >
}
```
## Include
Fields:
```cpp
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
Code Parent;
parser::Token* Tok;
StringCached Name;
CodeT Type;
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
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;
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;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
Code Parent;
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
2023-11-22 12:03:24 -08:00
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
< ModuleFlags > module < Name > ;
```
## Namespace
Fields:
```cpp
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;
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;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
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;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
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 >
}
```
## Parameters
Fields:
```cpp
2023-11-22 12:03:24 -08:00
CodeType ValueType;
Code Value;
CodeParam Last;
CodeParam Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
s32 NumEntries;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
< ValueType > < Name > , < Next > ... < Last >
```
## Pragma
Fields:
```cpp
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
#pragma <Content>
```
## Preprocessor Conditional
Fields:
```cpp
2023-11-22 12:03:24 -08:00
StringCached Content;
Code Prev;
Code Next;
paser::Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
#<based off Type> <Content>
```
## Specifiers
Fields:
```cpp
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;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
< Spec > , ...
```
## Template
Fields:
```cpp
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;
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;
2023-09-04 22:44:04 -07:00
CodeReturnType ReturnType;
CodeParam Params;
2023-08-22 23:17:47 -07:00
Code ArrExpr;
Code Prev;
Code Next;
2023-11-22 12:03:24 -08:00
parser::Token* Tok;
2023-08-22 23:17:47 -07:00
Code Parent;
StringCached Name;
CodeT Type;
2023-08-23 10:17:30 -07:00
b32 IsParamPack;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
2023-08-23 10:17:30 -07:00
< Attributes > < Name > < Specs > < IsParamPack ? : . . . >
2023-08-22 23:17:47 -07:00
```
## Typedef
Behave as usual except function or macro typedefs.
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.
2023-08-22 23:17:47 -07:00
Fields:
```cpp
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;
2023-08-22 23:17:47 -07:00
```
Serialization:
```cpp
// Regular
< ModuleFlags > typedef < UnderlyingType > < Name > ; < InlineCmt >
// Functions
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 >
2023-08-22 23:17:47 -07:00
```
## Union
Fields:
```cpp
CodeAttributes Attributes;
CodeBody Body;
Code Prev;
Code Next;
2023-11-21 18:27:33 -08:00
parser::Token* Tok;
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;
2023-11-21 18:27:33 -08:00
parser::Token* Tok;
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
2023-11-21 18:27:33 -08:00
[Algo ](./Parser_Algo.md: )
2023-08-22 23:17:47 -07:00
Fields:
```cpp
CodeComment InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType ValueType;
Code BitfieldSize;
Code Value;
2023-11-21 18:27:33 -08:00
CodeVar NextVar;
2023-08-22 23:17:47 -07:00
Code Prev;
Code Next;
2023-11-21 18:27:33 -08:00
parser::Token* Tok;
2023-08-22 23:17:47 -07:00
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
Serialization:
```cpp
// Regular
2023-11-21 18:27:33 -08:00
< ModuleFlags > < Attributes > < Specs > < ValueType > < Name > = < Value > , NextVar ...; < InlineCmt >
2023-08-22 23:17:47 -07:00
// Bitfield
2023-11-21 18:27:33 -08:00
< ModuleFlags > < Attributes > < Specs > < ValueType > < Name > : < BitfieldSize > = < Value > , NextVar ...; < InlineCmt >
2023-08-22 23:17:47 -07:00
```
