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

trying to get annie's to work

Browse Source
This commit is contained in:
Partho
2025-04-25 15:36:31 -04:00
parent 95c37db9ff
commit 46d8a852a6
7 changed files with 581 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/grammar.y
View File

@ -647,8 +647,7 @@ expression:
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
emit_binary_op(E_ADD,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -662,8 +661,8 @@ expression:
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
emit_binary_op(E_SUB,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -677,8 +676,7 @@ expression:
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
emit_binary_op(E_MUL,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -692,8 +690,7 @@ expression:
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
emit_binary_op(E_DIV,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -707,8 +704,7 @@ expression:
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
emit_binary_op(E_MOD,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -722,8 +718,7 @@ expression:
if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
emit_binary_op(E_AND,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -737,8 +732,7 @@ expression:
if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
emit_binary_op(E_OR,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -752,8 +746,7 @@ expression:
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
emit_binary_op(E_LESS_THAN,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {
$$=undefined;
@ -767,8 +760,7 @@ expression:
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1) != undefined) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of compariosn
emit_binary_op(E_EQUAL_TO,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
$$ = node;
} else {

1
src/intermediate_code.c
View File

@ -5,6 +5,7 @@
// check if start is NULL if it is assign it to the start globle variable
// otherwise make it next of current and set cur to your instruction.
TNodeOrConst * tn_or_const(Op op, void * tnc) {
TNodeOrConst * count = calloc(1, sizeof(*count));
count->d = op;

2
src/runner.c
View File

@ -2,6 +2,8 @@
/* The Translators - Spring 2025 */
#include "runner.h"
FILE *ir_flag = NULL;
FILE *cg_flag = NULL;
//Constant_Stack *head = NULL;
int main(int argc, char *argv[]) {
if (argc == 1) {

5
src/runner.h
View File

@ -35,7 +35,8 @@
#include "../tmp/grammar.tab.h"
#include "symbol_table.h"
extern int line_number, column_number;
extern int line_number;
extern int column_number;
extern char *yytext;
extern FILE *yyin;
extern bool DEBUG;
@ -46,8 +47,6 @@ SymbolTable *cur;
FILE *alpha_file;
FILE *tok_flag = NULL;
FILE *st_flag = NULL;
FILE *ir_flag = NULL;
FILE *cg_flag = NULL;
FILE *asc_flag = NULL;
bool tc_flag = false;
bool DEBUG = false;

532
src/symbol_table.c
View File

@ -10,6 +10,9 @@ char* temp = NULL;
int label_count=0;
Instruction* begin = NULL;
Instruction* current = NULL;
int offset = 0;
int currentsp = 0;
CGNode *cgList = NULL;
void printdebug_impl(char *file, int line, const char *format, ...) {
if (DEBUG) {
@ -1574,7 +1577,7 @@ TNodeOrConst * getOperand2(Instruction * i){
return i->operand2;
}
TableNode * get_result(Instruction * i){
TableNode * getResult(Instruction * i){
return i->result;
}
@ -1672,12 +1675,10 @@ char * get_string(TNodeOrConst * tc){
case STRING:
return tc->tnc_union->string;
case INTEGER:
return getName(integ);
s = calloc(10, sizeof(char));
sprintf(s, "%d", tc->tnc_union->integer);
return s;
case CHARACTER:
return getName(chara);
s = calloc(2, sizeof(char));
sprintf(s, "%c", tc->tnc_union->character);
return s;
@ -1690,11 +1691,12 @@ char * get_string(TNodeOrConst * tc){
}
void emit_as_file(FILE * out_file, Instruction * i){
if(!i){
if(i == NULL){
return;
}
switch(i->opcode){
case E_LABEL:
break;
// this is a terrible one to start with
// fprintf(out_file, "%04.d: %d ", i->index, i->label);
case E_ADD:
@ -1752,7 +1754,7 @@ void emit_as_file(FILE * out_file, Instruction * i){
case E_ASSIGN:
fprintf(out_file, "%4.d: %s = %s\n",
i->index, getName(i->result),
get_string(i->operand2));
get_string(i->operand1));
break;
case E_GOTO:
// are we ever going to use this?
@ -1945,4 +1947,524 @@ char * label_gen(){
sprintf(ret, "L_%d", label_count);
label_count++;
return ret;
}
//-------------------------------------------------------------------------------------
int generate(){
offset = 0;
Instruction* i = begin;
while (i != NULL) {
switch(getOp(i)) {
case E_LABEL:
generateLabel(i);
break;
case E_ADD:
generateAdd(i);
break;
case E_SUB:
generateSub(i);
break;
case E_MUL:
generateMult(i);
break;
case E_DIV:
generateDiv(i);
break;
case E_MOD:
generateMod(i);
break;
case E_OR:
generateOr(i);
break;
case E_AND:
generateAnd(i);
break;
case E_NEG:
generateNeg(i);
break;
case E_NOT:
generateNot(i);
break;
case E_ASSIGN:
generateAssign(i);
break;
case E_GOTO:
generateGoto(i);
break;
case E_IF_X_TRUE:
generateIfTrue(i);
break;
case E_IF_X_FALSE:
generateIfFalse(i);
break;
case E_LESS_THAN:
generateLessThan(i);
break;
case E_EQUAL_TO:
generateEqualTo(i);
break;
case E_CALL:
generateCall(i);
break;
case E_PARAM:
generateParam(i);
break;
case E_RETURN:
generateReturn(i);
break;
case E_INDEX_COPY_RIGHT:
generateCopyRight(i);
break;
case E_INDEX_COPY_LEFT:
generateCopyLeft(i);
break;
case E_ADDRESS_OF:
generateAddressOf(i);
break;
default:
;
}
}
return -1;
}
CGNode *getNextCG(CGNode *cg) {
if (cg == NULL) {
return NULL;
}
return cg->next;
}
int getAddress(CGNode *cg) {
if (cg == NULL) {
return -1;
}
return currentsp - cg->address;
}
TableNode *getTNofCG(CGNode *cg) {
if (cg == NULL) {
return NULL;
}
return cg->tn;
}
/*
movl $1, -4(%rbp)
add -4(%rbp), $2
*/
CGNode *findCG(TableNode *tn) {
CGNode *cg = cgList;
while (cg != NULL) {
if (getTNofCG(cg) == tn) {
return cg;
}
cg = getNextCG(cg);
}
return NULL;
}
CGNode *addCG(TableNode *tn, int sp) {
CGNode *cg = calloc(1, sizeof(CGNode));
cg->tn = tn;
cg->address = sp;
offset += getPrimSize(tn); //not sure if this is the correct amount to add to the offset
cg->next = cgList;
cgList = cg;
return cg;
}
int generateLabel(Instruction *inst) {
fprintf(cg_flag, ".L%d:\n", getLabel(inst));
return 0;
}
int generateAdd(Instruction *inst) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateAdd failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateAdd failed, %s is not initialized/in CG", getName(getTN(op1)));
return -1;
}
if (op2CG == NULL) {
printdebug("generateAdd failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\taddl\t%d(\%rbp), \%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateSub(Instruction *instruction) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateSub failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateSub failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateAdd failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tsubl\t%d(\%rbp), \%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateMult(Instruction *instruction){
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateMult failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateMult failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateMult failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tsubl\t%d(\%rbp), \%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateDiv(Instruction *instruction) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateDiv failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateDiv failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateDiv failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG)); //moves dividend into 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, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg)); //stores result
return 0;
}
int generateMod(Instruction *instruction) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateMod failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateMod failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateMod failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG)); //moves dividend into 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, "\tmovl\t\%edx, %d(\%rbp)\n", getAddress(cg)); //stores result from edx (remainder)
return 0;
}
int generateOr(Instruction *instruction) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateOr failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateOr failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateOr failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\torll\t%d(\%rbp), %eax\n", getAddress(op2CG));//divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg)); //stores result
return 0;
}
int generateAnd(Instruction *instruction) {
/*
Both immediate:
One immediate:
Neither immediate:
*/
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("%sgenerateAnd failed, NULL operand", COLOR_RED);
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateNeg failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateNeg failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tandl\t%d(\%rbp), %eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateNeg(Instruction *instruction) {
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateNeg failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateNeg failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateNeg failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tnegl\t%d %eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateNot(Instruction *instruction) {
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL || op2 == NULL) {
printdebug("generateNot failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(op1);
CGNode *op2CG = findCG(op2);
if (op1CG == NULL) {
printdebug("generateNot failed, op1 is not constant but not in CGlist");
return -1;
}
if (op2CG == NULL) {
printdebug("generateNot failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tnotl\t\%eax\n", getAddress(op2CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateAssign(Instruction *instruction) {
TNodeOrConst *op1 = getOperand1(inst);
CGNode *result = findCG(getResult(inst));
if (op1 == NULL) {
printdebug("generateAssign failed, NULL operand");
return -1;
}
if (result == NULL) {
result = addCG(getResult(inst), offset);
}
//add option for constant assignment (should be easy)
CGNode *op1CG = findCG(op1);
if (op1CG == NULL) {
printdebug("generateAssign failed, op1 is not constant but not in CGlist");
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(\%rbp), \%eax\n", getAddress(op1CG));
fprintf(cg_flag, "\tmovl\t\%eax, %d(\%rbp)\n", getAddress(cg));
return 0;
}
int generateGoto(Instruction *instruction){
return -1;
}
int generateCondGoto(Instruciton *instruction) {
return -1;
}
int generateIfTrue(Instruction *instruction){
return -1;
}
int generateIfFalse(Instruction *instruction){
return -1;
}
int generateLessThan(Instruction *instruction){
return -1;
}
int generateEqualTo(Instruction *instruction){
return -1;
}
int generateCall(Instruction *instruction){
return -1;
}
int generateReturn(Instruction *instruction){
return -1;
}
int generateCopyRight(Instruction *instruction){
return -1;
}
int generateCopyLeft(Instruction *instruction){
return -1;
}
int generateAddressOf(Instruction *instruction){
return -1;
}
int generateParam(Instruction *instruction){
return -1;
}

39
src/symbol_table.h
View File

@ -13,6 +13,7 @@
struct TableNode;
typedef struct TFList TFList;
typedef struct CGNode CGNode;
typedef struct Constant_Stack {
struct TableNode *theType;
@ -327,4 +328,40 @@ Track 4: Memory Access & Integration
* Document the complete intermediate instruction set
* Build integration test suite covering all language features
* Implement row-major/column-major array layout calculation
*/
*/
//-------------------------------------------------------------
extern FILE *cg_flag;
typedef struct CGNode {
TableNode *tn;
int address;
CGNode *next;
}CGNode;
int generate();
CGNode *getNextCG(CGNode *cg);
int getAddress(CGNode *cg);
TableNode *getTNofCG(CGNode *cg);
int generateLabel(Instruction *instruction);
int generateAdd(Instruction *instruction);
int generateSub(Instruction *instruction);
int generateMult(Instruction *instruction);
int generateDiv(Instruction *instruction);
int generateMod(Instruction *instruction);
int generateOr(Instruction *instruction);
int generateAnd(Instruction *instruction);
int generateNeg(Instruction *instruction);
int generateNot(Instruction *instruction);
int generateDiv(Instruction *instruction);
int generateAssign(Instruction *instruction); // is this for something like x = 1?
int generateGoto(Instruction *instruction);
int generateCondGoto(Instruction *instruction);
int generateIfTrue(Instruction *instruction);
int generateIfFalse(Instruction *instruction);
int generateLessThan(Instruction *instruction);
int generateEqualTo(Instruction *instruction);
int generateCall(Instruction *instruction);
int generateReturn(Instruction *instruction);
int generateCopyRight(Instruction *instruction);
int generateCopyLeft(Instruction *instruction);
int generateAddressOf(Instruction *instruction);
int generateParam(Instruction *instruction);

2
tests/sprint3/test/sp3_integer_binary_op_typecheck.alpha
View File

@ -7,7 +7,7 @@ entry (arg) := {
[integer:x; address: arr; address: arr2; Boolean : b2; Boolean : b1; character : a; rec : r]
x := 3 + 2 * 8;
x := 3 - 2 / 8;
x := 3 - 2 / 8;
x := a * 2 % 8;
b2 := 3 * 2 % 8;
x := 3 % 2 * 8;