remove debug print

.gitignore

@@ -1,8 +1,8 @@
-Lex_Yacc/as.tab*
+*.o
-Lex_Yacc/as.dot
+lex.yy.*
-Lex_Yacc/as.output
+as.tab.*
-Lex_Yacc/lex.yy.*
+*.asm
-Tables/tables.o
+!input.asm
-rondoudou_cross_assembleur
+*.txt
-Inputs/*
+cross_assembleur
-Outputs/*
+

Lex_Yacc/al.lex

@@ -1,51 +0,0 @@
-%{
-#include "as.tab.h"
-int yywrap(void){return 1;}
-void
-yyerror (char const *s)
-{
-
-  fprintf (stderr, "%s\n", s);
-}
-
-%}
-
-%%
-
-"ADD"     { return tADD;  } 
-"SOU"     { return tSUB;  }
-"MUL"     { return tMUL;  }
-"DIV"			{ return tDIV;  }
-"INF"			{ return tINF;  }
-"SUP"     { return tSUP;  }
-"EQU"     { return tEQU;  }
-
-"AFC"    	{ return tAFC;  }
-"COP"     { return tCPY;  }
-"AFCA"    { return tAFCA; }
-
-
-"READ"    { return tREAD; }
-"WR"      { return tWR;   }
-
-"JMP"     { return tJMP;  }
-"JMF"     { return tJMF;  }
-
-"GET"     { return tGET;  }
-"PRI"     { return tPRI;  }
-"PRIC"    { return tPRIC; }
-
-"CALL"    { return tCALL; }
-"RET"     { return tRET;  }
-
-"STOP"    { return tSTOP; }
-
-[0-9]+	  { yylval.nombre = atoi(yytext); return tNB; }
-
-"\n"	{}
-" "		{}
-"\t"	{}
-
-%%
-
-

Lex_Yacc/as.y

@@ -1,236 +0,0 @@
-%union {
-	int nombre;
-}
-%{
-#include "../Tables/tables.h"
-#include <stdio.h>
-
-FILE * file;
-FILE * file2;
-
-%}
-
-%token tMUL tDIV tADD tSUB tINF tSUP tEQU
-%token tAFC tCPY tAFCA
-%token tREAD tWR
-%token tJMP tJMF
-%token tGET tPRI tPRIC
-%token tCALL tRET
-%token tSTOP
-%token<nombre> tNB
-
-%%
-
-// Un programme est une suite d'au moins une instruction
-Programme : Instruction Programme;
-Programme : Instruction;
-
-
-// Liste de toutes les instructions et conversion
-
-// MUL, ADD, DIV.... -> 3 arguments 
-Instruction : tMUL tNB tNB tNB {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_src1 = get_reg_read($3, &added_instruction);  // On demande un registre en lecture pour l'argument B de l'instruction (adresse)
-																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
-																int reg_src2 = get_reg_read($4, &added_instruction);  // On demande un registre en lecture pour l'argument C de l'instruction (adresse)
-																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
-																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
-																																											//      On le fait après la demande en lecture TOUJOURS DEMANDER L'ECRITURE APRES LA LECTURE
-																add_instruction(MUL, reg_dest, reg_src1, reg_src2);   // On ajoute la traduction de l'instruction MUL
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-Instruction : tADD tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(ADD, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-Instruction : tDIV tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(DIV, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-Instruction : tSUB tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(SUB, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-Instruction : tINF tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(INF, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-Instruction : tSUP tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(SUP, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-Instruction : tEQU tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(EQU, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
-
-
-
-
-
-
-
-
-
-
-// AFC @ val -> AFC Ri val
-Instruction : tAFC tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
-																add_instruction(AFC, reg_dest, $3, 0);                // On ajoute la traduction de l'instruction AFC
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-// CPY @ @ -> CPY Ri Rj
-Instruction : tCPY tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_src = get_reg_read($3, &added_instruction);   // On demande un registre en lecture pour l'argument B de l'instruction (adresse)
-																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
-																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
-																																											//      On le fait après la demande en lecture TOUJOURS DEMANDER L'ECRITURE APRES LA LECTURE
-																add_instruction(CPY, reg_dest, reg_src, 0);           // On ajoute la traduction de l'instruction CPY
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-// AFCA @ val -> AFC Rlamda val; STOREA @ Rlamda
-Instruction : tAFCA tNB tNB     {increment_time();                                    // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_aux = get_reg_write(-1, &added_instruction);  // On demande un registre en écriture
-																																											//      On ne veut pas un registre associé a une adresse, juste un buffer d'où le -1
-																add_instruction(AFC, reg_aux, $3, 0);									// On affecte la valeur dans un registre lamda, elle sera tout de suite enregistré en mémoire
-																add_instruction(STOREA, $2, reg_aux, 0);              // On store la valeur en mémoire (avec un STOREA car AFCA, nous sommes donc obligé de le faire tout de suite)
-																unlink($2);                                           // On casse l'eventuel lien entre l'adresse et un registre
-																																											//      Si un registre était déjà associé a cette adresse, la valeur qu'il contient est obsolète, on le libère
-																new_instruction(added_instruction + 2);};             // On déclare le nombre d'instruction ajoutées
-
-
-
-
-
-
-
-
-
-// JMP Ins -> JMP Ins
-Instruction : tJMP tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																add_instruction(JMP, $2, 0, 0);												// On traduit le JMP sans rien changer
-																new_instruction(1);};                                 // On déclare le nombre d'instruction ajoutées
-// JMF @ Ins -> AFC Rlamda 0; SUB Rlamda Rlamda Ri; JMZ Ins
-Instruction : tJMF tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_src = get_reg_read($2, &added_instruction);   // On demande un registre en lecture pour l'argument A de l'instruction (adresse)
-																int reg_aux = get_reg_write(-1, &added_instruction);  // On demande un registre en écriture
-																																											//      On ne veut pas un registre associé a une adresse, juste un buffer d'où le -1
-																add_instruction(AFC, reg_aux, 0, 0);                  // On affecte 0 à un registre
-																add_instruction(SUB, reg_aux, reg_aux, reg_src);      // On Soustrait la valeur à 0, flag 0 levé si la valeur vallait 0 donc condition fausse
-																add_instruction(JMZ, $3, 0, 0);                       // On ajoute le JMZ
-																new_instruction(added_instruction + 3);};             // On déclare le nombre d'instruction ajoutées
-
-
-
-
-
-
-
-
-
-// READ @1 @2 -> LOADI @1 @2
-Instruction : tREAD tNB tNB    {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_addr = get_reg_read($3, &added_instruction);  // On demande un registre en lecture pour l'adresse de la lecture en mémore
-																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour loader la valeur depuis la mémoire
-																add_instruction(LOADI, reg_dest, reg_addr, 0);				// On traduit le READ
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-// WR @1 @2 -> STOREI @1 @2
-Instruction : tWR tNB tNB      {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_addr = get_reg_read($2, &added_instruction);  // On demande un registre en lecture pour l'adresse de l'écriture en mémore
-																int reg_value = get_reg_read($3, &added_instruction); // On demande un registre en lecture pour la valeur à écrire en mémoire
-																add_instruction(STOREI, reg_addr, reg_value, 0);      // On traduit le WR
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-
-
-
-
-
-
-
-
-
-// GET @ -> GET Ri
-Instruction : tGET tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en ecriture pour écrire la valeur lue
-																add_instruction(GET, reg_dest, 0, 0);                 // On traduit le GET
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-// PRI @ -> PRI Ri
-Instruction : tPRI tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_src = get_reg_read($2, &added_instruction);   // On demande un registre en lecture pour sortir la valeur à afficher
-																add_instruction(PRI, reg_src, 0, 0);                  // On traduit le PRI
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-
-// PRIC @ -> PRIC Ri
-Instruction : tPRIC tNB        {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
-																int reg_src = get_reg_read($2, &added_instruction);   // On demande un registre en lecture pour sortir la valeur à afficher
-																add_instruction(PRIC, reg_src, 0, 0);                 // On traduit le PRIC
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-
-
-
-
-
-
-
-
-
-// CALL Ins Val -> CALL Ins Val 
-Instruction : tCALL tNB tNB    {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = flush_and_init(file);         // On Store tous les registre en mémoire et réinitialise les correspondances
-																add_instruction(CALL, $2, $3, 0);                     // On traduit le CALL
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-// RET -> RET
-Instruction : tRET             {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																int added_instruction = flush_and_init(file);         // On Store tous les registre en mémoire et réinitialise les correspondances
-																add_instruction(RET, 0, 0, 0);                        // On traduit le RET
-																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
-
-
-
-
-
-
-
-
-
-// STOP Val -> STOP -> Val
-Instruction : tSTOP tNB        {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
-																add_instruction(STOP, $2, 0, 0);                      // On traduit le STOP
-																new_instruction(1);};                                 // On déclare le nombre d'instruction ajoutées
-
-%%
-
-int main(void) {
-	file = fopen("output.asm", "w");
-	file2 = fopen("output.bin", "w");
-  init();
-	yyparse();
-	write_asm(file);
-	write_code_machine(file2, 0);
-	return 0;
-}

Makefile

@@ -1,54 +1,24 @@
-default : 
+LEX = flex
-	@echo "Spécifiez une cible"
+YACC = bison -d
+CC = gcc
 
+cross_assembleur: tables.o as.tab.o lex.yy.o
+	$(CC) as.tab.o lex.yy.o tables.o -o cross_assembleur
 
+tables.o: tables.c tables.h
+	$(CC) -Wall -c tables.c -o tables.o
 
-###########################
+as.tab.c: as.y
-###      NETTOYAGE      ###
+	$(YACC) as.y
-###########################
-clean_all : clean clean_Inputs clean_Outputs
 
-clean: clean_Lex_Yacc clean_Tables
+lex.yy.c: al.lex
-	@rm -f cross_assembler
+	$(LEX) al.lex
 
-clean_Tables:
+as.tab.o: as.tab.c
-	@rm -f Tables/*.o
+	$(CC) -Wall -c as.tab.c -o as.tab.o
 
-clean_Lex_Yacc:
+lex.yy.o: lex.yy.c
-	@rm -f Lex_Yacc/as.output Lex_Yacc/as.tab.* Lex_Yacc/lex.yy.* Lex_Yacc/as.dot
+	$(CC) -Wall -c lex.yy.c -o lex.yy.o
 
-clean_Inputs:
+clean: 
-	@rm -f Inputs/*
+	rm -f *.o lex.yy.c lex.yy.h as.tab.c cross_assembleur
-
-clean_Outputs:
-	@rm -f Outputs/*
-
-
-
-###########################
-###     COMPILATION     ###
-###########################
-build : clean build_Tables build_Lex_Yacc
-	gcc Lex_Yacc/as.tab.o Lex_Yacc/lex.yy.o Tables/tables.o -o cross_assembler
-
-build_Tables: clean_Tables
-	gcc -c Tables/tables.c -o Tables/tables.o
-
-build_Lex_Yacc: clean_Lex_Yacc
-	bison -g -v -d -t -b Lex_Yacc/as Lex_Yacc/as.y
-	flex -o Lex_Yacc/lex.yy.c Lex_Yacc/al.lex
-	gcc -c Lex_Yacc/as.tab.c -o Lex_Yacc/as.tab.o
-	gcc -c Lex_Yacc/lex.yy.c -o Lex_Yacc/lex.yy.o
-
-
-
-###########################
-###       EDITION       ###
-###########################
-edit_Lex_Yacc: 
-	pluma Lex_Yacc/al.lex Lex_Yacc/as.y &
-
-edit_Tables: 
-	pluma Tables/tables.c Tables/tables.h &
-
-edit: edit_Lex_Yacc edit_Tables

ReadMe.md

@@ -1,51 +0,0 @@
-# Processeur sécurisé - CrossAssembleur
-
-
-
-Afin de pouvoir utiliser le code que nous avons compilé depuis le C avec notre compilateur sur notre processeur, il faut d'abord cross assembler le code assembleur orienté mémoire vers un langage d'assemblage orienté registres. Il faut au final refaire un autre compilateur.
-
-# Utilisation du cross assembleur
-
-Un Makefile a été inclus au sous module CrossAssembleur afin de simplifier son utilisation. Ainsi, afin de compiler tout le CrossAssembleur, il suffit de de rentrer la commande.
-``` bash
-make build
-```
-Pour lancer le CrossAssemblage du code qui aura été préalablement généré avec notre compilateur, il suffit de lancer la commande 
-``` bash
-cat FicherASM | ./rondoudou_cross_assembleur
-```
-Le résultat se trouvera dans les fichiers ***output.asm*** et ***output.bin***. 
-
-
-
-NB : Il est possible de rester au niveau du projet général. Un Makefile est aussi présent. Pour compiler le CrossAssembleur uniquement : 
-``` bash
-make compile QUOI="cross_assembleur"
-```
-Pour compiler le projet en entier :
-``` bash
-make compile QUOI="all"
-```
-
-Pour cross assembler le fichier ***file_name.memasm*** en ***file_name.regasm*** et ***file_name.bin*** :
-``` bash
-make exec SOURCE="file_name" QUOI="cross_assemble"
-```
-Pour compiler et cross assembler le fichier ***file_name.c*** et générer les fichiers ***file_name.memasm***, ***file_name.regasm***, ***file_name.bin***, et, copier le code binaire dans le fichier ***../Processeur/Processeur.srcs/sources1/new/MemoireInstructions.vhd*** :
-``` bash
-make exec SOURCE="file_name" QUOI="all"
-```
-
-# Implémentation
-
-L'implémentation a été réalisée grâce à Lex/Yacc. La gestion des registres est faite avec une politique de priorité LRU.
-
-# Points clés
-
-
-- Gestion des registres : Un tableau associe à chaque adresse un registre (-1 si aucun registre n'est affecté) et enregistre si la valeur en mémoire est à jour. Il existe deux fonctions permettant de demander des registres, une en lecture une en écriture. Ces deux fonctions renvoient le numéro du registre disponible et modifie la table comme il se doit. Si le registre était déjà associé à une adresse donc la valeur a été modifiée, elle est STORE en mémoire. Si la demande a été faite en lecture, on LOAD la valeur, en écriture non puisqu'elle sera écrasée. **TOUJOURS DEMANDER EN LECTURE AVANT DE DEMANDER EN ECRITURE**. 
-
-- Gestion des sauts : L'ajout des STORE et LOAD relatifs à la gestion des registre modifie les adresse des sauts. Pour chaque instruction orienté mémoire, on compte le nombre d'instructions orienté registre. Ainsi, on garde une table qui à chaque numéro d'instruction orienté mémoire associe le numéro d'instruction orienté registre correspondant. Lors de l'écriture du code orienté registre, on remplace les adresses des sauts grâce a cette table.
-
-
-

Tables/tables.h

@@ -1,79 +0,0 @@
-#ifndef TABLE_H
-#define TABLE_H
-
-#include <stdint.h>
-#include <stdio.h>
-
-
-// Initialise all : the addresses-registers association table, the registers priority table, the instructions buffer, the instruction address association table
-void init(void);
-
-
-
-
-/**************************************************/
-/**************************************************/
-/************** Registers Management **************/
-/**************************************************/
-/**************************************************/
-
-// Print the addresses-registers association table
-void print();
-
-// Increment the input instruction counter
-void increment_time();
-
-/* Ask for a register to read the value
-
-	@param  : 
-			- adresse : The address of value wanted
-			- added_instruction : Address of an int storing the number of added_instructions
-	@return : The number of the register corresponding to the given address
-*/
-int get_reg_read(int adresse, int * added_instruction);
-
-/* Ask for a register to write the value
-
-	@param  : 
-			- adresse : The address of value (if -1 return a free register without associating it to any address)
-			- added_instruction : Address of an int storing the number of added_instructions
-	@return : The number of the register corresponding to the given address
-
-	WARNING : The value of the address will not be LOADED in the register
-						Always ask READ registers before the WRITE register
-*/
-int get_reg_write(int adresse, int * added_instruction);
-
-// Broke the association between adresse and its corresponding register
-void unlink(int adresse);
-
-// Store used register, init the association table between addresses and registers 
-int flush_and_init();
-
-
-
-
-
-/**************************************************/
-/**************************************************/
-/************** Instructions Writing **************/
-/**************************************************/
-/**************************************************/
-
-
-// Enum of the register oriented instruction (warning order correspond to the binary code)
-enum instruction_t {NOP, ADD, MUL, SUB, DIV, INF, SUP, EQU, CPY, AFC, LOAD, STORE, LOADI, STOREI, STOREA, JMP, JMZ, PRI, PRIC, GET, CALL, RET, STOP};
-
-// Add a new Registers oriented instruction
-void add_instruction(enum instruction_t inst, int param1, int param2, int param3);
-
-// Specifie the number of Register oriented instructions corresponding to the memory oriented instruction
-void new_instruction(int nb_inst);
-
-// Write the new assembly in the given file
-void write_asm(FILE * file);
-
-// Write the binary code in the given file
-void write_code_machine(FILE * file, char compact);
-
-#endif

