wraith-lang/src/ast.h

#ifndef WRAITH_AST_H
#define WRAITH_AST_H

#include <stdint.h>
#include "identcheck.h"

typedef enum
{
    AccessExpression,
    AllocExpression,
    Assignment,
    BinaryExpression,
    Comment,
    CustomTypeNode,
    Declaration,
    DeclarationSequence,
    Expression,
    ForLoop,
    FunctionArgumentSequence,
    FunctionCallExpression,
    FunctionDeclaration,
    FunctionModifiers,
    FunctionSignature,
    FunctionSignatureArguments,
    GenericConstraint,
    GenericConstraints,
    Identifier,
    IfStatement,
    IfElseStatement,
    InterfaceDeclaration,
    Number,
    PrimitiveTypeNode,
    ReferenceTypeNode,
    Return,
    ReturnVoid,
    StatementSequence,
    StaticModifier,
    StringLiteral,
    StructDeclaration,
    Type,
    UnaryExpression
} SyntaxKind;

typedef enum
{
    Negate
} UnaryOperator;

typedef enum
{
    Add,
    Subtract,
    Multiply,
    Mod,
    Equal,
    LessThan,
    GreaterThan,
    LogicalOr
} BinaryOperator;

typedef enum
{
    Void,
    Bool,
    Int,
    UInt,
    Float,
    Double,
    String
} PrimitiveType;

typedef union
{
    UnaryOperator unaryOperator;
    BinaryOperator binaryOperator;
} Operator;

typedef struct TypeTag
{
    enum Type
    {
        Unknown,
        Primitive,
        Reference,
        Custom
    } type;
    union
    {
        /* Valid when type = Primitive. */
        PrimitiveType primitiveType;
        /* Valid when type = Reference. */
        struct TypeTag *referenceType;
        /* Valid when type = Custom. */
        char *customType;
    } value;
} TypeTag;

typedef struct Node
{
    SyntaxKind syntaxKind;
    struct Node **children;
    uint32_t childCount;
    union
    {
        UnaryOperator unaryOperator;
        BinaryOperator binaryOperator;
    } operator;
    union
    {
        char *string;
        uint64_t number;
    } value;
    PrimitiveType primitiveType;
    TypeTag *typeTag;
    IdNode *idLink;
} Node;

const char* SyntaxKindString(SyntaxKind syntaxKind);

uint8_t IsPrimitiveType(Node *typeNode);
Node* MakePrimitiveTypeNode(
    PrimitiveType type
);
Node* MakeCustomTypeNode(
    char *string
);
Node* MakeReferenceTypeNode(
    Node *typeNode
);
Node* MakeTypeNode(
    Node *typeNode /* can be primitive, custom, or reference */
);
Node* MakeIdentifierNode(
    const char *id
);
Node* MakeNumberNode(
    const char *numberString
);
Node* MakeStringNode(
    const char *string
);
Node* MakeStaticNode();
Node* MakeFunctionModifiersNode(
    Node **pModifierNodes,
    uint32_t modifierCount
);
Node* MakeUnaryNode(
    UnaryOperator operator,
    Node *child
);
Node* MakeBinaryNode(
    BinaryOperator operator,
    Node *left,
    Node *right
);
Node* MakeDeclarationNode(
    Node* typeNode,
    Node* identifierNode
);
Node* MakeAssignmentNode(
    Node *left,
    Node *right
);
Node* StartStatementSequenceNode(
    Node* statementNode
);
Node* AddStatement(
    Node* statementSequenceNode,
    Node *statementNode
);
Node* MakeReturnStatementNode(
    Node *expressionNode
);
Node* MakeReturnVoidStatementNode();
Node* StartFunctionSignatureArgumentsNode(
    Node *argumentNode
);
Node* AddFunctionSignatureArgumentNode(
    Node *argumentsNode,
    Node *argumentNode
);
Node* MakeEmptyFunctionSignatureArgumentsNode();
Node* MakeGenericConstraintNode(
    Node *identifierNode,
    Node *interfaceNode
);
Node* StartGenericConstraintsNode(Node *genericNode);
Node* AddGenericConstraint(
    Node *genericsNode,
    Node *genericNode
);
Node* MakeEmptyGenericConstraintsNode();
Node* MakeFunctionSignatureNode(
    Node *identifierNode,
    Node *typeNode,
    Node *argumentsNode,
    Node *modifiersNode,
    Node *genericConstraintsNode
);
Node* MakeFunctionDeclarationNode(
    Node *functionSignatureNode,
    Node *functionBodyNode
);
Node* MakeStructDeclarationNode(
    Node *identifierNode,
    Node *declarationSequenceNode
);
Node* MakeInterfaceDeclarationNode(
    Node *identifierNode,
    Node *declarationSequenceNode
);
Node* StartDeclarationSequenceNode(
    Node *declarationNode
);
Node* AddDeclarationNode(
    Node *declarationSequenceNode,
    Node *declarationNode
);
Node *StartFunctionArgumentSequenceNode(
    Node *argumentNode
);
Node *AddFunctionArgumentNode(
    Node *argumentSequenceNode,
    Node *argumentNode
);
Node *MakeEmptyFunctionArgumentSequenceNode();
Node* MakeFunctionCallExpressionNode(
    Node *identifierNode,
    Node *argumentSequenceNode
);
Node* MakeAccessExpressionNode(
    Node *accessee,
    Node *accessor
);
Node* MakeAllocNode(
    Node *typeNode
);
Node* MakeIfNode(
    Node *expressionNode,
    Node *statementSequenceNode
);
Node* MakeIfElseNode(
    Node *ifNode,
    Node *statementSequenceNode
);
Node* MakeForLoopNode(
    Node *identifierNode,
    Node *startNumberNode,
    Node *endNumberNode,
    Node *statementSequenceNode
);

