Browse Source

En cours de clean

Paul Faure 2 years ago
parent
commit
bbd3585d96

+ 1
- 0
.gitignore View File

9
 Lex_Yacc/as.output 
9
 Lex_Yacc/as.output 
10
 Lex_Yacc/as.tab.* 
10
 Lex_Yacc/as.tab.* 
11
 Lex_Yacc/lex.yy.*
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
-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
 
30
 
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)
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
 ## INF @X @A @B
45
 ## INF @X @A @B
46
 
46
 
62
 
62
 
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).
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
 ##RET
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
-%{
1
+%{ // Ne pas toucher
2
 #include "as.tab.h"
2
 #include "as.tab.h"
3
 int yywrap(void){return 1;}
3
 int yywrap(void){return 1;}
4
 void
4
 void
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
 struct type_t type_courant;
14
 struct type_t type_courant;
15
 struct type_t return_type_fonc;
15
 struct type_t return_type_fonc;
16
 
16
 
17
-
17
+// Tableau pour le management des patchs des JMP
18
 int instructions_ligne_to_patch[10][20];
18
 int instructions_ligne_to_patch[10][20];
19
 int nbs_instructions_to_patch[10];
19
 int nbs_instructions_to_patch[10];
20
 
20
 
21
 %}
21
 %}
22
 
22
 
23
+// Récupération des tokens
23
 %token tMAIN
24
 %token tMAIN
24
 %token tOBRACKET tCBRACKET
25
 %token tOBRACKET tCBRACKET
25
 %token<nombre> tOBRACE tCBRACE
26
 %token<nombre> tOBRACE tCBRACE
45
 %left tADD tSUB
46
 %left tADD tSUB
46
 %left tMUL tDIV
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
 Fonctions : Fonction Fonctions;
76
 Fonctions : Fonction Fonctions;
63
 Fonctions : ;
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
 Instructions : Instruction Instructions ;
193
 Instructions : Instruction Instructions ;