al.lex

@@ -0,0 +1,32 @@
+%{
+#include "as.tab.h"
+int yywrap(void){return 1;}
+void
+yyerror (char const *s)
+{
+
+  fprintf (stderr, "%s\n", s);
+}
+
+%}
+
+%%
+
+"ADD"     { return tADD ;} 
+"MUL"     { return tMUL; }
+"SOU"     { return tSUB;}
+"DIV"	  { return tDIV; }
+
+"COP"     { return tCPY; }
+"AFC"     { return tAFC; }
+
+
+[0-9]+	  { yylval.nombre = atoi(yytext); return tNB; }
+
+"\n"	{}
+" "		{}
+"\t"	{}
+
+%%
+
+

as.y

@@ -0,0 +1,92 @@
+%union {
+	int nombre;
+}
+%{
+#include "tables.h"
+#include <stdio.h>
+
+FILE * file;
+FILE * file2;
+
+%}
+
+%token tMUL tDIV tADD tSUB
+%token tAFC tCPY
+%token<nombre> tNB
+
+%%
+
+Programme : Instruction Programme;
+Programme : Instruction;
+
+Instruction : tMUL tNB tNB tNB {increment_time();
+																int added_instruction = 0;
+																int reg_src1 = get_reg_read($3, &added_instruction);
+																int reg_src2 = get_reg_read($4, &added_instruction);
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(MUL, reg_dest, reg_src1, reg_src2);
+																new_instruction(added_instruction + 1);};
+Instruction : tADD tNB tNB tNB {increment_time();
+																int added_instruction = 0;
+																int reg_src1 = get_reg_read($3, &added_instruction);
+																int reg_src2 = get_reg_read($4, &added_instruction);
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(ADD, reg_dest, reg_src1, reg_src2);
+																new_instruction(added_instruction + 1);};
+Instruction : tDIV tNB tNB tNB {increment_time();
+																int added_instruction = 0;
+																int reg_src1 = get_reg_read($3, &added_instruction);
+																int reg_src2 = get_reg_read($4, &added_instruction);
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(DIV, reg_dest, reg_src1, reg_src2);
+																new_instruction(added_instruction + 1);};
+Instruction : tSUB tNB tNB tNB {increment_time();
+																int added_instruction = 0;
+																int reg_src1 = get_reg_read($3, &added_instruction);
+																int reg_src2 = get_reg_read($4, &added_instruction);
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(SUB, reg_dest, reg_src1, reg_src2);
+																new_instruction(added_instruction + 1);};
+
+Instruction : tAFC tNB tNB     {increment_time();
+																int added_instruction = 0;
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(AFC, reg_dest, $3, 0);
+																new_instruction(added_instruction + 1);};
+Instruction : tCPY tNB tNB     {increment_time();
+																int added_instruction = 0;
+																int reg_src = get_reg_read($3, &added_instruction);
+																int reg_dest = get_reg_write($2, &added_instruction);
+																add_instruction(CPY, reg_dest, reg_src, 0);
+																new_instruction(added_instruction + 1);};
+
+%%
+
+#include <string.h>
+
+int main(int argc, char *argv[]) {
+  char *output_filename = "output_cross";
+
+  if (argc >= 2) {
+      output_filename = argv[1];
+  }
+
+  char *asm_filename = malloc(strlen(output_filename) + 5);
+  char *bin_filename = malloc(strlen(output_filename) + 9);
+  strcpy(asm_filename, output_filename);
+  strcpy(bin_filename, output_filename);
+  strcat(asm_filename, ".asm");
+  strcat(bin_filename, "_bin.txt");
+
+  file = fopen(asm_filename, "w");
+  file2 = fopen(bin_filename, "w");
+  init();
+  yyparse();
+  flush_and_init();
+  write_asm(file);
+  write_code_machine(file2);
+
+  free(asm_filename);
+  free(bin_filename);
+  return 0;
+}

