implement arithmetic operations asm generation

Makefile

 all: compilateur test
 
 test: symbol_table.test.c symbol_table.c symbol_table.h
-	$(CC) -o test symbol_table.test.c symbol_table.c
+	$(CC) -g -o test symbol_table.test.c symbol_table.c
 
-compilateur: as.tab.c lex.yy.c symbol_table.c symbol_table.h asm_instructions.c asm_instructions.h
-	$(CC) -o compilateur as.tab.c lex.yy.c symbol_table.c asm_instructions.c
+compilateur: as.tab.c lex.yy.c symbol_table.c symbol_table.h asm_instructions.c asm_instructions.h yacc_util.c yacc_util.h
+	$(CC) -o compilateur as.tab.c lex.yy.c symbol_table.c asm_instructions.c yacc_util.c
 
 as.tab.c: as.y
 	$(YACC) as.y

al.lex

 %{
+#include "asm_instructions.h"
+#include "symbol_table.h"
 #include "as.tab.h"
 %}
 
                 return tNB;
             }
 
-"+"			{ return tADD; }
-"-"			{ return tSUB; }
-"*"			{ return tMUL; }
-"/"			{ return tDIV; }
+"+"			{ 
+                yylval.instruction = ADD;
+                return tADD; 
+            }
+"-"			{ 
+                yylval.instruction = SOU;
+                return tSUB;
+            }
+"*"			{ 
+                yylval.instruction = MUL;
+                return tMUL;
+            }
+"/"			{ 
+                yylval.instruction = DIV;
+                return tDIV;
+            }
 "="			{ return tEQ; }
 "("			{ return tPO; }
 ")"			{ return tPF; }

as.y

 #include "stdio.h"
 #include "stdlib.h"
 #include "symbol_table.h"
+#include "asm_instructions.h"
+#include "yacc_util.h"
 
 enum Type current_type = TYPE_INT;
 
 SymbolTable symbol_table;
+InstructionTable instruction_table;
 
 %}
 
 %union {
     char* symbol_name;
+    SymbolItem* symbol;
 	int nombre;
+	Instruction instruction;
 }
 
 %token<nombre> tNB
-%token tADD
-%token tSUB
-%token tMUL
-%token tDIV
+%token<instruction> tADD
+%token<instruction> tSUB
+%token<instruction> tMUL
+%token<instruction> tDIV
 %token tPO
 %token tPF
 %token tPV
 %left tSUB
 %left tMUL
 %left tDIV
-// %type<nombre> E
+%type<symbol> E
 
 %%
 
 
 Instruction : Aff | Printf { printf("Instruction\n"); } ;
 
-Aff : tID tEQ E tPV { mark_symbol_initialized(&symbol_table, $1); } ;
+Aff : tID tEQ E tPV { write_affectation(&symbol_table, &instruction_table, $1, $3); } ;
 
-E : tNB { printf("%d\n", $1); } | tID | E tADD E | E tMUL E | E tSUB E | E tDIV E | tPO E tPF | tSUB E ;
+E : tNB { $$ = init_temp_symbol(&symbol_table, &instruction_table, $1); } 
+    | tID { $$ = get_symbol_item(&symbol_table, $1); } 
+    | E tADD E {$$ = write_op(&symbol_table, &instruction_table, $2, $1, $3); } 
+    | E tMUL E { $$ = write_op(&symbol_table, &instruction_table, $2, $1, $3); } 
+    | E tSUB E { $$ = write_op(&symbol_table, &instruction_table, $2, $1, $3); } 
+    | E tDIV E { $$ = write_op(&symbol_table, &instruction_table, $2, $1, $3); } 
+    | tPO E tPF { $$ = $2; } 
+    | tSUB E  { $$ = write_negation(&symbol_table, &instruction_table, $2); } ;
 
-Declarations : | Declaration Declarations { printf("Declarations\n"); } ;
+Declarations : | Declaration Declarations ;
 
-Declaration : DeclarationInt | DeclarationConst { printf("Declaration\n"); } ;
+Declaration : DeclarationInt | DeclarationConst ;
 
 DeclarationInt : tINT { current_type = TYPE_INT; } DeclarationBody tPV ;
 
 
 void init() {
     init_table(&symbol_table);
+    init_instruction_table(&instruction_table);
 }
 
 void yyerror(char const* err) {
     init();
 	yyparse();
 	print_table(&symbol_table);
+    FILE *f = fopen("instruction_table.txt", "w+");
+	write_instruction_table(&instruction_table, f);
+    fclose(f);
 }

