stack sequence structure

pull/1/head
cosmonaut 2021-04-18 13:14:50 -07:00
parent 465daaa931
commit 4bc7aca15e
4 changed files with 324 additions and 45 deletions

121
ast.h
View File

@ -1,3 +1,6 @@
#ifndef WRAITH_AST_H
#define WRAITH_AST_H
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@ -9,12 +12,18 @@ typedef enum
BinaryExpression, BinaryExpression,
Comment, Comment,
Declaration, Declaration,
DeclarationSequence,
Expression, Expression,
ForLoop, ForLoop,
FunctionDeclaration,
FunctionSignature,
Identifier, Identifier,
Number, Number,
Return, Return,
StatementSequence,
StringLiteral, StringLiteral,
StructDeclaration,
Type,
UnaryExpression UnaryExpression
} SyntaxKind; } SyntaxKind;
@ -82,15 +91,33 @@ const char* SyntaxKindString(SyntaxKind syntaxKind)
{ {
case Assignment: return "Assignment"; case Assignment: return "Assignment";
case BinaryExpression: return "BinaryExpression"; case BinaryExpression: return "BinaryExpression";
case Comment: return "Comment";
case Declaration: return "Declaration"; case Declaration: return "Declaration";
case DeclarationSequence: return "DeclarationSequence";
case FunctionDeclaration: return "FunctionDeclaration";
case FunctionSignature: return "FunctionSignature";
case Identifier: return "Identifier"; case Identifier: return "Identifier";
case Number: return "Number"; case Number: return "Number";
case Return: return "Return";
case StatementSequence: return "StatementSequence";
case StringLiteral: return "StringLiteral"; case StringLiteral: return "StringLiteral";
case StructDeclaration: return "StructDeclaration";
case Type: return "Type";
case UnaryExpression: return "UnaryExpression"; case UnaryExpression: return "UnaryExpression";
default: return "Unknown"; default: return "Unknown";
} }
} }
Node* MakeTypeNode(
PrimitiveType type
) {
Node* node = (Node*) malloc(sizeof(Node));
node->syntaxKind = Type;
node->type = type;
node->childCount = 0;
return node;
}
Node* MakeIdentifierNode( Node* MakeIdentifierNode(
const char *id const char *id
) { ) {
@ -151,14 +178,15 @@ Node* MakeBinaryNode(
} }
Node* MakeDeclarationNode( Node* MakeDeclarationNode(
PrimitiveType type, Node* typeNode,
const char *id Node* identifierNode
) { ) {
Node* node = (Node*) malloc(sizeof(Node)); Node* node = (Node*) malloc(sizeof(Node));
node->syntaxKind = Declaration; node->syntaxKind = Declaration;
node->type = type; node->children = (Node**) malloc(sizeof(Node*) * 2);
node->value.string = strdup(id); node->childCount = 2;
node->childCount = 0; node->children[0] = typeNode;
node->children[1] = identifierNode;
return node; return node;
} }
@ -175,6 +203,80 @@ Node* MakeAssignmentNode(
return node; return node;
} }
Node* MakeStatementSequenceNode(
Node** pNodes,
uint32_t nodeCount
) {
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];
}
return node;
}
Node* MakeFunctionSignatureNode(
Node *identifierNode,
Node* typeNode,
Node* arguments
) {
uint32_t i;
Node* node = (Node*) malloc(sizeof(Node));
node->syntaxKind = FunctionSignature;
node->childCount = 3;
node->children = (Node**) malloc(sizeof(Node*) * (node->childCount));
node->children[0] = identifierNode;
node->children[1] = typeNode;
node->children[2] = arguments;
return node;
}
Node* MakeFunctionDeclarationNode(
Node* functionSignatureNode,
Node* functionBodyNode
) {
Node* node = (Node*) malloc(sizeof(Node));
node->syntaxKind = FunctionDeclaration;
node->childCount = 2;
node->children = (Node**) malloc(sizeof(Node*) * 2);
node->children[0] = functionSignatureNode;
node->children[1] = functionBodyNode;
return node;
}
Node* MakeStructDeclarationNode(
Node *identifierNode,
Node *declarationSequenceNode
) {
Node* node = (Node*) malloc(sizeof(Node));
node->syntaxKind = StructDeclaration;
node->childCount = 2;
node->children = (Node**) malloc(sizeof(Node*) * 2);
node->children[0] = identifierNode;
node->children[1] = declarationSequenceNode;
return node;
}
Node* MakeDeclarationSequenceNode(
Node **pNodes,
uint32_t nodeCount
) {
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];
}
return node;
}
static const char* PrimitiveTypeToString(PrimitiveType type) static const char* PrimitiveTypeToString(PrimitiveType type)
{ {
switch (type) switch (type)
@ -199,8 +301,6 @@ static void PrintBinaryOperator(BinaryOperator expression)
printf("-"); printf("-");
break; break;
} }
printf("\n");
} }
static void PrintNode(Node *node, int tabCount) static void PrintNode(Node *node, int tabCount)
@ -219,7 +319,10 @@ static void PrintNode(Node *node, int tabCount)
break; break;
case Declaration: case Declaration:
printf("%s %s", PrimitiveTypeToString(node->type), node->value.string); break;
case Type:
printf("%s", PrimitiveTypeToString(node->type));
break; break;
case Identifier: case Identifier:
@ -243,3 +346,5 @@ void PrintTree(Node *node, uint32_t tabCount)
PrintTree(node->children[i], tabCount + 1); PrintTree(node->children[i], tabCount + 1);
} }
} }
#endif /* WRAITH_AST_H */

