#ifndef WRAITH_AST_H #define WRAITH_AST_H #include #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 */