Browse Source

En cours de clean

Paul Faure 1 month ago
parent
commit
bbd3585d96

+ 1
- 0
.gitignore View File

@@ -9,3 +9,4 @@ Tables/Fonctions/test
9 9
 Lex_Yacc/as.output 
10 10
 Lex_Yacc/as.tab.* 
11 11
 Lex_Yacc/lex.yy.*
12
+Lex_Yacc/as.dot

BIN
Documentation/Projet_Syst_Info_2021.pdf View File


+ 0
- 52
Documentation/grammaire_c_minimaliste View File

@@ -1,52 +0,0 @@
1
-les fonctions (avec parametres)
2
-le if
3
-le while
4
-les declarations
5
-les affectations
6
-les operations arith.
7
-le retour de fonction
8
-l'invocation de fonctions
9
-
10
-
11
-C : Fonctions ;
12
-Fonctions : Fonction Fonctions | Fonction ;
13
-
14
-Fonction : tInt tID tPO Params tPF Body ;
15
-
16
-Params : | Param SuiteParams ;
17
-Param : tInt tID ;
18
-
19
-SuiteParams : tVirgule Param SuiteParams | ;
20
-
21
-// Ps : P Ps | ;
22
-// P : tInt tID tVirgule
23
-// Ps =>* tInt tID tVirgule tInt tID tVirgule
24
-// Ps => P Ps => P P Ps ...
25
-
26
-Body : tAO Instructions tAF ;
27
-
28
-Instructions : Instruction Instructions | ;
29
-
30
-Instruction : Aff | If | While | Return | Decl | Invocation tPV ;
31
-
32
-Aff : tID tEQ E tPV ;
33
-
34
-E : tNB | tID | E tADD E | E tMUL E | E tMINUS E | E tDIV E | Invocation | tPO E tPF | tMINUS E ;
35
-
36
-// E : tID tADD tID | ...
37
-
38
-If : tIF tPO Cond tPF Body ;
39
-
40
-Cond : Cond tAND Cond | Cond tOR Cond | E tEQ2 E | E tINF E | tNOT Cond ;
41
-
42
-Invocation : tID tPO  Args  tPF ;
43
-
44
-Args : .... cf params
45
-
46
-Return : tRET E tPV ;
47
-
48
-
49
-
50
-
51
-
52
-

+ 12
- 11
Documentation/transcription_opcodes.md View File

@@ -30,17 +30,17 @@ Copie la valeur val à l'adresse @X
30 30
 
31 31
 Copie la valeur contenue dans @C à l'adresse @X en considérant que ce qui est copié est une adresse (et donc il faut ajouter BP)
32 32
 
33
-## AFCA @X addr
33
+## AFCA @X val
34 34
 
35
-Copie la valeur addr à l'adresse @X en considérant que ce qui est copié est une adresse (et donc il faut ajouter BP)
35
+Copie la val à l'adresse @X en considérant que ce qui est copié est une adresse (et donc il faut ajouter BP)
36 36
 
37
-## JMP lig
37
+## JMP ins
38 38
 
39
-Saute vers la ligne lig dans le code sans condition
39
+Saute vers la ligne ins dans le code sans condition
40 40
 
41
-## JMF @X lig
41
+## JMF @X ins
42 42
 
43
-Saute vers la ligne lig dans le code si la valeur à l'adresse @X est 0
43
+Saute vers la ligne ins dans le code si la valeur à l'adresse @X est 0
44 44
 
45 45
 ## INF @X @A @B
46 46
 
@@ -62,14 +62,15 @@ Va mettre à l'adresse @X ce qui est à l'addresse contenue à l'adresse @Y (on
62 62
 
63 63
 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).
64 64
 
65
-##CALL lig taille_pile_fonction_appelante
65
+##CALL ins taille_pile_fonction_appelante
66
+
67
+Appelle la fonction dont la première ligne est ins et taille_pile_fonction_appelante est la taille de la zone mémoire utilisée par la fonction appelante (avant le push des arguments !)
66 68
 
67
-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 !)
68 69
 ##RET
69 70
 
70
-Bouge BP et saute à l'adresse de retour (selon les valeur qui sont dans la pile de contrôle).
71
+Restore BP et saute à l'adresse de retour (selon les valeur qui sont dans la pile de contrôle).
71 72
 
72
-##STOP
73
+##STOP val
73 74
 