input.asm

@@ -0,0 +1,9 @@
+AFC 99 2
+COP 0 99
+AFC 98 3
+AFC 97 3
+ADD 96 98 97
+ADD 95 96 0
+COP 1 95
+AFC 94 3
+COP 0 94

tables.c

@@ -1,24 +1,27 @@
+
+/* 
+----------------------------------------
+|  Adresse   |  Registre  |  Modifié   | 
+----------------------------------------
+|            |            |            |            
+|            |            |            |            
+|            |            |            |            
+|      i     | 0x777756b8 |     int    |       
+|    size    | 0x777756b8 |     int    |        
+----------------------------------------
+*/
+
 #include "tables.h"
-#define NB_REG 16                // Nombre de registre dans le processeur
+#include <stdlib.h>
-#define MEM_SIZE 64             // Taille de la mémoire de données
+#define NB_REG 16
-#define MEM_INST_SIZE 512       // Taille de la mémoire d'instruction
+#define MEM_SIZE 256
-#define NB_BITS_INSTRUCTION 5   // Nombres de bits codant une instruction
+#define NB_INSTRUCTIONS 256
-#define NB_BITS 16               // Taille d'un mot du processeur
+#define MEM_INST_SIZE 256
+#define NB_BITS_INSTRUCTION 8
+#define NB_BITS 8
 
