From 7ca87d6b1318a48b858371f1b71ab74ba30dcd0c Mon Sep 17 00:00:00 2001 From: cosmonaut Date: Thu, 29 Apr 2021 12:42:51 -0700 Subject: [PATCH] parser sequence refactor --- CMakeLists.txt | 2 - example.w | 9 +++ generators/wraith.y | 128 ++++++++++++++----------------------------- src/ast.c | 131 ++++++++++++++++++++++++++++++-------------- src/ast.h | 45 ++++++++++----- src/parser.c | 4 +- src/stack.c | 65 ---------------------- src/stack.h | 27 --------- 8 files changed, 173 insertions(+), 238 deletions(-) delete mode 100644 src/stack.c delete mode 100644 src/stack.h diff --git a/CMakeLists.txt b/CMakeLists.txt index d298384..51630b6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,11 +42,9 @@ add_executable( src/ast.h src/codegen.h src/parser.h - src/stack.h src/ast.c src/codegen.c src/parser.c - src/stack.c src/main.c # Generated code ${BISON_Parser_OUTPUTS} diff --git a/example.w b/example.w index 21f7736..2248179 100644 --- a/example.w +++ b/example.w @@ -15,6 +15,11 @@ struct MyStruct myInt = myInt + 1; } + Decrement(): void + { + myInt = myInt - 1; + } + static MyFunction(input: int): int { return input * 2; @@ -40,6 +45,10 @@ struct Program { myStruct.Increment(); } + else + { + myStruct.Decrement(); + } return myStruct.myInt; } diff --git a/generators/wraith.y b/generators/wraith.y index 67e6f48..6d7e861 100644 --- a/generators/wraith.y +++ b/generators/wraith.y @@ -1,13 +1,12 @@ %code requires { - #include "../src/stack.h" + #include "../src/ast.h" } %{ #include #include "../src/ast.h" -#include "../src/stack.h" -void yyerror(FILE *fp, Stack *stack, Node **pRootNode, char *s) +void yyerror(FILE *fp, Node **pRootNode, char *s) { fprintf (stderr, "%s\n", s); } @@ -62,7 +61,7 @@ extern FILE *yyin; %token COMMENT %token NEWLINE -%parse-param { FILE* fp } { Stack *stack } { Node **pRootNode } +%parse-param { FILE* fp } { Node **pRootNode } %define parse.error verbose @@ -73,16 +72,7 @@ extern FILE *yyin; %% Program : TopLevelDeclarations { - Node **declarations; - Node *declarationSequence; - uint32_t declarationCount; - - declarations = GetNodes(stack, &declarationCount); - declarationSequence = MakeDeclarationSequenceNode(declarations, declarationCount); - - PopStackFrame(stack); - - *pRootNode = declarationSequence; + *pRootNode = $1; } BaseType : VOID @@ -220,13 +210,7 @@ ReturnStatement : RETURN Expression FunctionCallExpression : AccessExpression LEFT_PAREN Arguments RIGHT_PAREN { - Node **arguments; - uint32_t argumentCount; - - arguments = GetNodes(stack, &argumentCount); - $$ = MakeFunctionCallExpressionNode($1, MakeFunctionArgumentSequenceNode(arguments, argumentCount)); - - PopStackFrame(stack); + $$ = MakeFunctionCallExpressionNode($1, $3); } PartialStatement : FunctionCallExpression @@ -237,91 +221,68 @@ PartialStatement : FunctionCallExpression IfStatement : IF LEFT_PAREN Expression RIGHT_PAREN LEFT_BRACE Statements RIGHT_BRACE { - Node **statements; - Node *statementSequence; - uint32_t statementCount; + $$ = MakeIfNode($3, $6); + } - statements = GetNodes(stack, &statementCount); - statementSequence = MakeStatementSequenceNode(statements, statementCount); - - $$ = MakeIfNode($3, statementSequence); - - PopStackFrame(stack); +Conditional : IfStatement + | IfStatement ELSE LEFT_BRACE Statements RIGHT_BRACE + { + $$ = MakeIfElseNode($1, $4); } Statement : PartialStatement SEMICOLON - | IfStatement + | Conditional ; -Statements : Statement Statements +Statements : Statement { - AddNode(stack, $1); + $$ = StartStatementSequenceNode($1); } - | + | Statements Statement { - PushStackFrame(stack); + $$ = AddStatement($1, $2); } -Arguments : PrimaryExpression COMMA Arguments +Arguments : PrimaryExpression { - AddNode(stack, $1); + $$ = StartFunctionArgumentSequenceNode($1); } - | PrimaryExpression + | Arguments COMMA PrimaryExpression { - PushStackFrame(stack); - AddNode(stack, $1); + $$ = AddFunctionArgumentNode($1, $3); } | { - PushStackFrame(stack); + $$ = MakeEmptyFunctionArgumentSequenceNode(); } - ; -SignatureArguments : VariableDeclaration COMMA SignatureArguments +SignatureArguments : VariableDeclaration { - AddNode(stack, $1); + $$ = StartFunctionSignatureArgumentsNode($1); } - | VariableDeclaration + | SignatureArguments COMMA VariableDeclaration { - PushStackFrame(stack); - AddNode(stack, $1); + $$ = AddFunctionSignatureArgumentNode($1, $3); } | + { + $$ = MakeEmptyFunctionSignatureArgumentsNode(); + } ; Body : LEFT_BRACE Statements RIGHT_BRACE { - Node **statements; - Node *statementSequence; - uint32_t statementCount; - - statements = GetNodes(stack, &statementCount); - statementSequence = MakeStatementSequenceNode(statements, statementCount); - $$ = MakeStatementSequenceNode(statements, statementCount); - - PopStackFrame(stack); + $$ = $2; } FunctionSignature : Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type { - Node **declarations; - uint32_t declarationCount; - - declarations = GetNodes(stack, &declarationCount); - $$ = MakeFunctionSignatureNode($1, $6, MakeFunctionSignatureArgumentsNode(declarations, declarationCount), MakeFunctionModifiersNode(NULL, 0)); - - PopStackFrame(stack); + $$ = MakeFunctionSignatureNode($1, $6, $3, MakeFunctionModifiersNode(NULL, 0)); } | STATIC Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type { - Node **declarations; - uint32_t declarationCount; Node *modifier = MakeStaticNode(); - - declarations = GetNodes(stack, &declarationCount); - $$ = MakeFunctionSignatureNode($2, $7, MakeFunctionSignatureArgumentsNode(declarations, declarationCount), MakeFunctionModifiersNode(&modifier, 1)); - - PopStackFrame(stack); + $$ = MakeFunctionSignatureNode($2, $7, $4, MakeFunctionModifiersNode(&modifier, 1)); } FunctionDeclaration : FunctionSignature Body @@ -331,39 +292,30 @@ FunctionDeclaration : FunctionSignature Body StructDeclaration : STRUCT Identifier LEFT_BRACE Declarations RIGHT_BRACE { - Node **declarations; - Node *declarationSequence; - uint32_t declarationCount; - - declarations = GetNodes(stack, &declarationCount); - declarationSequence = MakeDeclarationSequenceNode(declarations, declarationCount); - $$ = MakeStructDeclarationNode($2, declarationSequence); - - PopStackFrame(stack); + $$ = MakeStructDeclarationNode($2, $4); } - Declaration : FunctionDeclaration | VariableDeclaration SEMICOLON ; -Declarations : Declaration Declarations +Declarations : Declaration { - AddNode(stack, $1); + $$ = StartDeclarationSequenceNode($1); } - | + | Declarations Declaration { - PushStackFrame(stack); + $$ = AddDeclarationNode($1, $2); } TopLevelDeclaration : StructDeclaration; -TopLevelDeclarations : TopLevelDeclaration TopLevelDeclarations +TopLevelDeclarations : TopLevelDeclaration { - AddNode(stack, $1); + $$ = StartDeclarationSequenceNode($1); } - | + | TopLevelDeclarations TopLevelDeclaration { - PushStackFrame(stack); + $$ = AddDeclarationNode($1, $2); } %% diff --git a/src/ast.c b/src/ast.c index 23f87e0..b736938 100644 --- a/src/ast.c +++ b/src/ast.c @@ -36,6 +36,8 @@ const char* SyntaxKindString(SyntaxKind syntaxKind) case FunctionSignature: return "FunctionSignature"; case FunctionSignatureArguments: return "FunctionSignatureArguments"; case Identifier: return "Identifier"; + case IfStatement: return "If"; + case IfElseStatement: return "IfElse"; case Number: return "Number"; case PrimitiveTypeNode: return "PrimitiveTypeNode"; case ReferenceTypeNode: return "ReferenceTypeNode"; @@ -211,22 +213,27 @@ Node* MakeAssignmentNode( return node; } -Node* MakeStatementSequenceNode( - Node** pNodes, - uint32_t nodeCount +Node* StartStatementSequenceNode( + Node *statementNode ) { - int32_t i; Node* node = (Node*) malloc(sizeof(Node)); node->syntaxKind = StatementSequence; - node->children = (Node**) malloc(sizeof(Node*) * nodeCount); - node->childCount = nodeCount; - for (i = nodeCount - 1; i >= 0; i -= 1) - { - node->children[nodeCount - 1 - i] = pNodes[i]; - } + node->children = (Node**) malloc(sizeof(Node*)); + node->childCount = 1; + node->children[0] = statementNode; return node; } +Node* AddStatement( + Node* statementSequenceNode, + Node *statementNode +) { + statementSequenceNode->children = realloc(statementSequenceNode->children, sizeof(Node*) * (statementSequenceNode->childCount + 1)); + statementSequenceNode->children[statementSequenceNode->childCount] = statementNode; + statementSequenceNode->childCount += 1; + return statementSequenceNode; +} + Node* MakeReturnStatementNode( Node *expressionNode ) { @@ -247,21 +254,33 @@ Node* MakeReturnVoidStatementNode() return node; } -Node *MakeFunctionSignatureArgumentsNode( - Node **pArgumentNodes, - uint32_t argumentCount +Node *StartFunctionSignatureArgumentsNode( + Node *argumentNode ) { - int32_t i; Node* node = (Node*) malloc(sizeof(Node)); node->syntaxKind = FunctionSignatureArguments; - node->childCount = argumentCount; - node->children = (Node**) malloc(sizeof(Node*) * (node->childCount)); + node->childCount = 1; + node->children = (Node**) malloc(sizeof(Node*)); + node->children[0] = argumentNode; + return node; +} - for (i = argumentCount - 1; i >= 0; i -= 1) - { - node->children[argumentCount - 1 - i] = pArgumentNodes[i]; - } +Node* AddFunctionSignatureArgumentNode( + Node *argumentsNode, + Node *argumentNode +) { + argumentsNode->children = realloc(argumentsNode->children, sizeof(Node*) * (argumentsNode->childCount + 1)); + argumentsNode->children[argumentsNode->childCount] = argumentNode; + argumentsNode->childCount += 1; + return argumentsNode; +} +Node *MakeEmptyFunctionSignatureArgumentsNode() +{ + Node* node = (Node*) malloc(sizeof(Node)); + node->syntaxKind = FunctionSignatureArguments; + node->childCount = 0; + node->children = NULL; return node; } @@ -308,35 +327,54 @@ Node* MakeStructDeclarationNode( return node; } -Node* MakeDeclarationSequenceNode( - Node **pNodes, - uint32_t nodeCount +Node* StartDeclarationSequenceNode( + Node *declarationNode ) { - int32_t i; Node* node = (Node*) malloc(sizeof(Node)); node->syntaxKind = DeclarationSequence; - node->children = (Node**) malloc(sizeof(Node*) * nodeCount); - node->childCount = nodeCount; - for (i = nodeCount - 1; i >= 0; i -= 1) - { - node->children[nodeCount - 1 - i] = pNodes[i]; - } + node->children = (Node**) malloc(sizeof(Node*)); + node->childCount = 1; + node->children[0] = declarationNode; return node; } -Node *MakeFunctionArgumentSequenceNode( - Node **pArgumentNodes, - uint32_t argumentCount +Node* AddDeclarationNode( + Node *declarationSequenceNode, + Node *declarationNode +) { + declarationSequenceNode->children = realloc(declarationSequenceNode->children, sizeof(Node*) * (declarationSequenceNode->childCount + 1)); + declarationSequenceNode->children[declarationSequenceNode->childCount] = declarationNode; + declarationSequenceNode->childCount += 1; + return declarationSequenceNode; +} + +Node* StartFunctionArgumentSequenceNode( + Node *argumentNode ) { - int32_t i; Node* node = (Node*) malloc(sizeof(Node)); node->syntaxKind = FunctionArgumentSequence; - node->childCount = argumentCount; - node->children = (Node**) malloc(sizeof(Node*) * node->childCount); - for (i = argumentCount - 1; i >= 0; i -= 1) - { - node->children[argumentCount - 1 - i] = pArgumentNodes[i]; - } + node->childCount = 1; + node->children = (Node**) malloc(sizeof(Node*)); + node->children[0] = argumentNode; + return node; +} + +Node* AddFunctionArgumentNode( + Node *argumentSequenceNode, + Node *argumentNode +) { + argumentSequenceNode->children = realloc(argumentSequenceNode->children, sizeof(Node*) * (argumentSequenceNode->childCount + 1)); + argumentSequenceNode->children[argumentSequenceNode->childCount] = argumentNode; + argumentSequenceNode->childCount += 1; + return argumentSequenceNode; +} + +Node *MakeEmptyFunctionArgumentSequenceNode() +{ + Node* node = (Node*) malloc(sizeof(Node)); + node->syntaxKind = FunctionArgumentSequence; + node->childCount = 0; + node->children = NULL; return node; } @@ -389,6 +427,19 @@ Node* MakeIfNode( return node; } +Node* MakeIfElseNode( + Node *ifNode, + Node *statementSequenceNode +) { + Node* node = (Node*) malloc(sizeof(Node)); + node->syntaxKind = IfElseStatement; + node->childCount = 2; + node->children = (Node**) malloc(sizeof(Node*)); + node->children[0] = ifNode; + node->children[1] = statementSequenceNode; + return node; +} + static const char* PrimitiveTypeToString(PrimitiveType type) { switch (type) diff --git a/src/ast.h b/src/ast.h index 6f31bde..9a37da6 100644 --- a/src/ast.h +++ b/src/ast.h @@ -23,6 +23,7 @@ typedef enum FunctionSignatureArguments, Identifier, IfStatement, + IfElseStatement, Number, PrimitiveTypeNode, ReferenceTypeNode, @@ -131,22 +132,29 @@ Node* MakeAssignmentNode( Node *left, Node *right ); -Node* MakeStatementSequenceNode( - Node** pNodes, - uint32_t nodeCount +Node* StartStatementSequenceNode( + Node* statementNode +); +Node* AddStatement( + Node* statementSequenceNode, + Node *statementNode ); Node* MakeReturnStatementNode( Node *expressionNode ); Node* MakeReturnVoidStatementNode(); -Node* MakeFunctionSignatureArgumentsNode( - Node **pArgumentNodes, - uint32_t argumentCount +Node* StartFunctionSignatureArgumentsNode( + Node *argumentNode ); +Node* AddFunctionSignatureArgumentNode( + Node *argumentsNode, + Node *argumentNode +); +Node *MakeEmptyFunctionSignatureArgumentsNode(); Node* MakeFunctionSignatureNode( Node *identifierNode, Node* typeNode, - Node* arguments, + Node* argumentsNode, Node* modifiersNode ); Node* MakeFunctionDeclarationNode( @@ -157,14 +165,21 @@ Node* MakeStructDeclarationNode( Node *identifierNode, Node *declarationSequenceNode ); -Node* MakeDeclarationSequenceNode( - Node **pNodes, - uint32_t nodeCount +Node* StartDeclarationSequenceNode( + Node *declarationNode ); -Node *MakeFunctionArgumentSequenceNode( - Node **pArgumentNodes, - uint32_t argumentCount +Node* AddDeclarationNode( + Node *declarationSequenceNode, + Node *declarationNode ); +Node *StartFunctionArgumentSequenceNode( + Node *argumentNode +); +Node *AddFunctionArgumentNode( + Node *argumentSequenceNode, + Node *argumentNode +); +Node *MakeEmptyFunctionArgumentSequenceNode(); Node* MakeFunctionCallExpressionNode( Node *identifierNode, Node *argumentSequenceNode @@ -180,6 +195,10 @@ Node* MakeIfNode( Node *expressionNode, Node *statementSequenceNode ); +Node* MakeIfElseNode( + Node *ifNode, + Node *statementSequenceNode +); void PrintTree(Node *node, uint32_t tabCount); diff --git a/src/parser.c b/src/parser.c index 856504c..434ed7a 100644 --- a/src/parser.c +++ b/src/parser.c @@ -2,7 +2,6 @@ #include "y.tab.h" #include "ast.h" -#include "stack.h" extern FILE *yyin; extern int yydebug; @@ -10,14 +9,13 @@ extern int yydebug; int Parse(char *inputFilename, Node **pRootNode, uint8_t parseVerbose) { int result; - Stack *stack = CreateStack(); yydebug = parseVerbose; FILE *fp = fopen(inputFilename, "r"); if (fp != NULL) { yyin = fp; - result = yyparse(fp, stack, pRootNode); + result = yyparse(fp, pRootNode); fclose(fp); } else diff --git a/src/stack.c b/src/stack.c deleted file mode 100644 index 43c48ab..0000000 --- a/src/stack.c +++ /dev/null @@ -1,65 +0,0 @@ -#include -#include -#include "stack.h" - -Stack* CreateStack() -{ - int32_t i; - Stack *stack = (Stack*) malloc(sizeof(Stack)); - stack->stackCapacity = 4; - stack->stackFrames = (StackFrame*) malloc(sizeof(StackFrame) * stack->stackCapacity); - for (i = 0; i < stack->stackCapacity; i += 1) - { - stack->stackFrames[i].nodes = NULL; - stack->stackFrames[i].nodeCapacity = 0; - stack->stackFrames[i].nodeCount = 0; - } - stack->stackIndex = 0; - - PushStackFrame(stack); - return stack; -} - -void PushStackFrame(Stack *stack) -{ - stack->stackIndex += 1; - - if (stack->stackIndex == stack->stackCapacity) - { - stack->stackCapacity += 1; - stack->stackFrames = (StackFrame*) realloc(stack->stackFrames, sizeof(StackFrame) * stack->stackCapacity); - stack->stackFrames[stack->stackIndex].nodes = NULL; - stack->stackFrames[stack->stackIndex].nodeCapacity = 0; - stack->stackFrames[stack->stackIndex].nodeCount = 0; - } - - stack->stackFrames[stack->stackIndex].nodeCount = 0; -} - -void PopStackFrame(Stack *stack) -{ - stack->stackIndex -= 1; -} - -void AddNode(Stack *stack, Node *statementNode) -{ - StackFrame *stackFrame = &stack->stackFrames[stack->stackIndex]; - if (stackFrame->nodeCount == stackFrame->nodeCapacity) - { - stackFrame->nodeCapacity += 1; - stackFrame->nodes = (Node**) realloc(stackFrame->nodes, sizeof(Node*) * stackFrame->nodeCapacity); - } - stackFrame->nodes[stackFrame->nodeCount] = statementNode; - stackFrame->nodeCount += 1; -} - -Node** GetNodes(Stack *stack, uint32_t *pCount) -{ - if (stack->stackIndex < 0) { - *pCount= 0; - return NULL; - } - - *pCount = stack->stackFrames[stack->stackIndex].nodeCount; - return stack->stackFrames[stack->stackIndex].nodes; -} diff --git a/src/stack.h b/src/stack.h deleted file mode 100644 index 549e72e..0000000 --- a/src/stack.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef WRAITH_STACK_H -#define WRAITH_STACK_H - -#include "ast.h" - -typedef struct StackFrame -{ - Node **nodes; - uint32_t nodeCount; - uint32_t nodeCapacity; -} StackFrame; - -typedef struct Stack -{ - StackFrame *stackFrames; - int32_t stackCapacity; - int32_t stackIndex; -} Stack; - -Stack* CreateStack(); -void PushStackFrame(Stack *stack); -void PopStackFrame(Stack *stack); - -void AddNode(Stack *stack, Node *statementNode); -Node** GetNodes(Stack *stack, uint32_t *pCount); - -#endif /* WRAITH_STACK_H */