void PrintTree(Node *node, uint32_t tabCount);
const char* SyntaxKindString(SyntaxKind syntaxKind);

TypeTag* MakeTypeTag(Node *node);
char* TypeTagToString(TypeTag *tag);

#endif /* WRAITH_AST_H */
stack sequence structure 2021-04-18 20:14:50 +00:00			`#ifndef WRAITH_AST_H`
			`#define WRAITH_AST_H`

initial commit 2021-04-16 07:35:35 +00:00			`#include <stdint.h>`
Possibly implements full type annotation of the AST 2021-05-13 04:54:09 +00:00			`#include "identcheck.h"`
initial commit 2021-04-16 07:35:35 +00:00
			`typedef enum`
			`{`
scope refactor 2021-04-22 04:29:38 +00:00			`AccessExpression,`
starting a heap alloc system 2021-04-28 19:49:45 +00:00			`AllocExpression,`
initial commit 2021-04-16 07:35:35 +00:00			`Assignment,`
			`BinaryExpression,`
			`Comment,`
started expanding type system 2021-04-24 19:59:30 +00:00			`CustomTypeNode,`
more parser progress 2021-04-16 21:40:28 +00:00			`Declaration,`
stack sequence structure 2021-04-18 20:14:50 +00:00			`DeclarationSequence,`
initial commit 2021-04-16 07:35:35 +00:00			`Expression,`
			`ForLoop,`
support function calls 2021-04-20 17:47:40 +00:00			`FunctionArgumentSequence,`
			`FunctionCallExpression,`
stack sequence structure 2021-04-18 20:14:50 +00:00			`FunctionDeclaration,`
add static modifier 2021-04-22 07:35:42 +00:00			`FunctionModifiers,`
stack sequence structure 2021-04-18 20:14:50 +00:00			`FunctionSignature,`
basic compilation structure 2021-04-20 01:18:45 +00:00			`FunctionSignatureArguments,`
started work on generics 2021-05-03 07:06:54 +00:00			`GenericConstraint,`
			`GenericConstraints,`
initial commit 2021-04-16 07:35:35 +00:00			`Identifier,`
add if statement 2021-04-29 04:25:25 +00:00			`IfStatement,`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`IfElseStatement,`
started work on generics 2021-05-03 07:06:54 +00:00			`InterfaceDeclaration,`
initial commit 2021-04-16 07:35:35 +00:00			`Number,`
started expanding type system 2021-04-24 19:59:30 +00:00			`PrimitiveTypeNode,`
			`ReferenceTypeNode,`
initial commit 2021-04-16 07:35:35 +00:00			`Return,`
compile struct functions 2021-04-21 02:00:18 +00:00			`ReturnVoid,`
stack sequence structure 2021-04-18 20:14:50 +00:00			`StatementSequence,`
add static modifier 2021-04-22 07:35:42 +00:00			`StaticModifier,`
more parser progress 2021-04-16 21:40:28 +00:00			`StringLiteral,`
stack sequence structure 2021-04-18 20:14:50 +00:00			`StructDeclaration,`
			`Type,`
initial commit 2021-04-16 07:35:35 +00:00			`UnaryExpression`
			`} SyntaxKind;`

			`typedef enum`
			`{`
			`Negate`
			`} UnaryOperator;`

			`typedef enum`
			`{`
			`Add,`
support function calls 2021-04-20 17:47:40 +00:00			`Subtract,`
add if statement 2021-04-29 04:25:25 +00:00			`Multiply,`
initial for loop range implementation 2021-04-30 06:49:35 +00:00			`Mod,`
			`Equal,`