asm_instructions.c

 #include "asm_instructions.h"
 
+char* instructions_labels[12] = {
+        "ADD",
+        "MUL",
+        "SOU",
+        "DIV",
+        "COP",
+        "AFC",
+        "JMP",
+        "JMF",
+        "INF",
+        "SUP",
+        "EQU",
+        "PRI"
+};
+
 void init_instruction_table(InstructionTable *table) {
     table->index = 0;
 }
 }
 
 void write_instruction(InstructionItem *item, FILE *file) {
-    fprintf(file, "%s %d %d %d", instructions_labels[item->instruction], item->arg1, item->arg2, item->arg3);
+    fprintf(file, "%s %d %d %d\n", instructions_labels[item->instruction], item->arg1, item->arg2, item->arg3);
 }

asm_instructions.h

 typedef enum Instruction {
         ADD,
         MUL,
-        SUO,
+        SOU,
         DIV,
         COP,
         AFC,
         PRI
 } Instruction;
 
-char* instructions_labels[12] = {
-        "ADD",
-        "MUL",
-        "SUO",
-        "DIV",
-        "COP",
-        "AFC",
-        "JMP",
-        "JMF",
-        "INF",
-        "SUP",
-        "EQU",
-        "PRI"
-};
+char* instructions_labels[12];
 
 
 typedef struct InstructionItem {

symbol_table.c

     table->temp_index = SYMBOL_TABLE_SIZE - 1;
 }
 
