Fonctions ok mais pas forcement juste faut tester

Documentation/transcription_opcodes.md

@@ -62,7 +62,15 @@ Va mettre à l'adresse @X ce qui est à l'addresse contenue à l'adresse @Y (on
 
 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).
 
-##CALL lig taille
+##CALL lig taille_arg addr_ret
 
-Appelle la fonction dont la première ligne est lig est dont la taille des arguments est en @Y (afin de pouvoir bouger ebp).
+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.
+
+##RET
+
+Bouge BP et saute à l'adresse de retour (selon les valeur qui sont dans la pile de contrôle).
+
+##COPR @X taille
+
+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).
 

Fichiers_Tests/progC

@@ -1,10 +1,9 @@
-
 int fonction(int * p){ 
 	int b =  *p + 2;
+	return 1;
 }
 
 int main(){
-	int a = 255;
-	fonction(&a);
+	int b = 1;
+	fonction(&b);
 }
-

Lex_Yacc/al.lex

@@ -4,7 +4,6 @@ int yywrap(void){return 1;}
 void
 yyerror (char const *s)
 {
-
   fprintf (stderr, "%s\n", s);
 }
 
@@ -22,6 +21,7 @@ yyerror (char const *s)
 "printf"    { return tPRINTF; } //Degeu mais à degager
 "if"        { return tIF; }
 "while"     { return tWHILE; }
+"return"    {return tRETURN; }
 "<"         { return tLT; }
 ">"         { return tGT; }
 "=="        { return tEQCOND; }

Lex_Yacc/as.y

@@ -14,6 +14,7 @@
 struct type_t type_courant;
 struct type_t return_type_fonc;
 
+
 int instructions_ligne_to_patch[10][20];
 int nbs_instructions_to_patch[10];
 
@@ -21,7 +22,7 @@ int nbs_instructions_to_patch[10];
 
 %token tMAIN
 %token tOBRACKET tCBRACKET
-%token tOBRACE tCBRACE
+%token<nombre> tOBRACE tCBRACE
 %token tOCROCH tCCROCH
 %token tINT
 %token tCONST
@@ -32,6 +33,7 @@ int nbs_instructions_to_patch[10];
 %token tPRINTF
 %token tERROR
 %token<nombre> tIF tWHILE tELSE
+%token tRETURN
 %token tLT tGT tEQCOND
 %token tAND tOR
 %token tADDR
@@ -62,9 +64,11 @@ Fonctions : ;
 
 Main : tINT {printf("Déclaration du main\n");} tMAIN tOBRACE Args tCBRACE Body { print(); create_asm();} ; 
 
-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();} ;
+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(); };
+
 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];}};
@@ -83,9 +87,18 @@ Instruction : Decl {};
 Instruction : Invocation tPV{};
 Instruction : If {};
 Instruction : While {};
+Instruction : Return {};
 
 
-Invocation : tID tOBRACE Params tCBRACE {multiple_pop($3); struct fonction_t fonc = get_fonction($1); add_operation(CALL,fonc.first_instruction_line, fonc.taille_args,0);};
+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); 
+}
+else{
+$2 = 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?)
@@ -150,7 +163,7 @@ E : E tMUL E { printf("Mul\n"); add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
 E : E tDIV E { printf("Div\n");  add_operation(DIV, $1,$1,$3); $$ = $1; pop();};
 E : E tSUB E { printf("Sub\n"); add_operation(SOU,$1,$1,$3); $$ = $1; pop();};
 E : E tADD E { printf("Add\n"); add_operation(ADD,$1,$1,$3); $$ = $1; pop();};
-E : Invocation { printf("Invoc\n"); int addr = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr,$1,0); $$ = addr;};
+E : Invocation {$$ = $1;};
 E : tOBRACE E tCBRACE { printf("Parentheses\n"); $$=$2;};
 E : tSUB E { printf("Moins\n");  int addr = push("0_TEMPORARY", 1, integer);  add_operation(AFC, addr,0,0); add_operation(SOU, $2,$2,addr);  $$ = $2; pop();};
 E : E tEQCOND E { printf("==\n"); add_operation(EQU,$1,$1,$3); $$ = $1; pop();};
@@ -163,7 +176,7 @@ 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 : tADDR EBis {add_operation(COPA,$2, $2,0); $$=$2;};
+E : tADDR EBis {$$=$2;};
 
 EBis : tID tOCROCH E tCCROCH {struct symbole_t * symbole  = get_variable($1); 
 struct type_t type = symbole->type; type.nb_blocs = 1; 

Makefile

@@ -64,6 +64,6 @@ edit_Progs:
 	pluma Fichiers_Tests/progC &
 
 edit_Fonctions :
-	pluma Tables/Fonctions/tab_fonctions.c Tables/Fonctions/tab_fonctions.h
+	pluma Tables/Fonctions/tab_fonctions.c Tables/Fonctions/tab_fonctions.h &
 
 edit: edit_Lex_Yacc edit_Symboles edit_Instructions edit_Progs edit_Fonctions

Tables/Instructions/tab_instruc.c

@@ -67,7 +67,13 @@ 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\n",op.arg1, op.arg2);
+			sprintf(buffer,"CALL %d %d %d\n",op.arg1, op.arg2, op.arg3);
+			break;
+		case (RET):
+			sprintf(buffer,"RET\n");
+			break;
+		case (COPR):
+			sprintf(buffer,"COPR %d %d\n",op.arg1, op.arg2);
 			break;
 	}
 	return buffer;

Tables/Instructions/tab_instruc.h

@@ -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};
+enum opcode_t {ADD,MUL,SOU,DIV,COP,AFC,AFCA,COPA,JMP,JMF,INF,SUP,EQU,PRI,READ,WR,CALL,RET,COPR};
 
 struct operation_t {
 	enum opcode_t opcode;