diff --git a/src/intermediate_code.c b/src/intermediate_code.c index 9948115..7dcf481 100644 --- a/src/intermediate_code.c +++ b/src/intermediate_code.c @@ -3,398 +3,570 @@ #include "intermediate_code.h" -// TODO: this is here to bring your attention to the comment bellow. -// 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* getOperand1(Instruction* i) { - return i->operand1; +Stack * S_Init(){ + Stack * s = calloc(1, sizeof(*s)); + return s; } -TNodeOrConst* getOperand2(Instruction* i) { - return i->operand2; +void S_Free(Stack *s){ + // since we are not responsible for the values we can just pop until + // NULL + for (void * p = S_Pop(s); p != NULL; p = S_Pop(s)); + free(s); } -TableNode* getResult(Instruction* i) { - return i->result; +void S_Push(Stack * s, void *v) { + __Node * n = calloc(1, sizeof(*n)); + n->v = v + n->next = s->n; + s->n = n; + s->size = s->size + 1; } -Op getOp(Instruction* i) { - return i->opcode; -} - -int getLabel(Instruction* i) { - return i->label; -} - -int get_index(Instruction* i) { - return i->index; -} - -void set_label(Instruction* i, int label) { - i->label = label; -} - -bool isConst(TNodeOrConst* tnc) { - return tnc->d != NODE; -} - -TNodeOrConst* tn_or_const(Discriminant d, void* tnc) { - TNodeOrConst* count = calloc(1, sizeof(*count)); - count->d = d; - count->tnc_union = calloc(1, sizeof(*count->tnc_union)); - switch (d) { - case NODE: - count->tnc_union->node = tnc; - break; - case ADDRESS: - count->tnc_union->address = tnc; - break; - case STRING: - count->tnc_union->string = tnc; - break; - case INTEGER: - count->tnc_union->integer = *(int*)tnc; - break; - case CHARACTER: - count->tnc_union->character = *(char*)tnc; - break; - case BOOLEAN: - count->tnc_union->Boolean = *(uint_least8_t*)tnc; - break; +void * S_Pop(Stack *s) { + if (s->size == 0) { + return NULL; } - return count; + __Node * node = s->n; + s->n = node->next; + s->size = s->size - 1; + void * r = node->v; + free(node); + return r; } -static void emit_helper(void) { - Instruction* inst = calloc(1, sizeof(*inst)); - if (begin == NULL) { - begin = current = inst; - current->index = 1; - } else { - current->next = inst; - inst->prev = current; - inst->index = current->index + 1; - current = inst; + +void * S_Peek(Stack *s){ + if (!S_IsEmpty(s)) { + return NULL; } + return s->n->v; } -void emit_binary_op(Op op, TableNode* result, TNodeOrConst* arg1, TNodeOrConst* arg2) { - emit_helper(); - current->opcode = op; - // TODO: create temp and remove result from param list - current->result = result; - current->operand1 = arg1; - current->operand2 = arg2; -} - -void emit_unary_op(Op op, TableNode* result, TNodeOrConst* arg) { - emit_helper(); - current->opcode = op; - current->result = result; - current->operand1 = arg; -} - -void emit_assignment(TableNode* target, TNodeOrConst* source) { - emit_helper(); - current->opcode = E_ASSIGN; - current->result = target; - current->operand1 = source; -} - -char* get_string(TNodeOrConst* tc) { - char* s; - switch (tc->d) { - case NODE: - return getName(tc->tnc_union->node); - case ADDRESS: - return strdup("null"); - case STRING: - return tc->tnc_union->string; - case INTEGER: - s = calloc(10, sizeof(char)); - sprintf(s, "%d", tc->tnc_union->integer); - return s; - case CHARACTER: - s = calloc(2, sizeof(char)); - sprintf(s, "%c", tc->tnc_union->character); - return s; - case BOOLEAN: - if (tc->tnc_union->Boolean) { - return strdup("true"); - } - return strdup("false"); +bool S_IsEmpty(Stack *s){ + if(!s->size) { + return true; } + return false; } -void emit_as_file(FILE* out_file, Instruction* 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: - fprintf(out_file, "%4.d: %s = %s + %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_SUB: - fprintf(out_file, "%4.d: %s = %s - %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_MUL: - fprintf(out_file, "%4.d: %s = %s * %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_DIV: - fprintf(out_file, "%4.d: %s = %s / %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_MOD: - fprintf(out_file, "%4.d: %s = %s %% %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_OR: - fprintf(out_file, "%4.d: %s = %s | %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_AND: - fprintf(out_file, "%4.d: %s = %s & %s\n", - i->index, getName(i->result), - get_string(i->operand1), - get_string(i->operand2)); - break; - case E_NEG: - fprintf(out_file, "%4.d: %s = -%s\n", - i->index, getName(i->result), - get_string(i->operand1)); - break; - case E_NOT: - fprintf(out_file, "%4.d: %s = !%s\n", - i->index, getName(i->result), - get_string(i->operand1)); - break; - case E_ASSIGN: - fprintf(out_file, "%4.d: %s = %s\n", - i->index, getName(i->result), - get_string(i->operand1)); - break; - case E_GOTO: - // are we ever going to use this? - // yes we do look at bounds checking - case E_IF_X_TRUE: - fprintf(out_file, "%4.d: if %s goto %d\n", - i->index, get_string(i->operand1), - i->label); - break; - case E_IF_X_FALSE: - fprintf(out_file, "%4.d: if %s false goto %d\n", - i->index, get_string(i->operand1), - i->label); - break; - case E_LESS_THAN: - fprintf(out_file, "%4.d: if %s < %s goto %d\n", - i->index, get_string(i->operand1), - get_string(i->operand2), i->label); - break; - case E_EQUAL_TO: - fprintf(out_file, "%4.d: if %s = %s goto %d\n", - i->index, get_string(i->operand1), - get_string(i->operand2), i->label); - break; - case E_CALL: - fprintf(out_file, "%4.d: call %s %s\n", - i->index, get_string(i->operand1), - get_string(i->operand2)); - break; - - case E_PARAM: - fprintf(out_file, "%4.d: param %s \n", - i->index, get_string(i->operand1)); - break; - case E_RETURN: - - case E_INDEX_COPY_RIGHT: - case E_INDEX_COPY_LEFT: - - case E_ADDRESS_OF: - - case E_DEREF_RIGHT: - case E_DEREF_LEFT: - } - - emit_as_file(out_file, i->next); +int S_Size(Stack *s){ + return s->size; } +//_______________________________________________________________________ -void emit_label(int label) { - emit_helper(); - current->opcode = E_LABEL; - current->label = label; -} +Instruction * begin; +Instruction * current; +char * temp = NULL; -void emit_jump(int label) { - emit_helper(); - current->opcode = E_GOTO; - current->label = label; -} -void emit_conditional_jump(Op condition, int label, ...) { - // when this instruction is a conditional jump then the imput looks like (Op, int, TNodeOrConst *). - // when the inst is a cond with a Relational operation then the input looks like (Op, int, TNodeOrConst *, TNodeOrConst *) - emit_helper(); - va_list argptr; - va_start(argptr, label); - current->opcode = condition; - current->label = label; - TNodeOrConst* n1; - TNodeOrConst* n2; - switch (condition) { - case E_IF_X_TRUE: - case E_IF_X_FALSE: - n1 = va_arg(argptr, TNodeOrConst*); - current->operand1 = n1; - break; - case E_LESS_THAN: - case E_EQUAL_TO: - n1 = va_arg(argptr, TNodeOrConst*); - n2 = va_arg(argptr, TNodeOrConst*); - current->operand1 = n1; - current->operand2 = n2; - break; - } - va_end(argptr); -} - -void emit_function_start(TNodeOrConst * name) { - emit_helper(); - current->opcode = E_LABEL; // I think this is right TODO: ask - current->operand1 = name; - // this is probabaly a func declaration -} - -void emit_parameter(TNodeOrConst* param) { - emit_helper(); - current->opcode = E_PARAM; - current->operand1 = param; -} - -void emit_function_call(TableNode* result, int param_count, TNodeOrConst* name) { - emit_helper(); - current->opcode = E_CALL; - current->operand1 = tn_or_const(INTEGER, ¶m_count); - current->operand2 = name; - current->result = result; -} - -void emit_return(TNodeOrConst* value) { - emit_helper(); - current->opcode = E_RETURN; - current->operand1 = value; -} - -void emit_reserve(TableNode* result, TNodeOrConst* size) { - emit_parameter(size); - emit_function_call(result, 1, tn_or_const(NODE, look_up(cur, "reserve"))); -} - -void emit_release(TableNode* pointer) { - emit_parameter(tn_or_const(NODE, pointer)); - emit_function_call(pointer, 1, tn_or_const(NODE, look_up(cur, "release"))); -} - -void emit_deref_right() { - return; -} - -void emit_deref_left() { - return; -} - -void emit_field_access(char* result, char* record, char* field) { - emit_helper(); -} - -void emit_array_access(Op op, TableNode* result, TNodeOrConst* array, TNodeOrConst* index) { - emit_helper(); - current->opcode; - current->result = result; - current->operand1 = array; - current->operand2 = index; - // TODO: Still don't know what to do with the dimentions -} - -void emit_bounds_check(TNodeOrConst* index, TNodeOrConst* arr) { - /* - {[string: 5] - . - . - s:= reserve s(5); - s(0) := 'H'; - s(1) := 'e'; - . - . - s._0 num of dims Known at compile time - s._1 size Known at run time - s._1 int | 1 byte - +-------+---+---+---+---+---+ - | 5 | H | e | l | l | o | - +-------+---+---+---+---+---+ - size - ^ - | - p - s._0 ok - s._1 ok - s._2 not ok - t_0 is index - t_1 = *(int *)p = s._1 - if t_0 < 0 GOTO ERROR - if t_0 < s._1 GOTO access array - GOTO ERROR + /* + TODO: this is here to bring your attention to the comment bellow. + 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. */ - //emit_conditional_jump(E_LESS_THAN, ); - //emit_conditional_jump(E_LESS_THAN, ); - //emit_jump(); - /* We need a label ERROR to jump to - */ + + +TNodeOrConst * getOperand1(Instruction * i){ + return i->operand1; } -/*// * Implement temp variable generator function that produces unique names (t1, t2, etc.) +TNodeOrConst * getOperand2(Instruction * i){ + return i->operand2; +} + +TableNode * getResult(Instruction * i){ + return i->result; +} + +Op getOp(Instruction * i){ + return i->opcode; +} + +int getLabel(Instruction * i){ + return i->label; +} + +int get_index(Instruction * i){ + return i->index; +} + +void set_label(Instruction * i, int label){ + i->label = label; +} + +bool isConst(TNodeOrConst * tnc) { + return tnc->d != NODE; +} + +TNodeOrConst * tn_or_const(Discriminant d, void * tnc) { + TNodeOrConst * count = calloc(1, sizeof(*count)); + count->d = d; + count->tnc_union = calloc(1, sizeof(*count->tnc_union)); + switch (d) { + case NODE: + count->tnc_union->node = tnc; + break; + case ADDRESS: + count->tnc_union->address = tnc; + break; + case STRING: + count->tnc_union->string = tnc; + break; + case INTEGER: + count->tnc_union->integer = *(int*)tnc; + break; + case CHARACTER: + count->tnc_union->character = *(char*)tnc; + break; + case BOOLEAN: + count->tnc_union->Boolean = *(uint_least8_t*)tnc; + break; + } + return count; +} + +static void emit_helper(void){ + Instruction * inst = calloc(1, sizeof(*inst)); + if(begin == NULL){ + begin = current = inst; + current->index = 1; + } else { + current->next = inst; + inst->prev = current; + inst->index = current->index + 1; + current = inst; + } +} + +void emit_binary_op( + Op op, + TableNode * result, + TNodeOrConst * arg1, + TNodeOrConst * arg2 + ){ + emit_helper(); + current->opcode = op; + // TODO: create temp and remove result from param list + current->result = result; + current->operand1 = arg1; + current->operand2 = arg2; + } + +void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){ + emit_helper(); + current->opcode = op; + current->result = result; + current->operand1 = arg; + } + +void emit_assignment(TableNode * target, TNodeOrConst * source){ + emit_helper(); + current->opcode = E_ASSIGN; + current->result = target; + current->operand1 = source; + } + +char * get_string(TNodeOrConst * tc){ + char * s; + switch (tc->d) { + case NODE: + return getName(tc->tnc_union->node); + case ADDRESS: + return strdup("null"); + case STRING: + return tc->tnc_union->string; + case INTEGER: + s = calloc(10, sizeof(char)); + sprintf(s, "%d", tc->tnc_union->integer); + return s; + case CHARACTER: + s = calloc(2, sizeof(char)); + sprintf(s, "%c", tc->tnc_union->character); + return s; + case BOOLEAN: + if(tc->tnc_union->Boolean){ + return strdup("true"); + } + return strdup("false"); + } +} + +void emit_label(int label){ + emit_helper(); + current->opcode = E_LABEL; + current->label = label; +} + +void emit_jump(int label){ + emit_helper(); + current->opcode = E_GOTO; + current->label = label; +} + +void emit_conditional_jump(Op condition, int label, ...){ + // when this instruction is a conditional jump then the imput looks like (Op, int, TNodeOrConst *). + // when the inst is a cond with a Relational operation then the input looks like (Op, int, TNodeOrConst *, TNodeOrConst *) + emit_helper(); + va_list argptr; + va_start(argptr, label); + current->opcode = condition; + current->label = label; + TNodeOrConst * n1; + TNodeOrConst * n2; + switch (condition) { + case E_IF_X_TRUE: case E_IF_X_FALSE: + n1 = va_arg(argptr, TNodeOrConst *); + current->operand1 = n1; + break; + case E_LESS_THAN: case E_EQUAL_TO: + n1 = va_arg(argptr, TNodeOrConst *); + n2 = va_arg(argptr, TNodeOrConst *); + current->operand1 = n1; + current->operand2 = n2; + break; + } + va_end(argptr); +} + +void emit_function_start(TableNode * name){ + emit_helper(); + current->opcode = E_FUNC_START; + current->result = name; +} + +void emit_parameter(TNodeOrConst * param){ + emit_helper(); + current->opcode = E_PARAM; + current->operand1 = param; +} + +void emit_function_call( + TableNode * result, + int param_count, + TNodeOrConst * name + ){ + emit_helper(); + current->opcode = E_CALL; + current->operand1 = tn_or_const(INTEGER, ¶m_count); + current->operand2 = name; + current->result = result; +} + +void emit_return(TNodeOrConst * value){ + emit_helper(); + current->opcode = E_RETURN; + current->operand1 = value; +} + +void emit_reserve(TableNode * result, TNodeOrConst * size){ + emit_parameter(size); + emit_function_call(result, 1, tn_or_const(NODE, look_up(cur, "reserve"))); +} + +void emit_release(TableNode * pointer){ + emit_parameter(tn_or_const(NODE, pointer)); + emit_function_call(pointer, 1, tn_or_const(NODE, look_up(cur, "release"))); +} + +void emit_deref_right(TableNode * x, TNodeOrConst * y){ + emit_helper(); + current->opcode = E_DEREF_RIGHT; + current->result = x; + current->operand1 = y; +} + +void emit_deref_left(TableNode * x, TNodeOrConst * y){ + emit_helper(); + current->opcode = E_DEREF_LEFT; + current->result = x; + current->operand1 = y; +} + +void emit_address_of(TableNode * x, TNodeOrConst * y){ + emit_helper(); + current->opcode = E_ADDRESS_OF; + current->result = x; + current->opernad1 = y; +} + +void emit_field_access(char* result, char* record, char* field){ + emit_helper(); +} + +void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index){ + emit_helper(); + current->opcode = op; + current->result = result; + current->operand1 = array; + current->operand2 = index; + // TODO: Still don't know what to do with the dimentions +} + +void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr){ + /* + {[string: 5] + . + . + s:= reserve s(5); + s(0) := 'H'; + s(1) := 'e'; + . + . + s._0 num of dims Known at compile time + s._1 size Known at run time + s._1 int | 1 byte + +-------+---+---+---+---+---+ + | 5 | H | e | l | l | o | + +-------+---+---+---+---+---+ + size + ^ + | + p + s._0 ok + s._1 ok + s._2 not ok + t_0 is index + t_1 = *(int *)p = s._1 + if t_0 < 0 GOTO ERROR + if t_0 < s._1 GOTO access array + GOTO ERROR + */ + /* We need a label ERROR to jump to + emit_conditional_jump(E_LESS_THAN, ); + emit_conditional_jump(E_LESS_THAN, ); + emit_jump(); + */ +} + +// * Implement temp variable generator function that produces unique names (t1, t2, etc.) char * temp_var_gen(){ - char * ret = calloc(9, sizeof(*ret)); - sprintf(ret, "$t%d", temp_count); - temp_count++; - return ret; -} -*/ -int label_gen(){ - label_count++; - return label_count; + char * ret = calloc(9, sizeof(*ret)); + sprintf(ret, "$t%d", temp_count); + temp_count++; + return ret; } -TableNode* getTN(TNodeOrConst* tnc) { - if (tnc->d == NODE) { - return tnc->tnc_union->node; - } - return NULL; +char * label_gen(){ + char * ret = calloc( 9, sizeof(*ret)); + sprintf(ret, "L_%d", label_count); + label_count++; + return ret; } -int getConst(TNodeOrConst* tnc) { - if (tnc->d == INTEGER) { - return tnc->tnc_union->integer; - } - return -1; +void emit_as_file(FILE * out_file, Instruction * i){ + if(i == NULL){ + return; + } + switch(i->opcode){ + case E_FUNC_START: + fprintf(out_file, + "%4.d: func : %s\n", + i->index, + getName(i->result) + ); + break; + case E_LABEL: + fprintf(out_file, + "%4.d: Label : %d\n", + i->index, + i->label + ); + break; + case E_ADD: + fprintf(out_file, + "%4.d: %s = %s + %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_SUB: + fprintf(out_file, + "%4.d: %s = %s - %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_MUL: + fprintf(out_file, + "%4.d: %s = %s * %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_DIV: + fprintf(out_file, + "%4.d: %s = %s / %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_MOD: + fprintf(out_file, + "%4.d: %s = %s %% %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_OR: + fprintf(out_file, + "%4.d: %s = %s | %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_AND: + fprintf(out_file, + "%4.d: %s = %s & %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_NEG: + fprintf(out_file, + "%4.d: %s = -%s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + break; + case E_NOT: + fprintf(out_file, + "%4.d: %s = !%s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + break; + case E_ASSIGN: + fprintf(out_file, + "%4.d: %s = %s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + break; + case E_GOTO: + fprintf(out_file, + "%4.d: GOTO : %d\n", + i->index, + i->label + ); + break; + case E_IF_X_TRUE: + fprintf(out_file, + "%4.d: if %s goto %d\n", + i->index, + get_string(i->operand1), + i->label + ); + break; + case E_IF_X_FALSE: + fprintf(out_file, + "%4.d: if %s false goto %d\n", + i->index, + get_string(i->operand1), + i->label + ); + break; + case E_LESS_THAN: + // this feels wrong I need to TODO: this + fprintf(out_file, + "%4.d: %s = %s < %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_EQUAL_TO: + // this feels wrong I need to TODO: this + fprintf(out_file, + "%4.d: %s = %s == %s\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_CALL: + fprintf(out_file, + "%4.d: call : %s %s\n", + i->index, + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_PARAM: + fprintf(out_file, + "%4.d: param %s \n", + i->index, + get_string(i->operand1) + ); + break; + case E_RETURN: + fprintf(out_file, + "%4.d: return : %s\n", + i->index, + get_string(i->operand1) + ); + break; + case E_INDEX_COPY_RIGHT: + fprintf(out_file, + "%4.d: %s = %s[ %s ]\n", + i->index, + getName(i->result), + get_string(i->operand1), + get_string(i->operand2) + ); + break; + case E_INDEX_COPY_LEFT: + fprintf(out_file, + "%4.d: %s[ %s ] = %s\n", + i->index, + getName(i->result), + get_string(i->operand2), + get_string(i->operand1)); + break; + case E_ADDRESS_OF: + fprintf(out_file, + "%4.d: %s = &%s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + break; + + + case E_DEREF_RIGHT: + fprintf(out_file, + "%4.d: %s = *%s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + case E_DEREF_LEFT: + fprintf(out_file, + "%4.d: *%s = %s\n", + i->index, + getName(i->result), + get_string(i->operand1) + ); + } + + emit_as_file(out_file, i->next); } \ No newline at end of file diff --git a/src/intermediate_code.h b/src/intermediate_code.h index c1efb76..9f99d2b 100644 --- a/src/intermediate_code.h +++ b/src/intermediate_code.h @@ -12,113 +12,127 @@ #include "symbol_table.h" -// these are from page 364 -typedef enum { - E_LABEL = 10000, // this is not in the book - E_ADD, // 1 from the list - E_SUB, // 1 - E_MUL, // 1 - E_DIV, // 1 - E_MOD, // 1 - E_OR, // 1 - E_AND, // 1 - E_NEG, // 2 - E_NOT, // 2 - E_ASSIGN, // 3 - E_GOTO, // 4 - E_COND_GOTO, // 5 I don't thik I need this because we could just follow the < or the = and just assume that it's a cond got - E_IF_X_TRUE, // 5 - E_IF_X_FALSE, // 5 - E_LESS_THAN, // 6 rule 1 + 5 - E_EQUAL_TO, // 6 rule 1 + 5 - E_CALL, // 7 - E_PARAM, // 7 - E_RETURN, // 7 - E_INDEX_COPY_RIGHT, // 8 this is x = y[i] - E_INDEX_COPY_LEFT, // 8 x[i] = y - E_ADDRESS_OF, // 9 x = &y - E_DEREF_RIGHT, // 9 x = *y - E_DEREF_LEFT // 9 x* = y +typedef struct Stack Stack; +typedef struct __Node __Node; + +typedef struct __Node { + void * v; + __Node * next; +} __Node; + +typedef struct Stack { + __Node * n; + int size; +} Stack; +//______________________________________________________________________________________________ + +typedef union TNConstUnion TNConstUnion; +typedef struct Instruction Instruction; +typedef struct TNodeOrConst TNodeOrConst; + +typedef enum { // these are from page 364 + E_LABEL = 10000, // this is not in the book + E_FUNC_START, + E_ADD, // 1 from the list + E_SUB, // 1 + E_MUL, // 1 + E_DIV, // 1 + E_MOD, // 1 TODO: Please change to REM + E_OR, // 1 + E_AND, // 1 + E_NEG, // 2 + E_NOT, // 2 + E_ASSIGN, // 3 + E_GOTO, // 4 + E_COND_GOTO, // 5 I don't thik I need this because we could just follow the < or the = and just assume that it's a cond got + E_IF_X_TRUE, // 5 + E_IF_X_FALSE, // 5 + E_LESS_THAN, // 6 rule 1 + 5 + E_EQUAL_TO, // 6 rule 1 + 5 + E_CALL, // 7 + E_PARAM, // 7 + E_RETURN, // 7 + E_INDEX_COPY_RIGHT, // 8 this is x = y[i] + E_INDEX_COPY_LEFT, // 8 x[i] = y + E_ADDRESS_OF, // 9 x = &y + E_DEREF_RIGHT, // 9 x = *y + E_DEREF_LEFT // 9 x* = y } Op; typedef enum { - NODE = 11000, // TableNode - INTEGER, // int - STRING, // char * - CHARACTER, // char - ADDRESS, // void * - BOOLEAN // bool + NODE = 11000, // TableNode + INTEGER, // int + STRING, // char * + CHARACTER, // char + ADDRESS, // void * + BOOLEAN // bool } Discriminant; -typedef union { - TableNode* node; - int integer; - char* string; - char character; - void* address; - bool Boolean; +typedef union TNConstUnion { + TableNode * node; + int integer; + char * string; + char character; + void * address; + bool Boolean; } TNConstUnion; -typedef struct { - Discriminant d; - TNConstUnion* tnc_union; +typedef struct TNodeOrConst { + Discriminant d; + TNConstUnion * tnc_union; } TNodeOrConst; -typedef struct Instruction Instruction; typedef struct Instruction { - Op opcode; - TableNode* result; - TNodeOrConst* operand1; - TNodeOrConst* operand2; - int label; - int index; + Op opcode; + TableNode * result; + TNodeOrConst * operand1; + TNodeOrConst * operand2; + int label; + int index; - Instruction* prev; - Instruction* next; + Instruction * prev; + Instruction * next; } Instruction; + +// NOTE We are not using this We are using the Stack api typedef struct TFList { - Instruction* i; - TFList* next; + Instruction * i; + TFList * next; } TFList; -TNodeOrConst* getOperand1(Instruction* i); -TNodeOrConst* getOperand2(Instruction* i); -TableNode* getResult(Instruction* i); -Op getOp(Instruction* i); -int getLabel(Instruction* i); -int get_index(Instruction* i); -void set_label(Instruction* i, int label); -bool isConst(TNodeOrConst* tnc); -TNodeOrConst* tn_or_const(Discriminant d, void* tnc); -static void emit_helper(void); -void emit_binary_op(Op op, TableNode* result, TNodeOrConst* arg1, TNodeOrConst* arg2); -void emit_unary_op(Op op, TableNode* result, TNodeOrConst* arg); -void emit_assignment(TableNode* target, TNodeOrConst* source); -char* get_string(TNodeOrConst* tc); -void emit_as_file(FILE* out_file, Instruction* i); +TFList * make_list(Instruction * i); + // - makelist(i) function to create instruction lists +void merge(TFList * l1, TFList * l2); + // - merge(p1,p2) function to concatenate lists +void backpatch(TFList * l, int label); + // - backpatch(p,i) function to fill in jump targets +void bp_temp(int n); + + +extern Instruction * begin; +extern Instruction * current; +int temp_count = 0; +int label_count = 0; +bool code_gen = true; + + +TNodeOrConst * tn_or_const(Discriminant , void * ); +void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TNodeOrConst * arg2); +void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg); +void emit_assignment(TableNode * target, TNodeOrConst * source); +void emit_as_file(FILE * out_file, Instruction * instr_arr); void emit_label(int label); void emit_jump(int label); + void emit_conditional_jump(Op condition, int label, ...); -void emit_function_start(TNodeOrConst * name); -void emit_parameter(TNodeOrConst* param); -void emit_function_call(TableNode* result, int param_count, TNodeOrConst* name); -void emit_return(TNodeOrConst* value); -void emit_reserve(TableNode* result, TNodeOrConst* size); -void emit_release(TableNode* pointer); -void emit_deref_right(); -void emit_deref_left(); + +void emit_function_start(int name); +void emit_parameter(TNodeOrConst * param); +void emit_function_call(TableNode * result, int param_count, TNodeOrConst * name); +void emit_return(TNodeOrConst * value); +void emit_reserve(TableNode * result, TNodeOrConst * size); +void emit_release(TableNode * pointer); void emit_field_access(char* result, char* record, char* field); -void emit_array_access(Op op, TableNode* result, TNodeOrConst* array, TNodeOrConst* index); -void emit_bounds_check(TNodeOrConst* index, TNodeOrConst* arr); -int label_gen(); -TableNode* getTN(TNodeOrConst* tnc); -int getConst(TNodeOrConst* tnc); - -extern int label_count; -extern Instruction* begin; -extern Instruction* current; - -extern int offset; -extern int currentsp; -extern CGNode* cgList; \ No newline at end of file +void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index); +void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr, int error_label); \ No newline at end of file