scarlett/compiler-the-translators
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'Dev' into MoreTypeCheck

Browse Source
This commit is contained in:
Moroseui
2025-05-02 17:26:29 -04:00
committed by GitHub
parent c32e85c24b 6434b7dfeb
commit e7aae04952
15 changed files with 476 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -3,7 +3,8 @@ CC := gcc
FLEX := flex FLEX := flex
BISON = bison BISON = bison
CFLAGS := -ggdb CFLAGS := -ggdb -g -O0 #-fsanitize=address
# LDFLAGS := -fsanitize=address
BISONFLAGS := -d -Wcounterexamples BISONFLAGS := -d -Wcounterexamples
LEX := src/lexicalStructure.lex LEX := src/lexicalStructure.lex
@ -24,7 +25,7 @@ TESTS-S4 := $(wildcard tests/sprint4/test/*.alpha)
all: compiler all: compiler
compiler: clean tmp $(OBJS) compiler: clean tmp $(OBJS)
$(CC) $(CFLAGS) -o $(EXE) $(OBJS) $(CC) $(CFLAGS) -o $(EXE) $(OBJS) $(LDFLAGS)
clean: clean:
rm -f $(EXE) rm -f $(EXE)

94
src/codegen.c
View File

@ -46,7 +46,7 @@ int generate(){
break; break;
case E_IF_X_TRUE: case E_IF_X_TRUE:
generateIfTrue(i); generateIfTrue(i);
break; break;
case E_IF_X_FALSE: case E_IF_X_FALSE:
generateIfFalse(i); generateIfFalse(i);
break; break;
@ -118,7 +118,7 @@ CGNode *findCG(TableNode *tn) {
CGNode *addCG(TableNode *tn, int sp) { CGNode *addCG(TableNode *tn, int sp) {
CGNode *cg = calloc(1, sizeof(CGNode)); CGNode *cg = calloc(1, sizeof(CGNode));
cg->tn = tn; cg->tn = tn;
offset += 4; // <- quick fix getPrimSize(getTypeEntry(tn)) offset += getPrimSize(getTypeEntry(tn));
cg->address = offset; cg->address = offset;
cg->next = cgList; cg->next = cgList;
cgList = cg; cgList = cg;
@ -139,7 +139,7 @@ int generateAdd(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateAdd failed, NULL operand"); printdebug("generateAdd failed, NULL operand");
return -1; return -1;
@ -148,8 +148,8 @@ int generateAdd(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op1)); CGNode *op2CG = findCG(getTN(op1));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -177,7 +177,7 @@ int generateSub(Instruction *instruction) {
TNodeOrConst *op1 = getOperand1(instruction); TNodeOrConst *op1 = getOperand1(instruction);
TNodeOrConst *op2 = getOperand2(instruction); TNodeOrConst *op2 = getOperand2(instruction);
CGNode *cg = findCG(getResult(instruction)); CGNode *cg = findCG(getResult(instruction));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateSub failed, NULL operand"); printdebug("generateSub failed, NULL operand");
return -1; return -1;
@ -186,7 +186,7 @@ int generateSub(Instruction *instruction) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(instruction), offset); cg = addCG(getResult(instruction), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -214,7 +214,7 @@ int generateMult(Instruction *inst){
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateMult failed, NULL operand"); printdebug("generateMult failed, NULL operand");
return -1; return -1;
@ -250,7 +250,7 @@ int generateDiv(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateDiv failed, NULL operand"); printdebug("generateDiv failed, NULL operand");
return -1; return -1;
@ -259,7 +259,7 @@ int generateDiv(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -275,7 +275,7 @@ int generateDiv(Instruction *inst) {
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#division start\n", getAddress(op1CG)); //moves dividend into eax fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#division start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result
return 0; return 0;
} }
@ -288,7 +288,7 @@ int generateMod(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateMod failed, NULL operand"); printdebug("generateMod failed, NULL operand");
return -1; return -1;
@ -303,12 +303,12 @@ int generateMod(Instruction *inst) {
printdebug("generateMod failed, op1 is not constant but not in CGlist"); printdebug("generateMod failed, op1 is not constant but not in CGlist");
return -1; return -1;
} }
if (op2CG == NULL) { if (op2CG == NULL) {
printdebug("generateMod failed, %s is not initialized/in CG", getName(getTN(op2))); printdebug("generateMod failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1; return -1;
} }
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#mod start\n", getAddress(op1CG)); //moves dividend into eax fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#mod start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
@ -325,7 +325,7 @@ int generateOr(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("generateOr failed, NULL operand"); printdebug("generateOr failed, NULL operand");
return -1; return -1;
@ -334,7 +334,7 @@ int generateOr(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -349,22 +349,22 @@ int generateOr(Instruction *inst) {
int label = label_gen(); int label = label_gen();
fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG)); fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG));
fprintf(cg_flag, "\tjne\t.L%dor2\n", label); fprintf(cg_flag, "\tjne\t.L%dor2\n", label);
fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG)); fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
fprintf(cg_flag, "\tje\t.L%dor3\n", label); fprintf(cg_flag, "\tje\t.L%dor3\n", label);
fprintf(cg_flag, ".L%dor2:\n", label); fprintf(cg_flag, ".L%dor2:\n", label);
fprintf(cg_flag, "\tmovl\t$1, %%eax\n"); fprintf(cg_flag, "\tmovl\t$1, %%eax\n");
fprintf(cg_flag, "\tjmp\t.L%dor4\n", label); fprintf(cg_flag, "\tjmp\t.L%dor4\n", label);
fprintf(cg_flag, ".L%dor3:\n", label); fprintf(cg_flag, ".L%dor3:\n", label);
fprintf(cg_flag, "\tmovl\t$0, %%eax\n"); fprintf(cg_flag, "\tmovl\t$0, %%eax\n");
fprintf(cg_flag, ".L%dor4:\n", label); fprintf(cg_flag, ".L%dor4:\n", label);
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg)); fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result
return 0; return 0;
} }
@ -377,7 +377,7 @@ int generateAnd(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("%sgenerateAnd failed, NULL operand", COLOR_RED); printdebug("%sgenerateAnd failed, NULL operand", COLOR_RED);
return -1; return -1;
@ -386,7 +386,7 @@ int generateAnd(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -400,27 +400,27 @@ int generateAnd(Instruction *inst) {
} }
int label = label_gen(); int label = label_gen();
fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG)); fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
fprintf(cg_flag, "\tje\t.L%dor2\n", label); fprintf(cg_flag, "\tje\t.L%dor2\n", label);
fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG)); fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
fprintf(cg_flag, "\tje\t.L%dor2\n", label); fprintf(cg_flag, "\tje\t.L%dor2\n", label);
fprintf(cg_flag, "\tmovl\t$1, %%eax\n"); fprintf(cg_flag, "\tmovl\t$1, %%eax\n");
fprintf(cg_flag, "\tjmp\t.L%dor3\n", label); fprintf(cg_flag, "\tjmp\t.L%dor3\n", label);
fprintf(cg_flag, ".L%dor2:\n", label); fprintf(cg_flag, ".L%dor2:\n", label);
fprintf(cg_flag, "\tmovl\t$0, %%eax\n"); fprintf(cg_flag, "\tmovl\t$0, %%eax\n");
fprintf(cg_flag, ".L%dor3:\n", label); fprintf(cg_flag, ".L%dor3:\n", label);
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg)); fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result
return 0; return 0;
} }
int generateNeg(Instruction *inst) { int generateNeg(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL) { if (op1 == NULL) {
printdebug("generateNeg failed, NULL operand"); printdebug("generateNeg failed, NULL operand");
return -1; return -1;
@ -429,14 +429,14 @@ int generateNeg(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
if (op1CG == NULL) { if (op1CG == NULL) {
printdebug("generateNeg failed, op1 is not constant but not in CGlist"); printdebug("generateNeg failed, op1 is not constant but not in CGlist");
return -1; return -1;
} }
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#negation start\n", getAddress(op1CG)); fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#negation start\n", getAddress(op1CG));
fprintf(cg_flag, "\tnegl\t%%eax\n"); fprintf(cg_flag, "\tnegl\t%%eax\n");
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#negation end\n", getAddress(cg)); fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#negation end\n", getAddress(cg));
return 0; return 0;
@ -444,7 +444,7 @@ int generateNeg(Instruction *inst) {
int generateNot(Instruction *inst) { int generateNot(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL) { if (op1 == NULL) {
printdebug("generateNot failed, NULL operand"); printdebug("generateNot failed, NULL operand");
return -1; return -1;
@ -453,7 +453,7 @@ int generateNot(Instruction *inst) {
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
if (op1CG == NULL) { if (op1CG == NULL) {
printdebug("generateNot failed, op1 is not constant but not in CGlist"); printdebug("generateNot failed, op1 is not constant but not in CGlist");
@ -474,7 +474,7 @@ int generateAssign(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL) { if (op1 == NULL) {
printdebug("generateAssign failed, NULL operand"); printdebug("generateAssign failed, NULL operand");
return -1; return -1;
@ -490,14 +490,14 @@ int generateAssign(Instruction *inst) {
fprintf(cg_flag, "\tmovl\t$%d, %d(%%rbp)\t#constant assign\n", getConst(op1), getAddress(cg)); fprintf(cg_flag, "\tmovl\t$%d, %d(%%rbp)\t#constant assign\n", getConst(op1), getAddress(cg));
return 0; return 0;
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
if (op1CG == NULL) { if (op1CG == NULL) {
printdebug("generateAssign failed, op1 is not constant but not in CGlist"); printdebug("generateAssign failed, op1 is not constant but not in CGlist");
return -1; return -1;
} }
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG)); fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG));
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign end\n", getAddress(cg)); fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign end\n", getAddress(cg));
return 0; return 0;
} }
@ -528,7 +528,7 @@ int generateLessThan(Instruction *inst){
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED); printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED);
return -1; return -1;
@ -537,7 +537,7 @@ int generateLessThan(Instruction *inst){
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -550,7 +550,7 @@ int generateLessThan(Instruction *inst){
return -1; return -1;
} }
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#less than start\n", getAddress(op1CG)); fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#less than start\n", getAddress(op1CG));
fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG)); fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tsetl\t%%al\n"); fprintf(cg_flag, "\tsetl\t%%al\n");
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#less than end\n", getAddress(cg)); fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#less than end\n", getAddress(cg));
@ -566,7 +566,7 @@ int generateEqualTo(Instruction *inst){
TNodeOrConst *op1 = getOperand1(inst); TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst); TNodeOrConst *op2 = getOperand2(inst);
CGNode *cg = findCG(getResult(inst)); CGNode *cg = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) { if (op1 == NULL || op2 == NULL) {
printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED); printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED);
return -1; return -1;
@ -575,7 +575,7 @@ int generateEqualTo(Instruction *inst){
if (cg == NULL) { if (cg == NULL) {
cg = addCG(getResult(inst), offset); cg = addCG(getResult(inst), offset);
} }
CGNode *op1CG = findCG(getTN(op1)); CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2)); CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) { if (op1CG == NULL) {
@ -588,7 +588,7 @@ int generateEqualTo(Instruction *inst){
return -1; return -1;
} }
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG)); fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG));
fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG)); fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tsete\t%%al\n"); fprintf(cg_flag, "\tsete\t%%al\n");
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg)); fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg));
@ -614,4 +614,4 @@ int generateAddressOf(Instruction *instruction){
int generateParam(Instruction *instruction){ int generateParam(Instruction *instruction){
//need to check if op1 is null, then add it to the appropriate register/cg node. need a way to keep track of this, maybe just have global count of params generated //need to check if op1 is null, then add it to the appropriate register/cg node. need a way to keep track of this, maybe just have global count of params generated
return -1; return -1;
} }

4
src/grammar.h
View File

@ -31,4 +31,6 @@ int offset;
int currentsp; int currentsp;
CGNode *cgList; CGNode *cgList;
extern Stack* stack; Stack* stack;
Stack* TrueList;
Stack* FalseList;

318
src/grammar.y
View File

@ -123,7 +123,7 @@ prototype_or_definition_list:
prototype: prototype:
L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID
; ;
@ -131,40 +131,29 @@ prototype:
definition: definition:
TYPE ID COLON TYPE ID COLON
{ {
printdebug("Currently see a record definition for %s", $2); printdebug("Currently see a record definition for %s", $2);
tn = CreateEntry(getAncestor(cur),TYPE_RECORD_TYPE, recprime, $2, CreateRecordInfo(0, cur = CreateScope(cur, 0, 0))); tn = CreateEntry(getAncestor(cur),TYPE_RECORD_TYPE, recprime, $2, CreateRecordInfo(0, cur = CreateScope(cur, 0, 0)));
printdebug("Created a new scope"); printdebug("Created a new scope");
//if (look_up(cur, $2) == undefined) { } dblock {
// printdebug("rec not found");
//}
}
dblock
{
//We are scanning through the dblock scope to get the length of the dblock (num of elements) from getRecSize
//and then putting it in the entry that we created above.
setRecSize(look_up(getParent(cur), $2), getRecSize(cur)); setRecSize(look_up(getParent(cur), $2), getRecSize(cur));
//putting in all the offsets
setRecOffsetInfo(cur, look_up(getParent(cur),$2)); setRecOffsetInfo(cur, look_up(getParent(cur),$2));
printdebug("Moving up a scope after seeing a record definition"); printdebug("Moving up a scope after seeing a record definition");
cur = getParent(cur); cur = getParent(cur);
} }
| TYPE ID COLON C_INTEGER ARROW id_or_types | TYPE ID COLON C_INTEGER ARROW id_or_types
{ {
printdebug("Currently see a array definition of name %s,storing type %s, of dimensions %d", $2, getName((TableNode*)$6), $4); printdebug("Currently see a array definition of name %s,storing type %s, of dimensions %d", $2, getName((TableNode*)$6), $4);
CreateEntry(cur,TYPE_ARRAY_TYPE, arrayprim, $2, CreateArrayInfo($4, (TableNode*)$6)); CreateEntry(cur,TYPE_ARRAY_TYPE, arrayprim, $2, CreateArrayInfo($4, (TableNode*)$6));
printdebug("%sID: %s, dimensions: %d, typeOfArray: %s", COLOR_GREEN, $2, $4, getName((TableNode*)$6)); printdebug("%sID: %s, dimensions: %d, typeOfArray: %s", COLOR_GREEN, $2, $4, getName((TableNode*)$6));
} }
| function_declaration | function_declaration
| TYPE ID COLON id_or_types ARROW id_or_types | TYPE ID COLON id_or_types ARROW id_or_types
{ {
printdebug("Currently see a function type definition of name %s,parameter type %s, of return type %s", $2, getName((TableNode*)$4), getName((TableNode*)$6)); printdebug("Currently see a function type definition of name %s,parameter type %s, of return type %s", $2, getName((TableNode*)$4), getName((TableNode*)$6));
CreateEntry(cur,TYPE_FUNCTION_TYPE,funtypeprime,$2,CreateFunctionTypeInfo((TableNode*)$4 ,(TableNode*)$6)); CreateEntry(cur,TYPE_FUNCTION_TYPE,funtypeprime,$2,CreateFunctionTypeInfo((TableNode*)$4 ,(TableNode*)$6));
} }
| ID { | ID {
emit_function_start(table_lookup(cur,$1)); emit_function_start(table_lookup(cur,$1));
//printf("ID: %s\n", $1); //printf("ID: %s\n", $1);
@ -175,11 +164,11 @@ definition:
printdebug("Undefined node declared."); printdebug("Undefined node declared.");
}else if(getAdInfoType(node) != TYPE_FUNCTION_DECLARATION){ }else if(getAdInfoType(node) != TYPE_FUNCTION_DECLARATION){
throw_error(ERROR_SYNTAX, "Not a valid function declaration."); throw_error(ERROR_SYNTAX, "Not a valid function declaration.");
} }
else { else {
printdebug("setting as keyword to true"); printdebug("setting as keyword to true");
setStartLine(node, @1.first_line); setStartLine(node, @1.first_line);
setAsKeyword(node, true); setAsKeyword(node, true);
} }
cur = CreateScope(cur, 0, 0); cur = CreateScope(cur, 0, 0);
printdebug("Created a new scope"); printdebug("Created a new scope");
@ -195,10 +184,10 @@ definition:
|| type_of_param_type == TYPE_FUNCTION_DECLARATION || type_of_param_type == TYPE_FUNCTION_DECLARATION
|| type_of_param_type == TYPE_ARRAY || type_of_param_type == TYPE_ARRAY
|| type_of_param_type == TYPE_PRIMITIVE || type_of_param_type == TYPE_PRIMITIVE
|| type_of_param_type == TYPE_ALL_ELSE || type_of_param_type == TYPE_ALL_ELSE
|| type_of_param_type == TYPE_SYSTEM_DEFINED || type_of_param_type == TYPE_SYSTEM_DEFINED
|| type_of_param_type == TYPE_RECORD || type_of_param_type == TYPE_RECORD
|| type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused
throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(parameter)); throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(parameter));
type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases
} }
@ -230,10 +219,10 @@ definition:
|| type_of_param_type == TYPE_FUNCTION_TYPE || type_of_param_type == TYPE_FUNCTION_TYPE
|| type_of_param_type == TYPE_ARRAY_TYPE || type_of_param_type == TYPE_ARRAY_TYPE
|| type_of_param_type == TYPE_PRIMITIVE_TYPE || type_of_param_type == TYPE_PRIMITIVE_TYPE
|| type_of_param_type == TYPE_ALL_ELSE || type_of_param_type == TYPE_ALL_ELSE
|| type_of_param_type == TYPE_SYSTEM_DEFINED || type_of_param_type == TYPE_SYSTEM_DEFINED
|| type_of_param_type == TYPE_RECORD_TYPE || type_of_param_type == TYPE_RECORD_TYPE
|| type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused
throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(entry)); throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(entry));
type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases
}else{ }else{
@ -259,6 +248,7 @@ definition:
if(type_of_param_type == TYPE_PRIMITIVE){ if(type_of_param_type == TYPE_PRIMITIVE){
printdebug("primitive type of parameter inside record"); printdebug("primitive type of parameter inside record");
CreateEntry(cur, TYPE_PRIMITIVE, getTypeEntry(entry),NULL, getAdInfo(entry)); CreateEntry(cur, TYPE_PRIMITIVE, getTypeEntry(entry),NULL, getAdInfo(entry));
//throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");} //throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");}
} }
if(type_of_param_type == TYPE_RECORD){ if(type_of_param_type == TYPE_RECORD){
@ -266,6 +256,7 @@ definition:
CreateEntry(cur, TYPE_RECORD, getTypeEntry(entry),NULL, getAdInfo(entry)); CreateEntry(cur, TYPE_RECORD, getTypeEntry(entry),NULL, getAdInfo(entry));
//throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");} //throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");}
} }
/*printdebug("creating entry of type %s for function", getType(entry)); /*printdebug("creating entry of type %s for function", getType(entry));
CreateEntry(cur, getTypeEntry(entry), "undefined", NULL);*/ CreateEntry(cur, getTypeEntry(entry), "undefined", NULL);*/
} }
@ -289,13 +280,13 @@ definition:
} }
//printf("Ending ID: %s\n", $1); //printf("Ending ID: %s\n", $1);
//printf("Ending Type: %s\n", getType(table_lookup(getAncestor(cur), $1))); //printf("Ending Type: %s\n", getType(table_lookup(getAncestor(cur), $1)));
} }
; ;
function_declaration: function_declaration:
FUNCTION ID COLON ID FUNCTION ID COLON ID
{ {
if(getAdInfoType(table_lookup(cur, $4))==TYPE_FUNCTION_TYPE){ if(getAdInfoType(table_lookup(cur, $4))==TYPE_FUNCTION_TYPE){
//printf("%s\n",$2); //printf("%s\n",$2);
//printf("%s\n",getName(table_lookup(cur, $4))); //printf("%s\n",getName(table_lookup(cur, $4)));
@ -309,7 +300,7 @@ function_declaration:
} }
| EXTERNAL FUNCTION ID COLON ID | EXTERNAL FUNCTION ID COLON ID
{ {
if(getAdInfoType(look_up(cur, $5))==TYPE_FUNCTION_TYPE){ if(getAdInfoType(look_up(cur, $5))==TYPE_FUNCTION_TYPE){
CreateEntry(cur,TYPE_FUNCTION_DECLARATION, look_up(cur, $5), $3, CreateFunctionDeclarationInfo(-1, false)); CreateEntry(cur,TYPE_FUNCTION_DECLARATION, look_up(cur, $5), $3, CreateFunctionDeclarationInfo(-1, false));
} }
@ -357,7 +348,7 @@ idlist:
{ {
$$ = $4 + 1; $$ = $4 + 1;
} }
| ID | ID
{ printdebug("idlist rule 2 ID: %s", $1); { printdebug("idlist rule 2 ID: %s", $1);
TableNode *entry = getFirstEntry(cur); TableNode *entry = getFirstEntry(cur);
@ -379,13 +370,14 @@ idlist:
printdebug("Type of entry is %s", getType(entry)); printdebug("Type of entry is %s", getType(entry));
printdebug("tag is %d", getAdInfoType(entry)); printdebug("tag is %d", getAdInfoType(entry));
} }
; ;
sblock: sblock:
L_BRACE L_BRACE
{ {
// emit_label(label_gen());
if (getLine(cur) != 0) { if (getLine(cur) != 0) {
cur = CreateScope(cur,@1.first_line,@1.first_column); cur = CreateScope(cur,@1.first_line,@1.first_column);
printdebug("Created a new scope"); printdebug("Created a new scope");
@ -402,7 +394,7 @@ sblock:
} }
R_BRACE R_BRACE
{$$ = $3;} {$$ = $3;}
| L_BRACE | L_BRACE
{ {
if (getLine(cur) != 0) { if (getLine(cur) != 0) {
@ -423,87 +415,95 @@ sblock:
printdebug("Moving up a scope after seeing sblock with dblock"); printdebug("Moving up a scope after seeing sblock with dblock");
cur = getParent(cur); cur = getParent(cur);
//$<tn>$ = $5; //$<tn>$ = $5;
} }
R_BRACE R_BRACE
{$$ = $5;} {$$ = $5;}
; ;
dblock: dblock:
L_BRACKET L_BRACKET
{ {
if (getLine(cur) == 0) { if (getLine(cur) == 0) {
setLineNumber(cur, @1.first_line); setLineNumber(cur, @1.first_line);
setColumnNumber(cur,@1.first_line); setColumnNumber(cur,@1.first_line);
printdebug("Did not create a new scope when saw dblock, set line number to %d instead", @1.first_line); printdebug("Did not create a new scope when saw dblock, set line number to %d instead", @1.first_line);
} else{ } else{
//cur = CreateScope(cur,@1.first_line,@1.first_column); // <----- What is this? //cur = CreateScope(cur,@1.first_line,@1.first_column); // <----- What is this?
printdebug("Created a new scope when seeing a dblock"); printdebug("Created a new scope when seeing a dblock");
} }
} }
declaration_list R_BRACKET declaration_list R_BRACKET
; ;
declaration_list: declaration_list:
declaration SEMI_COLON declaration_list declaration SEMI_COLON declaration_list
| declaration | declaration
| error SEMI_COLON { yyerrok; } declaration_list //only perform error recovery once we see semi-colon | error SEMI_COLON { yyerrok; } declaration_list //only perform error recovery once we see semi-colon
; ;
declaration: declaration:
id_or_types COLON ID id_or_types COLON ID
{ {
printdebug("ID/TYPE: %s, ID: %s", getName((TableNode*)$1), $3) ; printdebug("ID/TYPE: %s, ID: %s", getName((TableNode*)$1), $3) ;
int d = getAdInfoType((TableNode*)$1); int d = getAdInfoType((TableNode*)$1);
if(d == TYPE_UNDEFINED) { if(d == TYPE_UNDEFINED) {
throw_error(ERROR_TYPE, "Undefined type passed in declaration list"); throw_error(ERROR_TYPE, "Undefined type passed in declaration list");
printdebug("Undefined type passed in declaration list"); printdebug("Undefined type passed in declaration list");
CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)); CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1));
} }
else if(d == TYPE_FUNCTION_TYPE) { else if(d == TYPE_FUNCTION_TYPE) {
printdebug("invalid (function) type passed in declaration list in dblock", @2.first_line, @2.first_column); printdebug("invalid (function) type passed in declaration list in dblock", @2.first_line, @2.first_column);
d = TYPE_FUNCTION_DECLARATION; d = TYPE_FUNCTION_DECLARATION;
if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){ if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
throw_error(ERROR_TYPE, "Duplicate defination of function in declaration list"); throw_error(ERROR_TYPE, "Duplicate defination of function in declaration list");
} }
} }
else if(d == TYPE_ARRAY_TYPE){ else if(d == TYPE_ARRAY_TYPE){
printdebug("array variable at line %d and column %d", @2.first_line, @2.first_column); printdebug("array variable at line %d and column %d", @2.first_line, @2.first_column);
d = TYPE_ARRAY; d = TYPE_ARRAY;
if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){ if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
throw_error(ERROR_TYPE, "Duplicate defination of array in declaration list"); throw_error(ERROR_TYPE, "Duplicate defination of array in declaration list");
} }
} }
else if(d == TYPE_RECORD_TYPE){ else if(d == TYPE_RECORD_TYPE){
printdebug("record variable at line %d and column %d", @2.first_line, @2.first_column); printdebug("record variable at line %d and column %d", @2.first_line, @2.first_column);
d = TYPE_RECORD; d = TYPE_RECORD;
if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1))== undefined){ if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1))== undefined){
throw_error(ERROR_TYPE, "Duplicate defination of record in declaration list"); throw_error(ERROR_TYPE, "Duplicate defination of record in declaration list");
} }
} }
else if(d == TYPE_PRIMITIVE_TYPE){ else if(d == TYPE_PRIMITIVE_TYPE){
printdebug("primitive variable at line %d and column %d", @2.first_line, @2.first_column); printdebug("primitive variable at line %d and column %d", @2.first_line, @2.first_column);
d = TYPE_PRIMITIVE; d = TYPE_PRIMITIVE;
if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){ if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
throw_error(ERROR_TYPE, "Duplicate defination of primitive in declaration list"); throw_error(ERROR_TYPE, "Duplicate defination of primitive in declaration list");
} }
}else { }else {
throw_error(ERROR_TYPE, "%s is being defined with an undefined type", $3); throw_error(ERROR_TYPE, "%s is being defined with an undefined type", $3);
CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)); CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1));
} }
} }
; ;
@ -514,13 +514,13 @@ id_or_types:
printdebug("string of id is %s in ID pattern of id_or_type rule.", $1); printdebug("string of id is %s in ID pattern of id_or_type rule.", $1);
$$ = table_lookup(getAncestor(cur), $1); $$ = table_lookup(getAncestor(cur), $1);
} }
| types | types
{ {
printdebug("string of type is %s in types pattern of id_or_type rule.",getName((TableNode*)$1)); printdebug("string of type is %s in types pattern of id_or_type rule.",getName((TableNode*)$1));
$$ = (TableNode*)$1; $$ = (TableNode*)$1;
} }
; ;
@ -548,7 +548,7 @@ compound_statement statement_list {
} }
| compound_statement { | compound_statement {
$$ = $1; $$ = $1;
} }
| simple_statement SEMI_COLON statement_list{ | simple_statement SEMI_COLON statement_list{
if ($1 == undefined && $3 != undefined) { if ($1 == undefined && $3 != undefined) {
$$ = $3; $$ = $3;
@ -579,24 +579,55 @@ compound_statement statement_list {
compound_statement: compound_statement:
WHILE L_PAREN expression R_PAREN sblock { WHILE L_PAREN {
$$ = $5; S_Push(TrueList, S_Init(), 0);
} S_Push(FalseList, S_Init(), 0);
| IF L_PAREN expression R_PAREN THEN sblock ELSE sblock { int *l = calloc(1, sizeof(int));
if ($6 == undefined && $8 != undefined) { *l = label_gen();
emit_label(*l);
S_Push(stack, l, 2);
} expression R_PAREN {
emit_label(label_gen());
emit_backpatch(S_Pop(TrueList), getLabel(current));
} sblock {
$$ = $7;
int l = label_gen();
emit_backpatch(S_Pop(FalseList), l);
emit_goto(*(int*)(S_Pop(stack)));
emit_label(l);
}
| IF L_PAREN {
S_Push(TrueList, S_Init(), 0);
S_Push(FalseList, S_Init(), 0);
}expression R_PAREN THEN {
emit_label(label_gen());
emit_backpatch(S_Pop(TrueList), getLabel(current));
} sblock ELSE {
// NOTE we are not going back to
int l = label_gen();
emit_backpatch(S_Pop(FalseList), l);
S_Push(FalseList, S_Init(), 0);
emit_goto(0);
S_Push(S_Peek(FalseList), current, 1);
emit_label(l);
} sblock {
int l = label_gen();
emit_backpatch(S_Pop(FalseList), l);
emit_label(l);
if ($8 == undefined && $11 != undefined) {
$$ = $11;
} else if ($8 != undefined && $11 == undefined) {
$$ = $8; $$ = $8;
} else if ($6 != undefined && $8 == undefined) { } else if ($8 == $11) {
$$ = $6;
} else if ($6 == $8) {
$$ = $6;
}else if((getAdInfoType((TableNode*)$6) == TYPE_ARRAY_TYPE) && ((TableNode*)$8)==addr){
$$ = $6;
}else if((getAdInfoType((TableNode*)$6) == TYPE_RECORD_TYPE) && ((TableNode*)$8)==addr){
$$ = $6;
}else if(((TableNode*)$6)==addr && (getAdInfoType((TableNode*)$8) == TYPE_ARRAY_TYPE)){
$$ = $8; $$ = $8;
}else if(((TableNode*)$6)==addr && (getAdInfoType((TableNode*)$8) == TYPE_RECORD_TYPE)){ }else if((getAdInfoType((TableNode*)$8) == TYPE_ARRAY_TYPE) && ((TableNode*)$11)==addr){
$$ = $8; $$ = $8;
}else if((getAdInfoType((TableNode*)$8) == TYPE_RECORD_TYPE) && ((TableNode*)$11)==addr){
$$ = $8;
}else if(((TableNode*)$8)==addr && (getAdInfoType((TableNode*)$11) == TYPE_ARRAY_TYPE)){
$$ = $11;
}else if(((TableNode*)$8)==addr && (getAdInfoType((TableNode*)$11) == TYPE_RECORD_TYPE)){
$$ = $11;
} else { } else {
printdebug("3 differing return types within same function at line %d, column %d", @1.first_line, @1.first_column); printdebug("3 differing return types within same function at line %d, column %d", @1.first_line, @1.first_column);
//printf("%s\n", getName((TableNode*)$6)); //printf("%s\n", getName((TableNode*)$6));
@ -604,7 +635,7 @@ WHILE L_PAREN expression R_PAREN sblock {
$$ = undefined; $$ = undefined;
} }
} }
| sblock { | sblock {
$$ = $1; $$ = $1;
} }
@ -614,14 +645,14 @@ WHILE L_PAREN expression R_PAREN sblock {
simple_statement: simple_statement:
assignable ASSIGN expression assignable ASSIGN expression
{ printdebug("simple statement"); { printdebug("simple statement");
TableNode* node; TableNode* node;
if((getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_FUNCTION_TYPE)|| if((getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_FUNCTION_TYPE)||
(getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_ARRAY_TYPE)|| (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_ARRAY_TYPE)||
(getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_RECORD_TYPE)|| (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_RECORD_TYPE)||
(getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_PRIMITIVE_TYPE)){ (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_PRIMITIVE_TYPE)){
node = ((TableNode*)$1); node = ((TableNode*)$1);
} else { } else {
//printf("%d\n",getAdInfoType((getTypeEntry((TableNode*)$1)))); //printf("%d\n",getAdInfoType((getTypeEntry((TableNode*)$1))));
@ -643,8 +674,8 @@ simple_statement:
emit_assignment($1, tn_or_const(NODE, $3)); emit_assignment($1, tn_or_const(NODE, $3));
printdebug("%s[☺] Passed type check; %s = %s", COLOR_GREEN, getType(node), getType((TableNode*)$3)); printdebug("%s[☺] Passed type check; %s = %s", COLOR_GREEN, getType(node), getType((TableNode*)$3));
} }
else { else {
//printf("%d\n",getAdInfoType((TableNode*)$1)); //printf("%d\n",getAdInfoType((TableNode*)$1));
//printf("%d\n",getAdInfoType((TableNode*)$3)); //printf("%d\n",getAdInfoType((TableNode*)$3));
@ -660,9 +691,9 @@ simple_statement:
| RETURN expression { | RETURN expression {
$$ = getTypeEntry((TableNode*)$2); $$ = getTypeEntry((TableNode*)$2);
emit_return(tn_or_const(NODE,(TableNode*)$2));} emit_return(tn_or_const(NODE,(TableNode*)$2));}
|simple_statement error {yyerrok; printdebug("error in simple statement");} |simple_statement error {yyerrok; yyclearin; printdebug("error in simple statement");}
; ;
@ -670,49 +701,61 @@ simple_statement:
rec_op: rec_op:
DOT DOT
; ;
ablock: ablock:
L_PAREN argument_list R_PAREN L_PAREN{
if (stack == NULL){
stack = S_Init();
}
Stack * t = S_Init();
S_Push(stack, t, 0);
}
argument_list {
} R_PAREN
{ {
$$ = $2; // here
$$ = $3;
printdebug("ablock is %d", $$); printdebug("ablock is %d", $$);
} }
; ;
argument_list: argument_list:
//NEED TO EMIT PARAMETERS HERE. MAYBE USE STACK STRUCTURE
expression{ expression{
char* name = arg_var_gen(); TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), name, NULL); // ----------------------------------------------------------------------------
emit_parameter(tn_or_const(NODE,arg)); // this is emitting the param withthe wrong TableNode
//S_Push(stack,current); // We need to fiture out how to get the right one.
//emit_detach(); Stack * t = S_Peek(stack);
//printdebug("[ARGUMENT_LIST] argument list is %d", $$); if(t==NULL){
t = S_Init();
S_Push(stack, t, 1);
}
emit_parameter(tn_or_const(NODE,$1));
S_Push(t, current, 1);
emit_detach();
// ----------------------------------------------------------------------------
} }
COMMA argument_list COMMA argument_list
{$$ = $4 + 1;} {$$ = $4 + 1;}
| expression | expression
{ {
char* name = arg_var_gen(); TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), name, NULL); emit_parameter(tn_or_const(NODE,$1));
emit_parameter(tn_or_const(NODE,arg));
//S_Push(stack,current);
//emit_detach();
$$ = 1; $$ = 1;
printdebug("[ARGUMENT_LIST] argument list is %d", $$); printdebug("[ARGUMENT_LIST] argument list is %d", $$);
} }
; ;
@ -855,14 +898,27 @@ expression:
throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be Boolean", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3)); throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be Boolean", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3));
} }
} }
| expression LESS_THAN expression | expression LESS_THAN expression
{ {
emit_conditional_jump(E_LESS_THAN, 0, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
Stack * t = S_Peek(TrueList);
if(t==NULL){
t = S_Init();
S_Push(TrueList, t, 1);
}
S_Push(t, current, 1);
emit_goto(0);
t = S_Peek(FalseList);
if(t==NULL){
t = S_Init();
S_Push(FalseList, t, 1);
}
S_Push(t, current, 1);
printdebug("less than expression"); printdebug("less than expression");
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==integ) { if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==integ) {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL); TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
emit_binary_op(E_LESS_THAN,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node; $$ = node;
} else if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==boo){ } else if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==boo){
char* temp = temp_var_gen(); char* temp = temp_var_gen();
@ -881,9 +937,22 @@ expression:
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1) != undefined) { if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1) != undefined) {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL); TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
emit_binary_op(E_EQUAL_TO,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3)); emit_conditional_jump(E_EQUAL_TO, 0, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
Stack * t = S_Peek(TrueList);
if(t==NULL){
t = S_Init();
S_Push(TrueList, t, 1);
}
S_Push(t, current, 1);
emit_goto(0);
t = S_Peek(FalseList);
if(t==NULL){
t = S_Init();
S_Push(FalseList, t, 1);
}
S_Push(t, current, 1);
$$ = node; $$ = node;
} else { } else {
$$ = undefined; $$ = undefined;
throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be the same type", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3)); throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be the same type", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3));
@ -894,15 +963,19 @@ expression:
{ {
$$ = $1; $$ = $1;
} }
| L_PAREN expression R_PAREN | L_PAREN expression R_PAREN
{ {
printdebug("paren expression. current type is %s",getType((TableNode*)$2)); printdebug("paren expression. current type is %s",getType((TableNode*)$2));
$$=$2; $$=$2;
} }
| RESERVE assignable // TODO: We need to type check this.
{ | RESERVE ID {$$ = undefined; }
| RELEASE ID {$$ = undefined; }
| RESERVE ID L_PAREN argument_list R_PAREN {$$ = undefined; }
| RELEASE ID L_PAREN argument_list R_PAREN
{
int d = getAdInfoType((TableNode*)$2); int d = getAdInfoType((TableNode*)$2);
//commenting out type checks for now since assignable is being resolved to something before reserve is being applied which is tricky //commenting out type checks for now since assignable is being resolved to something before reserve is being applied which is tricky
//if(d == TYPE_ARRAY ||d == TYPE_RECORD) { //if(d == TYPE_ARRAY ||d == TYPE_RECORD) {
@ -915,6 +988,7 @@ expression:
// $$=undefined; // $$=undefined;
// } // }
} }
/*
| RELEASE assignable | RELEASE assignable
{ {
int d = getAdInfoType((TableNode*)$2); int d = getAdInfoType((TableNode*)$2);
@ -929,7 +1003,8 @@ expression:
// $$=undefined; // $$=undefined;
// } // }
} }
*/
; ;
//UPDATED $$ for tablenodes to this point //UPDATED $$ for tablenodes to this point
@ -938,17 +1013,16 @@ expression:
// add array case // add array case
// include type check for ablock in arrays - ablock is always the int of the elements in array/rec // include type check for ablock in arrays - ablock is always the int of the elements in array/rec
assignable: assignable:
ID ID
{ {
TableNode* pass = look_up(cur,$1); TableNode* pass = look_up(cur,$1);
if(pass == undefined){ if(pass == undefined){
throw_error(ERROR_TYPE, "Undefined variable %s", $1); throw_error(ERROR_TYPE, "Undefined variable %s", $1);
} }
$$ = pass; $$ = pass;
printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getType(pass), getName(pass)); printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getType(pass), getName(pass));
} }
| assignable
| assignable
{ {
printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN); printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN);
//Creating a dummy scope where we create entries for all the arguments of a function call //Creating a dummy scope where we create entries for all the arguments of a function call
@ -956,13 +1030,13 @@ assignable:
cur = CreateScope(cur, -1,-1); cur = CreateScope(cur, -1,-1);
} }
//we have to consider emmissions in ablocks //we have to consider emmissions in ablocks
ablock ablock
{ {
//int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1))); //int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
int type = getAdInfoType(getTypeEntry((TableNode*)$1)); int type = getAdInfoType(getTypeEntry((TableNode*)$1));
printdebug("%stype is %d", COLOR_PURPLE, type); printdebug("%stype is %d", COLOR_PURPLE, type);
printdebug("%s", getName((TableNode*)$1)); printdebug("%s", getName((TableNode*)$1));
if (type == TYPE_FUNCTION_TYPE) { if (type == TYPE_FUNCTION_TYPE) {
printdebug("%sEntering function call", COLOR_LIGHTGREEN); printdebug("%sEntering function call", COLOR_LIGHTGREEN);
//getting the parameter. The type of assignable is a function type so we need to access the paramater of the type //getting the parameter. The type of assignable is a function type so we need to access the paramater of the type
@ -1034,6 +1108,14 @@ assignable:
throw_error(ERROR_TYPE, "Undefined type returned by function."); throw_error(ERROR_TYPE, "Undefined type returned by function.");
} }
TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL); TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
//-----------------------------------------------------------------------------
// Please don't touch
// the + 1 is here because I don't detach the last param
int a = S_Size(S_Peek(stack)) + 1;
emit_push_all(S_Peek(stack));
S_Pop(stack);
emit_function_call(node, a, tn_or_const(NODE, $1));
//-----------------------------------------------------------------------------
$$ = node; $$ = node;
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK for function call) //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK for function call)
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName(typeNode2), getName((TableNode*)$1)); printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName(typeNode2), getName((TableNode*)$1));
@ -1062,8 +1144,8 @@ assignable:
throw_error(ERROR_TYPE, "Undefined type stored in array."); throw_error(ERROR_TYPE, "Undefined type stored in array.");
} }
TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL); TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
//emit assign here //TODO: emit assign here
//emit_array_access(char* node, char* array, ...) //TODO: emit_array_access(char* node, char* array, ...)
$$ = node; $$ = node;
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getType((TableNode*)$1), getName((TableNode*)$1)); printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getType((TableNode*)$1), getName((TableNode*)$1));
} }
@ -1086,8 +1168,8 @@ assignable:
} }
| assignable rec_op ID | assignable rec_op ID
{ {
if(getAdInfoType((TableNode*)$1) != TYPE_RECORD){ if(getAdInfoType((TableNode*)$1) != TYPE_RECORD){
throw_error(ERROR_TYPE, "Invalid type passed to record access"); throw_error(ERROR_TYPE, "Invalid type passed to record access");
$$ = undefined; $$ = undefined;
@ -1115,16 +1197,16 @@ assignable:
TableNode* node = CreateEntry(cur,t, type, temp, NULL); TableNode* node = CreateEntry(cur,t, type, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK) //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//emit_field_access(char* node, char* record, $3) //emit_field_access(char* node, char* record, $3)
$$=node; $$=node;
}else{ }else{
throw_error(ERROR_TYPE, "Invalid field access %s", $3); throw_error(ERROR_TYPE, "Invalid field access %s", $3);
$$=undefined; $$=undefined;
} }
printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3)); printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
} }
; ;
@ -1146,7 +1228,7 @@ constant:
printdebug("number of C_INTEGER in constant is %d", $1); printdebug("number of C_INTEGER in constant is %d", $1);
$$ = node; $$ = node;
} }
| C_NULL | C_NULL
{ {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
@ -1155,7 +1237,7 @@ constant:
printdebug("string of C_NULL in constant is NULL"); printdebug("string of C_NULL in constant is NULL");
$$ = node; $$ = node;
} }
| C_CHARACTER | C_CHARACTER
{ {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
@ -1164,7 +1246,7 @@ constant:
printdebug("string of C_CHARACTER in constant is %s",$1); printdebug("string of C_CHARACTER in constant is %s",$1);
$$ = node; $$ = node;
} }
| C_TRUE | C_TRUE
{ {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
@ -1174,7 +1256,7 @@ constant:
printdebug("string of C_TRUE in constant is true"); printdebug("string of C_TRUE in constant is true");
$$ = node; $$ = node;
} }
| C_FALSE | C_FALSE
{ {
char* temp = temp_var_gen(); char* temp = temp_var_gen();
@ -1189,25 +1271,25 @@ constant:
types: types:
T_INTEGER T_INTEGER
{ {
$$ = $1; $$ = $1;
printdebug("string of T_INTEGER in types is %s",getName((TableNode*)$1)); printdebug("string of T_INTEGER in types is %s",getName((TableNode*)$1));
} }
| T_ADDRESS | T_ADDRESS
{ {
$$ = $1; $$ = $1;
printdebug("string of T_ADDRESS in types is %s",getName((TableNode*)$1)); printdebug("string of T_ADDRESS in types is %s",getName((TableNode*)$1));
} }
| T_CHARACTER | T_CHARACTER
{ {
$$ = $1; $$ = $1;
printdebug("string of T_CHARACTER in types is %s",getName((TableNode*)$1)); printdebug("string of T_CHARACTER in types is %s",getName((TableNode*)$1));
} }
| T_BOOLEAN | T_BOOLEAN
{ {
$$ = $1; $$ = $1;
@ -1294,7 +1376,7 @@ void throw_error(ErrorType error_type, const char *format, ...) {
void yyerror(const char *err) { void yyerror(const char *err) {
int line = yylloc.first_line; int line = yylloc.first_line;
int column = yylloc.first_column; int column = yylloc.first_column;
// Grammar Fallback Case // Grammar Fallback Case
if (strcmp(err, "syntax error") == 0) { if (strcmp(err, "syntax error") == 0) {
if (asc_flag != NULL) { if (asc_flag != NULL) {

66
src/intermediate_code.c
View File

@ -15,16 +15,17 @@ void S_Free(Stack *s){
free(s); free(s);
} }
void S_Push(Stack * s, void *v) { void S_Push(Stack * s, void *v, int i) {
__Node * n = calloc(1, sizeof(*n)); __Node * n = calloc(1, sizeof(*n));
n->v = v; n->v = v;
n->next = s->n; n->next = s->n;
s->n = n; s->n = n;
s->w = i;
s->size = s->size + 1; s->size = s->size + 1;
} }
void * S_Pop(Stack *s) { void * S_Pop(Stack *s) {
if (s->size == 0) { if (s == NULL || S_IsEmpty(s)) {
return NULL; return NULL;
} }
__Node * node = s->n; __Node * node = s->n;
@ -37,22 +38,31 @@ void * S_Pop(Stack *s) {
void * S_Peek(Stack *s){ void * S_Peek(Stack *s){
if (!S_IsEmpty(s)) { if (s == NULL || S_IsEmpty(s)) {
return NULL; return NULL;
} }
return s->n->v; return s->n->v;
} }
bool S_IsEmpty(Stack *s){ bool S_IsEmpty(Stack *s){
if(!s->size) { if(s == NULL || s->size == 0) {
return true; return true;
} }
return false; return false;
} }
int S_Size(Stack *s){ int S_Size(Stack *s){
if (s == NULL || S_IsEmpty(s)) {
return 0;
}
return s->size; return s->size;
} }
void emit_backpatch(Stack * s, int l){
for (Instruction * i = S_Pop(s); i; i = S_Pop(s)){
i->label = l;
}
}
//_______________________________________________________________________ //_______________________________________________________________________
char * temp = NULL; char * temp = NULL;
@ -64,11 +74,28 @@ char * temp = NULL;
otherwise make it next of current and set cur to your instruction. otherwise make it next of current and set cur to your instruction.
*/ */
void emit_push_all(Stack * s){
for (Instruction * i = S_Pop(s); i; i = S_Pop(s)){
current->next = i;
i->prev = current;
i->index = current->index + 1;
current = i;
current->next = NULL;
}
}
void emit_detach(){ void emit_detach(){
current = current->prev; current = current->prev;
current->next = NULL; current->next = NULL;
} }
void backpatch(Stack *s, int l){
while (!S_IsEmpty(s)){
Instruction * i = S_Pop(s);
set_label(i, l);
}
}
TNodeOrConst * getOperand1(Instruction * i){ TNodeOrConst * getOperand1(Instruction * i){
return i->operand1; return i->operand1;
} }
@ -155,6 +182,12 @@ void emit_binary_op(
current->operand2 = arg2; current->operand2 = arg2;
} }
void emit_goto(int i){
emit_helper();
current->opcode = E_GOTO;
current->label = i;
}
void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){ void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){
emit_helper(); emit_helper();
current->opcode = op; current->opcode = op;
@ -250,8 +283,8 @@ void emit_function_call(
){ ){
emit_helper(); emit_helper();
current->opcode = E_CALL; current->opcode = E_CALL;
current->operand1 = tn_or_const(INTEGER, &param_count); current->operand1 = name;
current->operand2 = name; current->operand2 = tn_or_const(INTEGER, &param_count);
current->result = result; current->result = result;
} }
@ -349,6 +382,11 @@ int label_gen(){
} }
void emit_as_file(FILE * out_file, Instruction * i){ void emit_as_file(FILE * out_file, Instruction * i){
if (out_file == NULL){
fprintf(stderr, "Error: output file is NULL\n");
return;
}
if(i == NULL){ if(i == NULL){
return; return;
} }
@ -463,7 +501,7 @@ void emit_as_file(FILE * out_file, Instruction * i){
break; break;
case E_IF_X_TRUE: case E_IF_X_TRUE:
fprintf(out_file, fprintf(out_file,
"%4.d: if %s goto %d\n", "%4.d: if %s GOTO %d\n",
i->index, i->index,
get_string(i->operand1), get_string(i->operand1),
i->label i->label
@ -471,7 +509,7 @@ void emit_as_file(FILE * out_file, Instruction * i){
break; break;
case E_IF_X_FALSE: case E_IF_X_FALSE:
fprintf(out_file, fprintf(out_file,
"%4.d: if %s false goto %d\n", "%4.d: if %s false GOTO %d\n",
i->index, i->index,
get_string(i->operand1), get_string(i->operand1),
i->label i->label
@ -480,21 +518,21 @@ void emit_as_file(FILE * out_file, Instruction * i){
case E_LESS_THAN: case E_LESS_THAN:
// this feels wrong I need to TODO: this // this feels wrong I need to TODO: this
fprintf(out_file, fprintf(out_file,
"%4.d: %s = %s < %s\n", "%4.d: if ( %s < %s ) GOTO %d\n",
i->index, i->index,
getName(i->result),
get_string(i->operand1), get_string(i->operand1),
get_string(i->operand2) get_string(i->operand2),
i->label
); );
break; break;
case E_EQUAL_TO: case E_EQUAL_TO:
// this feels wrong I need to TODO: this // this feels wrong I need to TODO: this
fprintf(out_file, fprintf(out_file,
"%4.d: %s = %s == %s\n", "%4.d: if ( %s = %s ) GOTO %d\n",
i->index, i->index,
getName(i->result),
get_string(i->operand1), get_string(i->operand1),
get_string(i->operand2) get_string(i->operand2),
i->label
); );
break; break;
case E_CALL: case E_CALL:

17
src/intermediate_code.h
View File

@ -22,11 +22,12 @@ typedef struct __Node {
typedef struct Stack { typedef struct Stack {
__Node * n; __Node * n;
int w;
int size; int size;
} Stack; } Stack;
Stack * S_Init(); Stack * S_Init();
void S_Free(Stack *s); void S_Free(Stack *s);
void S_Push(Stack * s, void *v); void S_Push(Stack * s, void *v, int i);
void * S_Pop(Stack *s); void * S_Pop(Stack *s);
void * S_Peek(Stack *s); void * S_Peek(Stack *s);
bool S_IsEmpty(Stack *s); bool S_IsEmpty(Stack *s);
@ -108,19 +109,20 @@ typedef struct TFList {
TFList * next; TFList * next;
} TFList; } TFList;
TFList * make_list(Instruction * i); // TFList * make_list(Instruction * i);
// - makelist(i) function to create instruction lists // - makelist(i) function to create instruction lists
void merge(TFList * l1, TFList * l2); // void merge(TFList * l1, TFList * l2);
// - merge(p1,p2) function to concatenate lists // - merge(p1,p2) function to concatenate lists
void backpatch(TFList * l, int label); // void backpatch(TFList * l, int label);
// - backpatch(p,i) function to fill in jump targets // - backpatch(p,i) function to fill in jump targets
void bp_temp(int n); // void bp_temp(int n);
extern Instruction * begin; extern Instruction * begin;
extern Instruction * current; extern Instruction * current;
extern int label_count; extern int label_count;
extern bool code_gen; extern bool code_gen;
extern FILE * ir_flag;
TNodeOrConst * tn_or_const(Discriminant , void * ); TNodeOrConst * tn_or_const(Discriminant , void * );
@ -142,6 +144,9 @@ void emit_release(TableNode * pointer);
void emit_field_access(char* result, char* record, char* field); void emit_field_access(char* result, char* record, char* field);
void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index); void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index);
void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr); void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr);
void emit_goto(int i);
void emit_detach();
void emit_push_all(Stack * s);
int getLabel(Instruction * i); int getLabel(Instruction * i);
@ -159,3 +164,5 @@ int get_index(Instruction * i);
void set_label(Instruction * i, int label); void set_label(Instruction * i, int label);
bool isConst(TNodeOrConst * tnc); bool isConst(TNodeOrConst * tnc);
int label_gen(); int label_gen();
void backpatch(Stack *s, int l);
void emit_backpatch(Stack *s, int l);

9
src/runner.c
View File

@ -102,7 +102,7 @@ void print_tok(int tok) {
int run(FILE *alpha) { int run(FILE *alpha) {
int token; int token;
top = cur = init(CreateScope(NULL, 1, 1)); top = cur = init(CreateScope(NULL, 1, 1));
Stack *s = S_Init();
// If file is not found // If file is not found
if (alpha == NULL) { if (alpha == NULL) {
@ -127,6 +127,9 @@ int run(FILE *alpha) {
fseek(alpha, 0, SEEK_SET); fseek(alpha, 0, SEEK_SET);
yyin = alpha; yyin = alpha;
stack = S_Init();
TrueList = S_Init();
FalseList = S_Init();
yyparse(); yyparse();
if (tok_flag != NULL) { if (tok_flag != NULL) {
@ -192,7 +195,7 @@ int new_file(char *arg, char *alpha) {
mkdir("./out", 0777); mkdir("./out", 0777);
char *new_basename = calloc(strlen(basename) + 5, sizeof(char)); char *new_basename = calloc(strlen(basename) + 7, sizeof(char));
strcpy(new_basename, "./out/"); strcpy(new_basename, "./out/");
strcat(new_basename, basename); strcat(new_basename, basename);
basename = new_basename; basename = new_basename;
@ -335,4 +338,4 @@ char *file_read_line(FILE *fp) {
str[len] = '\0'; str[len] = '\0';
return str; return str;
} }

5
src/runner.h
View File

@ -70,6 +70,9 @@ TableNode *recprime;
TableNode *funtypeprime; TableNode *funtypeprime;
TableNode *undefined; TableNode *undefined;
extern Instruction *begin; extern Instruction *begin;
extern Stack* stack;
extern Stack* TrueList;
extern Stack* FalseList;
int main(int argc, char *argv[]); int main(int argc, char *argv[]);
int check_flag(char *arg, char *alpha); int check_flag(char *arg, char *alpha);
@ -108,4 +111,4 @@ CodeLine *code_head;
char *file_read_line(FILE *fp); char *file_read_line(FILE *fp);
void insert_code_line(char * error_message, int line_number); void insert_code_line(char * error_message, int line_number);
void append_code_line(CodeLine *code_line); void append_code_line(CodeLine *code_line);
void print_code_lines(); void print_code_lines();

4
tests/carl/NoErrors/selectionSort.alpha
View File

@ -45,9 +45,9 @@ selectionSort(data) := {
data(i) := temp; data(i) := temp;
i := i + 1; i := i + 1;
} }
return true; return true;
} }
(* Function definition (* Function definition
entry is the first function called entry is the first function called

6
tests/sprint1/test/sp1_simple_alpha.alpha Normal file
View File

@ -0,0 +1,6 @@
type main: string -> integer
function entry: main
entry(arg) := {
return 0;
}

5
tests/sprint2/test/sp2_llnode.alpha
View File

@ -15,7 +15,6 @@ function make_list : list
make_list (a) := { make_list (a) := {
[integer:orig_a; llnode: ret; llnode: curr; llnode: temp] [integer:orig_a; llnode: ret; llnode: curr; llnode: temp]
if (a < 0 | a = 0) then { if (a < 0 | a = 0) then {
return null; return null;
} else { } else {
@ -73,8 +72,8 @@ entry (arg) := {
w := reserve w; w := reserve w;
w.x := 5; w.x := 5;
w.y := 7; w.y := 7;
result := bar1(w); (* result := bar1(w); *)
result := bar2(5,7); result := bar2(5,7);
return 0; return 0;
} }

80
tests/sprint2/test/sp2_llnode_bad.alpha Normal file
View File

@ -0,0 +1,80 @@
type main: string -> integer
function entry: main
type rec: [integer: x; integer: y]
type T1: integer -> integer
type T2: rec -> integer
type llnode: [llnode: prev; integer: val; llnode: next]
type list: integer -> llnode
function foo : T1
function bar1 : T2
function bar2 : T2
function make_list : list
make_list (a) := {
[integer:orig_a; llnode: ret; llnode: curr; llnode: temp]
if (a < 0 | a = 0) then {
return null;
} else {
ret := reserve ret;
ret.prev := null;
ret.next := null;
ret.val := a;
while (0 < a) {
temp := reserve temp;
temp.prev := null;
temp.next := null;
temp.val := ret.val;
if (a = orig_a) then {
ret.next := temp;
temp.prev := ret;
curr := temp;
} else {
curr.next := temp;
temp.prev := curr;
curr := temp;
}
a := a - 1;
}
return ret;
}
}
foo (x) := {
return x * x;
}
bar1(a,b) := {
return a * b;
}
bar2(r,s) := {
if (r < s) then {
while (!(r < s)) {
r := r + 1;
}
} else {
[integer: x]
x := 0;
while (x < 10) {
r := r + s;
}
}
return r * s;
}
entry (arg) := {
[ integer: result ; rec: w; llnode: li; boolean: b]
li := make_list(6, 7);
result := foo(5);
w := reserve w;
w.x := 5;
w.y := 7;
result := bar1(w);
result := bar2(5,7);
return 'a';
}

25
tests/sprint3/test/sp3_if_else.alpha Normal file
View File

@ -0,0 +1,25 @@
type rec: [character: x; integer: y]
type T2: rec -> integer
type main: string -> integer
function entry: main
function bar: T2
bar (r,s) := {
return 0;
}
entry (arg) := {
[ integer: result ; rec: w]
if ( result = result ) then {
if ( result < w.y ) then {
result := 8;
} else {
result := 9;
}(* *)
} else {
result := bar('c', 7);
}
return 0;
}

27
tests/sprint3/test/sp3_if_while.alpha Normal file
View File

@ -0,0 +1,27 @@
type rec: [character: x; integer: y]
type T2: rec -> integer
type main: string -> integer
function entry: main
function bar: T2
bar (r,s) := {
return 0;
}
entry (arg) := {
[ integer: result ; rec: w]
while ( result = result ) {
result := result + 8;
if ( result < w.y ) then {
while (true) {
result := 8;
}
} else {
result := 9;
}
result := bar('c', 7);
}
return 0;
}

9
tests/sprint3/test/sp3_multiple_args.alpha
View File

@ -12,7 +12,12 @@ bar (r,s) := {
entry (arg) := { entry (arg) := {
[ integer: result ; rec: w] [ integer: result ; rec: w]
result := bar(1,2); while ( result = result ) {
while ( result < w.y ) {
result := 8;
}
result := 9;
}
result := bar('c', 7); result := bar('c', 7);
return 0; return 0;
} }