ed/gencpp

Fork 0

mirror of https://github.com/Ed94/gencpp.git synced 2024-12-22 07:44:45 -08:00

Ed_ 76ac3a0f93 Introduced the general context struct for gencpp

2024-12-13 19:16:52 -05:00

13 KiB

Raw Blame History

Top

<- docs - General

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 CodeType type:

Class_Body
Enum_Body
Export_Body
Extern_Linkage_Body
Function_Body
Global_Body
Namespace_Body
Struct_Body
Union_Body

Fields:

StrCached   Name;
Code           Front;
Code           Back;
Token*         Tok;
Code           Parent;
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 CodeType type for the type of defintion used.

Serialization:

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

<Front>
...
<Back>

Attributes

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

Fields:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

<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:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

<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:

CodeComment    InlineCmt;  // Only supported by forward declarations
CodeAttributes Attributes;
CodeType       ParentType;
CodeBody       Body;
StrCached   Name;
CodeType       Prev;
CodeType       Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;
AccessSpec     ParentAccess;

Serialization:

// 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 are assumed to be interfaces and are given public acess specifiers.

Constructor

Fields:

CodeComment    InlineCmt;  // Only supported by forward declarations
Code           InitializerList;
CodeParams     Params;
Code           Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

// 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:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

#define <Name> <Content>

Destructor

Fields:

CodeComment    InlineCmt;
CodeSpecifiers Specs;
Code           Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

// 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:

CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeType       UnderlyingType;
Code           UnderlyingTypeMacro;
CodeBody       Body;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
StrCached   Name;
CodeT          Type;
ModuleFlag     ModuleFlags;

UnderlyingTypeMacro is a macro the library natively supports: enum_underlying(type) that is meant to behave as a wrapper for underlying type assignment.
The enum_underlying_sig is a Str global var that can be set which will be defined within PreprocessorDefines and used in parser_parse_enum to identify a valid macro.

Serialization:

// Enum_Fwd
<ModuleFlags> enum class <Name> : <UnderlyingType> or <UnderlyingTypeMacro> ; <InlineCmt>

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

Execution

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

Fields:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

<Content>

External Linkage

Fields:

CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

extern "<Name>"
{
    <Body>
}

Include

Fields:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Code           Parent;
Token*         Tok;
CodeT          Type;

Serialization:

#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:

CodeComment    InlineCmt;
Code           Declaration;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

friend <Declaration>; <InlineCmt>

Function

Fields:

CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ReturnType;
CodeParams     Params;
CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

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

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

Module

Fields:

StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

<ModuleFlags> module <Name>;

Namespace

Fields:

CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

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

Operator Overload (Operator)

Fields:

CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ReturnType;
CodeParams     Params;
CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;
OperatorT      Op;

Serialization:

// 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, OpCast )

Fields:

CodeComment    InlineCmt;
CodeSpecifiers Specs;
CodeType       ValueType;
CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

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

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

Parameters (AST_Params)

Fields:

CodeType       ValueType;
Code           Macro;
Code           Value;
Code           PostNameMacro;
StrCached   Name;
CodeParams     Last;
CodeParams     Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
s32            NumEntries;

Serialization:

<Macro>, <Next> ... <Last>

<Macro> <ValueType> <Name> <PostNameMacro> = <Value>, <Next>... <Last>

Pragma

Fields:

StrCached   Content;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;

Serialization:

#pragma <Content>

Preprocessor Conditional

Fields:

StrCached  Content;
StrCached  Name;
Code          Prev;
Code          Next;
Token*        Tok;
Code          Parent;
CodeT         Type;

Serialization:

#<based off Type> <Content>

Specifiers

Fields:

SpecifierT     ArrSpecs[ AST_ArrSpecs_Cap ];
CodeSpecifiers NextSpecs;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
s32            NumEntries;

Serialization:

<Spec>, ...

Template

Fields:

CodeParams     Params;
Code           Declaration;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

<ModuleFlags>
template< <Params> >
<Declaration>

Typename

Typenames represent the type "symbol".

Fields:

CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeReturnType ReturnType;
CodeParams     Params;
Code           ArrExpr;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
StrCached   Name;
CodeT          Type;
b32            IsParamPack;
ETypenameTag   TypeTag;

Serialization:

<Attributes> <TypeTag> <Name> <Specs> <IsParamPack ?: ...> 
// Function
<Attributes> <ReturnType> <Name> <Params> <Specs>

<Name> currently has the full serialization of anything with

Note: ArrExpr is not used in serialization by typename_to_strbuilder_ref its instead handled by a parent AST's serailization (variable, typedef, using).

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:

CodeComment   InlineCmt;
Code          UnderlyingType;
StrCached  Name;
Code          Prev;
Code          Next;
Token*        Tok
Code          Parent;
CodeT         Type;
ModuleFlag    ModuleFlags;
b32           IsFunction;

Serialization:

// Regular
<ModuleFlags> typedef <UnderlyingType> <Name> <UnderlyingType-ArrExpr>; <InlineCmt>

// Functions

// Currently:
<ModuleFlags> typedef <UnderlyingType (Serialized expression)>; <InlineCmt>

// Desired: Not handled yet
<ModuleFlags> typedef <UnderlyingType->ReturnType> UnderlyingType->Name> <UnderlyingType-ArrExpr> ( <UnderlyingType->Parameters> ); <InlineCmt>
<ModuleFlags> typedef <UnderlyingType->ReturnType> ( <Name->Namespace> for<Specs->has(Spec_Ptr) ?: *> <UnderlyingType->Name> <UnderlyingType-ArrExpr> ) ( <UnderlyingType->Parameters> ); <InlineCmt>

Union

Fields:

CodeAttributes Attributes;
CodeBody       Body;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

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

Using

Fields:

CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeType       UnderlyingType;
StrCached   Name;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;

Serialization:

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

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

Variable

Algo

Fields:

CodeComment    InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType       ValueType;
Code           BitfieldSize;
Code           Value;
StrCached   Name;
CodeVar        NextVar;
Code           Prev;
Code           Next;
Token*         Tok;
Code           Parent;
CodeT          Type;
ModuleFlag     ModuleFlags;
s32            VarParenthesizedInit;

Serialization:

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

// Bitfield
<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>

// VarParenthesizedInit
<Attributes> <Specs> <ValueType> <Name>( <Value>, NextVar ... ); <InlineCmt>

13 KiB Raw Blame History

Navigation

AST Types Documentation

Body

Attributes

Comment

Class & Struct

Constructor

Define

Destructor

Enum

Execution

External Linkage

Include

Friend

Function

Module

Namespace

Operator Overload (Operator)

Operator Cast Overload ( User-Defined Type Conversion, OpCast )

Parameters (AST_Params)

Pragma

Preprocessor Conditional

Specifiers

Template

Typename

Typedef

Union

Using

Variable

13 KiB

Raw Blame History