88
 Instructions : ;
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
 E : E tAND E {add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
454
 E : E tAND E {add_operation(MUL,$1,$1,$3); $$ = $1; pop();};
177
 E : E tOR E {add_operation(ADD,$1,$1,$3); $$ = $1; pop();} ;
455
 E : E tOR E {add_operation(ADD,$1,$1,$3); $$ = $1; pop();} ;
178
 E : tMUL E { add_operation(READ, $2, $2, 0); $$=$2;};
456
 E : tMUL E { add_operation(READ, $2, $2, 0); $$=$2;};

+ 25
- 0
Makefile View File

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

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

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

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

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

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

1
 #include "tab_instruc.h"
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
 int current_index = 1;
13
 int current_index = 1;
14
+// Tableau des instructions (programme en assembleur)
3
 struct operation_t tab_op[MAXTAILLE];
15
 struct operation_t tab_op[MAXTAILLE];
4
 
16
 
17
+// Insertion d'une opération dans le tableau
5
 void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
18
 void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){
6
 	if (current_index == MAXTAILLE){
19
 	if (current_index == MAXTAILLE){
7
 		printf("Taillemax tableau operations atteinte\n");
20
 		printf("Taillemax tableau operations atteinte\n");
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
 void create_jump_to_main(int line){
30
 void create_jump_to_main(int line){
17
     struct operation_t new_op = {JMP,line, 0, 0};
31
     struct operation_t new_op = {JMP,line, 0, 0};
18
     tab_op[0] = new_op;
32
     tab_op[0] = new_op;
19
 }
33
 }
20
 
34
 
21
-
35
+// Fonction traduisant une opération en assembleur
22
 char * get_asm_line_from_op(struct operation_t op){
36
 char * get_asm_line_from_op(struct operation_t op){
23
 	char * buffer = malloc(sizeof(char)*200);
37
 	char * buffer = malloc(sizeof(char)*200);
24
 	switch (op.opcode){
38
 	switch (op.opcode){
73
 		case (RET):
87
 		case (RET):
74
 			sprintf(buffer,"RET\n");
88
 			sprintf(buffer,"RET\n");
75
 			break;
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
 	return buffer;
97
 	return buffer;
84
 }
98
 }
85
 
99
 
100
+// Genere le code asm dans un fichier
86
 void create_asm(){
101
 void create_asm(){
87
 	FILE * output = fopen("output.txt","w");
102
 	FILE * output = fopen("output.txt","w");
88
 	for (int i = 0; i < current_index; i++){
103
 	for (int i = 0; i < current_index; i++){
92
 	}
107
 	}
93
 }
108
 }
94
 
109
 
110
+// Renvoi l'index courrant dans le tableau
95
 int get_current_index(){return current_index;}
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
 void patch(int index, int arg){
115
 void patch(int index, int arg){
100
 	if (tab_op[index].opcode == JMP){
116
 	if (tab_op[index].opcode == JMP){
101
 		tab_op[index].arg1 = arg;
117
 		tab_op[index].arg1 = arg;

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

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

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

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
 #include "table_symboles.h"
1
 #include "table_symboles.h"
30
 #include <stdlib.h>
2
 #include <stdlib.h>
31
 #include <string.h>
3
 #include <string.h>
32
 #include <stdio.h>
4
 #include <stdio.h>
33
-#define MAXADDR 1024*5
34
 
5
 
6
+// Première adresse disponible
35
 int last_addr = 0;
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
 int profondeur = 0;
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
 struct element_t {
18
 struct element_t {
43
 	struct symbole_t symbole;
19
 	struct symbole_t symbole;
44
 	struct element_t * suivant;
20
 	struct element_t * suivant;
45
 };
21
 };
46
 
22
 
23
+// Structure de la pile des symboles
47
 struct pile_t {
24
 struct pile_t {
48
 	int taille;
25
 	int taille;
49
 	struct element_t * first;
26
 	struct element_t * first;
50
 };
27
 };
28
+
29
+// Pile des symboles
51
 struct pile_t * pile;
30
 struct pile_t * pile;
52
 
31
 
32
+// Fonction d'affichage pour un type
53
 char * type_to_string(struct type_t type) {
33
 char * type_to_string(struct type_t type) {
54
     char * star = "*";
34
     char * star = "*";
55
     char * resultat = malloc(sizeof(char)*20);
35
     char * resultat = malloc(sizeof(char)*20);
64
     return resultat;
44
     return resultat;
65
 }
45
 }
66
 
46
 
47
+// Fonction d'affichage pour un symbole
67
 void print_symbole(struct symbole_t symbole) {
48
 void print_symbole(struct symbole_t symbole) {
68
     char * type = type_to_string(symbole.type);
49
     char * type = type_to_string(symbole.type);
69
     if (symbole.initialized) {
50
     if (symbole.initialized) {
74
     free(type);
55
     free(type);
75
 }
56
 }
76
 
57
 
58
+// Initialisation de la pile
77
 void init (void) {
59
 void init (void) {
78
-    pile = malloc(sizeof(struct pile_t));
60
+  pile = malloc(sizeof(struct pile_t));
79
 	pile->first = NULL;
61
 	pile->first = NULL;
80
 	pile->taille = 0;
62
 	pile->taille = 0;
81
 }
63
 }
82
 
64
 
83
-
84
-
65
+// Fonction d'ajout d'un symbole à la pile
85
 int push(char * nom, int isInit, struct type_t type) {
66
 int push(char * nom, int isInit, struct type_t type) {
86
 	struct element_t * aux = malloc(sizeof(struct element_t));
67
 	struct element_t * aux = malloc(sizeof(struct element_t));
87
 	struct symbole_t symbole = {"", last_addr, type, isInit,profondeur}; 
68
 	struct symbole_t symbole = {"", last_addr, type, isInit,profondeur}; 
95
 	return addr_var;
76
 	return addr_var;
96
 }
77
 }
97
 
78
 
79
+// Fonction renvoyant et supprimant le premier symbole
98
 struct symbole_t pop() {
80
 struct symbole_t pop() {
99
 	struct symbole_t retour = {"", 0, UNKNOWN, 0, 0};
81
 	struct symbole_t retour = {"", 0, UNKNOWN, 0, 0};
100
 	struct element_t * aux;
82
 	struct element_t * aux;
109
 	return retour;
91
 	return retour;
110
 }
92
 }
111
 
93
 
112
-
113
-
94
+// Fonction supprimant les n premiers symboles
114
 void multiple_pop(int n){
95
 void multiple_pop(int n){
115
 	for (int i =0; i<n; i++){
96
 	for (int i =0; i<n; i++){
116
 		pop();
97
 		pop();
117
 	}
98
 	}
118
 }
99
 }
119
 
100
 
101
+// Fonction d'accès a un symbole par son nom
120
 struct symbole_t * get_variable(char * nom){
102
 struct symbole_t * get_variable(char * nom){
121
 	struct symbole_t * retour = NULL;
103
 	struct symbole_t * retour = NULL;
122
 	struct element_t * aux = pile->first;
104
 	struct element_t * aux = pile->first;
132
 	return retour;
114
 	return retour;
133
 }
115
 }
134
 
116
 
117
+// Fonction d'affichage de la pile
135
 void print() {
118
 void print() {
136
 	printf("Affichage de la Table des Symboles\n\tSize : %d\n\tContenu : \n", pile->taille);
119
 	printf("Affichage de la Table des Symboles\n\tSize : %d\n\tContenu : \n", pile->taille);
137
 	struct element_t * aux = pile->first;
120
 	struct element_t * aux = pile->first;
146
 	}
129
 	}
147
 }
130
 }
148
 
131
 
149
-
132
+// Getteur sur la première adresse dispo (utile pour le CALL)
150
 int get_last_addr(){
133
 int get_last_addr(){
151
 	return last_addr;
134
 	return last_addr;
152
 }
135
 }
153
 
136
 
137
+
138
+
139
+
140
+/********************************/
141
+/*** GESTION DE LA PROFONDEUR ***/
142
+/********************************/
154
 void inc_prof() {
143
 void inc_prof() {
155
     profondeur++;
144
     profondeur++;
156
 }
145
 }

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

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
 #ifndef TAB_SYMB_H
1
 #ifndef TAB_SYMB_H
29
 #define TAB_SYMB_H
2
 #define TAB_SYMB_H
30
 
3
 
31
 #include <stdint.h>
4
 #include <stdint.h>
32
 
5
 
33
 
6
 
34
-
35
-
36
-
37
-
38
-
39
-
40
-
41
 /**************************************/
7
 /**************************************/
42
 /**************************************/
8
 /**************************************/
43
 /**** Gestion des types possibles  ****/
9
 /**** Gestion des types possibles  ****/
45
 /**************************************/
11
 /**************************************/
46
 
12
 
47
 //Enumération des types de base reconnus 
13
 //Enumération des types de base reconnus 
48
-enum base_type_t {UNKNOWN, INT};
14
+enum base_type_t {UNKNOWN, INT, ADDR};
49
 //Table enregistrant la taille de ces types de bases (indexée sur les types)
15
 //Table enregistrant la taille de ces types de bases (indexée sur les types)
50
 extern int taille_types[];
16
 extern int taille_types[];
51
 //Structure gérant les types 
17
 //Structure gérant les types 
54
     enum base_type_t base;
20
     enum base_type_t base;
55
     //Si la variable est un pointeur, on enregitre son niveau (nombre de *)
21
     //Si la variable est un pointeur, on enregitre son niveau (nombre de *)
56
     int pointeur_level;
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
 char * type_to_string(struct type_t type);
30
 char * type_to_string(struct type_t type);
65
 //Constante pour les entiers
31
 //Constante pour les entiers
66
 extern const struct type_t integer;
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
     //Est il initialisé
67
     //Est il initialisé
101
 	int initialized;
68
 	int initialized;
102
     //Sa profondeur de création
69
     //Sa profondeur de création
103
-    int profondeur;
70
+  int profondeur;
104
 };
71
 };
105
 
72
 
106
 //Fonction d'affichage d'un symbole
73
 //Fonction d'affichage d'un symbole
124
 int push(char * nom, int isInit, struct type_t type);
91
 int push(char * nom, int isInit, struct type_t type);
125
 //Destruction et récupération du premier élément de la table
92
 //Destruction et récupération du premier élément de la table
126
 struct symbole_t pop();
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
 void multiple_pop(int n);
95
 void multiple_pop(int n);
129
 //Retourne la dernière adresse disponible
96
 //Retourne la dernière adresse disponible
130
 int get_last_addr();
97
 int get_last_addr();

Loading…
Cancel
Save