+int traduction_JMP[NB_INSTRUCTIONS];
 
-
-/**************************************************/
-/**************************************************/
-/***************** Initialisation *****************/
-/**************************************************/
-/**************************************************/
-
-// Buffer to patch Jumps difference due to adding LOAD and STORE
-int traduction_JMP[MEM_INST_SIZE];
-// Index of the buffer
-int last_instruction = 0;
-
-// Structure coding an instruction
 struct str_instruction {
 	enum instruction_t instruction;
 	int param1;
@@ -26,23 +29,114 @@ struct str_instruction {
 	int param3;
 };
 
-// Buffer to store registers oriented instructions
+int last_instruction = 0;
-struct str_instruction buffer[3*MEM_INST_SIZE];
+struct str_instruction buffer[3*NB_INSTRUCTIONS];
+
+void add_instruction(enum instruction_t inst, int param1, int param2, int param3) {
+	struct str_instruction my_instruction = {inst, param1, param2, param3};
+	buffer[last_instruction] = my_instruction;
+	last_instruction++;
+}
+
+void write_asm(FILE * file) {
+	int i = 0;
+	while (i<MEM_INST_SIZE) {
+		if (buffer[i].instruction == ADD) {
+			fprintf(file, "ADD %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
+		} else if (buffer[i].instruction == NOP) {
+			fprintf(file, "NOP 0 0 0\n");
+		} else if (buffer[i].instruction == SUB) {
+			fprintf(file, "SUB %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
+		} else if (buffer[i].instruction == MUL) {
+			fprintf(file, "MUL %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
+		} else if (buffer[i].instruction == DIV) {
+			fprintf(file, "DIV %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
+		} else if (buffer[i].instruction == AFC) {
+			fprintf(file, "AFC %d %d\n", buffer[i].param1, buffer[i].param2);
+		} else if (buffer[i].instruction == CPY) {
+			fprintf(file, "CPY %d %d\n", buffer[i].param1, buffer[i].param2);
+		} else if (buffer[i].instruction == LOAD) {
+			fprintf(file, "LOAD %d %d\n", buffer[i].param1, buffer[i].param2);
+		} else if (buffer[i].instruction == STORE) {
+			fprintf(file, "STORE %d %d\n", buffer[i].param1, buffer[i].param2);
+        } else {
+            printf("Error: unexpected instruction: %d\n", buffer[i].instruction);
+            exit(1);
+        }
+		i++;
+	}
+}
+
+void int_2_bin(char * buff, int n) {
+	int _m = n; 
+	for (int i = 0; i < 32; i++) { 
+		buff[31 - i] = ((_m & (1 << 31)) ? '1' : '0'); 
+		_m = _m << 1; 
+	} 
+}
+
+void convert_to_binary_on_N(int value, int N, char * buff) {
+	char tampon[33];
+	int_2_bin(tampon, value);
+	int i;
+	for (i = N-1; i>=0; i--) {
+		buff[N-1-i] = tampon[i];
+	}
+	buff[N] = '\0';
+}
+
+void write_instruction_binary(FILE * file, struct str_instruction instr, int compact, int printSeparator) {
+	char buff1[33];
+	char buff2[33];
+	char buff3[33];
+	char buff4[33];
+	convert_to_binary_on_N(instr.instruction, NB_BITS_INSTRUCTION, buff1);
+
+	convert_to_binary_on_N(instr.param1, NB_BITS, buff2);
+	
+	convert_to_binary_on_N(instr.param2, NB_BITS, buff3);
+	convert_to_binary_on_N(instr.param3, NB_BITS, buff4);
+	if (compact) {
+		fprintf(file, "%s%s%s%s", buff1, buff2, buff3, buff4);
+	} else {
+		fprintf(file, "\"%s%s%s%s\"", buff1, buff2, buff3, buff4);
+        if (printSeparator) {
+            fprintf(file, ", ");
+        }
+	}
+}
+
+
+void write_code_machine(FILE * file) {
+	int i = MEM_INST_SIZE - 1;
+    fprintf(file, "signal memory: MEMORY_TYPE := (");
+	while (i >= 0) {
+		write_instruction_binary(file, buffer[i], 0, i != 0);
+		i--;
+	}
+    fprintf(file, ");");
+}
+
+void write_code_machine_compact(FILE * file) {
+	fprintf(file, "\"");
+	int i = MEM_INST_SIZE - 1;
+	while (i >= 0) {
+		write_instruction_binary(file, buffer[i], 1, 0);
+		i--;
+	}
+	fprintf(file, "\"\n");
+}
+
 
-// Structure coding an address and the correpondance with a register 
 struct case_adresse {
 	int adresse;
 	int registre;
 	char modifie;
 };
 
-// Buffer of addresses (Memory)
 struct case_adresse tableau[MEM_SIZE];
-
-// Buffer to manage priority policy
 int registres[NB_REG];
 
-// Initialise all : the addresses-registers association table, the registers priority table, the instructions buffer, the instruction address association table
 void init (void) {
   int i;
 	struct case_adresse case_courante = {0, -1, 0};
@@ -59,20 +153,10 @@ void init (void) {
 	}
 }
 
-
-/**************************************************/
-/**************************************************/
-/************** Registers Management **************/
-/**************************************************/
-/**************************************************/
-
-// INTERN FUNCTION
-// Print a case address
 void print_case_adresse(struct case_adresse case_courante) {
 	printf("{addr : %d ; reg : %d ; modi : %d}\n", case_courante.adresse, case_courante.registre, (int)case_courante.modifie);
 }
 
-// Print the adresses-registers correspondance table
 void print() {
   int i;
 	for (i=0; i<MEM_SIZE; i++) {
@@ -80,14 +164,11 @@ void print() {
 	}
 }
 
-// INTERN FUNCTION
+
-// return the case corresponding to the given address
 struct case_adresse get_info(int adresse) {
 	return tableau[adresse];
 }
 
-// INTERN FUNCTION
-// return the address corresponding to the given register
 int get_adresse (int registre) {
 	int i = 0;
 	while (i < MEM_SIZE && tableau[i].registre != registre) {
@@ -100,19 +181,14 @@ int get_adresse (int registre) {
 	}
 }
 
-// INTERN FUNCTION
-// Set the given register to the given address
 void set_registre(int adresse, int registre) {
 	tableau[adresse].registre = registre;
 }
 
-// INTERN FUNCTION
-// Set modifie to the address (0 the value in the memory is up to date, 1 the value in the register is more recent)
 void set_modifie(int adresse, char modifie) {
 	tableau[adresse].modifie = modifie;
 }
 
-// Increment the register priority policy buffer
 void increment_time() {
 	int i;
 	for (i=0; i<NB_REG; i++) {
@@ -120,14 +196,10 @@ void increment_time() {
 	}
 }
 
-// INTERN FUNCTION
-// Specifie that the given register have been used
 void refresh_registre(int registre) {
 	registres[registre] = 0;
 }
 
-// INTERN FUNCTION
-// Return the LRU register
 int get_register() {
 	int i;
 	int index_max = 0;
@@ -139,48 +211,6 @@ int get_register() {
 	return index_max;
 }
 
-/* Ask for a register to read the value
-
-	@param  : 
-			- adresse : The address of value wanted
-			- added_instruction : Address of an int storing the number of added_instructions
-	@return : The number of the register corresponding to the given address
-*/
-int get_reg_read(int adresse, int * added_instruction) {
-	struct case_adresse ma_case = get_info(adresse);
-	if (ma_case.registre == -1) {
-		int dispo = get_register();
-		int previous_addr = get_adresse(dispo);
-		if (previous_addr != -1) {
-			struct case_adresse ancienne_case = get_info(previous_addr);
-			if (ancienne_case.modifie == 1) {
-				*added_instruction = (*added_instruction) + 1;
-				add_instruction(STORE, previous_addr, dispo, 0);
-				set_modifie(previous_addr, 0);
-			}
-			set_registre(previous_addr, -1);
-		}
-		*added_instruction = (*added_instruction) + 1;
-		add_instruction(LOAD, dispo, adresse, 0);
-		set_registre(adresse, dispo);
-		refresh_registre(dispo);
-		return dispo;
-	} else {
-		refresh_registre(ma_case.registre);
-		return ma_case.registre;
-	}
-}
-
-/* Ask for a register to write the value
-
-	@param  : 
-			- adresse : The address of value (if -1 return a free register without associating it to any address)
-			- added_instruction : Address of an int storing the number of added_instructions
-	@return : The number of the register corresponding to the given address
-
-	WARNING : The value of the address will not be LOADED in the register
-						Always ask READ registers before the WRITE register
-*/
 int get_reg_write(int adresse, int * added_instruction) {
 	if (adresse == -1) {
 		int dispo = get_register();
@@ -220,12 +250,35 @@ int get_reg_write(int adresse, int * added_instruction) {
 	}
 }
 
-// Broke the association between adresse and its corresponding register
+int get_reg_read(int adresse, int * added_instruction) {
+	struct case_adresse ma_case = get_info(adresse);
+	if (ma_case.registre == -1) {
+		int dispo = get_register();
+		int previous_addr = get_adresse(dispo);
+		if (previous_addr != -1) {
+			struct case_adresse ancienne_case = get_info(previous_addr);
+			if (ancienne_case.modifie == 1) {
+				*added_instruction = (*added_instruction) + 1;
+				add_instruction(STORE, previous_addr, dispo, 0);
+				set_modifie(previous_addr, 0);
+			}
+			set_registre(previous_addr, -1);
+		}
+		*added_instruction = (*added_instruction) + 1;
+		add_instruction(LOAD, dispo, adresse, 0);
+		set_registre(adresse, dispo);
+		refresh_registre(dispo);
+		return dispo;
+	} else {
+		refresh_registre(ma_case.registre);
+		return ma_case.registre;
+	}
+}
+
 void unlink(int adresse) {
 	set_registre(adresse, -1);
 }
 
-// Store used register, init the association table between addresses and registers
 int flush_and_init() {
 	int i;
 	int added_instruction = 0;
@@ -247,25 +300,6 @@ int flush_and_init() {
 	return added_instruction;
 }
 
-	
-
-
-
-
-/**************************************************/
-/**************************************************/
-/************** Instructions Writing **************/
-/**************************************************/
-/**************************************************/
-
-// Add a new Registers oriented instruction
-void add_instruction(enum instruction_t inst, int param1, int param2, int param3) {
-	struct str_instruction my_instruction = {inst, param1, param2, param3};
-	buffer[last_instruction] = my_instruction;
-	last_instruction++;
-}
-
-// Specifie the number of Register oriented instructions corresponding to the memory oriented instruction
 void new_instruction(int nb_inst) {
 	static int last_intruction_adresse = 0;
 	static int current_instruction = 0; 
@@ -273,124 +307,21 @@ void new_instruction(int nb_inst) {
 	current_instruction++;
 	last_intruction_adresse += nb_inst;
 }
+	
+
+
+
+
+
+
+
+
 
-// Write the new assembly in the given file
-void write_asm(FILE * file) {
-	int i = 0;
-	while (i<MEM_INST_SIZE) {
-		if (buffer[i].instruction == ADD) {
-			fprintf(file, "ADD %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == SUB) {
-			fprintf(file, "SUB %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == MUL) {
-			fprintf(file, "MUL %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == DIV) {
-			fprintf(file, "DIV %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == INF) {
-			fprintf(file, "INF %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == SUP) {
-			fprintf(file, "SUP %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
-		} else if (buffer[i].instruction == EQU) {
-			fprintf(file, "EQU %d %d %d\n", buffer[i].param1, buffer[i].param2, buffer[i].param3);
 
-		} else if (buffer[i].instruction == AFC) {
-			fprintf(file, "AFC %d %d\n", buffer[i].param1, buffer[i].param2);
-		} else if (buffer[i].instruction == CPY) {
-			fprintf(file, "CPY %d %d\n", buffer[i].param1, buffer[i].param2);
 
-		} else if (buffer[i].instruction == LOAD) {
-			fprintf(file, "LOAD %d %d\n", buffer[i].param1, buffer[i].param2);
-		} else if (buffer[i].instruction == STORE) {
-			fprintf(file, "STORE %d %d\n", buffer[i].param1, buffer[i].param2);
-		} else if (buffer[i].instruction == LOADI) {
-			fprintf(file, "LOADI %d %d\n", buffer[i].param1, buffer[i].param2);
-		} else if (buffer[i].instruction == STOREI) {
-			fprintf(file, "STOREI %d %d\n", buffer[i].param1, buffer[i].param2);
-		} else if (buffer[i].instruction == STOREA) {
-			fprintf(file, "STOREA %d %d\n", buffer[i].param1, buffer[i].param2);
 
-		} else if (buffer[i].instruction == JMP) {
-			fprintf(file, "JMP %d\n", traduction_JMP[buffer[i].param1]);
-		} else if (buffer[i].instruction == JMZ) {
-			fprintf(file, "JMZ %d\n", traduction_JMP[buffer[i].param1]);
-		} else if (buffer[i].instruction == GET) {
-			fprintf(file, "GET %d\n", buffer[i].param1);
-		} else if (buffer[i].instruction == PRI) {
-			fprintf(file, "PRI %d\n", buffer[i].param1);
-    } else if (buffer[i].instruction == PRIC) {
-			fprintf(file, "PRIC %d\n", buffer[i].param1);
 
-		} else if (buffer[i].instruction == CALL) {
-			fprintf(file, "CALL %d %d\n", traduction_JMP[buffer[i].param1], buffer[i].param2);
-		} else if (buffer[i].instruction == RET) {
-			fprintf(file, "RET\n");
-		} else if (buffer[i].instruction == STOP) {
-			fprintf(file, "STOP %d\n", buffer[i].param1);
-		} 
-		i++;
-	}
-}
 
-// INTERN FUNCTION
-// Write binary value of n in buff
-void int_2_bin(char * buff, int n) {
-	int _m = n; 
-	for (int i = 0; i < 32; i++) { 
-		buff[31 - i] = ((_m & (1 << 31)) ? '1' : '0'); 
-		_m = _m << 1; 
-	} 
-}
 
-// INTERN FUNCTION
-// Write binary value of value in buff on N bits
-void convert_to_binary_on_N(int value, int N, char * buff) {
-	char tampon[33];
-	int_2_bin(tampon, value);
-	int i;
-	for (i = N-1; i>=0; i--) {
-		buff[N-1-i] = tampon[i];
-	}
-	buff[N] = '\0';
-}
 
-// INTERN FUNCTION
-// Write a binary instruction in the given file
-// If not compact ("010..10" & ) else only (010..10)
-void write_instruction_binary(FILE * file, struct str_instruction instr, char compact) {
-	char buff1[33];
-	char buff2[33];
-	char buff3[33];
-	char buff4[33];
-	convert_to_binary_on_N(instr.instruction, NB_BITS_INSTRUCTION, buff1);
-	if (instr.instruction == JMP || instr.instruction == JMZ || instr.instruction == CALL) {
-		convert_to_binary_on_N(traduction_JMP[instr.param1], NB_BITS, buff2);
-	} else {
-		convert_to_binary_on_N(instr.param1, NB_BITS, buff2);
-	}
-	convert_to_binary_on_N(instr.param2, NB_BITS, buff3);
-	convert_to_binary_on_N(instr.param3, NB_BITS, buff4);
-	if (compact) {
-		fprintf(file, "%s%s%s%s", buff1, buff2, buff3, buff4);
-	} else {
-		fprintf(file, "\"%s%s%s%s\" & ", buff1, buff2, buff3, buff4);
-	}
-}
 
-// Write the binary code in the given file
-void write_code_machine(FILE * file, char compact) {
-	if (compact) {
-		int i = MEM_INST_SIZE - 1;
-		while (i>=0) {
-			write_instruction_binary(file, buffer[i], 0);
-			i--;
-		}
-	} else {
-		fprintf(file, "\"");
-		int i = MEM_INST_SIZE - 1;
-		while (i>=0) {
-			write_instruction_binary(file, buffer[i], 1);
-			i--;
-		}
-		fprintf(file, "\"\n");
-	}
-}

tables.h

@@ -0,0 +1,35 @@
+#ifndef TABLE_H
+#define TABLE_H
+
+/* 
+----------------------------------------
+|  Adresse   |  Registre  |  Modifié   | 
+----------------------------------------
+|            |            |            |            
+|            |            |            |            
+|            |            |            |            
+|      i     | 0x777756b8 |     int    |       
+|    size    | 0x777756b8 |     int    |        
+----------------------------------------
+*/
+
+
+
+#include <stdint.h>
+#include <stdio.h>
+
+enum instruction_t {NOP, ADD, MUL, SUB, DIV, CPY, AFC, LOAD, STORE};
+
+void init(void);
+void print();
+void increment_time();
+int get_reg_read(int adresse, int * added_instruction);
+int get_reg_write(int adresse, int * added_instruction);
+void unlink(int adresse);
+int flush_and_init();
+void new_instruction(int nb_inst);
+void write_asm(FILE * file);
+void write_code_machine(FILE * file);
+void add_instruction(enum instruction_t inst, int param1, int param2, int param3);
+
+#endif