74
-Arrete le processeur (à mettre à la fin de l'ASM)
75
+Arrete le processeur si val vaut 0 (à mettre à la fin de l'ASM), ou, arrete le processeur pour val tick d'horloge (si val > 0)
75 76
 

+ 52
- 39
Lex_Yacc/al.lex View File

@@ -1,4 +1,4 @@
1
-%{
1
+%{ // Ne pas toucher
2 2
 #include "as.tab.h"
3 3
 int yywrap(void){return 1;}
4 4
 void
@@ -11,44 +11,57 @@ yyerror (char const *s)
11 11
 
12 12
 %%
13 13
 
14
-"main"      { return tMAIN ;} 
15
-"{"         { return tOBRACKET;}
16
-"}"         { return tCBRACKET; }
17
-"("			{ return tOBRACE; }
18
-")"			{ return tCBRACE; }
19
-"const"     { return tCONST; }
20
-"int"       { return tINT; }
21
-"printf"    { return tPRINTF; } //Degeu mais à degager
22
-"if"        { return tIF; }
23
-"while"     { return tWHILE; }
24
-"return"    {return tRETURN; }
25
-"<"         { return tLT; }
26
-">"         { return tGT; }
27
-"=="        { return tEQCOND; }
28
-"&&"        { return tAND; }
29
-"||"        { return tOR; }
30
-"else"      { return tELSE;}
31
-"&"         { return tADDR;}
32
-"["         { return tOCROCH;}
33
-"]" 		{ return tCCROCH;}
34
-"get"       { return tGET;}
35
-"stop"      { return tSTOP;}
36
-
37
-
38
-[0-9]+	{ yylval.nombre = atoi(yytext); return tNB; }
39
-[0-9]+e[0-9]+	{ yylval.nombre = -1; return tNBEXP; } //Renvoyer le token tNB et pas tNBEXP
40
-"+"			{ return tADD; }
41
-"-"			{ return tSUB; }
42
-"*"         { return tMUL; }
43
-"/"         { return tDIV; }
44
-"="         { return tEQ; }
45
-";"			{ return tPV; }
46
-" "			{} //Ne pas les retourner à Yacc
47
-"   "       {} //Ne pas les retourner à Yacc
48
-","         { return tCOMA; }
49
-"\n"        {} //Ne pas les retourner à Yacc
50
-[a-zA-Z][a-zA-Z0-9_]* { strcpy(yylval.id, yytext); return tID; }
51
-.				{ }//return tERROR; }
14
+
15
+"main"      { return tMAIN;     }    // Token de la fonction main
16
+
17
+"{"         { return tOBRACKET; }    // Token accolade ouvrante
18
+"}"         { return tCBRACKET; }    // Token accolade fermante
19
+"("		    	{ return tOBRACE;   }    // Token parenthèse ouvrante
20
+")"	    		{ return tCBRACE;   }    // Token parenthèse fermante
21
+
22
+"const"     { return tCONST;    }    // Token constante
23
+"int"       { return tINT;      }    // Token type int
24
+
25
+"if"        { return tIF;       }    // Token if
26
+"else"      { return tELSE;     }    // Token else
27
+"while"     { return tWHILE;    }    // Token while
28
+
29
+"return"    {return tRETURN;    }    // Token return
30
+
31
+"<"         { return tLT;       }    // Token plus petit que
32
+">"         { return tGT;       }    // Token plus grand que
33
+"=="        { return tEQCOND;   }    // Token égal comparaison
34
+
35
+"&&"        { return tAND;      }    // Token ET
36
+"||"        { return tOR;       }    // Token OU
37
+
38
+"&"         { return tADDR;     }    // Token adresse
39
+"["         { return tOCROCH;   }    // Token crochet ouvrante
40
+"]" 		    { return tCCROCH;   }    // Token crochet ouvrante
41
+
42
+"get"       { return tGET;      }    // Token fonction get
43
+"printf"    { return tPRINTF;   }    // Token fonction print
44
+"stop"      { return tSTOP;     }    // Token fonction stop
45
+
46
+"+"			    { return tADD;      }    // Token addition
47
+"-"		    	{ return tSUB;      }    // Token soustraction
48
+"*"         { return tMUL;      }    // Token multiplication
49
+"/"         { return tDIV;      }    // Token division
50
+
51
+"="         { return tEQ;       }    // Token egal affectation
52
+
53
+";"			    { return tPV;       }
54
+","         { return tCOMA;     }
55
+
56
+[0-9]+	        { yylval.nombre = atoi(yytext); return tNB; }    // Token nombre au format classique
57
+[0-9]+e[0-9]+ 	{ yylval.nombre = -1; return tNB;        }       // Token nombre au format exponentiel
58
+
59
+[a-zA-Z][a-zA-Z0-9_]* { strcpy(yylval.id, yytext); return tID; } // Chaine de caractère (identifiant variable, fonction..)
60
+
61
+
62
+" "			    {} //Ne pas les retourner à Yacc (espace)
63
+"   "       {} //Ne pas les retourner à Yacc (tabulation)
64
+"\n"        {} //Ne pas les retourner à Yacc (retour chariot)
52 65
 
53 66
 %%
54 67
 

+ 0
- 1048
Lex_Yacc/as.dot
File diff suppressed because it is too large
View File


+ 377
- 99
Lex_Yacc/as.y View File

@@ -14,12 +14,13 @@
14 14
 struct type_t type_courant;
15 15
 struct type_t return_type_fonc;
16 16
 
17
-
17
+// Tableau pour le management des patchs des JMP
18 18
 int instructions_ligne_to_patch[10][20];
19 19
 int nbs_instructions_to_patch[10];
20 20
 
21 21
 %}
22 22
 
23
+// Récupération des tokens
23 24
 %token tMAIN
24 25
 %token tOBRACKET tCBRACKET
25 26
 %token<nombre> tOBRACE tCBRACE
@@ -45,134 +46,411 @@ int nbs_instructions_to_patch[10];
45 46
 %left tADD tSUB
46 47
 %left tMUL tDIV
47 48
 
48
-%type<nombre> E DebutAff SuiteAffPointeur DebutAffPointeur EBis Invocation Args ArgSuite Arg SuiteParams Params Get
49
+%type<nombre> E SuiteAffPointeur DebutAffPointeur EBis Invocation Args ArgSuite Arg SuiteParams Params Get
49 50
 
51
+%%
50 52
 
53
+/*************************************/
54
+/*************************************/
55
+/*********** Programme C *************/
56
+/*************************************/
57
+/*************************************/
51 58
 
52
-//%type<nombre> E
59
+// Un programme C correspond a des focntion et un main, une fois que le programme est compilé, on ajoute le STOP et l'on exporte l'assembleur.
60
+C : Fonctions Main                {add_operation(STOP,0,0,0); 
61
+                                   create_asm();
62
+                                  };
53 63
 
54
-/******************************************** FAIRE LA GENERATION DU CODE ASSEMBLEUR DANS UN TABLEAU AVEC UN FPRINTF *******************/
55 64
 
56
-%%
57 65
 
58 66
 
59 67
 
60
-C : Fonction Fonctions {add_operation(STOP,0,0,0); create_asm();};
61 68
 
69
+/*************************************/
70
+/*************************************/
71
+/************ Fonctions **************/
72
+/*************************************/
73
+/*************************************/
74
+
75
+// Des fonctions sont une suite de fonctions (possiblement nulle)
62 76
 Fonctions : Fonction Fonctions;
63 77
 Fonctions : ;
64 78
 
65
-Main : tINT {printf("Déclaration du main\n"); create_jump_to_main(get_current_index());} tMAIN tOBRACE Args tCBRACE Body { print(); } ; 
66 79
 
67
-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);} ;
68
-Fonction : Main {print_fonctions();};
69 80
 
70
-Get : tGET tOBRACE tCBRACE {int addr = push("0_TEMPORARY", 0, integer); add_operation(GET,addr,0,0); $$ = addr;};
71 81
 
72
-Stop : tSTOP tOBRACE tNB tCBRACE {add_operation(STOP,$3,0,0);};
73 82
 
74
-Return : tRETURN E tPV {add_operation(COP,0,$2,0); pop(); };
83
+/*************************************/
84
+/*************************************/
85
+/************** Main *****************/
86
+/*************************************/
87
+/*************************************/
88
+
89
+// Le main, renvoi un int, possède le mot clé main, des arguments et un body
90
+// Dès que le main est reconnu (token main) on met en place le JMP
91
+Main : tINT tMAIN                 {printf("Déclaration du main\n");
92
+                                   create_jump_to_main(get_current_index());
93
+                                  }
94
+       tOBRACE Args tCBRACE Body; 
95
+
96
+
97
+// Une fonction possède un Type , un identifiant
98
+Fonction : Type tID               {return_type_fonc = type_courant;                                // On récupère le ype de la fonction
99
+                                   printf("Déclaration de la fonction  %s\n", $2);                  
100
+                                  } 
101
+           tOBRACE                {inc_prof();                                                     // On incrémente la profondeur pour les arguments, ils font parti de la fonction
102
+                                  } 
103
+           Args                   {decrement_prof();                                               // Quand les arguments sont passés, on peur décrémenter la profondeur (sans effacer les variables)
104
+                                   push_fonction($2,return_type_fonc,get_current_index(), $6);     // On enregistre la fonction dans la table des fonctions
105
+                                  }
106
+           tCBRACE Body           {add_operation(RET,0,0,0);                                       // On ajoute le RET
107
+                                  };
108
+
109
+// Get, une fonction particulière -> renvoi l'adresse de la valeur getée
110
+Get : tGET tOBRACE tCBRACE        {int addr = push("0_TEMPORARY", 0, integer);                     // On déclare la var temporelle
111
+                                   add_operation(GET,addr,0,0);                                    // On ajoute le GET
112
+                                   $$ = addr;                                                      // On renvoi l'adresse
113
+                                  };
114
+
115
+// Print, une fonction particulière
116
+Print : tPRINTF tOBRACE E tCBRACE {add_operation(PRI,$3,0,0);                                      // On ajoute l'instruction PRI
117
+																	 pop();                                                          // On supprime la variable temporaire
118
+                                  };
119
+
120
+// Stop, une fonction particulière
121
+Stop : tSTOP tOBRACE tNB tCBRACE  {add_operation(STOP,$3,0,0);                                     // On ajoute juste l'instruction stop
122
+                                  };
123
+
124
+// Return, etape clé d'une fonction
125
+Return : tRETURN E tPV            {add_operation(COP,0,$2,0);                                      // On copie la valeur retournée à l'adresse 0 de la frame 
126
+                                   pop();                                                          // On pop la variable temporaire
127
+                                  };
128
+
75 129
 
76
-Args : Arg ArgSuite {$$ = $1 + $2; printf("Les arguments de la fonctions vont avoir une taille dans la pile de : %d\n",$$);};
77
-Args : {$$ = 0;};
78
-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];}};
79
-Arg : Type tID tOCROCH tCCROCH {type_courant.isTab = 2; int addr = push($2,1, type_courant); $$ = taille_types[INT];};
80
-ArgSuite : tCOMA Arg ArgSuite {$$ = $2 + $3;} ;
81
-ArgSuite : {$$ = 0;}; 
82 130
 
