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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
/* Chrysalide - Outil d'analyse de fichiers binaires
* variable.h - prototypes pour la manipulation des variables en tout genre
*
* Copyright (C) 2009-2012 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Foobar. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANALYSIS_VARIABLE_H
#define _ANALYSIS_VARIABLE_H
#include <stdbool.h>
#include <glib-object.h>
#include "types/basic.h"
#include "types/encaps.h"
/* ------------------- ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION ------------------- */
#define G_TYPE_BIN_VARIABLE g_binary_variable_get_type()
#define G_BINARY_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_variable_get_type(), GBinVariable))
#define G_IS_BIN_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_variable_get_type()))
#define G_BINARY_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BIN_VARIABLE, GBinVariableClass))
#define G_IS_BIN_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BIN_VARIABLE))
#define G_BINARY_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BIN_VARIABLE, GBinVariableClass))
/* Base de variable (instance) */
typedef struct _GBinVariable GBinVariable;
/* Base de variable (classe) */
typedef struct _GBinVariableClass GBinVariableClass;
/* Indique le type défini pour une base de variable. */
GType g_binary_variable_get_type(void);
/* Crée une représentation de variable de type donné. */
GBinVariable *g_binary_variable_new(GDataType *);
/* Fournit le type d'une variable donnée. */
GDataType *g_binary_variable_get_vtype(const GBinVariable *);
/* Fournit le nom d'une variable donnée. */
const char *g_binary_variable_get_name(const GBinVariable *);
/* Définit le nom d'une variable donnée. */
void g_binary_variable_set_name(GBinVariable *, const char *);
/* Fournit la zone d'appartenance d'une variable donnée. */
GDataType *g_binary_variable_get_owner(const GBinVariable *);
/* Définit la zone d'appartenance d'une variable donnée. */
void g_binary_variable_set_owner(GBinVariable *, GDataType *);
/* Décrit la variable donnée sous forme de caractères. */
char *g_binary_variable_to_string(const GBinVariable *, bool);
/* Procède à l'impression de la description d'une variable. */
//void g_binary_variable_output(const GBinVariable *, GLangOutput *, GBufferLine *, bool, bool);
/* -------------------- BASE DE VARIABLES OU VARIABLES INCONNUES -------------------- */
#define G_TYPE_UNKNOWN_VARIABLE g_unknown_variable_get_type()
#define G_UNKNOWN_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_unknown_variable_get_type(), GUnknownVariable))
#define G_IS_UNKNOWN_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_unknown_variable_get_type()))
#define G_UNKNOWN_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_UNKNOWN_VARIABLE, GUnknownVariableClass))
#define G_IS_UNKNOWN_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_UNKNOWN_VARIABLE))
#define G_UNKNOWN_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_UNKNOWN_VARIABLE, GUnknownVariableClass))
/* Base de variable (instance) */
typedef struct _GUnknownVariable GUnknownVariable;
/* Base de variable (classe) */
typedef struct _GUnknownVariableClass GUnknownVariableClass;
/* Indique le type défini pour une base de variable. */
GType g_unknown_variable_get_type(void);
/* Crée une représentation de variable de type inconnu. */
GUnknownVariable *g_unknown_variable_new(void);
/* Etablit la comparaison ascendante entre deux variables. */
int g_unknown_variable_compare(const GUnknownVariable **, const GUnknownVariable **);
/* Définit la position associée à une variable. */
void g_unknown_variable_set_offset(GUnknownVariable *, size_t);
/* Fournit la position associée à une variable. */
size_t g_unknown_variable_get_offset(const GUnknownVariable *);
/* Indique si une position est contenue dans une variable. */
bool g_unknown_variable_contains_offset(const GUnknownVariable *, size_t);
/* Variable repésentant un argument ou un type de retour */
typedef struct _variable variable;
/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */
/* Liste des types de base existants */
#if 0
typedef enum _BaseType
{
BTP_VOID, /* void */
BTP_WCHAR_T, /* wchar_t */
BTP_BOOL, /* bool */
BTP_CHAR, /* char */
BTP_SCHAR, /* signed char */
BTP_UCHAR, /* unsigned char */
BTP_SHORT, /* short */
BTP_USHORT, /* unsigned short */
BTP_INT, /* int */
BTP_UINT, /* unsigned int */
BTP_LONG, /* long */
BTP_ULONG, /* unsigned long */
BTP_LONG_LONG, /* long long, __int64 */
BTP_ULONG_LONG, /* unsigned long long, __int64 */
BTP_INT128, /* __int128 */
BTP_UINT128, /* unsigned __int128 */
BTP_FLOAT, /* float */
BTP_DOUBLE, /* double */
BTP_LONG_DOUBLE, /* long double, __float80 */
BTP_FLOAT128, /* __float128 */
BTP_ELLIPSIS, /* ... */
BTP_754R_64, /* IEEE 754r float (64 bits) */
BTP_754R_128, /* IEEE 754r float (128 bits) */
BTP_754R_32, /* IEEE 754r float (32 bits) */
BTP_754R_16, /* IEEE 754r float (16 bits) */
BTP_CHAR32_T, /* char32_t */
BTP_CHAR16_T, /* char16_t */
BTP_OTHER /* Extension utilisateur */
} BaseType;
#endif
/* Variable repésentant un argument ou un type de retour */
typedef struct _simple_variable simple_variable;
/* Crée une représentation de variable. */
simple_variable *create_simple_var(void);
/* Crée une représentation de variable à type connu. */
simple_variable *create_typed_simple_var(BaseType);
/* Définit le type d'une variable simple. */
void set_simple_var_type(simple_variable *, BaseType);
/* --------------------- ENCAPSULATIONS DES VARIABLES COMPLEXES --------------------- */
/* Représentation d'une variable complexe */
typedef struct _complex_variable complex_variable;
#define COMPLEX_VAR(v) ((complex_variable *)v)
/* ---------------------- VARIABLES DE CLASSES ET ENUMERATIONS ---------------------- */
/* Type de ces variables */
#if 0
typedef enum _ClassEnumType
{
CET_UNKNOWN, /* Statut inconnu */
CET_STRUCT, /* Structure */
CET_ENUM, /* Enumération */
CET_CLASS /* Classe */
} ClassEnumType;
#endif
/* Représentation des classes et des énumérations */
typedef struct _class_enum_variable class_enum_variable;
/* Crée une représentation de variable de classe/enumération. */
complex_variable *create_class_enum_var(char *);
/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
/* Cas d'encapsulation possibles */
#if 0
typedef enum _EncapsulationType
{
ECT_POINTER, /* Pointeur */
ECT_REFERENCE, /* Référence */
ECT_RVALUE_REF, /* Référence ?? (C++0x) */
ECT_COMPLEX, /* Complexe (C 2000) */
ECT_IMAGINARY /* Imaginaire (C 2000) */
} EncapsulationType;
#endif
/* Représentation des variables dérivées */
typedef struct _encapsulated_variable encapsulated_variable;
/* Crée une représentation de variable dérivée. */
complex_variable *create_encapsulated_var(EncapsulationType, variable *);
/* ---------------------- MANIPULATION GENERIQUE DES VARIABLES ---------------------- */
/* Qualificatifs de variables */
typedef enum _VariableQualifier
{
VQF_RESTRICT = (1 << 0), /* restrict (C99) */
VQF_VOLATILE = (1 << 1), /* volatile */
VQF_CONST = (1 << 2) /* const */
} VariableQualifier;
/* Crée une représentation de variable (simple). */
variable *create_var_from_simple_one(simple_variable *);
/* Crée une représentation de variable (complexe). */
variable *create_var_from_complex_one(complex_variable *);
/* Supprime la représentation de variable de la mémoire. */
void delete_var(variable *);
/* Ajoute un qualificatif à la variable. */
void add_qualifier_to_var(variable *, VariableQualifier);
/* Décrit la variable sous forme de caractères. */
char *var_to_string(const variable *);
#endif /* _ANALYSIS_VARIABLE_H */
|