92
stack.h Normal file
View File

@ -0,0 +1,92 @@
#ifndef WRAITH_STACK_H
#define WRAITH_STACK_H
#include <stdint.h>
#include "ast.h"
typedef struct StackFrame
{
Node **statements;
uint32_t statementCount;
uint32_t statementCapacity;
Node **declarations;
uint32_t declarationCount;
uint32_t declarationCapacity;
} StackFrame;
typedef struct Stack
{
StackFrame *stackFrames;
uint32_t stackCapacity;
uint32_t stackIndex;
} Stack;
Stack* CreateStack()
{
Stack *stack = (Stack*) malloc(sizeof(Stack));
stack->stackCapacity = 4;
stack->stackFrames = (StackFrame*) malloc(sizeof(StackFrame) * stack->stackCapacity);
stack->stackIndex = 0;
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].statementCapacity = 0;
stack->stackFrames[stack->stackIndex].declarationCapacity = 0;
}
stack->stackFrames[stack->stackIndex].statementCount = 0;
stack->stackFrames[stack->stackIndex].declarationCount = 0;
}
void PopStackFrame(Stack *stack)
{
stack->stackIndex -= 1;
}
void AddStatement(Stack *stack, Node *statementNode)
{
StackFrame *stackFrame = &stack->stackFrames[stack->stackIndex];
if (stackFrame->statementCount == stackFrame->statementCapacity)
{
stackFrame->statementCapacity += 1;
stackFrame->statements = (Node**) realloc(stackFrame->statements, stackFrame->statementCapacity);
}
stackFrame->statements[stackFrame->statementCount] = statementNode;
stackFrame->statementCount += 1;
}
Node** GetStatements(Stack *stack, uint32_t *pCount)
{
*pCount = stack->stackFrames[stack->stackIndex].statementCount;
return stack->stackFrames[stack->stackIndex].statements;
}
void AddDeclaration(Stack *stack, Node *declarationNode)
{
StackFrame *stackFrame = &stack->stackFrames[stack->stackIndex];
if (stackFrame->declarationCount == stackFrame->declarationCapacity)
{
stackFrame->declarationCapacity += 1;
stackFrame->declarations = (Node**) realloc(stackFrame->declarations, stackFrame->declarationCapacity);
}
stackFrame->declarations[stackFrame->declarationCount] = declarationNode;
stackFrame->declarationCount += 1;
}
Node** GetDeclarations(Stack *stack, uint32_t *pCount)
{
*pCount = stack->stackFrames[stack->stackIndex].declarationCount;
return stack->stackFrames[stack->stackIndex].declarations;
}
#endif /* WRAITH_STACK_H */

View File

@ -8,6 +8,7 @@
"double" return DOUBLE; "double" return DOUBLE;
"string" return STRING; "string" return STRING;
"bool" return BOOL; "bool" return BOOL;
"struct" return STRUCT;
[a-zA-Z][a-zA-Z0-9]* return ID; [a-zA-Z][a-zA-Z0-9]* return ID;
\"[a-zA-Z][a-zA-Z0-9]*\" return STRING_LITERAL; \"[a-zA-Z][a-zA-Z0-9]*\" return STRING_LITERAL;
"+" return PLUS; "+" return PLUS;

155
wraith.y
View File

