CompilationProject/code.h at master · minh-n/CompilationProject · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
#ifndef YY_YY_CODE_H_INCLUDED
# define YY_YY_CODE_H_INCLUDED

#include <stdlib.h>


/*void generateur(TreeP tree);*/
void listeSymboles();


InstanceP makeInstance(VarDeclP var);
InstanceP makeInstance2(char *nom,ClasseP type);
void addInstance(InstanceP ins);
int adresse(char *id);
int tailleListeArbre(TreeP t);


void codeLInstr(TreeP tree);
void codeInstr(TreeP tree);
void codeEnvoi(TreeP tree);
void codeConstructeur(TreeP tree);
void codeConstructeurVersionStructure(ClasseP classe);

void codeExpr(TreeP tree);
void codeSelec(TreeP tree);
void codeAff();
void codeBloc(TreeP bloc);


void codeBlocObj(TreeP tree);
void codeDeclChampMethode(TreeP tree);
void codeLDeclChamp(TreeP tree);
void codeLDeclChampStructure(LVarDeclP lChamps);
void codeDeclChampStructure(VarDeclP Champ);
void codeObj(ClasseP classe);
void codeDeclChamp(TreeP tree);
void codeDeclMethode(MethodeP methode);
bool codePrint(TreeP expr, TreeP methodeC);

void codeClasse(ClasseP classe);
void genCode(TreeP LClasse, TreeP Bloc);
void codeITE(TreeP tree);

int getTailleListeMethode(LMethodeP liste);
void codeTV();
void codeToString();

VarDeclP getVarDeclFromName(char *name);
MethodeP getMethodeFromName(ClasseP classe, char *name);
int getOffset(ClasseP classe, char *idNom);
InstanceP getInstFromName(char *name);


/* Fonctions servant à la génération de code
 * pour la machine virtuelle
 */
void NOP();

/*ERR str, START, STOP*/
void PUSHI(int i);
void PUSHS(char *c);
void PUSHG(int a);
void PUSHL(int a);

/*PUSHSP, PUSHFP*/
void STOREL(int x);
void STOREG(int x);
void PUSHN(int x);
void POPN(int x);
void DUPN(int x);
void SWAP();
void EQUAL();
void NOT();
void JUMP(char* label);
void JZ(char* label);
void PUSHA(char* a);
void CALL();

void CRETURN();
void CADD();
void CMUL();
void CSUB();
void CDIV();
void CINF();
void CINFEQ();
void CSUP();
void CSUPEQ();
void WRITEI();
void WRITES();
void CCONCAT();
void STORE(int x);
void LOAD(int x);
void ALLOC(int x);


/*OK A PARTIR D'ICI C'EST DE L'EXPERIMENTAL.mp4*/


/**
 *La table des symboles est une structure de données
 *qui est utilisée tout au long de la compilation. Son
 *rôle est de mémoriser toutes les informations qu’on
 *peut associer à un identificateur : est-ce un
 *identificateur de type, de variable, de constante,
 *de sous-programme ? Si c’est une variable, est-elle
 *locale, globale ? Est-ce un paramètre ? On y stockera aussi
 *la taille en mots mémoire de l’objet référencé par
 *cet identificateur, son adresse de début (ou le méca-
 *nisme d’adressage associé) et toute autre information
 *qui permettra d’engendrer du code plus facilement.
 */


typedef struct _unSymbole{

  /*typeIdent type;*/

  TreeP tree;

  int adresse;    /*nécessaire ?*/

  struct _elemPile* suiv;

  int offset;     /*decalage par rapport a FP*/

} unSymbole, *unSymboleP;


/*contenu d'un elem de la pile
typedef struct _contenuPile{

} contenuPile, *contenuPileP;*/


/*conteneur de la pile de symboles*/
typedef struct _Pile{

  int taille;
  unSymboleP sommet;

} Pile, *PileP;


/*
table des symboles :
addSymbole(Ident x)
  declVar symboleX
  symboleX->name = x.lexval
  symboleX->adresse = offset +1;
  taillePile += 1;
getAddre()
for taille pile
  if adresse
    return
return adresse de x
*/


#endif /* !YY_YY_CODE_H_INCLUDED */