pfaure/Compilateur
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Normalement tout bon mais moche

Browse source
This commit is contained in:
Tali Elies 2021-05-04 15:31:55 +02:00
parent 24b08129bb
commit 1ec1d418b7
11 changed files with 1094 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
Documentation/transcription_opcodes.md
View file

@ -60,17 +60,16 @@ Va mettre à l'adresse @X ce qui est à l'addresse contenue à l'adresse @Y (on
## WR @X @Y
Va mettre le contenue dans @Y dans l'adresse qui est la valeur dans @X (on considère que @X est un pointeur et on écrit dans l'adresse qui est contenue dans @X). Attention, considérer des addresses globales (pas relatives).
Va mettre le contenu de @Y dans l'adresse qui est la valeur dans @X (on considère que @X est un pointeur et on écrit dans l'adresse qui est contenue dans @X). Attention, considérer des addresses globales (pas relatives).
##CALL lig taille_arg addr_ret
Appelle la fonction dont la première ligne est lig est dont la taille des arguments en 2ème (pour bouger BP) et en trois l'addresse de retour.
##CALL lig taille_pile_fonction_appelante
Appelle la fonction dont la première ligne est lig et taille_pile_fonction_appelante est la taille de la zone mémoire utilisée par la fonction appelante (avant le push des args !)
##RET
Bouge BP et saute à l'adresse de retour (selon les valeur qui sont dans la pile de contrôle).
##COPR @X taille
##STOP
Va copier dans l'emplacement réservé à la valeur de retour la valeur contenue dans @X (on copie à l'addresse BP - taille en gros car on a reservé en avance cet emplacement mémoire).
Arrete le processeur (à mettre à la fin de l'ASM)

18
Fichiers_Tests/progC
View file

@ -1,9 +1,19 @@
int fonction(int * p){
int b = *p + 2;
int g(int y[]){
int u;
y[1] = 2;
return 15;
}
int fonction(int p[]){
g(p);
return 1;
}
int main(){
int b = 1;
fonction(&b);
int b[2];
int c = fonction(b);
c = get();
b[0] = 25;
printf(b[0]);
}

1
Lex_Yacc/al.lex
View file

@ -31,6 +31,7 @@ yyerror (char const *s)
"&" { return tADDR;}
"[" { return tOCROCH;}
"]" { return tCCROCH;}
"get" { return tGET;}
[0-9]+ { yylval.nombre = atoi(yytext); return tNB; }

1030
Lex_Yacc/as.dot Normal file
View file

File diff suppressed because it is too large Load diff

BIN
Lex_Yacc/as.pdf Normal file
View file

Binary file not shown.

49
Lex_Yacc/as.y
View file

@ -30,13 +30,13 @@ int nbs_instructions_to_patch[10];
%token tMUL tDIV tADD tSUB tEQ
%token<nombre> tNB tNBEXP
%token<id> tID
%token tPRINTF
%token tPRINTF tGET
%token tERROR
%token<nombre> tIF tWHILE tELSE
%token tRETURN
%token tLT tGT tEQCOND
%token tAND tOR
%token tADDR
%token tADDR
%left tLT tGT
%left tEQCOND
@ -45,7 +45,7 @@ int nbs_instructions_to_patch[10];
%left tADD tSUB
%left tMUL tDIV
%type<nombre> E DebutAff SuiteAffPointeur DebutAffPointeur EBis Invocation Args ArgSuite Arg SuiteParams Params
%type<nombre> E DebutAff SuiteAffPointeur DebutAffPointeur EBis Invocation Args ArgSuite Arg SuiteParams Params Get
@ -57,51 +57,51 @@ int nbs_instructions_to_patch[10];
C : Fonction Fonctions;
C : Fonction Fonctions {add_operation(STOP,0,0,0); create_asm();};
Fonctions : Fonction Fonctions;
Fonctions : ;
Main : tINT {printf("Déclaration du main\n");} tMAIN tOBRACE Args tCBRACE Body { print(); create_asm();} ;
Main : tINT {printf("Déclaration du main\n"); create_jump_to_main(get_current_index());} tMAIN tOBRACE Args tCBRACE Body { print(); } ;
Fonction : Type tID {return_type_fonc = type_courant; printf("Déclaration de la fonction %s\n", $2);} tOBRACE {inc_prof();} Args {decrement_prof(); push_fonction($2,return_type_fonc,get_current_index(), $6);} tCBRACE Body { print_fonctions(); add_operation(RET,0,0,0);} ;
Fonction : Main {print_fonctions();};
Return : tRETURN E tPV {if (return_type_fonc.pointeur_level > 0 || return_type_fonc.isTab){add_operation(COPR,$2, taille_types[INT],0);} else {add_operation(COPR,$2,taille_types[return_type_fonc.base],0);} pop(); };
Get : tGET tOBRACE tCBRACE {int addr = push("0_TEMPORARY", 0, integer); add_operation(GET,addr,0,0); $$ = addr;};
Return : tRETURN E tPV {add_operation(COP,0,$2,0); pop(); };
Args : Arg ArgSuite {$$ = $1 + $2; printf("Les arguments de la fonctions vont avoir une taille dans la pile de : %d\n",$$);};
Args : {$$ = 0;};
Arg : Type tID {int addr = push($2,1, type_courant); if (type_courant.pointeur_level > 0){$$ = taille_types[INT];} else{$$ = taille_types[type_courant.base];}};
Arg : Type tID tOCROCH tCCROCH {int addr = push($2,1, type_courant); $$ = taille_types[INT];};
Arg : Type tID tOCROCH tCCROCH {type_courant.isTab = 2; int addr = push($2,1, type_courant); $$ = taille_types[INT];};
ArgSuite : tCOMA Arg ArgSuite {$$ = $2 + $3;} ;
ArgSuite : {$$ = 0;};
Body : tOBRACKET {inc_prof();} Instructions tCBRACKET {print(); reset_prof();} ;
Body : tOBRACKET {inc_prof();} Instructions tCBRACKET {print(); reset_prof();};
Instructions : Instruction Instructions ;
Instructions : ;
Instruction : Aff {};
Instruction : Decl {};
Instruction : Invocation tPV{};
Instruction : Invocation tPV{pop();};
Instruction : If {};
Instruction : While {};
Instruction : Return {};
Invocation : tID tOBRACE {struct fonction_t fonc = get_fonction($1); if (fonc.return_type.pointeur_level > 0 || fonc.return_type.isTab){
$2 = push("0_TEMPORARY_RETURN", 0, integer);
Invocation : tID tOBRACE {struct fonction_t fonc = get_fonction($1);}
Params tCBRACE {struct fonction_t fonc = get_fonction($1); multiple_pop($4);
add_operation(CALL,fonc.first_instruction_line, get_last_addr(),0); if (fonc.return_type.pointeur_level > 0 || fonc.return_type.isTab){
$$ = push("0_TEMPORARY_RETURN", 0, integer);
}
else{
$2 = push("0_TEMPORARY_RETURN", 0, fonc.return_type);
}}
$$ = push("0_TEMPORARY_RETURN", 0, fonc.return_type);
}};
Params tCBRACE {struct fonction_t fonc = get_fonction($1); multiple_pop($4);
add_operation(CALL,fonc.first_instruction_line, fonc.taille_args,get_current_index() + 1); $$ = $2;};
//Pour les tableaux quand on les passe en arguments, il faudra faire gaffe à bien les passer comme un pointeur vers un tableau et pas juste un tableau car sinon in ne pourra pas accéder au tableau de base depuis la fonction appellée. Il faut pour cela peut être rajouter un nouveau champ (isArg) dans la table des symboles (ou autre idée?)
Invocation : tPRINTF tOBRACE E tCBRACE{add_operation(PRI,$3,0,0); pop();};
Params : {$$ = 0; printf("Sans Params\n"); } ;
Params : Param SuiteParams {$$ = $2 + 1;};
@ -154,7 +154,7 @@ DebutAff : tID {struct symbole_t * symbole = get_variable($1); symbole->initial
DebutAffPointeur : tMUL SuiteAffPointeur {add_operation(READ, $2, $2, 0); $$=$2;};
DebutAffPointeur : SuiteAffPointeur {$$=$1;};
SuiteAffPointeur : tMUL tID {struct symbole_t * symbole = get_variable($2); int addr = push("0_TEMPORARY", 1, symbole->type); add_operation(COP, addr,symbole->adresse,0); $$=addr;};
SuiteAffPointeur : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1); int addr = push("0_TEMPORARY", 1, symbole->type); if (symbole->type.pointeur_level > 0){add_operation(COP, addr,symbole->adresse,0);} else{add_operation(AFCA, addr,symbole->adresse,0);} int addr2 = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr2, taille_types[symbole->type.base],0); add_operation(MUL,$3,addr2,$3); add_operation(ADD,$3,addr,$3); $$=$3; pop(); pop();};
SuiteAffPointeur : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1); int addr = push("0_TEMPORARY", 1, symbole->type); if (symbole->type.isTab == 2){add_operation(COP, addr,symbole->adresse,0);} else{add_operation(AFCA, addr,symbole->adresse,0);} int addr2 = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr2, taille_types[symbole->type.base],0); add_operation(MUL,$3,addr2,$3); add_operation(ADD,$3,addr,$3); $$=$3; pop(); pop();};
E : tNB { int addr = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr,$1,0); $$ = addr;};
@ -173,15 +173,18 @@ E : tNOT E { printf("!\n"); };
E : E tAND E {add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
E : E tOR E {add_operation(ADD,$1,$1,$3); $$ = $1; pop();} ;
E : tMUL E { add_operation(READ, $2, $2, 0); $$=$2;};
E : tID { printf("Id\n"); struct symbole_t * symbole = get_variable($1); struct type_t type = symbole->type; type.nb_blocs = 1; int addr = push("0_TEMPORARY", 1, type); if (symbole->type.isTab){add_operation(AFCA, addr,symbole->adresse,0); } else{add_operation(COP, addr,symbole->adresse,0);} $$=addr;};
E : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1); struct type_t type = symbole->type; type.nb_blocs = 1; int addr = push("0_TEMPORARY", 1, type); if(type.pointeur_level > 0) {add_operation(COP, addr,symbole->adresse,0);} else{add_operation(AFCA, addr,symbole->adresse,0);} int addr2 = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr2, taille_types[symbole->type.base],0); add_operation(MUL,$3,addr2,$3);
add_operation(ADD,$3,addr,$3); add_operation(READ,$3,$3,0); $$=$3; pop(); pop();};
E : tID { printf("Id\n"); struct symbole_t * symbole = get_variable($1); struct type_t type = symbole->type; type.nb_blocs = 1; int addr = push("0_TEMPORARY", 1, type); if (symbole->type.isTab == 1){add_operation(AFCA, addr,symbole->adresse,0);} else{add_operation(COP, addr,symbole->adresse,0);} $$=addr;};
E : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1); struct type_t type = symbole->type; type.nb_blocs = 1; int addr = push("0_TEMPORARY", 1, type); if(type.isTab == 2) {add_operation(COP, addr,symbole->adresse,0);} else{add_operation(AFCA, addr,symbole->adresse,0);} int addr2 = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr2, taille_types[symbole->type.base],0); add_operation(MUL,$3,addr2,$3);
add_operation(ADD,$3,addr,$3); add_operation(READ,$3,$3,0); $$=$3; pop(); pop();};
E : tADDR EBis {$$=$2;};
E : Get {$$ = $1;};
EBis : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1);
struct type_t type = symbole->type; type.nb_blocs = 1;
int addr = push("0_TEMPORARY", 1, type);
if(type.pointeur_level > 0) {
if(type.isTab == 2) {
add_operation(COP, addr,symbole->adresse,0);
}
else{

4
Makefile
View file

@ -21,7 +21,7 @@ clean_Lex_Yacc:
@rm -f Lex_Yacc/as.output Lex_Yacc/as.tab.* Lex_Yacc/lex.yy.*
build : clean build_Symboles build_Instructions build_Lex_Yacc build_Fonctions
gcc Lex_Yacc/as.tab.o Lex_Yacc/lex.yy.o Tables/Instructions/tab_instruc.o Tables/Symboles/table_symboles.o Tables/Fonctions/tab_fonctions.o -ll -o rondoudou_gcc
gcc Lex_Yacc/as.tab.o Lex_Yacc/lex.yy.o Tables/Instructions/tab_instruc.o Tables/Symboles/table_symboles.o Tables/Fonctions/tab_fonctions.o -ly -o rondoudou_gcc
build_Symboles: clean_Symboles
gcc -c Tables/Symboles/table_symboles.c -o Tables/Symboles/table_symboles.o
@ -33,7 +33,7 @@ build_Fonctions : clean_Fonctions
gcc -c Tables/Fonctions/tab_fonctions.c -o Tables/Fonctions/tab_fonctions.o
build_Lex_Yacc: clean_Lex_Yacc
bison -d -t -b Lex_Yacc/as Lex_Yacc/as.y
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

BIN
Tables/Fonctions/tab_fonctions.o
View file

Binary file not shown.

20
Tables/Instructions/tab_instruc.c
View file

@ -1,5 +1,5 @@
#include "tab_instruc.h"
int current_index = 0;
int current_index = 1;
struct operation_t tab_op[MAXTAILLE];
void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
@ -13,6 +13,10 @@ void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
}
}
void create_jump_to_main(int line){
struct operation_t new_op = {JMP,line, 0, 0};
tab_op[0] = new_op;
}
char * get_asm_line_from_op(struct operation_t op){
@ -39,9 +43,6 @@ char * get_asm_line_from_op(struct operation_t op){
case (AFCA):
sprintf(buffer,"AFCA %d %d\n",op.arg1, op.arg2);
break;
case (COPA):
sprintf(buffer,"COPA %d %d\n",op.arg1, op.arg2);
break;
case (JMP):
sprintf(buffer,"JMP %d\n",op.arg1);
break;
@ -67,14 +68,17 @@ char * get_asm_line_from_op(struct operation_t op){
sprintf(buffer,"WR %d %d\n",op.arg1, op.arg2);
break;
case (CALL):
sprintf(buffer,"CALL %d %d %d\n",op.arg1, op.arg2, op.arg3);
sprintf(buffer,"CALL %d %d\n",op.arg1, op.arg2);
break;
case (RET):
sprintf(buffer,"RET\n");
break;
case (COPR):
sprintf(buffer,"COPR %d %d\n",op.arg1, op.arg2);
break;
case (GET):
sprintf(buffer,"GET %d\n",op.arg1);
break;
case (STOP):
sprintf(buffer,"STOP\n");
break;
}
return buffer;
}

4
Tables/Instructions/tab_instruc.h
View file

@ -7,7 +7,7 @@
#include <stdio.h>
enum opcode_t {ADD,MUL,SOU,DIV,COP,AFC,AFCA,COPA,JMP,JMF,INF,SUP,EQU,PRI,READ,WR,CALL,RET,COPR};
enum opcode_t {ADD,MUL,SOU,DIV,COP,AFC,AFCA,JMP,JMF,INF,SUP,EQU,PRI,READ,WR,CALL,RET,GET,STOP};
struct operation_t {
enum opcode_t opcode;
@ -24,5 +24,7 @@ int get_current_index();
void patch(int index, int arg);
//Ecrit la table des intructions dans un fichier ASM
void create_asm();
//Crée la ligne assembleur en 1er dans le fichier pour sauter au main
void create_jump_to_main(int line);
#endif

3
Tables/Symboles/table_symboles.h
View file

@ -56,9 +56,8 @@ struct type_t {
int pointeur_level;
//Si il s'agit d'un tableau, on enregistre sa taille (nombre de cases) (même si c'est une variable on met quand même un nb_blocs à)
int nb_blocs;
//Si c'est un tableau, cette valeur est à 1
//Si c'est un tableau addressale directement, cette valeur est à 1. Si c'est un pointeur vers un tableau, valeur à 2.
int isTab;
};
//REtourne la représentation d'un type en string