Added a partial support of the Itanium C++ ABI mangling.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@52 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 176 insertions, 0 deletions

diff --git a/src/analysis/variable.h b/src/analysis/variable.h
new file mode 100644
index 0000000..8b50cf4
--- /dev/null
+++ b/src/analysis/variable.h
@@ -0,0 +1,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 */