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