@ -1,14 +1,17 @@
%{ %{
#include <stdio.h> #include <stdio.h>
#include "ast.h" #include "ast.h"
#include "stack.h"
#define YYSTYPE struct Node* #define YYSTYPE struct Node*
void yyerror(FILE *fp, char *s) void yyerror(FILE *fp, char *s)
{ {
fprintf (stderr, "%s\n", s); fprintf (stderr, "%s\n", s);
} }
Node **statements;
uint32_t statementCount; Stack *stack;
uint32_t i;
#define YYDEBUG 1
int yydebug=1;
%} %}
%token NUMBER %token NUMBER
@ -18,6 +21,7 @@ uint32_t i;
%token DOUBLE %token DOUBLE
%token STRING %token STRING
%token BOOL %token BOOL
%token STRUCT
%token ID %token ID
%token STRING_LITERAL %token STRING_LITERAL
%token PLUS %token PLUS
@ -53,14 +57,45 @@ uint32_t i;
%left LEFT_PAREN RIGHT_PAREN %left LEFT_PAREN RIGHT_PAREN
%% %%
Program : Statements Program : Declarations
{ {
for (i = 0; i < statementCount; i += 1) Node **declarations;
{ Node *declarationSequence;
PrintTree(statements[i], 0); uint32_t declarationCount;
}
declarations = GetDeclarations(stack, &declarationCount);
declarationSequence = MakeDeclarationSequenceNode(declarations, declarationCount);
PopStackFrame(stack);
PrintTree(declarationSequence, 0);
} }
Type : INT
{
$$ = MakeTypeNode(Int);
}
| UINT
{
$$ = MakeTypeNode(UInt);
}
| FLOAT
{
$$ = MakeTypeNode(Float);
}
| DOUBLE
{
$$ = MakeTypeNode(Double);
}
| STRING
{
$$ = MakeTypeNode(String);
}
| BOOL
{
$$ = MakeTypeNode(Bool);
}
;
Identifier : ID Identifier : ID
{ {
$$ = MakeIdentifierNode(yytext); $$ = MakeIdentifierNode(yytext);
@ -76,6 +111,9 @@ PrimaryExpression : Identifier
$$ = MakeStringNode(yytext); $$ = MakeStringNode(yytext);
} }
| LEFT_PAREN Expression RIGHT_PAREN | LEFT_PAREN Expression RIGHT_PAREN
{
$$ = $2;
}
; ;
UnaryExpression : BANG Expression UnaryExpression : BANG Expression
@ -97,29 +135,9 @@ Expression : PrimaryExpression
| BinaryExpression | BinaryExpression
; ;
VariableDeclaration : INT ID VariableDeclaration : Type Identifier SEMICOLON
{ {
$$ = MakeDeclarationNode(Int, yytext); $$ = MakeDeclarationNode($1, $2);
}
| UINT ID
{
$$ = MakeDeclarationNode(UInt, yytext);
}
| FLOAT ID
{
$$ = MakeDeclarationNode(Float, yytext);
}
| DOUBLE ID
{
$$ = MakeDeclarationNode(Double, yytext);
}
| STRING ID
{
$$ = MakeDeclarationNode(String, yytext);
}
| BOOL ID
{
$$ = MakeDeclarationNode(Bool, yytext);
} }
AssignmentStatement : VariableDeclaration EQUAL Expression AssignmentStatement : VariableDeclaration EQUAL Expression
@ -131,20 +149,80 @@ AssignmentStatement : VariableDeclaration EQUAL Expression
$$ = MakeAssignmentNode($1, $3); $$ = MakeAssignmentNode($1, $3);
} }
Statement : AssignmentStatement PartialStatement : AssignmentStatement
| VariableDeclaration
; ;
CompleteStatement : Statement SEMICOLON; Statement : PartialStatement SEMICOLON;
Statements : Statements CompleteStatement Statements : Statement
{ {
statements = realloc(statements, statementCount + 1); Node **statements;
statements[statementCount] = $2; uint32_t statementCount;
statementCount += 1;
AddStatement(stack, $1);
statements = GetStatements(stack, &statementCount);
$$ = MakeStatementSequenceNode(statements, statementCount);
PopStackFrame(stack);
}
| Statement Statements
{
AddStatement(stack, $2);
}
Arguments : Arguments COMMA VariableDeclaration
| VariableDeclaration
;
Body : LEFT_BRACE Statements RIGHT_BRACE
{
$$ = $2;
}
FunctionSignature : Type Identifier LEFT_PAREN Arguments RIGHT_PAREN
{
$$ = MakeFunctionSignatureNode($2, $1, $4);
}
FunctionDeclaration : FunctionSignature Body
{
$$ = MakeFunctionDeclarationNode($1, $2);
}
VariableDeclarations : VariableDeclaration VariableDeclarations
{
AddDeclaration(stack, $1);
} }
| |
{ {
$$ = NULL; PushStackFrame(stack);
}
StructDeclaration : STRUCT Identifier LEFT_BRACE VariableDeclarations RIGHT_BRACE
{
Node **declarations;
Node *declarationSequence;
uint32_t declarationCount;
declarations = GetDeclarations(stack, &declarationCount);
declarationSequence = MakeDeclarationSequenceNode(declarations, declarationCount);
$$ = MakeStructDeclarationNode($2, declarationSequence);
PopStackFrame(stack);
}
Declaration : StructDeclaration
| FunctionDeclaration
;
Declarations : Declaration Declarations
{
AddDeclaration(stack, $1);
}
|
{
PushStackFrame(stack);
} }
%% %%
@ -158,9 +236,12 @@ int main(int argc, char *argv[])
return 1; return 1;
} }
stack = CreateStack();
FILE *fp = fopen(argv[1], "r"); FILE *fp = fopen(argv[1], "r");
yyin = fp; yyin = fp;
yyparse(fp); yyparse(fp);
fclose(fp); fclose(fp);
return 0; return 0;
} }