if-else chains 2021-04-29 22:26:30 +00:00			`LessThan,`
initial for loop range implementation 2021-04-30 06:49:35 +00:00			`GreaterThan,`
			`LogicalOr`
initial commit 2021-04-16 07:35:35 +00:00			`} BinaryOperator;`

more parser progress 2021-04-16 21:40:28 +00:00			`typedef enum`
			`{`
compile struct functions 2021-04-21 02:00:18 +00:00			`Void,`
more parser progress 2021-04-16 21:40:28 +00:00			`Bool,`
			`Int,`
			`UInt,`
			`Float,`
			`Double,`
started expanding type system 2021-04-24 19:59:30 +00:00			`String`
more parser progress 2021-04-16 21:40:28 +00:00			`} PrimitiveType;`

initial commit 2021-04-16 07:35:35 +00:00			`typedef union`
			`{`
			`UnaryOperator unaryOperator;`
			`BinaryOperator binaryOperator;`
			`} Operator;`

Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`typedef struct TypeTag`
			`{`
some minor style revisions 2021-05-14 18:53:09 +00:00			`enum Type`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`{`
			`Unknown,`
			`Primitive,`
			`Reference,`
			`Custom`
			`} type;`
some minor style revisions 2021-05-14 18:53:09 +00:00			`union`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`{`
some minor style revisions 2021-05-14 18:53:09 +00:00			`/* Valid when type = Primitive. */`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`PrimitiveType primitiveType;`
some minor style revisions 2021-05-14 18:53:09 +00:00			`/* Valid when type = Reference. */`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`struct TypeTag *referenceType;`
some minor style revisions 2021-05-14 18:53:09 +00:00			`/* Valid when type = Custom. */`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`char *customType;`
			`} value;`
			`} TypeTag;`

initial commit 2021-04-16 07:35:35 +00:00			`typedef struct Node`
			`{`
			`SyntaxKind syntaxKind;`
			`struct Node **children;`
			`uint32_t childCount;`
			`union`
			`{`
			`UnaryOperator unaryOperator;`
			`BinaryOperator binaryOperator;`
			`} operator;`
more parser progress 2021-04-16 21:40:28 +00:00			`union`
			`{`
			`char *string;`
			`uint64_t number;`
			`} value;`
started expanding type system 2021-04-24 19:59:30 +00:00			`PrimitiveType primitiveType;`
some minor style revisions 2021-05-14 18:53:09 +00:00			`TypeTag *typeTag;`
Possibly implements full type annotation of the AST 2021-05-13 04:54:09 +00:00			`IdNode *idLink;`
initial commit 2021-04-16 07:35:35 +00:00			`} Node;`

fix compilation structure 2021-04-18 22:29:54 +00:00			`const char* SyntaxKindString(SyntaxKind syntaxKind);`
initial commit 2021-04-16 07:35:35 +00:00
started expanding type system 2021-04-24 19:59:30 +00:00			`uint8_t IsPrimitiveType(Node *typeNode);`
			`Node* MakePrimitiveTypeNode(`
stack sequence structure 2021-04-18 20:14:50 +00:00			`PrimitiveType type`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
add custom types and local allocation 2021-04-21 06:51:26 +00:00			`Node* MakeCustomTypeNode(`
started expanding type system 2021-04-24 19:59:30 +00:00			`char *string`
			`);`
			`Node* MakeReferenceTypeNode(`
			`Node *typeNode`
			`);`
			`Node* MakeTypeNode(`
			`Node typeNode / can be primitive, custom, or reference */`
add custom types and local allocation 2021-04-21 06:51:26 +00:00			`);`
initial commit 2021-04-16 07:35:35 +00:00			`Node* MakeIdentifierNode(`
			`const char *id`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
initial commit 2021-04-16 07:35:35 +00:00			`Node* MakeNumberNode(`
			`const char *numberString`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
initial commit 2021-04-16 07:35:35 +00:00			`Node* MakeStringNode(`
			`const char *string`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
add static modifier 2021-04-22 07:35:42 +00:00			`Node* MakeStaticNode();`
			`Node* MakeFunctionModifiersNode(`
			`Node **pModifierNodes,`
			`uint32_t modifierCount`
			`);`
initial commit 2021-04-16 07:35:35 +00:00			`Node* MakeUnaryNode(`
			`UnaryOperator operator,`
			`Node *child`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
initial commit 2021-04-16 07:35:35 +00:00			`Node* MakeBinaryNode(`
			`BinaryOperator operator,`
			`Node *left,`
			`Node *right`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
