Browse Source

réorganisation

Nahom 2 months ago
parent
commit
271309e831

BIN
.DS_Store View File


+ 1
- 1
.idea/projet_systeme.iml View File

@@ -1,2 +1,2 @@
1 1
 <?xml version="1.0" encoding="UTF-8"?>
2
-<module classpath="External" external.linked.project.id="projet_systeme" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="Makefile" type="CPP_MODULE" version="4" />
2
+<module classpath="External" type="CPP_MODULE" version="4" />

+ 0
- 106
analyse_lexicale.lex View File

@@ -1,106 +0,0 @@
1
-%{ 
2
-#include "analyse_syntaxique.tab.h" 
3
-int yywrap(void){
4
-    return 1;
5
-}
6
-
7
-%}
8
-
9
-
10
-
11
-
12
-ADD         "+"
13
-SUB         "-"
14
-MUL         "*"
15
-DIV         "/"
16
-tPO         "("
17
-tPF         ")"
18
-tAO         "{"
19
-tAF         "}"
20
-EOL         "\n"
21
-EOI         ";"
22
-SPACE       " "
23
-TAB         "\t"
24
-VIRGULE     ","
25
-AFFECTATION        "="
26
-EQUAL       "=="
27
-LT          "<"
28
-GT          ">"
29
-LTE          "<="
30
-GTE          ">="
31
-tINT        "int"
32
-tMAIN       "main"  
33
-tPRINT      "printf"
34
-tRETURN     "return"
35
-tIF         "if"
36
-tELSE       "else"
37
-tWHILE      "while"
38
-tNOT        "!"
39
-tAND        "&&"
40
-tOR         "||"
41
-tDIFF       "!="
42
-tAPPERSAND  "&"
43
-DIGIT       [0-9]
44
-VARIABLE    [A-Za-z0-9_]+
45
-CONST       "const"
46
-DECIMAL     {DIGIT}+
47
-EXPONENTIEL {DIGIT}+"e"{DIGIT}+
48
-ENTIER      {DECIMAL}
49
-ENTIEREXP   {EXPONENTIEL}
50
-OPERATION   {ADD}|{SUB}|{MUL}|{DIV}
51
-COMPARATEUR {EGAL}|{LT}|{GT}
52
-SEPARATOR   {SPACE}|{TAB}
53
-
54
-%%
55
-
56
-{ADD}           {return tADD ;}
57
-{SUB}           {return tSUB ;}
58
-{MUL}           {return tMUL ;}
59
-{DIV}           {return tDIV ;}
60
-
61
-{tPO}           {return tPO ;}
62
-{tPF}           {return tPF ;}
63
-{tAO}           {return tAO ;}
64
-{tAF}           {return tAF ;}
65
-
66
-{EOI}           {return tPV ;}
67
-{SEPARATOR}     {}
68
-{EOL}           {}
69
-{VIRGULE}       {return tVIRGULE ;}
70
-
71
-{AFFECTATION}   {return tAFFECTATION ;}
72
-
73
-{EQUAL}          {return tEGAL ;}
74
-{tDIFF}          {return tDIFF ;}
75
-{LT}            {return tLT ;}
76
-{GT}            {return tGT ;}
77
-{LTE}           {return tLTE ;}
78
-{GTE}           {return tGTE ;}
79
-{tNOT}           {return tNOT ;}
80
-
81
-
82
-{tMAIN}         {return tMAIN ;}
83
-{tINT}          {return tINT ;}
84
-{tPRINT}        {return tPRINT ;}
85
-{tRETURN}       {return tRETURN ;}
86
-
87
-{tOR}           {return tOR ;}
88
-{tAND}          {return tAND ;}
89
-
90
-{tIF}           {return tIF ;}
91
-{tELSE}         {return tELSE ;}
92
-{tWHILE}        {return tWHILE ;}
93
-
94
-{tAPPERSAND}    {return tAPPERSAND;}
95
-{CONST}         {return tCONST ;}
96
-{ENTIER}        {yylval.nombre = atoi(yytext); return tENTIER ;}
97
-{ENTIEREXP}     {yylval.nombre = -1; return tENTIEREXP;}
98
-{VARIABLE}      {strcpy(yylval.id, yytext); return tVAR  ;}
99
-
100
-%%
101
-
102
-//int main(void){
103
-//    yylex();
104
-//}
105
-
106
-

+ 0
- 230
analyse_syntaxique.y View File