83 131
 
84
-Body : tOBRACKET {inc_prof();} Instructions tCBRACKET {print(); reset_prof();};
85 132
 
133
+/*************************************/
134
+/*************************************/
135
+/************ Arguments **************/
136
+/*************************************/
137
+/*************************************/
86 138
 
139
+// Les arguments : Args, Arg, ArgSuite renvoient la taille dans la pile des arguments déjà reconnus
140
+// Des argmuments correspondent à : un argument, puis la suite d'arguments
141
+Args : Arg ArgSuite               {$$ = $1 + $2;                                                   // La taille des arguments est la taille du premier argument plus celle des suivants
142
+                                  };
143
+Args :                            {$$ = 0;                                                         // Il peut ne pas y avoir d'arguments, alors la taille est 0
144
+                                  };
145
+// Un argument possède un type et un identifiant (nom)
146
+Arg : Type tID                    { int addr = push($2,1, type_courant);                           // On stocke l'argument dans la pile des symboles      
147
+                                    if (type_courant.pointeur_level > 0) {
148
+                                      $$ = taille_types[ADDR];                                     
149
+                                    } else {
150
+                                      $$ = taille_types[type_courant.base];                        
151
+                                    }
152
+                                  };
153
+// Un argument peut aussi être un tableau (argument classique et crochets) il est considéré comme un pointeur
154
+Arg : Type tID tOCROCH tCCROCH    {type_courant.pointeur_level++;                                  // Considéré comme un simple pointeur
155
+                                   int addr = push($2,1, type_courant);
156
+                                   $$ = taille_types[ADDR];
157
+                                  };
158
+// La suite d'un argument, une virgule, un argument, et d'autres arguments
159
+ArgSuite : tCOMA Arg ArgSuite     {$$ = $2 + $3;                                                
160
+                                  };
161
+// Cela peut être aucun arguments
162
+ArgSuite :                        {$$ = 0;
163
+                                  }; 
164
+
165
+
166
+
167
+
168
+
169
+/*************************************/
170
+/*************************************/
171
+/*************** Body ****************/
172
+/*************************************/
173
+/*************************************/
174
+
175
+// Un body n'est rien d'autre qu'une suite d'instructions entre deux accolades
176
+Body : tOBRACKET                  {inc_prof();                                                     // Lors de l'ouverture de l'accolade la profondeur augmente
177
+                                  }
178
+       Instructions tCBRACKET     {reset_prof();                                                   // A la sortie d'un body, on détruit toutes les variables locales de ce body
179
+                                  };
180
+
181
+
182
+
183
+
184
+
185
+
186
+/*************************************/
187
+/*************************************/
188
+/*********** Instructions ************/
189
+/*************************************/
190
+/*************************************/
191
+
192
+// Des instructions sont une instruction suivie d'autres instructions, ou, rien
87 193
 Instructions : Instruction Instructions ;
88 194
 Instructions : ;
89
-Instruction : Aff {};
90
-Instruction : Decl {};
91
-Instruction : Invocation tPV{pop();};
92
-Instruction : If {};
93
-Instruction : While {};
94
-Instruction : Return {};
95
-Instruction : Stop tPV {};
96
-
97
-
98
-Invocation : tID tOBRACE {struct fonction_t fonc = get_fonction($1);}
99
-Params tCBRACE {struct fonction_t fonc = get_fonction($1); multiple_pop($4);
100
-add_operation(CALL,fonc.first_instruction_line, get_last_addr(),0); if (fonc.return_type.pointeur_level > 0 || fonc.return_type.isTab){
101
- $$ = push("0_TEMPORARY_RETURN", 0, integer); 
102
-}
103
-else{
104
-$$ = push("0_TEMPORARY_RETURN", 0, fonc.return_type); 
105
-}};
106 195
 
107
-Invocation : tPRINTF tOBRACE E tCBRACE{add_operation(PRI,$3,0,0);};
196
+// Un instruction peut être : une affectation, une déclaration, une invocation, un if, un while, un return, une fonction particulière
197
+Instruction : Aff;
198
+Instruction : Decl;
199
+Instruction : Invocation tPV      {pop();};
200
+Instruction : If;
201
+Instruction : While;
202
+Instruction : Return;
203
+Instruction : Stop tPV;
204
+Instruction : Print tPV;
108 205
 