more parser progress 2021-04-16 21:40:28 +00:00			`Node* MakeDeclarationNode(`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node* typeNode,`
			`Node* identifierNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
more parser progress 2021-04-16 21:40:28 +00:00			`Node* MakeAssignmentNode(`
			`Node *left,`
			`Node *right`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node* StartStatementSequenceNode(`
			`Node* statementNode`
			`);`
			`Node* AddStatement(`
			`Node* statementSequenceNode,`
			`Node *statementNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
function parsing 2021-04-18 20:30:50 +00:00			`Node* MakeReturnStatementNode(`
			`Node *expressionNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
compile struct functions 2021-04-21 02:00:18 +00:00			`Node* MakeReturnVoidStatementNode();`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node* StartFunctionSignatureArgumentsNode(`
			`Node *argumentNode`
			`);`
			`Node* AddFunctionSignatureArgumentNode(`
			`Node *argumentsNode,`
			`Node *argumentNode`
basic compilation structure 2021-04-20 01:18:45 +00:00			`);`
started work on generics 2021-05-03 07:06:54 +00:00			`Node* MakeEmptyFunctionSignatureArgumentsNode();`
			`Node* MakeGenericConstraintNode(`
			`Node *identifierNode,`
			`Node *interfaceNode`
			`);`
			`Node* StartGenericConstraintsNode(Node *genericNode);`
			`Node* AddGenericConstraint(`
			`Node *genericsNode,`
			`Node *genericNode`
			`);`
			`Node* MakeEmptyGenericConstraintsNode();`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node* MakeFunctionSignatureNode(`
			`Node *identifierNode,`
started work on generics 2021-05-03 07:06:54 +00:00			`Node *typeNode,`
			`Node *argumentsNode,`
			`Node *modifiersNode,`
			`Node *genericConstraintsNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node* MakeFunctionDeclarationNode(`
started work on generics 2021-05-03 07:06:54 +00:00			`Node *functionSignatureNode,`
			`Node *functionBodyNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node* MakeStructDeclarationNode(`
			`Node *identifierNode,`
			`Node *declarationSequenceNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
started work on generics 2021-05-03 07:06:54 +00:00			`Node* MakeInterfaceDeclarationNode(`
			`Node *identifierNode,`
			`Node *declarationSequenceNode`
			`);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node* StartDeclarationSequenceNode(`
			`Node *declarationNode`
			`);`
			`Node* AddDeclarationNode(`
			`Node *declarationSequenceNode,`
			`Node *declarationNode`
fix compilation structure 2021-04-18 22:29:54 +00:00			`);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node *StartFunctionArgumentSequenceNode(`
			`Node *argumentNode`
support function calls 2021-04-20 17:47:40 +00:00			`);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node *AddFunctionArgumentNode(`
			`Node *argumentSequenceNode,`
			`Node *argumentNode`
			`);`
			`Node *MakeEmptyFunctionArgumentSequenceNode();`
support function calls 2021-04-20 17:47:40 +00:00			`Node* MakeFunctionCallExpressionNode(`
			`Node *identifierNode,`
			`Node *argumentSequenceNode`
			`);`
scope refactor 2021-04-22 04:29:38 +00:00			`Node* MakeAccessExpressionNode(`
			`Node *accessee,`
			`Node *accessor`
			`);`
starting a heap alloc system 2021-04-28 19:49:45 +00:00			`Node* MakeAllocNode(`
			`Node *typeNode`
			`);`
add if statement 2021-04-29 04:25:25 +00:00			`Node* MakeIfNode(`
			`Node *expressionNode,`
			`Node *statementSequenceNode`
			`);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node* MakeIfElseNode(`
			`Node *ifNode,`
			`Node *statementSequenceNode`
			`);`
initial for loop range implementation 2021-04-30 06:49:35 +00:00			`Node* MakeForLoopNode(`
			`Node *identifierNode,`
			`Node *startNumberNode,`
			`Node *endNumberNode,`
			`Node *statementSequenceNode`
			`);`
stack sequence structure 2021-04-18 20:14:50 +00:00
fix compilation structure 2021-04-18 22:29:54 +00:00			`void PrintTree(Node *node, uint32_t tabCount);`
Possibly implements full type annotation of the AST 2021-05-13 04:54:09 +00:00			`const char* SyntaxKindString(SyntaxKind syntaxKind);`
stack sequence structure 2021-04-18 20:14:50 +00:00
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00			`TypeTag* MakeTypeTag(Node *node);`
			`char* TypeTagToString(TypeTag *tag);`

stack sequence structure 2021-04-18 20:14:50 +00:00			`#endif /* WRAITH_AST_H */`