@@ -1,230 +0,0 @@
1
-%union {
2
-int nombre;
3
-char id[30];
4
-}
5
-
6
-%{
7
-#include <stdio.h>
8
-#include "table_symboles.h"
9
-#include "table_fonctions.h"
10
-#include "gen_assembleur.h"
11
-
12
-enum Initialised_Variable init;
13
-enum Symbole_Type type;
14
-enum Return_Type return_type;
15
-Table_Symboles table;
16
-Table_Fonctions table_fonctions;
17
-instructions_array array;
18
-int whileCondition;
19
-int return_value;
20
-%}
21
-
22
-
23
-%token<nombre> tENTIER
24
-%token<nombre> tENTIEREXP
25
-
26
-%type<nombre> E
27
-%type<nombre> Return Instructions
28
-%type<nombre> Cond
29
-%type<nombre> While Else Invocation
30
-
31
-
32
-%token tADD
33
-%token tSUB
34
-%token tMUL
35
-%token tDIV
36
-
37
-%token<nombre> tPO
38
-%token tPF
39
-%token tAO
40
-%token tAF
41
-
42
-%token tERROR
43
-
44
-%token tAPPERSAND
45
-%token tPV
46
-%token tVIRGULE
47
-%token tAFFECTATION
48
-%token tEGAL
49
-%token tDIFF
50
-%token tLT
51
-%token tGT
52
-%token tGTE
53
-%token tLTE
54
-%token tMAIN
55
-%token tINT
56
-%token tPRINT
57
-%token tRETURN
58
-%token tOR
59
-%token tAND
60
-%token<nombre> tIF
61
-%token tELSE
62
-%token<nombre> tWHILE
63
-%token tCONST
64
-%token<id> tVAR
65
-%token tNOT
66
-
67
-%left tADD
68
-%left tSUB
69
-%left tMUL
70
-%left tDIV
71
-%right tEGAL
72
-
73
-
74
-%%
75
-
76
-/*C : Fonctions Main ;
77
-
78
-Fonctions : ;
79
-Fonctions : Fonction Fonctions ;
80
-
81
-Fonction : tINT tVAR tPO Params tPF Body;*/
82
-
83
-C : {generate_instruction_1(&array, JMP, -1);} Fonctions;
84
-
85
-Fonctions: Main;
86
-Fonctions: Fonction Fonctions;
87
-
88
-
89
-Main : tINT tMAIN {update_jmp(&array, 0, array.index); add_function(&table_fonctions, "Main", RET_INT, array.index); table.depth++;} tPO Params tPF Body {print_table(&table);remove_symboles(&table); table.depth--;};
90
-Fonction : Function_type tVAR {{add_function(&table_fonctions, $2, return_type, array.index); table.depth++;}} tPO Params tPF Body {print_table(&table);remove_symboles(&table); table.depth--;};
91
-
92
-Function_type: tINT {type = TYPE_INT;} ;
93
-Function_type: tINT tMUL {type = TYPE_INT_PTR;};
94
-
95
-Params : {} ;
96
-Params : Param SuiteParams ;
97
-
98
-Param : Param_type tVAR {add_symbole_top(&table, $2, type, INITIALISED, table.depth);} ;
99
-
100
-Param_type: tINT {type = TYPE_INT;} ;
101
-Param_type: tINT tMUL {type = TYPE_INT_PTR;};
102
-
103
-SuiteParams : tVIRGULE Param SuiteParams ;
104
-SuiteParams : ;
105
-
106
-
107
-Body : tAO Instructions Return tAF {} ;
108
-
109
-Instructions : Instruction Instructions {$$ = array.index;};
110
-Instructions : {$$ = array.index;};
111
-
112
-Instruction : Aff ;
113
-Instruction : If ;
114
-Instruction : While ;
115
-Instruction : Print ;
116
-Instruction : Decl ;
117
-Instruction : Invocation tPV ;
118
-
119
-Decl : Type Valeur SuiteDecl tPV ;
120
-
121
-SuiteDecl: tVIRGULE Valeur SuiteDecl ;
122
-SuiteDecl: ;
123
-
124
-Type : tINT {type = TYPE_INT;} ;
125
-Type : tCONST tINT {type = TYPE_CONST_INT;} ;
126
-Type : tINT tMUL {type = TYPE_INT_PTR;};
127
-
128
-Valeur : tVAR {add_symbole_top(&table, $1, type, INITIALISED, table.depth);} tAFFECTATION E {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, varAddr, $4); free_temp(&table);};
129
-Valeur : tVAR {add_symbole_top(&table, $1, type, NOT_INITIALISED, table.depth);};
130
-
131
-
132
-Aff : tVAR tAFFECTATION E tPV {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, varAddr, $3); free_temp(&table); };
133
-Aff : tMUL tVAR tAFFECTATION E tPV {int varAddr = variable_exists(&table, $2); generate_instruction_2(&array, COP_STR, varAddr, $4); free_temp(&table); };
134
-
135
-
136
-E : tENTIER {int vt = new_temp(&table); generate_instruction_2(&array, AFC, vt, $1); $$ = vt;};
137
-E : tVAR {int vt = new_temp(&table); int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, vt, varAddr); $$ = vt;};
138
-E : E tADD E {generate_instruction_3(&array, ADD, $1, $1, $3); free_temp(&table); $$ = $1;} ;
139
-E : E tMUL E {generate_instruction_3(&array, MUL, $1, $1, $3); free_temp(&table); $$ = $1;}  ;
140
-E : E tSUB E {generate_instruction_3(&array, SOU, $1, $1, $3); free_temp(&table); $$ = $1;} ;
141
-E : E tDIV E {generate_instruction_3(&array, DIV, $1, $1, $3); free_temp(&table); $$ = $1;} ;
142
-E : tSUB E {printf("Variable negative\n");} ;
143
-E : Invocation {
144
-	//int vt = new_temp(&table);
145
-	//generate_instruction_2(&array, COP, vt, $1);
146
-	remove_symboles(&table);
147
-	table.depth--;
148
-	$$ = $1;};
149
-E : tPO E tPF {printf("Parenthèse\n"); $$ = $2; } ;
150
-E : tAPPERSAND tVAR {int vt = new_temp(&table); int varAddr = variable_exists(&table, $2); generate_instruction_2(&array, LEA, vt, varAddr); $$ = vt;};
151
-E : tMUL tVAR {int vt = new_temp(&table); int varAddr = variable_exists(&table, $2); generate_instruction_2(&array, COP, vt, varAddr); generate_instruction_2(&array, COP_LD, vt, vt); $$ = vt;};
152
-
153
-
154
-If : tIF tPO Cond tPF {
155
-    //gen_jmpf(&table, &array, $3, -1);
156
-    generate_instruction_2(&array, JMF, $3, -1);
157
-    free_temp(&table);
158
-    $1 = array.index;
159
-}
160
-tAO {table.depth++;} Instructions {generate_instruction_1(&array, JMP, -1);} tAF {remove_symboles(&table); table.depth--;}
161
-{
162
-    int adr_jmp = array.index;
163
-    update_jmf(&array, $1, adr_jmp);
164
-}
165
-Else {printf("updating jump\n"); update_jmp(&array, $8, $13);};
166
-
167
-Else : tELSE tAO {table.depth++;} Instructions tAF {remove_symboles(&table); table.depth--;} {$$ = array.index;} ;
168
-Else : {$$ = array.index;};
169
-Else : tELSE If {$$ = array.index;} ;
170
-
171
-While : tWHILE tPO {
172
-	$2 = array.index ;
173
-} Cond tPF {
174
-	//gen_jmpf(&table, &array, $4, -1);
175
-	generate_instruction_2(&array, JMF, $4, -1);
176
-	free_temp(&table);
177
-	$1 = array.index;
178
-}
179
-tAO {table.depth++;} Instructions tAF {remove_symboles(&table); table.depth--;} {
180
-	int adr_jmp = array.index;
181
-	update_jmf(&array, $1, adr_jmp);
182
-	//gen_jmpf(&table, &array, $1, $2);
183
-	generate_instruction_1(&array, JMP, $2);
184
-};
185
-
186
-Cond : E tEGAL E {generate_instruction_3(&array, EQ, $1, $1, $3); free_temp(&table); $$ = $3;};
187
-Cond : E tDIFF E {generate_instruction_3(&array, NEQ, $1, $1, $3); free_temp(&table); $$ = $3;} ;
188
-Cond : E tLT E {generate_instruction_3(&array, LT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
189
-Cond : E tGT E {generate_instruction_3(&array, GT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
190
-Cond : E tLTE E {generate_instruction_3(&array, LTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
191
-Cond : E tGTE E {generate_instruction_3(&array, GTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
192
-Cond : E tAND E {generate_instruction_3(&array, AND, $1, $1, $3); free_temp(&table); $$ = $3;} ;
193
-Cond : E tOR E {generate_instruction_3(&array, OR, $1, $1, $3); free_temp(&table); $$ = $3;} ;
194
-Cond : tNOT Cond {generate_instruction_2(&array, NOT, $2, $2); $$ = $2;} ;
195
-Cond : E {$$ = $1; };
196
-
197
-Invocation : tVAR tPO {table.depth++; prepare_function_call(&table); return_value = (table.indexAvailableBottom);} Args  tPF
198
-	{int function_index = function_exists(&table_fonctions, $1);
199
-	int jmp_addr = (table_fonctions.array[function_index]).start_addr;
200
-	generate_instruction_2(&array, CALL, jmp_addr, table.indexAvailableTop);
201
-	$$ = return_value;
202
-	};
203
-
204
-Args : Arg SuiteArgs ;
205
-Args :
206
-Arg : E {int arg_addr = prepare_argument_push(&table); generate_instruction_2(&array, COP, arg_addr, $1); free_temp(&table);};
207
-SuiteArgs : tVIRGULE Arg SuiteArgs ;
208
-SuiteArgs : ;
209
-
210
-Print : tPRINT tPO E tPF tPV {generate_instruction_1(&array, PRI, $3); free_temp(&table);};
211
-
212
-Return : tRETURN E tPV {$$ = generate_instruction_1(&array, RET, $2); free_temp(&table);};
213
-
214
-%%
215
-#include <stdio.h>
216
-void main(void){
217
-    //TODO: rajouter gestion des erreurs
218
-    initialise_table(&table);
219
-    initialise_function_table(&table_fonctions);
220
-    initialise_asm(&array);
221
-    yyparse();
222
-    print_table(&table);
223
-    printf("\n");
224
-    print_fonction_table(&table_fonctions);
225
-
226
-    //remove_symboles(&table, 0);
227
-    //print_table(&table);
228
-    exportInstructions(&array);
229
-}
230
-

BIN
cross_assembleur/.DS_Store View File


+ 1
- 0
cross_assembleur/STD_LOGIC_VECTOR_output View File

@@ -0,0 +1 @@
1
+(0=>"00000111000000010000001000000000", 1=>"00000111000000100000001100000000", 2=>"00000001000000110000000100000010", 3=>"00001000000000010000001100000000", 4=>"00000111000000010000001000000000", 5=>"00000111000000100000001100000000", 6=>"00000011000000110000000100000010", 7=>"00001000000000010000001100000000", 8=>"00000111000000010000001000000000", 9=>"00001000000000010000000100000000", others => "00000000000000000000000000000000")

+ 3
- 0
cross_assembleur/cross_input.txt View File

@@ -0,0 +1,3 @@
1
+ADD 1 2 3
2
+SOU 1 2 3
3
+COP 1 2

+ 10
- 0
cross_assembleur/cross_output.txt View File

@@ -0,0 +1,10 @@
1
+7 1 2 0
2
+7 2 3 0
3
+1 3 1 2
4
+8 1 3 0
5
+7 1 2 0
6
+7 2 3 0
7
+3 3 1 2
8
+8 1 3 0
9
+7 1 2 0
10
+8 1 1 0

+ 36
- 0
cross_assembleur/main.py View File

@@ -0,0 +1,36 @@
1
+import sys
2
+
3
+def output_instructions_binary(instructions):
4
+    file = open("STD_LOGIC_VECTOR_output", "w")
5
+    file.write("(")
6
+    for index, instruction in enumerate(instructions):
7
+        string_instruction = str(index) + "=>"
8
+        string_instruction+= "\""
9
+        op = f'{int(instruction[0]):08b}'
10
+        arg1 = f'{int(instruction[1]):08b}'
11
+        arg2 = f'{int(instruction[2]):08b}'
12
+        arg3 = f'{int(instruction[3]):08b}'
13
+        string_instruction += op + arg1 + arg2 + arg3
14
+        string_instruction += "\", "
15
+        file.write(string_instruction)
16
+    file.write("others => \"00000000000000000000000000000000\")")
17
+    file.close()
18
+
19
+
20
+if __name__ == '__main__':
21
+    if len(sys.argv) != 2:
22
+        print("Please only input one file name")
23
+        exit(0)
24
+
25
+    filename = sys.argv[1]
26
+    f = open(filename, "r")
27
+    lines = f.readlines()
28
+    lines = [line.strip() for line in lines]
29
+    instructions = [line.split(" ") for line in lines]
30
+
31
+    output_instructions_binary(instructions)
32
+    f.close()
33
+
34
+
35
+
36
+

+ 17
- 0
cross_assembleur/makefile View File

@@ -0,0 +1,17 @@
1
+SRCC:= ./src/*.c
2
+
3
+all: cross_assembler
4
+
5
+cross_assembler: src/cross.y src/cross.l src/cross_instructions.c
6
+	yacc -d ./src/cross.y
7
+	lex ./src/cross.l
8
+	gcc lex.yy.c y.tab.c ./src/cross_instructions.c -Isrc -o cross_assembler
9
+
10
+run: cross_assembler
11
+	./cross_assembler < cross_input.txt
12
+
13
+export_binary: run
14
+	python3 main.py cross_output.txt
15
+
16
+clean:
17
+	rm -f lex.yy.c cross_assembler y.tab.h y.tab.c *.o

BIN
cross_assembleur/src/.DS_Store View File


+ 32
- 0
cross_assembleur/src/cross.l View File

@@ -0,0 +1,32 @@
1
+%{
2
+    #include "y.tab.h"
3
+%}
4
+
5
+vSEP    [ \t\r\n]
6
+
7
+%%
8
+
9
+ADD {return tADD;}
10
+MUL {return tMUL;}
11
+SOU {return tSOU;}
12
+DIV {return tDIV;}
13
+COP {return tCOP;}
14
+AFC {return tAFC;}
15
+
16
+-?[0-9]+  {
17
+        yylval.nb = atoi(yytext);
18
+        return tNB;
19
+        }
20
+
21
+
22
+{vSEP}  {}
23
+
24
+.       {
25
+        fprintf(stderr, "ERROR lex : Unknown pattern %s", yytext);
26
+        exit(1);
27
+        }
28
+
29
+%%
30
+
31
+int yywrap(void) { return 1; }
32
+//int main(int argc, char *argv[]) { while (yylex()!=0) ; return 0; }

+ 88
- 0
cross_assembleur/src/cross.y View File

@@ -0,0 +1,88 @@
1
+%{
2
+    #include <stdio.h>
3
+    #include "cross_instructions.h"
4
+    int yylex();
5
+    void yyerror(char*);
6
+    int yydebug = 1;
7
+    extern int yylineno;
8
+
9
+    reg_instructions reg_array;
10
+%}
11
+
12
+/* Union for yylval */
13
+%union {
14
+    int nb;
15
+}
16
+
17
+%token tADD tMUL tSOU tDIV tCOP tAFC
18
+%token <nb> tNB
19
+
20
+%%
21
+
22
+%start File;
23
+
24
+File:
25
+    Instructions;
26
+
27
+Instructions:
28
+    /* epsilon */
29
+    | Instructions Instruction
30
+    ;
31
+
32
+Instruction:
33
+    tADD tNB tNB tNB
34
+        {
35
+        add_reg_oriented_instructions(&reg_array,LOAD, 1, $3, 0);
36
+        add_reg_oriented_instructions(&reg_array,LOAD, 2, $4, 0);
37
+        add_reg_oriented_instructions(&reg_array,ADD, 3, 1, 2);
38
+        add_reg_oriented_instructions(&reg_array,STORE, $2, 3, 0);
39
+        }
40
+    | tMUL tNB tNB tNB
41
+        {
42
+        add_reg_oriented_instructions(&reg_array,LOAD, 1, $3, 0);
43
+	add_reg_oriented_instructions(&reg_array,LOAD, 2, $4, 0);
44
+	add_reg_oriented_instructions(&reg_array,MUL, 3, 1, 2);
45
+	add_reg_oriented_instructions(&reg_array,STORE, $2, 3, 0);
46
+        }
47
+    | tSOU tNB tNB tNB
48
+        {
49
+        add_reg_oriented_instructions(&reg_array,LOAD, 1, $3, 0);
50
+	add_reg_oriented_instructions(&reg_array,LOAD, 2, $4, 0);
51
+	add_reg_oriented_instructions(&reg_array,SOU, 3, 1, 2);
52
+	add_reg_oriented_instructions(&reg_array,STORE, $2, 3, 0);
53
+        }
54
+    | tDIV tNB tNB tNB
55
+        {
56
+        add_reg_oriented_instructions(&reg_array,LOAD, 1, $3, 0);
57
+	add_reg_oriented_instructions(&reg_array,LOAD, 2, $4, 0);
58
+	add_reg_oriented_instructions(&reg_array,DIV, 3, 1, 2);
59
+	add_reg_oriented_instructions(&reg_array,STORE, $2, 3, 0);
60
+        }
61
+    | tCOP tNB tNB
62
+        {
63
+        add_reg_oriented_instructions(&reg_array,LOAD, 1, $3, 0);
64
+	add_reg_oriented_instructions(&reg_array,STORE, $2, 1, 0);
65
+        }
66
+    | tAFC tNB tNB
67
+        {
68
+	add_reg_oriented_instructions(&reg_array,AFC, 1, $3, 0);
69
+	add_reg_oriented_instructions(&reg_array,STORE, $2, 1, 0);
70
+        }
71
+;
72
+
73
+
74
+%%
75
+
76
+void yyerror(char* str) {
77
+    extern int yylineno;
78
+    fprintf(stderr, "ERROR yyparse : Line %d: %s\n", yylineno, str);
79
+}
80
+
81
+int main(int argc, char *argv[]) {
82
+    init_reg_oriented_instructions(&reg_array);
83
+    yyparse();
84
+    printf("INFO yyparse : Parsing End\n");
85
+    output_reg_oriented_instructions(&reg_array);
86
+    return 0;
87
+}
88
+

+ 23
- 0
cross_assembleur/src/cross_instructions.c View File

@@ -0,0 +1,23 @@
1
+#include <stdio.h>
2
+#include "cross_instructions.h"
3
+
4
+void init_reg_oriented_instructions(reg_instructions * instructions_array){
5
+    instructions_array->index = 0;
6
+}
7
+
8
+void add_reg_oriented_instructions(reg_instructions * instructions_array, int operation, int arg1, int arg2, int arg3) {
9
+    struct reg_instruction ins = {operation, arg1, arg2, arg3};
10
+    instructions_array->reg_instructions[instructions_array->index] = ins;
11
+    instructions_array->index++;
12
+}
13
+
14
+void output_reg_oriented_instructions(reg_instructions * instructions_array){
15
+    FILE *file;
16
+    file = fopen("cross_output.txt", "w");
17
+    struct reg_instruction instru;
18
+    for (int i = 0; i < instructions_array->index; i++){
19
+        instru = instructions_array->reg_instructions[i];
20
+        fprintf(file, "%d %d %d %d\n", instru.ins, instru.arg1, instru.arg2, instru.arg3);
21
+    }
22
+
23
+}

+ 33
- 0
cross_assembleur/src/cross_instructions.h View File

@@ -0,0 +1,33 @@
1
+#ifndef __INSTRUCTIONS_H__
2
+#define __INSTRUCTIONS_H__
3
+
4
+#define ADD 1
5
+#define MUL 2
6
+#define SOU 3
7
+#define DIV 4
8
+#define COP 5
9
+#define AFC 6
10
+#define LOAD 7
11
+#define STORE 8
12
+
13
+#define MAX_SIZE 256
14
+
15
+struct reg_instruction {
16
+    char ins;
17
+    int arg1;
18
+    int arg2;
19
+    int arg3;
20
+};
21
+
22
+typedef struct reg_instructions{
23
+    struct reg_instruction reg_instructions[MAX_SIZE];
24
+    int index;
25
+} reg_instructions;
26
+
27
+void init_reg_oriented_instructions(reg_instructions * instructions_array);
28
+
29
+void add_reg_oriented_instructions(reg_instructions * instructions_array, int operation, int arg1, int arg2, int arg3);
30
+
31
+void output_reg_oriented_instructions(reg_instructions * instructions_array);
32
+
33
+#endif // #ifndef __INSTRUCTIONS_H__

+ 0
- 357
gen_assembleur.c View File

@@ -1,357 +0,0 @@
1
-#include "gen_assembleur.h"
2
-#include <stdio.h>
3
-#include <stdlib.h>
4
-
5
-char * operationName(enum operation op){
6
-    switch(op){
7
-        case EQ:
8
-            return "EQ";
9
-        case NEQ:
10
-            return "NEQ";
11
-        case LT:
12
-            return "LT";
13
-        case GT:
14
-            return "GT";
15
-        case LTE:
16
-            return "LTE";
17
-        case GTE:
18
-            return "GTE";
19
-        case ADD:
20
-            return "ADD";
21
-        case SOU:
22
-            return "SOU";
23
-        case DIV:
24
-            return "DIV";
25
-        case MUL:
26
-            return "MUL";
27
-        case COP:
28
-            return "COP";
29
-        case AFC:
30
-            return "AFC";
31
-        case RET:
32
-            return "RET";
33
-        case JMF:
34
-            return "JPF";
35
-        case JMP:
36
-            return "JMP";
37
-        case AND:
38
-            return "AND";
39
-        case OR:
40
-            return "OR";
41
-        case NOT:
42
-            return "NOT";
43
-        case PRI:
44
-            return "PRI";
45
-        case LEA:
46
-            return "LEA";
47
-        case COP_LD:
48
-            return "COP_LD";
49
-        case COP_STR:
50
-            return "COP_STR";
51
-        case RET_FUN:
52
-            return "RET_FUN";
53
-        case CALL:
54
-            return "CALL";
55
-        default:
56
-            break;
57
-    }
58
-    return "";
59
-}
60
-
61
-void initialise_asm(instructions_array * array){
62
-    array->index = 0;
63
-}
64
-
65
-int add_instruction(instructions_array * array, instruction * instru){
66
-    if (array->index >= INSTRUCTION_TABLE_SIZE){
67
-        return 1;
68
-    }
69
-    array->array[array->index] = *instru;
70
-    array->index++;
71
-
72
-    return 0;
73
-}
74
-
75
-int new_temp(Table_Symboles * table){
76
-    int ret_addr ;
77
-    if(add_symbole_bottom(table) == -1) {
78
-        return -1;
79
-    }
80
-    ret_addr = table->indexAvailableBottom + 1;
81
-    return ret_addr;
82
-}
83
-
84
-int generate_instruction_0(instructions_array * array, enum operation op){
85
-    instruction instru;
86
-    char * opName = operationName(op);
87
-
88
-    instru.operation = op;
89
-
90
-    printf("%d\t %s\n", array->index, opName);
91
-
92
-    if (add_instruction(array, &instru) != 0){
93
-        //TODO: Error handling
94
-        exit(1);
95
-    }
96
-
97
-    return 0;
98
-}
99
-
100
-int generate_instruction_1(instructions_array * array, enum operation op, int arg1){
101
-    instruction instru;
102
-    char * opName = operationName(op);
103
-
104
-    instru.operation = op;
105
-    instru.reg1 = arg1;
106
-
107
-    printf("%d\t %s %d\n", array->index, opName, instru.reg1);
108
-
109
-    if (add_instruction(array, &instru) != 0){
110
-        //TODO: Error handling
111
-        exit(1);
112
-    }
113
-
114
-    return 0;
115
-}
116
-
117
-int generate_instruction_2(instructions_array * array, enum operation op, int arg1, int arg2){
118
-    instruction instru;
119
-    char * opName = operationName(op);
120
-
121
-    instru.operation = op;
122
-    instru.reg1 = arg1;
123
-    instru.reg2 = arg2;
124
-
125
-    printf("%d\t %s %d %d\n", array->index, opName, instru.reg1, instru.reg2);
126
-
127
-    if (add_instruction(array, &instru) != 0){
128
-        //TODO: Error handling
129
-        exit(1);
130
-    }
131
-
132
-    return 0;
133
-}
134
-
135
-int generate_instruction_3(instructions_array * array, enum operation op, int arg1, int arg2, int arg3){
136
-    instruction instru;
137
-    char * opName = operationName(op);
138
-
139
-    instru.operation = op;
140
-    instru.reg1 = arg1;
141
-    instru.reg2 = arg2;
142
-    instru.reg3 = arg3;
143
-
144
-    printf("%d\t %s %d %d %d\n", array->index, opName, instru.reg1, instru.reg2, instru.reg3);
145
-
146
-    if (add_instruction(array, &instru) != 0){
147
-        //TODO: Error handling
148
-        exit(1);
149
-    }
150
-
151
-    return 0;
152
-}
153
-
154
-void update_jmf(instructions_array * array, int instru_index, int adr_jmp){
155
-    array->array[instru_index - 1].reg2 = adr_jmp;
156
-    printf("%d\t JMP %d %d\n",  (instru_index - 1), array->array[instru_index].reg1, array->array[instru_index].reg2);
157
-}
158
-
159
-void update_jmp(instructions_array * array, int instru_index, int adr_jmp){
160
-    array->array[instru_index].reg1 = adr_jmp;
161
-    printf("%d\t JMP %d\n",  (instru_index - 1), array->array[instru_index].reg1);
162
-}
163
-
164
-void exportInstructions(instructions_array * array){
165
-    FILE *file;
166
-    file = fopen("instructions.txt", "w");
167
-    instruction instru;
168
-    enum operation op;
169
-
170
-    for (int i = 0; i < array->index; i++){
171
-        instru = array->array[i];
172
-        op = instru.operation;
173
-        switch (op) {
174
-            //0 parameters
175
-            case RET_FUN:
176
-                fprintf(file, "%s\n", operationName(op));
177
-                break;
178
-            //1 parameter
179
-            case JMP:
180
-            case PRI:
181
-            case RET:
182
-                fprintf(file, "%s %d\n", operationName(op), instru.reg1);
183
-                break;
184
-            //2 parameters
185
-            case JMF:
186
-            case NOT:
187
-            case AFC:
188
-            case COP:
189
-            case LEA:
190
-            case CALL:
191
-                fprintf(file, "%s %d %d\n", operationName(op), instru.reg1, instru.reg2);
192
-                break;
193
-            case COP_LD:
194
-                fprintf(file, "%s %d [%d]\n", operationName(op), instru.reg1, instru.reg2);
195
-                break;
196
-            case COP_STR:
197
-                fprintf(file, "%s [%d] %d\n", operationName(op), instru.reg1, instru.reg2);
198
-                break;
199
-            //3 parameters
200
-            case ADD:
201
-            case SOU:
202
-            case DIV:
203
-            case MUL:
204
-            case AND:
205
-            case OR:
206
-            case EQ:
207
-            case NEQ:
208
-            case LT:
209
-            case LTE:
210
-            case GT:
211
-            case GTE:
212
-                fprintf(file, "%s %d %d %d\n", operationName(op), instru.reg1, instru.reg2, instru.reg3);
213
-                break;
214
-            default:
215
-                break;
216
-        }
217
-    }
218
-
219
-    fclose(file);
220
-}
221
-
222
-/*int gen_print(Table_Symboles * table, instructions_array * array, int arg1){
223
-    instruction instru;
224
-    instru.operation = PRI;
225
-    instru.reg1 = arg1;
226
-
227
-    printf("%d\t PRI %d\n",  array->index, instru.reg1);
228
-
229
-    if (array->index < INSTRUCTION_TABLE_SIZE){
230
-        array->array[array->index] = instru;
231
-        array->index++;
232
-    }
233
-
234
-    free_temp(table);
235
-}*/
236
-
237
-/*void gen_arithmetique(instructions_array * array, enum operation op, int arg1, int arg2){
238
-    instruction instru;
239
-    instru.reg1 = arg1;
240
-    instru.reg2 = arg1;
241
-    instru.reg3 = arg2;
242
-
243
-    char * opName = operationName(op);
244
-    printf("%d\t %s %d %d %d\n", array->index, opName, arg1, arg1, arg2);
245
-
246
-    if (array->index < INSTRUCTION_TABLE_SIZE){
247
-        array->array[array->index] = instru;
248
-        array->index++;
249
-    }
250
-
251
-}
252
-
253
-int gen_var(Table_Symboles * table, instructions_array * array, char * varName){
254
-    int vt = new_temp(table);
255
-    int varAddr = variable_exists(table, varName);
256
-
257
-    //vérifier que non null
258
-    instruction instru;
259
-    instru.operation = COP;
260
-    instru.reg1 = vt;
261
-    instru.reg2 = varAddr;
262
-
263
-    printf("%d\t COP %d %d\n",  array->index, vt, varAddr);
264
-
265
-    if (array->index < INSTRUCTION_TABLE_SIZE){
266
-        array->array[array->index] = instru;
267
-        array->index++;
268
-    }
269
-
270
-    return vt;
271
-
272
-}
273
-
274
-int gen_entier(Table_Symboles * table, instructions_array * array, int entier){
275
-    int vt = new_temp(table);
276
-
277
-    //vérifier que non null
278
-    instruction instru;
279
-    instru.operation = AFC;
280
-    instru.reg1 = vt;
281
-    instru.reg2 = entier;
282
-
283
-    printf("%d\t AFC %d %d\n",  array->index, vt, entier);
284
-
285
-    if (array->index < INSTRUCTION_TABLE_SIZE){
286
-        array->array[array->index] = instru;
287
-        array->index++;
288
-    }
289
-
290
-    return vt;
291
-}
292
-
293
-int gen_condition(Table_Symboles * table, instructions_array * array, enum operation op,  int arg1, int arg2){
294
-
295
-    char * opName = operationName(op);
296
-
297
-    instruction instru;
298
-    instru.operation = op;
299
-    instru.reg1 = arg1;
300
-    instru.reg2 = arg1;
301
-    if (op != NOT){
302
-        instru.reg3 = arg2;
303
-        printf("%d\t %s %d %d %d\n", array->index, opName, instru.reg1, instru.reg2, instru.reg3);
304
-        free_temp(table);
305
-    } else {
306
-        printf("%d\t %s %d %d \n", array->index, opName, instru.reg1, instru.reg2);
307
-    }
308
-
309
-    if (array->index < INSTRUCTION_TABLE_SIZE){
310
-        array->array[array->index] = instru;
311
-        array->index++;
312
-    }
313
-
314
-    return instru.reg1;
315
-}
316
-
317
-int gen_return(Table_Symboles * table, instructions_array * array, int adr){
318
-
319
-    //vérifier que non null
320
-    instruction instru;
321
-    instru.operation = RET;
322
-    instru.reg1 = adr;
323
-
324
-    printf("%d\t RET %d\n",  array->index, adr);
325
-
326
-    if (array->index < INSTRUCTION_TABLE_SIZE){
327
-        array->array[array->index] = instru;
328
-        array->index++;
329
-    }
330
-
331
-    //free_temp(table);
332
-
333
-    return adr;
334
-}
335
-
336
-int gen_jmpf(Table_Symboles * table, instructions_array * array, int cond, int dest){
337
-       //vérifier que non null
338
-    instruction instru;
339
-    instru.operation = JMF;
340
-    instru.reg1 = cond;
341
-    instru.reg2 = dest;
342
-
343
-    printf("%d\t JMPF %d %d\n",  array->index, instru.reg1 , instru.reg2);
344
-
345
-    if (array->index < INSTRUCTION_TABLE_SIZE){
346
-        array->array[array->index] = instru;
347
-        array->index++;
348
-    }
349
-
350
-    //free_temp(table);
351
-
352
-    return cond;
353
-}
354
-
355
- */
356
-
357
-

+ 0
- 121
gen_assembleur.h View File

@@ -1,121 +0,0 @@
1
-#ifndef GEN_ASSEMBLEUR_H
2
-#define GEN_ASSEMBLEUR_H
3
-
4
-#define INSTRUCTION_TABLE_SIZE 1000
5
-
6
-#include "table_symboles.h"
7
-
8
-enum operation{ADD, SOU, MUL, DIV, COP, AFC, RET, JMF, JMP, EQ, NEQ, LT, GT, LTE,
9
-        GTE, AND, OR, NOT, PRI, LEA, COP_LD, COP_STR, CALL, RET_FUN};
10
-
11
-typedef struct instruction{
12
-    enum operation operation;
13
-    int reg1;
14
-    int reg2;
15
-    int reg3;
16
-}instruction;
17
-
18
-//table des instructions
19
-typedef struct instructions_array{
20
-    instruction array[INSTRUCTION_TABLE_SIZE];
21
-    int index;
22
-} instructions_array;
23
-
24
-/**
25
- *
26
- * @param op operation
27
- * @return returns the string that corresponds to the enum operation op
28
- */
29
-char * operationName(enum operation op);
30
-
31
-/**
32
- * Initialises the instructions array
33
- * @param array
34
- */
35
-void initialise_asm(instructions_array * array);
36
-
37
-//renvoie l'index (ou valeur?) de la premiere @ dispo
38
-/**
39
- * Fetch address of a temporary variable
40
- * @param table
41
- * @return first available temp address
42
- */
43
-int new_temp(Table_Symboles * table);
44
-
45
-/**
46
- * Adds intruction to instruction array
47
- * @param array
48
- * @param intru
49
- * @return 0 if instruction was added successfully, -1 if not
50
- */
51
-int add_instruction(instructions_array * array, instruction * intru);
52
-
53
-/**
54
- * Generates intruction with no parameter
55
- * @param array
56
- * @param op
57
- * @return
58
- */
59
-int generate_instruction_0(instructions_array * array, enum operation op);
60
-
61
-/**
62
- * Generates intruction with one parameter
63
- * @param array
64
- * @param op
65
- * @param arg1
66
- * @return
67
- */
68
-int generate_instruction_1(instructions_array * array, enum operation op, int arg1);
69
-
70
-/**
71
- * Generates intruction with two parameters
72
- * @param array
73
- * @param op
74
- * @param arg1
75
- * @param arg2
76
- * @return
77
- */
78
-int generate_instruction_2(instructions_array * array, enum operation op, int arg1, int arg2);
79
-
80
-/**
81
- * Generates intruction with three parameters
82
- * @param array
83
- * @param op
84
- * @param arg1
85
- * @param arg2
86
- * @param arg3
87
- * @return
88
- */
89
-int generate_instruction_3(instructions_array * array, enum operation op, int arg1, int arg2, int arg3);
90
-
91
-/**
92
- * Updates the JMF instruction with the correct jump destination address
93
- * @param array
94
- * @param instru_index
95
- * @param adr_jmp
96
- */
97
-void update_jmf(instructions_array * array, int instru_index, int adr_jmp);
98
-
99
-void update_jmp(instructions_array * array, int instru_index, int adr_jmp);
100
-
101
-
102
-
103
-
104
-void exportInstructions(instructions_array * array);
105
-
106
-/*
107
-void gen_arithmetique(instructions_array * array, enum operation op, int arg1, int arg2);
108
-
109
-int gen_var(Table_Symboles * table, instructions_array * array, char * varName);
110
-
111
-int gen_entier(Table_Symboles * table, instructions_array * array, int entier);
112
-
113
-int gen_return(Table_Symboles * table, instructions_array * array, int adr);
114
-
115
-int gen_jmpf(Table_Symboles * table, instructions_array * array, int cond, int dest);
116
-
117
-int gen_condition(Table_Symboles * table, instructions_array * array, enum operation op, int arg1, int arg2);
118
-
119
-int gen_print(Table_Symboles * table, instructions_array * array, int arg1);
120
- */
121
-#endif

+ 0
- 26
instructions.txt View File

@@ -1,26 +0,0 @@
1
-JMP 8
2
-COP 255 0
3
-COP_LD 255 [255]
4
-COP 1 255
5
-COP 255 1
6
-PRI 255
7
-AFC 255 1
8
-RET 255
9
-AFC 255 21
10
-COP 0 255
11
-LEA 255 0
12
-COP 1 255
13
-COP 255 1
14
-COP 5 255
15
-CALL 1 6
16
-COP 2 255
17
-COP 255 2
18
-PRI 255
19
-LEA 255 2
20
-COP 1 255
21
-AFC 255 2
22
-COP_STR [1] 255
23
-COP 255 2
24
-PRI 255
25
-AFC 255 0
26
-RET 255

BIN
interpreter/.DS_Store View File


BIN
interpreter/interpreter View File


+ 1
- 1
interpreter/makefile View File

@@ -8,7 +8,7 @@ interpreter: ./src/interpreter.y ./src/interpreter.l ./src/instructions.c
8 8
 	gcc lex.yy.c y.tab.c ./src/instructions.c -Isrc -o interpreter
9 9
 
10 10
 run: interpreter
11
-	./interpreter < input.txt
11
+	./interpreter < interpreter_input.txt
12 12
 
13 13
 clean:
14 14
 	rm -f lex.yy.c interpreter y.tab.h y.tab.c *.o

+ 0
- 22
script.sh View File

@@ -1,22 +0,0 @@
1
-bison -d -t analyse_syntaxique.y -v
2
-flex analyse_lexicale.lex 
3
-gcc -w *.c -ly
4
-echo "
5
-    int fonction1(int * a){
6
-      int b = *a;
7
-      printf(b);
8
-      return 1;
9
-    }
10
-
11
-    int main(){
12
-      int l = 21;
13
-      int * p = &l;
14
-      int c = fonction1(p);
15
-      printf(c);
16
-      p = &c;
17
-      *p = 2;
18
-      printf(c);
19
-
20
-      return 0;
21
-    }
22
-" | ./a.out

+ 0
- 59
table_fonctions.c View File

@@ -1,59 +0,0 @@
1
-#include "table_fonctions.h"
2
-#include <string.h>
3
-#include <stdio.h>
4
-
5
-void initialise_function_table(Table_Fonctions * table){
6
-    table->depth = 1;
7
-}
8
-
9
-void add_function(Table_Fonctions * table, char * function_name, enum Return_Type return_type, int start_addr){
10
-    Fonction fonction;
11
-    strcpy(fonction.function_name,function_name);
12
-    fonction.start_addr = start_addr;
13
-    fonction.type = return_type;
14
-    fonction.function_depth = table->depth;
15
-    table->array[table->depth] = fonction;
16
-    table->depth++;
17
-}
18
-
19
-void print_function(Fonction * fonction){
20
-    char * function_name = fonction->function_name;
21
-    int start_addr = fonction->start_addr;
22
-    int depth = fonction->function_depth;
23
-    int return_type = fonction->type;
24
-    char typeStr[20];
25
-    if (return_type == RET_INT){
26
-        strcpy(typeStr, "INT");
27
-    } else if (return_type == RET_INT_PTR){
28
-        strcpy(typeStr, "INT_PTR");
29
-    }
30
-    printf("%-20s\t\t %-12s\t\t %-12d\t %-12d\n", function_name, typeStr, start_addr, depth);
31
-}
32
-
33
-void print_fonction_table(Table_Fonctions * table) {
34
-    printf("%-20s\t\t %-12s\t\t %-12s\t %-20s\n", "Function Name", "Return Type", "Start Address", "Depth");
35
-    Fonction fonction;
36
-    for (int i = 1; i < table->depth; i++) {
37
-        fonction = table->array[i];
38
-        print_function(&fonction);
39
-    }
40
-}
41
-
42
-int function_exists(Table_Fonctions * table, char * func_name){
43
-    for (int i = 0; i < table->depth; i++){
44
-        if (strcmp(table->array[i].function_name, func_name) == 0){
45
-            return i;
46
-        }
47
-    }
48
-    return -1;
49
-}
50
-
51
-/*
52
-int main(){
53
-    Table_Fonctions table;
54
-    initialise_function_table(&table);
55
-    add_function(&table, "Fonction1", 0, 7);
56
-    add_function(&table, "Fonction2", 1, 23);
57
-    print_fonction_table(&table);
58
-    return 1;
59
-}*/

+ 0
- 35
table_fonctions.h View File

@@ -1,35 +0,0 @@
1
-//
2
-// Created by Nahom Belay on 29/04/2021.
3
-//
4
-
5
-#ifndef PROJET_SYSTEME_TABLE_FONCTIONS_H
6
-#define PROJET_SYSTEME_TABLE_FONCTIONS_H
7
-
8
-#define FUNCTION_TABLE_SIZE 50
9
-#define FUNCTION_NAME_SIZE 30
10
-
11
-enum Return_Type {RET_INT , RET_INT_PTR};
12
-
13
-typedef struct Fonction {
14
-    char function_name[FUNCTION_NAME_SIZE];
15
-    int start_addr ;
16
-    enum Return_Type type;
17
-    int function_depth;
18
-} Fonction;
19
-
20
-typedef struct Table_Fonctions {
21
-    Fonction array[FUNCTION_TABLE_SIZE];
22
-    int depth;
23
-} Table_Fonctions;
24
-
25
-void initialise_function_table(Table_Fonctions * table);
26
-
27
-void add_function(Table_Fonctions * table, char * function_name, enum Return_Type return_type, int start_addr);
28
-
29
-void print_fonction_table(Table_Fonctions * table);
30
-
31
-int function_exists(Table_Fonctions * table, char * func_name);
32
-
33
-
34
-
35
-#endif //PROJET_SYSTEME_TABLE_FONCTIONS_H

+ 0
- 152
table_symboles.c View File

@@ -1,152 +0,0 @@
1
-#include "table_symboles.h"
2
-#include <stdio.h>
3
-#include <string.h>
4
-
5
-
6
-void initialise_table(Table_Symboles * table){
7
-    table->indexAvailableBottom = TABLE_SIZE - 1;
8
-    table->indexAvailableTop = 0;
9
-    table->depth = 0;
10
-}
11
-
12
-int variable_exists(Table_Symboles * table, char * varName){
13
-    for (int i = 0; i < table->indexAvailableTop; i++){
14
-        if (strcmp(varName, table->array[i].Variable_Name) == 0){
15
-            return i;
16
-        }
17
-    }
18
-
19
-    for (int i = (table->indexAvailableBottom + 1); i < TABLE_SIZE; i++){
20
-        if (strcmp(varName, table->array[i].Variable_Name) == 0){
21
-            return i;
22
-        }
23
-    }
24
-    return 0;
25
-}
26
-int add_symbole_top(Table_Symboles * table, char * varName, enum Symbole_Type type, enum Initialised_Variable init, int depth){
27
-    Symbole symbole;
28
-    strcpy(symbole.Variable_Name, varName);
29
-    symbole.addr = table->indexAvailableTop;
30
-    symbole.init = init;
31
-    symbole.type = type;
32
-    symbole.symbole_depth = table->depth;
33
-    if (table->indexAvailableTop >= table->indexAvailableBottom){
34
-        return -1;
35
-    } else if (variable_exists(table, varName) != 0){
36
-        return -2;
37
-    } else {
38
-        table->array[table->indexAvailableTop] = symbole;
39
-        table->indexAvailableTop++;
40
-    }
41
-    return 0;
42
-}
43
-
44
-int add_symbole_bottom(Table_Symboles * table){
45
-    Symbole symbole;
46
-    symbole.addr = table->indexAvailableBottom;
47
-    //symbole.symbole_depth = -1;
48
-    if (table->indexAvailableTop >= table->indexAvailableBottom){
49
-        return -1;
50
-    } else {
51
-        table->array[table->indexAvailableBottom] = symbole;
52
-        table->indexAvailableBottom--;
53
-    }
54
-    return 0;
55
-}
56
-
57
-int remove_symboles(Table_Symboles * table){
58
-    if (table->indexAvailableTop > 0){
59
-        while(table->indexAvailableTop > 0){
60
-            if (table->array[table->indexAvailableTop-1].symbole_depth == table->depth){
61
-                table->indexAvailableTop--;
62
-            } else {
63
-                break;
64
-            }
65
-
66
-        }
67
-    }
68
-
69
-
70
-        //TODO: vérifier qu'il n'y a pas de varaibles temporarires au moment de changement de profondeur
71
-    return 0;
72
-}
73
-
74
-void free_temp(Table_Symboles * table){
75
-    table->indexAvailableBottom++;
76
-    if (table->indexAvailableBottom >= TABLE_SIZE){
77
-        printf("Huge error\n");
78
-        table->indexAvailableBottom--;
79
-    }
80
-}
81
-
82
-int prepare_function_call(Table_Symboles * table){
83
-    prepare_argument_push(table);
84
-    prepare_argument_push(table);
85
-}
86
-
87
-int prepare_argument_push(Table_Symboles * table){
88
-    Symbole symbole;
89
-    symbole.addr = table->indexAvailableTop;
90
-    symbole.symbole_depth = table->depth;
91
-    if (table->indexAvailableTop < table->indexAvailableBottom){
92
-        table->array[table->indexAvailableTop] = symbole;
93
-        table->indexAvailableTop++;
94
-        return (table->indexAvailableTop) - 1 ;
95
-    }
96
-
97
-}
98
-
99
-int initialise_symbole(Table_Symboles * table, char * varName){
100
-    int index = variable_exists(table, varName);
101
-    if (index == -1){
102
-        return -1;
103
-    } else {
104
-        table->array[index].init = INITIALISED;
105
-    }
106
-}
107
-
108
-void print_symbole(Symbole * symbole){
109
-    char * var = symbole->Variable_Name;
110
-    int addr = symbole->addr;
111
-    enum Symbole_Type type = symbole->type;
112
-    char typeStr[20];
113
-    if (type == TYPE_INT){
114
-        strcpy(typeStr, "INT");
115
-    } else if (type == TYPE_CONST_INT){
116
-        strcpy(typeStr, "CONST_INT");
117
-    } else if (type == TYPE_INT_PTR) {
118
-        strcpy(typeStr, "INT_PTR");
119
-    } else {
120
-        strcpy(typeStr, "Error type");
121
-    }
122
-    enum Initialised_Variable init = symbole->init;
123
-    char initStr[20];
124
-    if (init == INITIALISED){
125
-        strcpy(initStr,"INITIALISED");
126
-    } else{
127
-        strcpy(initStr,"NOT_INITIALISED");
128
-    }
129
-    int depth = symbole->symbole_depth;
130
-    printf("%-20s\t\t %-12s\t\t %-12d\t %-20s\t %-12d\n", var, typeStr, addr, initStr, depth);
131
-}
132
-
133
-void print_table(Table_Symboles * table){
134
-    printf("%-20s\t\t %-12s\t\t %-12s\t %-20s\t %-12s\n", "Variable Name", "Type", "Address", "Initialised", "Depth");
135
-    int indexTop = table->indexAvailableTop;
136
-    int indexBottom = table->indexAvailableBottom;
137
-    Symbole symbole;
138
-    for (int i = 0; i < indexTop; i++){
139
-        symbole = table->array[i];
140
-        print_symbole(&symbole);
141
-    }
142
-    if (table->indexAvailableBottom != TABLE_SIZE - 1){
143
-        printf("%-20s\t\t %-12s\t\t %-12s\t %-20s\t %-12s\n", "...", "...", "...", "...", "...");
144
-        for (int i = (indexBottom + 1); i < TABLE_SIZE; i++){
145
-            symbole = table->array[i];
146
-            print_symbole(&symbole);
147
-        }
148
-    }
149
-
150
-    
151
-
152
-}

+ 0
- 95
table_symboles.h View File

@@ -1,95 +0,0 @@
1
-#ifndef TABLE_SYMBOLES_H
2
-#define TABLE_SYMBOLES_H
3
-
4
-#define TABLE_SIZE 256
5
-#define VARIABLE_SIZE 30
6
-
7
-enum Symbole_Type {TYPE_INT , TYPE_CONST_INT, TYPE_INT_PTR};
8
-enum Initialised_Variable{INITIALISED , NOT_INITIALISED};
9
-
10
-typedef struct Symboles {
11
-    char Variable_Name[VARIABLE_SIZE];
12
-    int addr ;
13
-    enum Symbole_Type type;
14
-    enum Initialised_Variable init;
15
-    int symbole_depth;
16
-} Symbole;
17
-
18
-typedef struct Table_Symboles {
19
-    Symbole array[TABLE_SIZE];
20
-    int indexAvailableTop;
21
-    int indexAvailableBottom;
22
-    int depth;
23
-} Table_Symboles;
24
-
25
-/**
26
- * Initialises indexAvailableTop at 0 and indexAvailableBottom at TABLE_SIZE - 1
27
- * @param table
28
- */
29
-void initialise_table(Table_Symboles * table);
30
-
31
-/**
32
- * Adds a symbole at the top (regular varaibles)
33
- * @param table
34
- * @param varName
35
- * @param type
36
- * @param init
37
- * @return if symbole added successfully, -1 if the table is full and -2 if the varaible already exists in the table
38
- */
39
-int add_symbole_top(Table_Symboles * table, char * varName, enum Symbole_Type type , enum Initialised_Variable init, int depth);
40
-
41
-/**
42
- * Adds a symbole at the bottom (temp variables)
43
- * @param table
44
- * @return 0 if symbole added successfully, -1 if the table is full and -2 if the varaible already exists in the table
45
- */
46
-int add_symbole_bottom(Table_Symboles * table);
47
-
48
-
49
-
50
-/**
51
- * Verifies if a varaible name is already present in the table to avoid duplicates
52
- * @param table
53
- * @param varName
54
- * @return -1 if the varaible name exists, 0 if it doesn't
55
- */
56
-int variable_exists(Table_Symboles * table, char * varName);
57
-
58
-/**
59
- * Removes symbole from table having certain depth
60
- * @param table
61
- * @return -1 if the symbole isn't in the table, 0 otherwise
62
- */
63
-int remove_symboles(Table_Symboles * table);
64
-
65
-
66
-void free_temp(Table_Symboles * table);
67
-
68
-int prepare_function_call(Table_Symboles * table);
69
-
70
-int prepare_argument_push(Table_Symboles * table);
71
-
72
-
73
-/**
74
- * Initialises an already exisiting symbole
75
- * @param table
76
- * @param varName
77
- * @return -1 if the symbole isn't in the table, 0 otherwise
78
- */
79
-int initialise_symbole(Table_Symboles * table, char * varName);
80
-
81
-
82
-/**
83
- * Prints a symbole with this format
84
- * varName      | Type  | Address   | Initialised/Not_Initialised
85
- * @param symbole
86
- */
87
-void print_symbole(Symbole * symbole);
88
-
89
-/**
90
- * Prints the table
91
- * @param table
92
- */
93
-void print_table(Table_Symboles * table);
94
-
95
-#endif

+ 0
- 16
test_file View File

@@ -1,16 +0,0 @@
1
-int fonction1(int * a){
2
-      int b = *a;
3
-      printf(b);
4
-      return 1;
5
-    }
6
-
7
-int main(){
8
-  int l = 21;
9
-  int * p = &l;
10
-  int c = fonction1(p);
11
-  printf(c);
12
-  p = &c;
13
-  *p = 2;
14
-  printf(c);
15
-
16
-  return 0;

BIN
xilinx/.DS_Store View File


Loading…
Cancel
Save