109
-Params : {$$ = 0; printf("Sans Params\n"); } ;
110
-Params : Param SuiteParams {$$ = $2 + 1;};
111
-Param : E {printf("Parametre : %d\n", $1);};
112
-SuiteParams : tCOMA Param SuiteParams {$$ = $3 + 1;};
113
-SuiteParams : {$$ = 0;};
114 206
 
115 207
 
116 208
 
117
-//On considère que la première ligne du code en ASM est la ligne 0
118
-If : tIF tOBRACE E tCBRACE {
119
-add_operation(JMF,$3,0,0); $1 = get_current_index() - 1;} 
120
-Body  {int current = get_current_index();
121
-		patch($1,current + 1);
122
-		add_operation(JMP,0,0,0);
123
-		instructions_ligne_to_patch[get_prof()][nbs_instructions_to_patch[get_prof()]] = current;
124
-		nbs_instructions_to_patch[get_prof()]++;
125
-		pop();}
126
-Else {printf("If reconnu\n");};
127 209
 
210
+/*************************************/
211
+/*************************************/
212
+/************ Invocation *************/
213
+/*************************************/
214
+/*************************************/
215
+
216
+Invocation : tID tOBRACE Params tCBRACE  {struct fonction_t fonc = get_fonction($1);                              // On récupère la fonction
217
+                                          multiple_pop($3);                                                       // On pop les paramètres de la table des symboles
218
+                                          add_operation(CALL,fonc.first_instruction_line, get_last_addr(),0);     // On écrit le CALL
219
+																					// On renvoi l'adresse de la valeur retour de la fonction
220
+                                          if (fonc.return_type.pointeur_level > 0 || fonc.return_type.isTab) {
221
+                                            $$ = push("0_TEMPORARY_RETURN", 0, pointer); 
222
+                                          } else {
223
+                                            $$ = push("0_TEMPORARY_RETURN", 0, fonc.return_type); 
224
+                                          }
225
+                                         };
226
+
227
+
228
+
229
+
230
+
231
+/*************************************/
232
+/*************************************/
233
+/************ Paramètres *************/
234
+/*************************************/
235
+/*************************************/
236
+
237
+// Ici aussi, 0, 1 ou plusieurs paramètres avec une suite paramètre pour prendre en compte la virgule, on renvoi le nombre de paramètres
238
+Params :                                 {$$ = 0;
239
+                                         };
240
+Params : Param SuiteParams               {$$ = $2 + 1;
241
+                                         };
242
+Param : E                         
243
+SuiteParams : tCOMA Param SuiteParams    {$$ = $3 + 1;};
244
+SuiteParams :                            {$$ = 0;};
245
+
246
+
247
+
248
+
249
+
250
+
251
+
252
+/*************************************/
253
+/*************************************/
254
+/******** Sauts conditionnels ********/
255
+/*************************************/
256
+/*************************************/
257
+
258
+// Un if : le token, une expression entre parenthèse suivie d'un body et d'un else
259
+If : tIF tOBRACE E tCBRACE               {add_operation(JMF,$3,0,0);                                                                     // On ajoute le JMF sans préciser la ligne du saut
260
+                                          $1 = get_current_index() - 1;                                                                  // On stocke le numéro d'instruction à patcher
261
+                                         } 
262
+     Body                                {int current = get_current_index();                                                             // On récupère le numéro d'instrcution
263
+		                                      patch($1,current + 1);                                                                         // On patch le Jump en cas d'instruction fausse 
264
+																					add_operation(JMP,0,0,0);                                                                      // JMP pour skip le else si on devait faire le body 
265
+																					instructions_ligne_to_patch[get_prof()][nbs_instructions_to_patch[get_prof()]] = current;      // On spécifie que le JMP est a patcher
266
+																					nbs_instructions_to_patch[get_prof()]++;
267
+																					pop();                                                                                         // On pop la condition du if
268
+																				 }
269
+		 Else																 
270
+
271
+// Elsif 
272
+Else : tELSE If;
273
+
274
+// Else 
275
+Else : tELSE Body                        {int current = get_current_index(); 
276
+                                          for (int i = 0; i< nbs_instructions_to_patch[get_prof()]; i++) {
277
+	                                          patch(instructions_ligne_to_patch[get_prof()][i],current);                                   // On patch après le else
278
+                                          }
279
+                                          nbs_instructions_to_patch[get_prof()] = 0;
280
+                                         };
281
+
282
+// If sans else
283
+Else :                                   {int current = get_current_index(); 
284
+																					for (int i = 0; i< nbs_instructions_to_patch[get_prof()]; i++){
285
+																						patch(instructions_ligne_to_patch[get_prof()][i],current);                                   // On patch après le else
286
+																					}
287
+																					nbs_instructions_to_patch[get_prof()] = 0;
288
+																				 };
289
+
290
+
291
+
292
+
293
+
294
+
295
+/*************************************/
296
+/*************************************/
297
+/************** Boucles **************/
298
+/*************************************/
299
+/*************************************/
300
+
301
+While : tWHILE tOBRACE E tCBRACE         {add_operation(JMF,$3,0,0);                               // Ecriture du JMF
302
+                                          $1 = get_current_index() - 1;                            // Enregistrement de la ligne a patch
303
+                                          pop();                                                   // Pop de la condition
304
+                                         }
305
+        Body                             {int current = get_current_index();                       // Patch du JMF apres le body
306
+                                          patch($1,current + 1);
307
+                                          add_operation(JMP,$1,0,0);                               // JMP au debut de la boucle
308
+                                         };
309
+
310
+
311
+
312
+
313
+
314
+
315
+/*************************************/
316
+/*************************************/
317
+/************ Affectations ***********/           // A RETRAVAILLER 
318
+/*************************************/
319
+/*************************************/
320
+
321
+// Affectation simple
322
+Aff : tID tEQ E tPV                      {struct symbole_t * symbole  = get_variable($1);          // On récupère le symbole
323
+                                          symbole->initialized = 1;                                // Le symbole devient initialisé
324
+																					add_operation(COP, symbole->adresse, $3,0);              // On affecte la valeur
325
+                                          pop();                                                   // On pop l'expression
326
+                                         }; 
327
+
328
+// Debut d'une affectation avec déreférencement de pointeur //////// A RETRAVAILLERRRRRR
329
+DebutAffPointeur : tMUL SuiteAffPointeur {add_operation(READ, $2, $2, 0); 
330
+                                          $$=$2;
331
+                                         };
332
+
333
+DebutAffPointeur : SuiteAffPointeur      {$$=$1;
334
+                                         };
335
+
336
+SuiteAffPointeur : tMUL tID              {struct symbole_t * symbole = get_variable($2); 
337
+                                          int addr = push("0_TEMPORARY", 1, symbole->type); 
338
+                                          add_operation(COP, addr,symbole->adresse,0); 
339
+                                          $$=addr;
340
+                                         };
341
+
342
+SuiteAffPointeur : tID tOCROCH E tCCROCH {struct symbole_t * symbole = get_variable($1); 
343
+                                          int addr = push("0_TEMPORARY", 1, symbole->type); 
344
+                                          if (symbole->type.isTab == 2) {
345
+                                            add_operation(COP, addr,symbole->adresse,0);
346
+                                          } else { 
347
+                                            add_operation(AFCA, addr,symbole->adresse,0);
348
+                                          } 
349
+                                          int addr2 = push("0_TEMPORARY", 1, integer); 
350
+                                          add_operation(AFC, addr2, taille_types[symbole->type.base],0); 
351
+                                          add_operation(MUL,$3,addr2,$3); 
352
+                                          add_operation(ADD,$3,addr,$3); 
353
+                                          $$=$3; 
354
+                                          pop(); 
355
+                                          pop();
356
+                                         };
357
+
358
+
359
+
360
+// Affectation sur un pointeur
361
+Aff : DebutAffPointeur tEQ E tPV         {add_operation(WR,$1,$3,0); 
362
+                                          pop(); 
363
+                                          pop();
364
+                                         };
365
+
366
+
367
+
368
+
369
+
370
+
371
+
372
+
373
+
374
+
375
+
376
+
377
+/*************************************/
378
+/*************************************/
379
+/***** Expressions Arithmetiques *****/          
380
+/*************************************/
381
+/*************************************/
382
+
383
+// Pour une expression arithmétique, nous renvoyons toujours l'adresse du resultat
384
+
385
+// Un simple nombre 
386
+E : tNB                                  {int addr = push("0_TEMPORARY", 1, integer);              // On reserve la place de la variable temporaire
387
+                                          add_operation(AFC, addr,$1,0);                           // On Affecte la valeur a cette adresse
388
+                                          $$ = addr;                                               // On renvoi l'adresse
389
+                                         };
390
+
391
+// Un nombre sous forme XeY, même traitement qu'un nombre classique 
392
+E : tNBEXP                               {int addr = push("0_TEMPORARY", 1, integer); 
393
+                                          add_operation(AFC, addr,$1,0); 
394
+                                          $$ = addr;
395
+                                         };
396
+
397
+// Une Multiplication
398
+E : E tMUL E                             {add_operation(MUL,$1,$1,$3);                             // On Multiplie les valeurs et stockons le résultat dans la première variable temporaire
399
+                                          $$ = $1;                                                 // On renvoi l'adresse du resultat
400
+                                          pop();                                                   // On libère la seconde variable temporaire
401
+                                         };
402
+
403
+// Une Division (idem multiplication)
404
+E : E tDIV E                             {add_operation(DIV, $1,$1,$3); 
405
+                                          $$ = $1; 
406
+                                          pop();
407
+                                         };
408
+
409
+// Une Soustraction (idem multiplication)
410
+E : E tSUB E                             {add_operation(SOU,$1,$1,$3); 
411
+                                          $$ = $1; 
412
+                                          pop();
413
+                                         };
414
+
415
+// Une Addition (idem multiplication)
416
+E : E tADD E                             {add_operation(ADD,$1,$1,$3); 
417
+                                          $$ = $1; 
418
+                                          pop();
419
+                                         };
420
+
421
+// Une invocation
422
+E : Invocation                           {$$ = $1;                                                 // Une invocation renvoi déjà l'adresse, cette règle n'est qu'un cast d'Invocation en E
423
+                                         };
424
+
425
+// Consomation de parenthèses
426
+E : tOBRACE E tCBRACE                    {$$ = $2;                                                 // Cela permet de garantir la prioricité des expressions entre parenthèse
427
+                                         };
428
+
429
+// Négatif --> -E <=> 0-E
430
+E : tSUB E                               {int addr = push("0_TEMPORARY", 1, integer);              // On réserve la variable temporaire pour le 0
431
+                                          add_operation(AFC, addr,0,0);                            // On affecte le 0
432
+                                          add_operation(SOU, $2, addr, $2);                        // On applique le 0-E
433
+                                          $$ = $2;                                                 // On renvoi l'adresse
434
+                                          pop();                                                   // On libère la mémoire temporaire utilisée par 0
435
+                                         };
436
+
437
+E : E tEQCOND E                          {add_operation(EQU,$1,$1,$3); 
438
+                                          $$ = $1; 
439
+                                          pop();
440
+                                         };
441
+
442
+E : E tGT E                              {add_operation(SUP,$1,$1,$3); 
443
+                                          $$ = $1; 
444
+                                          pop();
445
+                                         };
446
+
447
+E : E tLT E                              {add_operation(INF,$1,$1,$3); 
448
+                                          $$ = $1; 
449
+                                          pop();
450
+                                         };
451
+
452
+E : tNOT E                               { printf("!\n"); };
128 453
 
