latest version still not working #t51

src/intermediate_code.c

@@ -4,13 +4,16 @@
 
 Instruction * begin;
 Instruction * current;
+char * temp = NULL;
 
 
 // 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.
 
-void emit_helper(void){
+TNodeOrConst * tn_or_const(Op op, RegConstUnion r);
+
+static void emit_helper(void){
         Instruction * inst = calloc(1, sizeof(*inst));
         if(begin == NULL){
                 begin = current = inst;
@@ -23,7 +26,7 @@ void emit_helper(void){
         }
 }
 
- void emit_binary_op(TableNode * result, Op op, TableNode * arg1, TableNode * arg2){
+void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TableNode * arg2){
         emit_helper();
         current->opcode = op;
         current->result = result;
@@ -32,7 +35,7 @@ void emit_helper(void){
         return;
  }
 
- void emit_unary_op(TableNode * result, Op op, TableNode * arg){
+void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){
         emit_helper();
         current->opcode = op;
         current->result = result;
@@ -40,11 +43,11 @@ void emit_helper(void){
         return;
  }
 
- void emit_assignment(char* target, char* source){
+void emit_assignment(TableNode * target, TNodeOrConst * source){
         emit_helper();
-        current->opcode = ADD; // TODO: replace with move
+        current->opcode = E_ASSIGN; // TODO: replace with move
-        current->result = look_up(cur, target);
+        current->result = target;
-        current->operand1 = look_up(cur, source);
+        current->operand1 = source;
         return;
  }
 
@@ -60,48 +63,77 @@ void emit_as_file(FILE * out_file, Instruction * instr_arr){
 
 void emit_label(char* label){
         emit_helper();
-        current->opcode = LABEL;
+        current->opcode = E_LABEL;
         current->label = label;
         return;
 }
 void emit_jump(char* label){
         emit_helper();
-        current->opcode = GOTO;
+        current->opcode = E_GOTO;
         current->label = label;
         return;
 }
-void emit_conditional_jump(char* condition, char* label){
+void emit_conditional_jump(int count, ...){
+        // it apears that I cant do what I want So we will have to deal with
+        // the limitations presented.
+        // arg_count is the number of args passed to the function
+        // from there the sequence is Op, char * , TableNode * , and an optional
+        // extra TableNode *.
+        // when this instruction is a conditional jump then ... is 1
+        // when the inst is a cond with a Relational op then ... is  2
         emit_helper();
-        current->opcode = CGOTO; // I am positive this needs to be 2 instructions
+        va_list argptr;
+        va_start(argptr, count);
+        Op condition = va_arg(argptr, Op);
+        char * label = va_arg(argptr, char *);
+        current->opcode = condition;
         current->label = label;
+        TNodeOrConst * n1;
+        TableNode * n2;
+        switch (condition) {
+                case E_IF_X_TRUE: case E_IF_X_FALSE:
+                        n1 = va_arg(argptr, TNodeOrConst *);
+                        current->operand1 = n1;
+                        break;
+                case E_LESSTHEN: case E_EQUALTO:
+                        n1 = va_arg(argptr, TNodeOrConst *);
+                        n2 = va_arg(argptr, TableNode *);
+                        current->operand1 = n1;
+                        current->operand2 = n2;
+                        break;
+        }
         return;
 }
 
-
-
 void emit_function_start(char * name){
         emit_helper();          // actualy what is this?
-        current->opcode = LABLE; // I think this is right TODO: ask
+        current->opcode = E_LABEL; // I think this is right TODO: ask
-        current->label = name;
+        current->label = name;  // wait what is a function start
+        // this is probabaly a func decleration
         return;
 }
-void emit_parameter(char* param){
+void emit_parameter(TNodeOrConst * param){
         emit_helper();
-        current->opcode = PARAM;
+        current->opcode = E_PARAM;
-        current->operand1 = look_up(cur, param);
+        current->operand1 = param;
         return;
 }
-void emit_function_call(char* result, char* name){
+
+void emit_function_call(TableNode * result, int param_count, TableNode * name){
         emit_helper();
-        current->opcode = CALL;
+        current->opcode = E_CALL;
-        current->operand1 = look_up(cur, name);
+        TNodeOrConst * count = calloc(1, sizeof(*count));
-        current->result = look_up(cur, result);
+        count->d = INTEGER;
+        count->rc_union->integer = param_count;
+        current->operand1 = count;
+        current->operand2 = name;
+        current->result = result;
         return;
 }
-void emit_return(char* value){
+void emit_return(TNodeOrConst * value){
         emit_helper();
-        current->opcode = RETURN;
+        current->opcode = E_RETURN;
-        current->operand1 = look_up(cur, name);
+        current->operand1 = value;
         return;
 }
 void emit_reserve(char* result, char* type_name, int size){
@@ -115,11 +147,30 @@ void emit_release(char* pointer){
 
 
 void emit_field_access(char* result, char* record, char* field){
+        emit_helper();
         return;
 }
 void emit_array_access(char* result, char* array, char* index, char* dimension){
+        emit_helper();
         return;
 }
 void emit_bounds_check(char* index, char* size, char* error_label){
+        emit_helper();
         return;
 }
+
+
+// * 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;
+}
+
+char * lable_gen(){
+        char * ret = calloc( 9, sizeof(*ret));
+        sprintf(ret, "L_%d", label_count);
+        label_count++;
+        return ret;
+}

src/intermediate_code.h

@@ -1,48 +1,46 @@
 // Track 1: Core Infrastructure & Basic Expressions
-// * Create intermediate_code.h/.c defining the instruction structure:
-//   - Struct with fields for: opcode, result, operand1, operand2, label
-//   - Enum for all operation types (ADD, SUB, MUL, DIV, etc.)
-// * Implement temp variable generator function that produces unique names (t1, t2, etc.)
-// * Create specific code emission functions:
-//   - emit_binary_op(char* result, char* op, char* arg1, char* arg2)
-//   - emit_unary_op(char* result, char* op, char* arg)
-//   - emit_assignment(char* target, char* source)
 // * Add Bison actions for arithmetic expressions:
 //   - Addition: $$ = new_temp(); emit_binary_op($$, "ADD", $1, $3);
 //   - Subtraction, multiplication, division, modulo
 #include "symbol_table.h"
+#include <stdarg.h>
 
 // these are from page 364
 typedef enum {
-        LABEL,          // this is not in the book
+        E_LABEL = 10000,            // this is not in the book
-        ADD,            // 1 from the list
+        E_ADD,              // 1 from the list
-        SUB,            // 1
+        E_SUB,              // 1
-        MUL,            // 1
+        E_MUL,              // 1
-        DIV,            // 1
+        E_DIV,              // 1
-        MOD,            // 1
+        E_MOD,              // 1
-        OR,             // 1
+        E_OR,               // 1
-        AND,            // 1
+        E_AND,              // 1
-        NEG,            // 2
+        E_NEG,              // 2
-        NOT,            // 2
+        E_NOT,              // 2
-        ASSIGN,         // 3
+        E_ASSIGN,           // 3
-        GOTO,           // 4
+        E_GOTO,             // 4
-        CGOTO,          // 5
+        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
-        LESSTHEN,       // 6 rule 1 + 5
+        E_IF_X_TRUE,        // 5
-        EQUALTO,        // 6 rule 1 + 5
+        E_IF_X_FALSE,       // 5
-        CALL,           // 7
+        E_LESSTHEN,         // 6 rule 1 + 5
-        PARAM,          // 7
+        E_EQUALTO,          // 6 rule 1 + 5
-        RETURN          // 7
+        E_CALL,             // 7
-
+        E_PARAM,            // 7
-
+        E_RETURN,           // 7
+        E_INDEX_COPY_RIGHT, // 8
+        E_INDEX_COPY_LEFT,  // 8
+        E_ADDRESS_OF        // 9
+        /* for x = *y and *y = x we can just use index copy right and left with
+        index 0*/
 } Op;
 
 typedef enum {
-        NODE,
+        NODE = 11000,               // TableNode
-        INTEGER,
+        INTEGER,            // int
-        STRING,
+        STRING,             // char *
-        CHARACTER,
+        CHARACTER,          // char
-        ADDRESS,
+        ADDRESS,            // void *
-        BOOLEAN
+        BOOLEAN             // bool
 } Discriminant;
 
 typedef union {
@@ -52,39 +50,41 @@ typedef union {
         char            character;
         void *          address;
         bool            Boolean;
-} Register_union;
+} RegConstUnion;
 
 typedef struct {
         Discriminant d;
-        Register_union r_union;
+        RegConstUnion * rc_union;
 } TNodeOrConst;
 
+typedef struct Instruction Instruction;
 typedef struct Instruction {
         Op opcode;
         TableNode * result;
-        TableNode * operand1;
+        TNodeOrConst * operand1;
         TableNode * operand2;
         char * label;
 
-
         int index;
 
-
         Instruction * prev;
         Instruction * next;
 } Instruction;
 
 extern Instruction * begin;
 extern Instruction * current;
+int temp_count = 0;
+int label_count = 0;
+bool code_gen = true;
 
 
-void emit_binary_op(char* result, Op op, char* arg1, char* arg2);
+
-void emit_unary_op(char* result, Op op, char* arg);
+void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TableNode * arg2);
-void emit_assignment(char* target, char* source);
+void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg);
+void emit_assignment(TableNode * target, TNodeOrConst * source);
 // TODO: Find out what these are suposed to do. Guess is create an entry in
 //       the list of instructions. Guess is that its suposed to ret a struct ptr
 
-
 // * Implement integer/boolean/character specific operation handling
 // TODO: Find out what this means.
 
@@ -95,16 +95,15 @@ void emit_as_file(FILE * out_file, Instruction * instr_arr);
 
 void emit_label(char* label);
 void emit_jump(char* label);
-void emit_conditional_jump(char* condition, char* label);
+void emit_conditional_jump(int count, ...);
 
 void emit_function_start(char* name);
-void emit_parameter(char* param);
+void emit_parameter(TNodeOrConst * param);
-void emit_function_call(char* result, char* name);
+void emit_function_call(TNodeOrConst * result, TNodeOrConst * name);
-void emit_return(char* value);
+void emit_return(TNodeOrConst * value);
 void emit_reserve(char* result, char* type_name, int size);
 void emit_release(char* pointer);
 
-
 void emit_field_access(char* result, char* record, char* field);
 void emit_array_access(char* result, char* array, char* index, char* dimension);
 void emit_bounds_check(char* index, char* size, char* error_label);