wraith-lang/src/ast.h

#ifndef WRAITH_AST_H
#define WRAITH_AST_H

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

/* -Wpedantic nameless union/struct silencing */
#ifndef WRAITHNAMELESS
#ifdef __GNUC__
#define WRAITHNAMELESS __extension__
#else
#define WRAITHNAMELESS
#endif /* __GNUC__ */
#endif /* WRAITHNAMELESS */

typedef enum
{
    AccessExpression,
    AllocExpression,
    Assignment,
    BinaryExpression,
    Comment,
    CustomTypeNode,
    Declaration,
    DeclarationSequence,
    ForLoop,
    FunctionArgumentSequence,
    FunctionCallExpression,
    FunctionDeclaration,
    FunctionModifiers,
    FunctionSignature,
    FunctionSignatureArguments,
    Identifier,
    IfStatement,
    IfElseStatement,
    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 Node;

struct Node
{
    Node *parent;
    SyntaxKind syntaxKind;
    WRAITHNAMELESS union
    {
        struct
        {
            Node *accessee;
            Node *accessor;
        } accessExpression;

        struct
        {
            Node *type;
        } allocExpression;

        struct
        {
            Node *left;
            Node *right;
        } assignmentStatement;

        struct
        {
            Node *left;
            Node *right;
            BinaryOperator operator;
        } binaryExpression;

        struct
        {

        } comment;

        struct
        {
            char *name;
        } customType;

        struct
        {
            Node *type;
            Node *identifier;
        } declaration;

        struct
        {
            Node **sequence;
            uint32_t count;
        } declarationSequence;

        struct
        {
            Node *declaration;
            Node *startNumber;
            Node *endNumber;
            Node *statementSequence;
        } forLoop;

        struct
        {
            Node **sequence;
            uint32_t count;
        } functionArgumentSequence;

        struct
        {
            Node *identifier; /* FIXME: need better name */
            Node *argumentSequence;
        } functionCallExpression;

        struct
        {
            Node *functionSignature;
            Node *functionBody;
        } functionDeclaration;

        struct
        {
            Node **sequence;
            uint32_t count;
        } functionModifiers;

        struct
        {
            Node *identifier;
            Node *type;
            Node *arguments;
            Node *modifiers;
        } functionSignature;

        struct
        {
            Node **sequence;
            uint32_t count;
        } functionSignatureArguments;

        struct
        {
            char *name;
        } identifier;

        struct
        {
            Node *expression;
            Node *statementSequence;
        } ifStatement;

        struct
        {
            Node *ifStatement;
            Node *elseStatement;
        } ifElseStatement;

        struct
        {
            uint64_t value;
        } number;

        struct
        {
            PrimitiveType type;
        } primitiveType;

        struct
        {
            Node *type;
        } referenceType;

        struct
        {
            Node *expression;
        } returnStatement;

        struct
        {

        } returnVoidStatement;

        struct
        {
            Node **sequence;
            uint32_t count;
        } statementSequence;

        struct
        {

        } staticModifier; /* FIXME: modifiers should just be an enum */

        struct
        {
            char *string;
        } stringLiteral;

        struct
        {
            Node *identifier;
            Node *declarationSequence;
        } structDeclaration;

        struct
        {
            Node *typeNode;
        } type; /* FIXME: this needs a refactor */

        struct
        {
            Node *child;
            UnaryOperator operator;
        } unaryExpression;
    };
    TypeTag *typeTag;
    IdNode *idLink;
};

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);
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 *MakeFunctionSignatureNode(
    Node *identifierNode,
    Node *typeNode,
    Node *argumentsNode,
    Node *modifiersNode);
Node *MakeFunctionDeclarationNode(
    Node *functionSignatureNode,
    Node *functionBodyNode);
Node *MakeStructDeclarationNode(
    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 *elseNode /* can be a conditional or a statement sequence */
);
Node *MakeForLoopNode(
    Node *identifierNode,
    Node *startNumberNode,
    Node *endNumberNode,
    Node *statementSequenceNode);

