wraith-lang/src/ast.h

#ifndef WRAITH_AST_H
#define WRAITH_AST_H

#include <stdint.h>
#include "identcheck.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 /* 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* 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 */