+void init_symbol_item(SymbolItem *symbol_item, size_t name_size) {
+    symbol_item->type = 0;
+    symbol_item->name = malloc(name_size);
+    symbol_item->address = 0;
+    symbol_item->init = 0;
+}
+
 int has_symbol(SymbolTable* table, char *name) {
     for (int i = 0; i < table->index; i++) {
         if (strcmp(table->table[i].name, name) == 0) {
         return -1;
     }
     SymbolItem newItem;
+    init_symbol_item(&newItem, strlen(name));
     newItem.type = type;
     newItem.name = name;
     newItem.address = table->index;
     return 0;
 }
 
-int add_temp_symbol(SymbolTable* table, enum Type type, char *name) {
+const SymbolItem* add_temp_symbol(SymbolTable* table, enum Type type) {
     if (table->temp_index < table->index) {
-        return -2;
-    }
-    if (has_symbol(table, name)) {
-        return -1;
-    }
-    if (name[0] != '_') {
-        return -3;
+        return NULL;
     }
 
-    SymbolItem newItem;
-    newItem.type = type;
-    newItem.name = name;
-    newItem.address = table->temp_index;
-    newItem.init = 0;
+    SymbolItem *newItem = &table->table[table->temp_index];
+    init_symbol_item(newItem, 10);
+    newItem->type = type;
+    sprintf(newItem->name, "_temp%d", table->temp_index);
+    newItem->address = table->temp_index;
+    newItem->init = 0;
 
-    table->table[table->temp_index] = newItem;
     table->temp_index--;
-    return 0;
+    return newItem;
 }
 
 int mark_symbol_initialized(SymbolTable *table, char *name) {
     }
 }
 
-SymbolItem *get_symbol_item(SymbolTable *table, char *name) {
+SymbolItem *get_symbol_item(SymbolTable *table, const char *name) {
     for (int i = 0; i < table->index; i++) {
         if (strcmp(table->table[i].name, name) == 0) {
             return &table->table[i];

symbol_table.h

 #ifndef SYMBOL_TABLE_H_INCLUDED
 #define SYMBOL_TABLE_H_INCLUDED
 
+#include <stddef.h>
+
 #define SYMBOL_TABLE_SIZE 100
 
 enum Type {
 void init_table(SymbolTable *table);
 
 /**
+ * Initializes the symbol
+ *
+ * @param table
+ */
+void init_symbol_item(SymbolItem *symbol_item, size_t name_size);
+
+/**
  * Checks if the given symbol is in the table
  *
  * @param table
  * @param table
  * @param type
  * @param name
- * @return 0 on success, -1 if the symbol already exists, -2 if the table is full
- *          -3 if the name doesn't start by _
+ * @return 0 on success, -1 if the table is full
  */
-int add_temp_symbol(SymbolTable* table, enum Type type, char *name);
+const SymbolItem* add_temp_symbol(SymbolTable* table, enum Type type);
 
 /**
  * Marks the given symbol as initialized
  * @param name
  * @return the item if found, NULL otherwise
  */
-SymbolItem *get_symbol_item(SymbolTable* table, char *name);
+SymbolItem *get_symbol_item(SymbolTable* table, const char *name);
 
 #endif /* !SYMBOL_TABLE_H_INCLUDED  */

symbol_table.test.c

 #include "symbol_table.h"
 #include <stdio.h>
 #include <assert.h>
+#include <string.h>
 
 int main() {
     int err;
     printf("Mark b initialized\n");
     assert(err == -1);
 
-    err = add_temp_symbol(&table, TYPE_INT, "_temp1");
-    printf("Add _temp1 temporary variable\n");
-    assert(err == 0);
-    err = add_temp_symbol(&table, TYPE_INT, "_temp2");
-    printf("Add _temp2 temporary variable\n");
-    assert(err == 0);
-    err = add_temp_symbol(&table, TYPE_INT, "_temp1");
-    printf("Add _temp1 temporary variable\n");
-    assert(err == -1);
-    err = add_temp_symbol(&table, TYPE_INT, "temp1");
-    printf("Add temp1 temporary variable\n");
-    assert(err == -3);
+    const SymbolItem* var1 = add_temp_symbol(&table, TYPE_INT);
+    printf("Add _temp99 temporary variable\n");
+    assert(strcmp(var1->name, "_temp99") == 0);
+    const SymbolItem* var2 = add_temp_symbol(&table, TYPE_INT);
+    printf("Add _temp98 temporary variable\n");
+    assert(strcmp(var2->name, "_temp98") == 0);
 
-    item = get_symbol_item(&table, "_temp1");
-    printf("_temp1:\n");
+    item = get_symbol_item(&table, "_temp98");
+    printf("_temp98:\n");
     print_item(item);
-    item = get_symbol_item(&table, "_temp5");
+    item = get_symbol_item(&table, "_temp0");
     printf("_temp5:\n");
     print_item(item);
 

test.c

     int x, y, z;
     const PL5_op, b, c;
     printf(x);
-    x = 3 + 2;
-    y = 3;
+    x = 2;
+    y = 3 + 3 + x;
 }

yacc_util.c

+#include "yacc_util.h"
+
+void write_affectation(SymbolTable* symbol_table, InstructionTable *instruction_table, char* symbol_dest, SymbolItem* src) {
+    mark_symbol_initialized(symbol_table, symbol_dest);
+    SymbolItem *dest = get_symbol_item(symbol_table, symbol_dest);
+    add_instruction(instruction_table, COP, src->address, dest->address, 0);
+}
+
+const SymbolItem* write_op(SymbolTable* symbol_table, InstructionTable *instruction_table, Instruction instruction, SymbolItem *op1, SymbolItem *op2) {
+    const SymbolItem* dest = add_temp_symbol(symbol_table, TYPE_INT);
+    add_instruction(instruction_table, instruction, dest->address, op1->address, op2->address);
+    return dest;
+}
+
+const SymbolItem* write_negation(SymbolTable* symbol_table, InstructionTable *instruction_table, SymbolItem *op2) {
+//    Create temp variable with 0
+    const SymbolItem* op1 = init_temp_symbol(symbol_table, instruction_table, 0);
+    const SymbolItem* dest = add_temp_symbol(symbol_table, TYPE_INT);
+//    Make the 0 - variable operation
+    add_instruction(instruction_table, SOU, dest->address, op1->address, op2->address);
+    return dest;
+}
+
+
+const SymbolItem* init_temp_symbol(SymbolTable* symbol_table, InstructionTable *instruction_table, int constant) {
+    const SymbolItem* dest = add_temp_symbol(symbol_table, TYPE_INT);
+    add_instruction(instruction_table, AFC, dest->address, constant, 0);
+    return dest;
+}
+

yacc_util.h

+#include "symbol_table.h"
+#include "asm_instructions.h"
+
+#ifndef COMPILATOR_2000_YACC_UTIL_H
+#define COMPILATOR_2000_YACC_UTIL_H
+
+
+void write_affectation(SymbolTable* symbolTable, InstructionTable *instructionTable, char* symbol_dest, SymbolItem* src);
+
+const SymbolItem* write_op(SymbolTable* symbol_table, InstructionTable *instruction_table, Instruction instruction, SymbolItem *op1, SymbolItem *op2);
+
+const SymbolItem* write_negation(SymbolTable* symbol_table, InstructionTable *instruction_table, SymbolItem *op2);
+
+const SymbolItem* init_temp_symbol(SymbolTable* symbol_table, InstructionTable *instruction_table, int constant);
+
+#endif //COMPILATOR_2000_YACC_UTIL_H