void PrintNode(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`

Possibly implements full type annotation of the AST 2021-05-13 04:54:09 +00:00			`#include "identcheck.h"`
clang-format config 2021-05-16 07:42:37 +00:00			`#include <stdint.h>`
initial commit 2021-04-16 07:35:35 +00:00
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`/* -Wpedantic nameless union/struct silencing */`
			`#ifndef WRAITHNAMELESS`
			`#ifdef __GNUC__`
			`#define WRAITHNAMELESS __extension__`
			`#else`
			`#define WRAITHNAMELESS`
			`#endif /* __GNUC__ */`
			`#endif /* WRAITHNAMELESS */`

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			`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,`
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,`
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;`

refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`typedef struct Node Node;`

			`struct Node`
initial commit 2021-04-16 07:35:35 +00:00			`{`
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`Node *parent;`
initial commit 2021-04-16 07:35:35 +00:00			`SyntaxKind syntaxKind;`
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`WRAITHNAMELESS union`
more parser progress 2021-04-16 21:40:28 +00:00			`{`
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`struct`
			`{`
			`Node *accessee;`
			`Node *accessor;`
			`} accessExpression;`

			`struct`
			`{`
			`Node *type;`
			`} allocExpression;`

			`struct`
			`{`
			`Node *left;`
			`Node *right;`
			`} assignmentStatement;`

			`struct`
			`{`
			`Node *left;`
			`Node *right;`
			`BinaryOperator operator;`
			`} binaryExpression;`

			`struct`
			`{`

			`} comment;`

			`struct`
			`{`
			`char *name;`
			`} customType;`

			`struct`
			`{`
			`Node *type;`
			`Node *identifier;`
			`} declaration;`

			`struct`
			`{`
			`Node **sequence;`
			`uint32_t count;`
			`} declarationSequence;`

			`struct`
			`{`
			`Node *declaration;`
			`Node *startNumber;`
			`Node *endNumber;`
			`Node *statementSequence;`
			`} forLoop;`

			`struct`
			`{`
			`Node **sequence;`
			`uint32_t count;`
			`} functionArgumentSequence;`

			`struct`
			`{`
			`Node identifier; / FIXME: need better name */`
			`Node *argumentSequence;`
			`} functionCallExpression;`

			`struct`
			`{`
			`Node *functionSignature;`
			`Node *functionBody;`
			`} functionDeclaration;`

			`struct`
			`{`
			`Node **sequence;`
			`uint32_t count;`
			`} functionModifiers;`

			`struct`
			`{`
			`Node *identifier;`
			`Node *type;`
			`Node *arguments;`
			`Node *modifiers;`
			`} functionSignature;`

			`struct`
			`{`
			`Node **sequence;`
			`uint32_t count;`
			`} functionSignatureArguments;`

			`struct`
			`{`
			`char *name;`
			`} identifier;`

			`struct`
			`{`
			`Node *expression;`
			`Node *statementSequence;`
			`} ifStatement;`

			`struct`
			`{`
			`Node *ifStatement;`
			`Node *elseStatement;`
			`} ifElseStatement;`

			`struct`
			`{`
			`uint64_t value;`
			`} number;`

			`struct`
			`{`
			`PrimitiveType type;`
			`} primitiveType;`

			`struct`
			`{`
			`Node *type;`
			`} referenceType;`

			`struct`
			`{`
			`Node *expression;`
			`} returnStatement;`

			`struct`
			`{`

			`} returnVoidStatement;`

			`struct`
			`{`
			`Node **sequence;`
			`uint32_t count;`
			`} statementSequence;`

			`struct`
			`{`

			`} staticModifier; /* FIXME: modifiers should just be an enum */`

			`struct`
			`{`
			`char *string;`
			`} stringLiteral;`

			`struct`
			`{`
			`Node *identifier;`
			`Node *declarationSequence;`
			`} structDeclaration;`

			`struct`
			`{`
			`Node *typeNode;`
			`} type; /* FIXME: this needs a refactor */`

			`struct`
			`{`
			`Node *child;`
			`UnaryOperator operator;`
			`} unaryExpression;`
			`};`
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;`
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`};`
initial commit 2021-04-16 07:35:35 +00:00
clang-format config 2021-05-16 07:42:37 +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);`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *MakePrimitiveTypeNode(PrimitiveType type);`
			`Node MakeCustomTypeNode(char string);`
			`Node MakeReferenceTypeNode(Node typeNode);`
			`Node MakeTypeNode(Node typeNode);`
			`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);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node *MakeEmptyFunctionSignatureArgumentsNode();`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *MakeFunctionSignatureNode(`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node *identifierNode,`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *typeNode,`
			`Node *argumentsNode,`
			`Node *modifiersNode);`
			`Node *MakeFunctionDeclarationNode(`
			`Node *functionSignatureNode,`
			`Node *functionBodyNode);`
			`Node *MakeStructDeclarationNode(`
stack sequence structure 2021-04-18 20:14:50 +00:00			`Node *identifierNode,`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *declarationSequenceNode);`
			`Node StartDeclarationSequenceNode(Node declarationNode);`
			`Node AddDeclarationNode(Node declarationSequenceNode, Node *declarationNode);`
			`Node StartFunctionArgumentSequenceNode(Node argumentNode);`
			`Node AddFunctionArgumentNode(Node argumentSequenceNode, Node *argumentNode);`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node *MakeEmptyFunctionArgumentSequenceNode();`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *MakeFunctionCallExpressionNode(`
support function calls 2021-04-20 17:47:40 +00:00			`Node *identifierNode,`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *argumentSequenceNode);`
			`Node MakeAccessExpressionNode(Node accessee, Node *accessor);`
			`Node MakeAllocNode(Node typeNode);`
			`Node MakeIfNode(Node expressionNode, Node *statementSequenceNode);`
			`Node *MakeIfElseNode(`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`Node *ifNode,`
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`Node elseNode / can be a conditional or a statement sequence */`
parser sequence refactor 2021-04-29 19:42:51 +00:00			`);`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *MakeForLoopNode(`
initial for loop range implementation 2021-04-30 06:49:35 +00:00			`Node *identifierNode,`
			`Node *startNumberNode,`
			`Node *endNumberNode,`
clang-format config 2021-05-16 07:42:37 +00:00			`Node *statementSequenceNode);`
stack sequence structure 2021-04-18 20:14:50 +00:00
refactor AST to use nameless union instead of child array 2021-05-15 22:34:15 +00:00			`void PrintNode(Node *node, uint32_t tabCount);`
clang-format config 2021-05-16 07:42:37 +00:00			`const char *SyntaxKindString(SyntaxKind syntaxKind);`
stack sequence structure 2021-04-18 20:14:50 +00:00
clang-format config 2021-05-16 07:42:37 +00:00			`TypeTag MakeTypeTag(Node node);`
			`char TypeTagToString(TypeTag tag);`
Adds type tags to the id-tree 2021-05-08 00:49:35 +00:00
stack sequence structure 2021-04-18 20:14:50 +00:00			`#endif /* WRAITH_AST_H */`