129
-Else : tELSE If { printf("Else if reconnu\n"); };
130
-Else : tELSE Body { printf("Else reconnu\n"); int current = get_current_index(); 
131
-for (int i = 0; i< nbs_instructions_to_patch[get_prof()]; i++){
132
-	patch(instructions_ligne_to_patch[get_prof()][i],current);
133
-}
134
-nbs_instructions_to_patch[get_prof()] = 0;
135
-};
136
-Else : {int current = get_current_index(); 
137
-for (int i = 0; i< nbs_instructions_to_patch[get_prof()]; i++){
138
-	patch(instructions_ligne_to_patch[get_prof()][i],current);
139
-}
140
-nbs_instructions_to_patch[get_prof()] = 0;};
141
-While : tWHILE tOBRACE E tCBRACE {
142
-add_operation(JMF,$3,0,0); 
143
-$1 = get_current_index() - 1;
144
-pop();}
145
-
146
-Body { printf("While reconnu\n");
147
-int current = get_current_index();
148
-patch($1,current + 1);
149
-add_operation(JMP,$1,0,0);};
150
-
151
-
152
-Aff : DebutAff tEQ E tPV {add_operation(COP, $1, $3,0); pop();} ; 
153
-Aff : DebutAffPointeur tEQ E tPV {add_operation(WR,$1,$3,0); pop(); pop();};
154
-
155
-DebutAff : tID {struct symbole_t * symbole  = get_variable($1); symbole->initialized = 1; $$=symbole->adresse; printf("%s prend une valeur\n", $1);};
156
-
157
-DebutAffPointeur : tMUL SuiteAffPointeur {add_operation(READ, $2, $2, 0); $$=$2;};
158
-DebutAffPointeur : SuiteAffPointeur {$$=$1;};
159
-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;};
160
-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();};
161
-
162
-
163
-E : tNB { int addr = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr,$1,0); $$ = addr;};
164
-E : tNBEXP { printf("Nombre exp\n"); int addr = push("0_TEMPORARY", 1, integer); add_operation(AFC, addr,$1,0); $$ = addr;};
165
-E : E tMUL E { printf("Mul\n"); add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
166
-E : E tDIV E { printf("Div\n");  add_operation(DIV, $1,$1,$3); $$ = $1; pop();};
167
-E : E tSUB E { printf("Sub\n"); add_operation(SOU,$1,$1,$3); $$ = $1; pop();};
168
-E : E tADD E { printf("Add\n"); add_operation(ADD,$1,$1,$3); $$ = $1; pop();};
169
-E : Invocation {$$ = $1;};
170
-E : tOBRACE E tCBRACE { printf("Parentheses\n"); $$=$2;};
171
-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();};
172
-E : E tEQCOND E { printf("==\n"); add_operation(EQU,$1,$1,$3); $$ = $1; pop();};
173
-E : E tGT E { printf(">\n"); add_operation(SUP,$1,$1,$3); $$ = $1; pop();};
174
-E : E tLT E { printf("<\n"); add_operation(INF,$1,$1,$3); $$ = $1; pop();};
175
-E : tNOT E { printf("!\n"); };
176 454
 E : E tAND E {add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
177 455
 E : E tOR E {add_operation(ADD,$1,$1,$3); $$ = $1; pop();} ;
178 456
 E : tMUL E { add_operation(READ, $2, $2, 0); $$=$2;};

+ 25
- 0
Makefile View File

@@ -1,6 +1,11 @@
1 1
 default : 
2 2
 	@echo "Spécifiez une cible"
3 3
 
4
+
5
+
6
+###########################
7
+###      NETTOYAGE      ###
8
+###########################
4 9
 clean : clean_Symboles clean_Instructions clean_Lex_Yacc clean_Fonctions
5 10
 	@rm -f rondoudou_gcc
6 11
 	@rm -f output.txt
@@ -20,6 +25,11 @@ clean_Fonctions:
20 25
 clean_Lex_Yacc:
21 26
 	@rm -f Lex_Yacc/as.output Lex_Yacc/as.tab.* Lex_Yacc/lex.yy.*
22 27
 
28
+
29
+
30
+###########################
31
+###     COMPILATION     ###
32
+###########################
23 33
 build : clean build_Symboles build_Instructions build_Lex_Yacc build_Fonctions
24 34
 	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
25 35
 
@@ -38,6 +48,11 @@ build_Lex_Yacc: clean_Lex_Yacc
38 48
 	gcc -c Lex_Yacc/as.tab.c -o Lex_Yacc/as.tab.o
39 49
 	gcc -c Lex_Yacc/lex.yy.c -o Lex_Yacc/lex.yy.o
40 50
 
51
+
52
+
53
+###########################
54
+###        TESTS        ###
55
+###########################
41 56
 test_Symboles: build_Symboles
42 57
 	gcc -c Tables/Symboles/test.c -o Tables/Symboles/test.o
43 58
 	gcc Tables/Symboles/test.o Tables/Symboles/table_symboles.o -o Tables/Symboles/test
@@ -48,9 +63,19 @@ test_Instructions: build_Instructions
48 63
 	gcc Tables/Instructions/test.o Tables/Instructions/tab_instruc.o -o Tables/Instructions/test
49 64
 	Tables/Instructions/test
50 65
 
66
+test_Fonctions: build_Fonctions
67
+	gcc -c Tables/Fonctions/test.c -o Tables/Fonctions/test.o
68
+	gcc Tables/Fonctions/test.o Tables/Fonctions/tab_fonctions.o -o Tables/Fonctions/test
69
+	Tables/Fonctions/test
70
+
51 71
 test: build
52 72
 	cat Fichiers_Tests/progC | ./rondoudou_gcc 
53 73
 
74
+
75
+
76
+###########################
77
+###       EDITION       ###
78
+###########################
54 79
 edit_Lex_Yacc: 
55 80
 	pluma Lex_Yacc/al.lex Lex_Yacc/as.y &
56 81
 

+ 7
- 0
Tables/Fonctions/tab_fonctions.c View File

@@ -1,9 +1,14 @@
1 1
 #include "tab_fonctions.h"
2 2
 
3
+#define MAX_TAILLE_FONC 50
4
+
5
+// Table des fonctions
3 6
 struct fonction_t tab_fonctions[MAX_TAILLE_FONC];
7
+// Index dispo dans la table
4 8
 int indexTab = 0;
5 9
 
6 10
 
11
+// Renvoi une fonction a partir de son nom
7 12
 struct fonction_t get_fonction(char * name){
8 13
 	int not_found = 1;
9 14
 	int i = 0;
@@ -18,6 +23,7 @@ struct fonction_t get_fonction(char * name){
18 23
 	return res;
19 24
 }
20 25
 
26
+// Insere une fonction
21 27
 void push_fonction(char * name, struct type_t type, int line, int taille_args){
22 28
 	 if (indexTab < MAX_TAILLE_FONC){
23 29
 		struct fonction_t fonc;
@@ -31,6 +37,7 @@ void push_fonction(char * name, struct type_t type, int line, int taille_args){
31 37
 	}
32 38
 }
33 39
 
40
+// Fonction d'affichage des fonctions connues
34 41
 void print_fonctions(){
35 42
 	printf("Affichage table des fonctions\n");
36 43
 	printf("\t Size : %d\n",indexTab);

+ 3
- 4
Tables/Fonctions/tab_fonctions.h View File

@@ -7,8 +7,6 @@
7 7
 #include <stdio.h>
8 8
 #include <stdlib.h>
9 9
 
10
-#define MAX_TAILLE_FONC 50
11
-
12 10
 //Struct dans le tableau qui permet d'identifier une fonction
13 11
 struct fonction_t {
14 12
 	char * name;
@@ -17,10 +15,11 @@ struct fonction_t {
17 15
 	int taille_args;
18 16
 };
19 17
 
18
+// Renvoi les informations sur une fonction à partir de son nom
20 19
 struct fonction_t get_fonction(char * name);
21
-
20
+// Insere une fonction dans la table (déclare une fonction)
22 21
 void push_fonction(char * name, struct type_t type, int line, int taille_args);
23
-
22
+// Fonction d'affichage des fonctions connues
24 23
 void print_fonctions();
25 24
 
26 25
 #endif

+ 24
- 8
Tables/Instructions/tab_instruc.c View File

@@ -1,7 +1,20 @@
1 1
 #include "tab_instruc.h"
2
+#define MAXTAILLE 1024
3
+
4
+// Structure représentant une opération 
5
+struct operation_t {
6
+	enum opcode_t opcode;
7
+	int arg1;
8
+	int arg2;
9
+	int arg3;
10
+};
11
+
12
+// Index dans le tableau des instruction
2 13
 int current_index = 1;
14
+// Tableau des instructions (programme en assembleur)
3 15
 struct operation_t tab_op[MAXTAILLE];
4 16
 
17
+// Insertion d'une opération dans le tableau
5 18
 void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
6 19
 	if (current_index == MAXTAILLE){
7 20
 		printf("Taillemax tableau operations atteinte\n");
@@ -13,12 +26,13 @@ void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
13 26
 	}
14 27
 }
15 28
 
29
+// Les fonctions étant compilées en premiers, la première instruction du programme doit être un JMP vers le main
16 30
 void create_jump_to_main(int line){
17 31
     struct operation_t new_op = {JMP,line, 0, 0};
18 32
     tab_op[0] = new_op;
19 33
 }
20 34
 
21
-
35
+// Fonction traduisant une opération en assembleur
22 36
 char * get_asm_line_from_op(struct operation_t op){
23 37
 	char * buffer = malloc(sizeof(char)*200);
24 38
 	switch (op.opcode){
@@ -73,16 +87,17 @@ char * get_asm_line_from_op(struct operation_t op){
73 87
 		case (RET):
74 88
 			sprintf(buffer,"RET\n");
75 89
 			break;
76
-        case (GET):
77
-            sprintf(buffer,"GET %d\n",op.arg1);
78
-            break;
79
-        case (STOP):
80
-            sprintf(buffer,"STOP %d\n", op.arg1);
81
-            break;
90
+    case (GET):
91
+      sprintf(buffer,"GET %d\n",op.arg1);
92
+      break;
93
+    case (STOP):
94
+      sprintf(buffer,"STOP %d\n", op.arg1);
95
+      break;
82 96
 	}
83 97
 	return buffer;
84 98
 }
85 99
 
100
+// Genere le code asm dans un fichier
86 101
 void create_asm(){
87 102
 	FILE * output = fopen("output.txt","w");
88 103
 	for (int i = 0; i < current_index; i++){
@@ -92,10 +107,11 @@ void create_asm(){
92 107
 	}
93 108
 }
94 109
 
110
+// Renvoi l'index courrant dans le tableau
95 111
 int get_current_index(){return current_index;}
96 112
 
97 113
 
98
-
114
+// Permet de modifier un instruction à postériorie (pour les JMP)
99 115
 void patch(int index, int arg){
100 116
 	if (tab_op[index].opcode == JMP){
101 117
 		tab_op[index].arg1 = arg;

+ 2
- 8
Tables/Instructions/tab_instruc.h View File

@@ -1,21 +1,15 @@
1 1
 #ifndef TAB_INST_H
2 2
 #define TAB_INST_H
3 3
 
4
-#define MAXTAILLE 1024
4
+
5 5
 #include <stdlib.h>
6 6
 #include <string.h>
7 7
 #include <stdio.h>
8 8
 
9 9
 
10
+// Liste de codes des instruction 
10 11
 enum opcode_t {ADD,MUL,SOU,DIV,COP,AFC,AFCA,JMP,JMF,INF,SUP,EQU,PRI,READ,WR,CALL,RET,GET,STOP};
11 12
 
12
-struct operation_t {
13
-	enum opcode_t opcode;
14
-	int arg1;
15
-	int arg2;
16
-	int arg3;
17
-};
18
-
19 13
 //Ajoute une opération dans la table (à la fin)
20 14
 void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3);
21 15
 //Renvoi le prochain slot disponible

+ 28
- 39
Tables/Symboles/table_symboles.c View File

@@ -1,55 +1,35 @@
1
-/* TABLE DES SYMBOLE DU COMPILATEUR (PILE)
2
-
3
------------------------------------------------------
4
-|  symbole   |  adresse   |    type    | initialisé |
5
------------------------------------------------------
6
-|            |            |            |            |
7
-|            |            |            |            |
8
-|            |            |            |            |
9
-|      i     | 0x777756b8 |     int    |    false   |
10
-|    size    | 0x777756b8 |     int    |    true    |
11
------------------------------------------------------
12
-
13
-Types pour l'implémentation : 
14
-	- enum type_t : [int]
15
-	- struct symbole : {
16
-			char nom[30];
17
-			uintptr_t adresse;
18
-			enum type_t type;
19
-			char initialized;
20
-		}
21
-
22
-Opérations possible : 
23
-	- init -> pile * -> void
24
-	- push -> symbole -> pile * -> void
25
-	- pop -> pile * -> symbole
26
-	- exist -> pile * -> symbole -> char
27
-	- initialized -> pile * -> symbole -> char					*/
28
-
29 1
 #include "table_symboles.h"
30 2
 #include <stdlib.h>
31 3
 #include <string.h>
32 4
 #include <stdio.h>
33
-#define MAXADDR 1024*5
34 5
 
6
+// Première adresse disponible
35 7
 int last_addr = 0;
36
-int temp_addr = MAXADDR;
37
-int taille_types[] = {-1, 1};
8
+// Tableau indexé sur les types donnant leur tailles 
9
+int taille_types[] = {-1, 1, 1};
10
+// Pronfondeur dans le code (pour la visibilité des variables)
38 11
 int profondeur = 0;
39
-int last_temp_var_size;
40
-const struct type_t integer = {INT, 0, 1};
12
+// Constante pour les entiers
13
+const struct type_t integer = {INT, 0, 1, 0};
14
+// Constante pour les pointeurs
15
+const struct type_t pointer = {ADDR, 0, 1, 0};
41 16
 
17
+// Structure chainant les symboles
42 18
 struct element_t {
43 19
 	struct symbole_t symbole;
44 20
 	struct element_t * suivant;
45 21
 };
46 22
 
23
+// Structure de la pile des symboles
47 24
 struct pile_t {
48 25
 	int taille;
49 26
 	struct element_t * first;
50 27
 };
28
+
29
+// Pile des symboles
51 30
 struct pile_t * pile;
52 31
 
32
+// Fonction d'affichage pour un type
53 33
 char * type_to_string(struct type_t type) {
54 34
     char * star = "*";
55 35
     char * resultat = malloc(sizeof(char)*20);
@@ -64,6 +44,7 @@ char * type_to_string(struct type_t type) {
64 44
     return resultat;
65 45
 }
66 46
 
47
+// Fonction d'affichage pour un symbole
67 48
 void print_symbole(struct symbole_t symbole) {
68 49
     char * type = type_to_string(symbole.type);
69 50
     if (symbole.initialized) {
@@ -74,14 +55,14 @@ void print_symbole(struct symbole_t symbole) {
74 55
     free(type);
75 56
 }
76 57
 
58
+// Initialisation de la pile
77 59
 void init (void) {
78
-    pile = malloc(sizeof(struct pile_t));
60
+  pile = malloc(sizeof(struct pile_t));
79 61
 	pile->first = NULL;
80 62
 	pile->taille = 0;
81 63
 }
82 64
 
83
-
84
-
65
+// Fonction d'ajout d'un symbole à la pile
85 66
 int push(char * nom, int isInit, struct type_t type) {
86 67
 	struct element_t * aux = malloc(sizeof(struct element_t));
87 68
 	struct symbole_t symbole = {"", last_addr, type, isInit,profondeur}; 
@@ -95,6 +76,7 @@ int push(char * nom, int isInit, struct type_t type) {
95 76
 	return addr_var;
96 77
 }
97 78
 
79
+// Fonction renvoyant et supprimant le premier symbole
98 80
 struct symbole_t pop() {
99 81
 	struct symbole_t retour = {"", 0, UNKNOWN, 0, 0};
100 82
 	struct element_t * aux;
@@ -109,14 +91,14 @@ struct symbole_t pop() {
109 91
 	return retour;
110 92
 }
111 93
 
112
-
113
-
94
+// Fonction supprimant les n premiers symboles
114 95
 void multiple_pop(int n){
115 96
 	for (int i =0; i<n; i++){
116 97
 		pop();
117 98
 	}
118 99
 }
119 100
 
101
+// Fonction d'accès a un symbole par son nom
120 102
 struct symbole_t * get_variable(char * nom){
121 103
 	struct symbole_t * retour = NULL;
122 104
 	struct element_t * aux = pile->first;
@@ -132,6 +114,7 @@ struct symbole_t * get_variable(char * nom){
132 114
 	return retour;
133 115
 }
134 116
 
117
+// Fonction d'affichage de la pile
135 118
 void print() {
136 119
 	printf("Affichage de la Table des Symboles\n\tSize : %d\n\tContenu : \n", pile->taille);
137 120
 	struct element_t * aux = pile->first;
@@ -146,11 +129,17 @@ void print() {
146 129
 	}
147 130
 }
148 131
 
149
-
132
+// Getteur sur la première adresse dispo (utile pour le CALL)
150 133
 int get_last_addr(){
151 134
 	return last_addr;
152 135
 }
153 136
 
137
+
138
+
139
+
140
+/********************************/
141
+/*** GESTION DE LA PROFONDEUR ***/
142
+/********************************/
154 143
 void inc_prof() {
155 144
     profondeur++;
156 145
 }

+ 10
- 43
Tables/Symboles/table_symboles.h View File

@@ -1,43 +1,9 @@
1
-/* TABLE DES SYMBOLE DU COMPILATEUR (PILE)
2
-
3
------------------------------------------------------
4
-|  symbole   |  adresse   |    type    | initialisé |
5
------------------------------------------------------
6
-|            |            |            |            |
7
-|            |            |            |            |
8
-|            |            |            |            |
9
-|      i     | 0x777756b8 |     int    |    false   |
10
-|    size    | 0x777756b8 |     int    |    true    |
11
------------------------------------------------------
12
-
13
-Types pour l'implémentation : 
14
-	- enum type_t : [int]
15
-	- struct symbole : {
16
-			char nom[30];
17
-			uintptr_t adresse;
18
-			enum type_t type;
19
-			char initialized;
20
-		}
21
-
22
-Opérations possible : 
23
-	- init -> pile * -> void
24
-	- push -> symbole -> pile * -> void
25
-	- pop -> pile * -> symbole
26
-	- status -> nom -> pile -> char					*/
27
-
28 1
 #ifndef TAB_SYMB_H
29 2
 #define TAB_SYMB_H
30 3
 
31 4
 #include <stdint.h>
32 5
 
33 6
 
34
-
35
-
36
-
37
-
38
-
39
-
40
-
41 7
 /**************************************/
42 8
 /**************************************/
43 9
 /**** Gestion des types possibles  ****/
@@ -45,7 +11,7 @@ Opérations possible :
45 11
 /**************************************/
46 12
 
47 13
 //Enumération des types de base reconnus 
48
-enum base_type_t {UNKNOWN, INT};
14
+enum base_type_t {UNKNOWN, INT, ADDR};
49 15
 //Table enregistrant la taille de ces types de bases (indexée sur les types)
50 16
 extern int taille_types[];
51 17
 //Structure gérant les types 
@@ -54,17 +20,18 @@ struct type_t {
54 20
     enum base_type_t base;
55 21
     //Si la variable est un pointeur, on enregitre son niveau (nombre de *)
56 22
     int pointeur_level;
57
-    //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 à) 
58
-	int nb_blocs;
59
-	//Si c'est un tableau addressale directement, cette valeur est à 1. Si c'est un pointeur vers un tableau, valeur à 2.
60
-	int isTab;
23
+    //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 à 1) 
24
+	  int nb_blocs;
25
+	  //Si c'est un tableau cette valeur est à 1, 0 sinon.
26
+	  int isTab;
61 27
 };
62 28
 
63
-//REtourne la représentation d'un type en string
29
+//Retourne la représentation d'un type en string
64 30
 char * type_to_string(struct type_t type);
65 31
 //Constante pour les entiers
66 32
 extern const struct type_t integer;
67
-
33
+//Constante pour les pointeurs
34
+extern const struct type_t pointer;
68 35
 
69 36
 
70 37
 /**************************************/
@@ -100,7 +67,7 @@ struct symbole_t {
100 67
     //Est il initialisé
101 68
 	int initialized;
102 69
     //Sa profondeur de création
103
-    int profondeur;
70
+  int profondeur;
104 71
 };
105 72
 
106 73
 //Fonction d'affichage d'un symbole
@@ -124,7 +91,7 @@ void init(void);
124 91
 int push(char * nom, int isInit, struct type_t type);
125 92
 //Destruction et récupération du premier élément de la table
126 93
 struct symbole_t pop();
127
-//Destruction des n premiers elee=ments de la table des symboles
94
+//Destruction des n premiers elements de la table des symboles
128 95
 void multiple_pop(int n);
129 96
 //Retourne la dernière adresse disponible
130 97
 int get_last_addr();

Loading…
Cancel
Save