summaryrefslogtreecommitdiff
path: root/src/analysis/variable.h
blob: 8b50cf4c919ed2adcd9b14b756798ad191d30fd7 (plain)
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

/* OpenIDA - Outil d'analyse de fichiers binaires
 * variable.h - prototypes pour la manipulation des variables en tout genre
 *
 * Copyright (C) 2008 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  OpenIDA 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.
 *
 *  OpenIDA 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



/* Variable repésentant un argument ou un type de retour */
typedef struct _variable variable;



/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */


/* Liste des types de base existants */
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;



/* 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 */
typedef enum _ClassEnumType
{
    CET_UNKNOWN,                            /* Statut inconnu              */
    CET_STRUCT,                             /* Structure                   */
    CET_ENUM,                               /* Enumération                 */
    CET_CLASS                               /* Classe                      */

} ClassEnumType;


/* 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 */
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;


/* 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 */