Improved the Itanium demangler.

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

7 files changed, 1981 insertions, 26 deletions

diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index d7f0f0e..3c22aa6 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -12,6 +12,7 @@ libanalysis_la_SOURCES =				\
 	line_prologue.h line_prologue.c		\
 	roptions.h roptions.c				\
 	routine.h routine.c					\
+	type.h type.c						\
 	variable.h variable.c
 
 libanalysis_la_LDFLAGS = 
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 4bbd712..cfa7cd5 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -43,17 +43,15 @@ struct _GBinRoutine
 
     RoutineType type;                       /* Type de routine             */
 
-    variable *ret_type;                     /* Type retourné               */
+    GOpenidaType *ret_type;                 /* Type retourné               */
 
     char *name;                             /* Désignation humaine         */
+    GOpenidaType *full_name;                /* Désignation très complète   */
 
-    variable **args_types;                  /* Types d'arguments           */
-    size_t old_args_count;                      /* Nombre d'arguments          */
-
-    GUnknownVariable **args;                /* Arguments de la routines    */
+    GBinVariable **args;                    /* Arguments de la routines    */
     size_t args_count;                      /* Nombre d'arguments          */
 
-    GUnknownVariable **locals;              /* Variables locales du code   */
+    GBinVariable **locals;                  /* Variables locales du code   */
     size_t locals_count;                    /* Nombre de variables locales */
 
 };
@@ -356,6 +354,9 @@ void g_binary_routine_set_name(GBinRoutine *routine, char *name)
 
 const char *g_binary_routine_get_name(const GBinRoutine *routine)
 {
+    if (routine->name == NULL && routine->full_name != NULL)
+        g_binary_routine_set_name(routine, g_openida_type_to_string(routine->full_name));
+
     return routine->name;
 
 }
@@ -364,7 +365,49 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : routine = routine à mettre à jour.                           *
-*                var     = variable représentant un type de retour.           *
+*                type    = désignation complète du nom de la routine.         *
+*                                                                             *
+*  Description : Définit de façon indirecte le nom humain d'une routine.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *type)
+{
+    if (routine->full_name != NULL)
+         g_object_unref(G_OBJECT(routine->full_name));
+
+    routine->full_name = type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à consulter.                               *
+*                                                                             *
+*  Description : Fournit le type construisant le nom humain d'une routine.    *
+*                                                                             *
+*  Retour      : Eventuel type à l'origine du nom ou NULL.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
+{
+    return routine->full_name;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à mettre à jour.                           *
+*                type    = indication sur le type de retour.                  *
 *                                                                             *
 *  Description : Définit le type de retour d'une routine.                     *
 *                                                                             *
@@ -374,12 +417,13 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_routine_set_return_type(GBinRoutine *routine, variable *var)
+void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
 {
     if (routine->ret_type != NULL)
-        delete_var(routine->ret_type);
+        g_object_unref(G_OBJECT(routine->ret_type));
 
-    routine->ret_type = var;
+    routine->ret_type = type;
+    g_object_ref(G_OBJECT(type));
 
 }
 
@@ -397,14 +441,14 @@ void g_binary_routine_set_return_type(GBinRoutine *routine, variable *var)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_routine_add_arg(GBinRoutine *routine, variable *var)
+void g_binary_routine_add_arg(GBinRoutine *routine, GBinVariable *var)
 {
-    routine->old_args_count++;
+    routine->args_count++;
 
-    routine->args_types = (variable **)realloc(routine->args_types,
-                                               routine->old_args_count * sizeof(variable *));
+    routine->args = (GBinVariable **)realloc(routine->args,
+                                             routine->args_count * sizeof(GBinVariable *));
 
-    routine->args_types[routine->old_args_count - 1] = var;
+    routine->args[routine->args_count - 1] = var;
 
 }
 
@@ -425,6 +469,7 @@ void g_binary_routine_add_arg(GBinRoutine *routine, variable *var)
 
 void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bool local)
 {
+#if 0 /* FIXME */
     GUnknownVariable ***list;               /* Liste à manipuler           */
     size_t *count;                          /* Taille de la liste          */
     bool found;                             /* Indication de présence      */
@@ -464,7 +509,7 @@ void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bo
 
 
     }
-
+#endif
 }
 
 
@@ -484,6 +529,7 @@ void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bo
 
 size_t g_binary_routine_get_var_index_from_offset(const GBinRoutine *routine, size_t offset, bool local)
 {
+#if 0 /* FIXME */
     size_t result;                          /* Indice à renvoyer           */
     GUnknownVariable ***list;               /* Liste à manipuler           */
     size_t *count;                          /* Taille de la liste          */
@@ -507,6 +553,9 @@ size_t g_binary_routine_get_var_index_from_offset(const GBinRoutine *routine, si
             result = i;
 
     return result;
+#endif
+
+    return SIZE_MAX;
 
 }
 
@@ -534,12 +583,12 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
     switch (routine->type)
     {
         case RTT_CONSTRUCTOR:
-            result = strdup(routine->name);
+            result = strdup(g_binary_routine_get_name(routine));
             result = stradd(result, "::");
             break;
 
         case RTT_DESTRUCTOR:
-            result = strdup(routine->name);
+            result = strdup(g_binary_routine_get_name(routine));
             result = stradd(result, "::~");
             break;
 
@@ -548,8 +597,9 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
             if (routine->ret_type == NULL) result = strdup("??? ");
             else
             {
-                result = var_to_string(routine->ret_type);
-                result = stradd(result, " ");
+                result = g_openida_type_to_string(routine->ret_type);
+                if (!g_openida_type_is_pointer(routine->ret_type, true))
+                    result = stradd(result, " ");
             }
             break;
 
@@ -557,17 +607,17 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
 
     /* Nom de la routine */
 
-    result = stradd(result, routine->name);
+    result = stradd(result, g_binary_routine_get_name(routine));
 
     /* Liste des arguments */
 
     result = stradd(result, "(");
 
-    for (i = 0; i < routine->old_args_count; i++)
+    for (i = 0; i < routine->args_count; i++)
     {
         if (i > 0) result = stradd(result, ", ");
 
-        typestr = var_to_string(routine->args_types[i]);
+        typestr = g_binary_variable_to_string(routine->args[i]);
         result = stradd(result, typestr);
         free(typestr);
 
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 4e47b5e..1a2b493 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -91,11 +91,17 @@ void g_binary_routine_set_name(GBinRoutine *, char *);
 /* Désignation humainement lisible ou NULL si non définie. */
 const char *g_binary_routine_get_name(const GBinRoutine *);
 
+/* Définit de façon indirecte le nom humain d'une routine. */
+void g_binary_routine_set_name_from_type(GBinRoutine *, GOpenidaType *);
+
+/* Fournit le type construisant le nom humain d'une routine. */
+const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
+
 /* Définit le type de retour d'une routine. */
-void g_binary_routine_set_return_type(GBinRoutine *, variable *);
+void g_binary_routine_set_return_type(GBinRoutine *, GOpenidaType *);
 
 /* Ajoute un argument à une routine. */
-void g_binary_routine_add_arg(GBinRoutine *, variable *);
+void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
 
 /* S'assure qu'une variable est bien associée à une routine. */
 void g_binary_routine_register_if_needed(GBinRoutine *, size_t, bool);
diff --git a/src/analysis/type.c b/src/analysis/type.c
new file mode 100644
index 0000000..c113499
--- /dev/null
+++ b/src/analysis/type.c
@@ -0,0 +1,1377 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * variable.h - prototypes pour la manipulation des variables en tout genre
+ *
+ * Copyright (C) 2009 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/>.
+ */
+
+
+#include "type.h"
+
+
+#include <malloc.h>
+#include <stdarg.h>
+#include <string.h>
+
+
+#include "routine.h"
+#include "../common/extstr.h"
+
+
+
+/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
+
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef GOpenidaType * (* type_dup_fc) (const GOpenidaType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef char * (* type_to_string_fc) (const GOpenidaType *);
+
+
+/* Description de type quelconque (instance) */
+struct _GOpenidaType
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    type_dup_fc dup;                        /* Copie d'instance existante  */
+    type_to_string_fc to_string;            /* Conversion au format texte  */
+
+    TypeQualifier qualifiers;               /* Eventuels qualificatifs     */
+
+    GTypesManager *manager;                 /* Gestionnaire global         */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GOpenidaTypeClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types quelconques. */
+static void g_openida_type_class_init(GOpenidaTypeClass *);
+
+/* Initialise l'instance d'un type quelconque. */
+static void g_openida_type_init(GOpenidaType *);
+
+
+
+/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */
+
+
+/* Description de type basique (instance) */
+struct _GBasicType
+{
+    GOpenidaType parent;                    /* A laisser en premier        */
+
+    BaseType type;                          /* Type représenté si connu    */
+
+};
+
+/* Description de type basique (classe) */
+struct _GBasicTypeClass
+{
+    GOpenidaTypeClass parent;               /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types basiques. */
+static void g_basic_type_class_init(GBasicTypeClass *);
+
+/* Initialise l'instance d'un type basique. */
+static void g_basic_type_init(GBasicType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_basic_type_dup(const GBasicType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_basic_type_to_string(const GBasicType *);
+
+
+
+/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
+
+
+/* Description de type encapsulé (instance) */
+struct _GEncapsulatedType
+{
+    GOpenidaType parent;                    /* A laisser en premier        */
+
+    EncapsulationType type;                 /* Encapsulation utilisée      */
+    GOpenidaType *child;                    /* Sous-type encadré           */
+    GBinRoutine *routine;                   /* Routine pointée             */
+
+};
+
+/* Description de type encapsulé (classe) */
+struct _GEncapsulatedTypeClass
+{
+    GOpenidaTypeClass parent;               /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types encapsulés. */
+static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *);
+
+/* Initialise l'instance d'un type encapsulé. */
+static void g_encapsulated_type_init(GEncapsulatedType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_encapsulated_type_dup(const GEncapsulatedType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *);
+
+
+
+/* ---------------------- CLASSES / STRUCTURES ET ENUMERATIONS ---------------------- */
+
+
+/* Description de type classe/structure et enumeration (instance) */
+struct _GClassEnumType
+{
+    GOpenidaType parent;                    /* A laisser en premier        */
+
+    ClassEnumType type;                     /* Type représenté si connu    */
+    char *name;                             /* Description humaine         */
+
+};
+
+/* Description de type classe/structure et enumeration (classe) */
+struct _GClassEnumTypeClass
+{
+    GOpenidaTypeClass parent;               /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types classe ou assimilés. */
+static void g_class_enum_type_class_init(GClassEnumTypeClass *);
+
+/* Initialise l'instance d'un type classe ou assimilé. */
+static void g_class_enum_type_init(GClassEnumType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_class_enum_type_dup(const GClassEnumType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_class_enum_type_to_string(const GClassEnumType *);
+
+
+
+/* ----------------------- ELEMENTS REPOSANT SUR DES GABARITS ----------------------- */
+
+
+/* Description de type reposant sur des gabarits (instance) */
+struct _GTemplateType
+{
+    GClassEnumType parent;                  /* A laisser en premier        */
+
+    GOpenidaType **models;                  /* Sous-types associés         */
+    size_t models_count;                    /* Quantité de ces modèles     */
+
+};
+
+/* Description de type reposant sur des gabarits (classe) */
+struct _GTemplateTypeClass
+{
+    GClassEnumTypeClass parent;             /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types reposant sur des gabarits. */
+static void g_template_type_class_init(GTemplateTypeClass *);
+
+/* Initialise l'instance d'un type reposant sur des gabarits. */
+static void g_template_type_init(GTemplateType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_template_type_dup(const GTemplateType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_template_type_to_string(const GTemplateType *);
+
+
+
+/* ---------------------- VALEUR LITERALE DES TYPES INSTANCIES ---------------------- */
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+struct _GLiteralType
+{
+    GOpenidaType parent;                    /* A laisser en premier        */
+
+    GOpenidaType *orig;                     /* Type instancié              */
+    literal_value value;                    /* Valeur d'instance           */
+
+};
+
+/* Description de type instancié avec une valeur litérale (classe) */
+struct _GLiteralTypeClass
+{
+    GOpenidaTypeClass parent;               /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des types instanciés avec des valeurs. */
+static void g_literal_type_class_init(GLiteralTypeClass *);
+
+/* Initialise l'instance d'un type instancié avec une valeur. */
+static void g_literal_type_init(GLiteralType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_literal_type_dup(const GLiteralType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_literal_type_to_string(const GLiteralType *);
+
+
+
+/* -------------------------- COLLECTE ET GESTION DE TYPES -------------------------- */
+
+
+/* Description de type quelconque (instance) */
+struct _GTypesManager
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    MemoryDataSize wdsize;                  /* Taille d'un mot en octet    */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GTypesManagerClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des gestionnaires de types. */
+static void g_types_manager_class_init(GTypesManagerClass *);
+
+/* Initialise l'instance d'un gestionnaire de types. */
+static void g_types_manager_init(GTypesManager *manager);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          REPRESENTATION INTERNE DES TYPES                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type quelconque. */
+G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types quelconques.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_openida_type_class_init(GOpenidaTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type quelconque.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_openida_type_init(GOpenidaType *type)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
+{
+    return type->dup(type);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_openida_type_to_string(const GOpenidaType *type)
+{
+    char *result;                           /* Chaîne à retourner          */
+
+    result = type->to_string(type);
+
+    if (type->qualifiers & TQF_RESTRICT)
+        strprep(result, "restrict ");
+
+    if (type->qualifiers & TQF_VOLATILE)
+        strprep(result, "volatile ");
+
+    if (type->qualifiers & TQF_CONST)
+        strprep(result, "const ");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type      = instance à mettre à jour.                        *
+*                qualifier = nouveau qualificatif pour la variable.           *
+*                                                                             *
+*  Description : Ajoute un qualificatif à une instance de type.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
+{
+    type->qualifiers |= qualifier;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à analyser.                                      *
+*                large = doit-on aussi inclure les types 'référence' ?        *
+*                                                                             *
+*  Description : Indique la terminaison de la représentation du type.         *
+*                                                                             *
+*  Retour      : true ou false, selon le type fourni.                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = G_IS_ENCAPSULATED_TYPE(type);
+
+    if (result)
+        switch (G_ENCAPSULATED_TYPE(type)->type)
+        {
+            case ECT_POINTER:
+                result = true;
+                break;
+            case ECT_REFERENCE:
+            case ECT_RVALUE_REF:
+                result = large;
+                break;
+            default:
+                result = false;
+                break;
+        }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                              TYPES DE DONNEES SIMPLES                              */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type basique. */
+G_DEFINE_TYPE(GBasicType, g_basic_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types basiques.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_basic_type_class_init(GBasicTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type basique.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_basic_type_init(GBasicType *type)
+{
+    GOpenidaType *oida_type;                /* Version basique             */
+
+    oida_type = G_OPENIDA_TYPE(type);
+
+    oida_type->dup = (type_dup_fc)g_basic_type_dup;
+    oida_type->to_string = (type_to_string_fc)g_basic_type_to_string;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type simple à représenter.                            *
+*                                                                             *
+*  Description : Crée une représentation de type basique.                     *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_basic_type_new(BaseType type)
+{
+    GBasicType *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_BASIC_TYPE, NULL);
+
+    result->type = type;
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GOpenidaType *g_basic_type_dup(const GBasicType *type)
+{
+    return g_basic_type_new(type->type);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_basic_type_to_string(const GBasicType *type)
+{
+    const char *desc;                       /* Représentation à copier     */
+
+    switch (type->type)
+    {
+        case BTP_VOID:
+            desc = "void";
+            break;
+
+        case BTP_WCHAR_T:
+            desc = "wchar_t";
+            break;
+
+        case BTP_BOOL:
+            desc = "bool";
+            break;
+
+        case BTP_CHAR:
+            desc = "char";
+            break;
+
+        case BTP_SCHAR:
+            desc = "signed char";
+            break;
+
+        case BTP_UCHAR:
+            desc = "unsigned char";
+            break;
+
+        case BTP_SHORT:
+            desc = "short";
+            break;
+
+        case BTP_USHORT:
+            desc = "unsigned short";
+            break;
+
+        case BTP_INT:
+            desc = "int";
+            break;
+
+        case BTP_UINT:
+            desc = "unsigned int";
+            break;
+
+        case BTP_LONG:
+            desc = "long";
+            break;
+
+        case BTP_ULONG:
+            desc = "unsigned long";
+            break;
+
+        case BTP_LONG_LONG:
+            desc = "long long";
+            break;
+
+        case BTP_ULONG_LONG:
+            desc = "unsigned long long";
+            break;
+
+        case BTP_INT128:
+            desc = "__int128";
+            break;
+
+        case BTP_UINT128:
+            desc = "unsigned __int128";
+            break;
+
+        case BTP_FLOAT:
+            desc = "float";
+            break;
+
+        case BTP_DOUBLE:
+            desc = "double";
+            break;
+
+        case BTP_LONG_DOUBLE:
+            desc = "long double";
+            break;
+
+        case BTP_FLOAT128:
+            desc = "__float128";
+            break;
+
+        case BTP_ELLIPSIS:
+            desc = "...";
+            break;
+
+        case BTP_754R_64:
+            desc = "__float754r_64";
+            break;
+
+        case BTP_754R_128:
+            desc = "__float754r_128";
+            break;
+
+        case BTP_754R_32:
+            desc = "__float754r_32";
+            break;
+
+        case BTP_754R_16:
+            desc = "__float754r_16";
+            break;
+
+        case BTP_CHAR32_T:
+            desc = "char32_t";
+            break;
+
+        case BTP_CHAR16_T:
+            desc = "char16_t";
+            break;
+
+        default:
+        case BTP_OTHER:
+            desc = "user";
+            break;
+
+    }
+
+    return strdup(desc);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            VARIABLES DEPENDANT D'AUTRES                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type encapsulé. */
+G_DEFINE_TYPE(GEncapsulatedType, g_encapsulated_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types encapsulés.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type encapsulé.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_encapsulated_type_init(GEncapsulatedType *type)
+{
+    GOpenidaType *oida_type;                /* Version basique             */
+
+    oida_type = G_OPENIDA_TYPE(type);
+
+    oida_type->dup = (type_dup_fc)g_encapsulated_type_dup;
+    oida_type->to_string = (type_to_string_fc)g_encapsulated_type_to_string;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type  = type d'extension à représenter.                      *
+*                child = variable dont on doit dériver.                       *
+*                                                                             *
+*  Description : Crée une représentation de variable dérivée.                 *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_encapsulated_type_new(EncapsulationType type, ...)
+{
+    GEncapsulatedType *result;              /* Structure à retourner       */
+    va_list ap;                             /* Liste variable d'arguments  */
+
+    result = g_object_new(G_TYPE_ENCAPSULATED_TYPE, NULL);
+
+    result->type = type;
+
+    va_start(ap, type);
+
+    switch (type)
+    {
+        case ECT_ROUTINE:
+            result->routine = va_arg(ap, GBinRoutine *);
+            g_binary_routine_set_name(result->routine, "(*)");
+            break;
+
+        default:
+            result->child = va_arg(ap, GOpenidaType *);
+            break;
+
+    }
+
+    va_end(ap);
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GOpenidaType *g_encapsulated_type_dup(const GEncapsulatedType *type)
+{
+    GOpenidaType *result;                   /* Nouvelle instance à renvoyer*/
+    GOpenidaType *child;                    /* Copie du type interne       */
+
+    switch (type->type)
+    {
+        case ECT_ROUTINE:
+            g_object_ref(G_OBJECT(type->routine));
+            result = g_encapsulated_type_new(type->type, type->routine);
+            break;
+
+        default:
+            child = g_openida_type_dup(type->child);
+            result = g_encapsulated_type_new(type->type, child);
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
+{
+    char *result;                           /* Chaîne finale à renvoyer    */
+
+    switch (type->type)
+    {
+        case ECT_ROUTINE:
+            result = g_binary_routine_to_string(type->routine);
+            break;
+
+        default:
+            result = g_openida_type_to_string(type->child);
+            break;
+
+    }
+
+    switch (type->type)
+    {
+        case ECT_POINTER:
+
+            if (G_IS_ENCAPSULATED_TYPE(type->child)
+                && G_ENCAPSULATED_TYPE(type->child)->type == ECT_ROUTINE) break;
+
+            if (!g_openida_type_is_pointer(type->child, false))
+                result = stradd(result, " ");
+            result = stradd(result, "*");
+
+            break;
+
+        case ECT_REFERENCE:
+            result = stradd(result, " &");
+            break;
+        case ECT_RVALUE_REF:
+            result = stradd(result, " &&");
+            break;
+        case ECT_COMPLEX:
+            result = stradd(result, " complex");
+            break;
+        case ECT_IMAGINARY:
+            result = stradd(result, " imaginary");
+            break;
+
+        default:
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        CLASSES / STRUCTURES ET ENUMERATIONS                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+G_DEFINE_TYPE(GClassEnumType, g_class_enum_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types classe ou assimilés.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_class_enum_type_class_init(GClassEnumTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type classe ou assimilé.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_class_enum_type_init(GClassEnumType *type)
+{
+    GOpenidaType *oida_type;                /* Version basique             */
+
+    oida_type = G_OPENIDA_TYPE(type);
+
+    oida_type->dup = (type_dup_fc)g_class_enum_type_dup;
+    oida_type->to_string = (type_to_string_fc)g_class_enum_type_to_string;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de structure à représenter.                      *
+*                name = désignation humaine du type.                          *
+*                                                                             *
+*  Description : Crée une représentation de classe, structure ou énumération. *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_class_enum_type_new(ClassEnumType type, const char *name)
+{
+    GClassEnumType *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_CLASS_ENUM_TYPE, NULL);
+
+    result->type = type;
+    result->name = strdup(name);
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GOpenidaType *g_class_enum_type_dup(const GClassEnumType *type)
+{
+    return g_class_enum_type_new(type->type, type->name);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_class_enum_type_to_string(const GClassEnumType *type)
+{
+    return strdup(type->name);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         ELEMENTS REPOSANT SUR DES GABARITS                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GTemplateType, g_template_type, G_TYPE_CLASS_ENUM_TYPE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types reposant sur des gabarits.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_template_type_class_init(GTemplateTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type reposant sur des gabarits.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_template_type_init(GTemplateType *type)
+{
+    GOpenidaType *oida_type;                /* Version basique             */
+    GClassEnumType *ce_type;                /* Version basique #2          */
+
+    oida_type = G_OPENIDA_TYPE(type);
+
+    oida_type->dup = (type_dup_fc)g_template_type_dup;
+    oida_type->to_string = (type_to_string_fc)g_template_type_to_string;
+
+    ce_type = G_CLASS_ENUM_TYPE(type);
+
+    ce_type->type = CET_CLASS;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : name = désignation humaine du type.                          *
+*                list = élements du modèle sur lequel doit reposer le type.   *
+*                                                                             *
+*  Description : Crée une représentation de type reposant sur des gabarits.   *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_template_type_new(const char *name, GSList *list)
+{
+    GTemplateType *result;                  /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_TEMPLATE_TYPE, NULL);
+
+    G_CLASS_ENUM_TYPE(result)->name = strdup(name);
+
+    g_template_type_add_params(result, list);
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GOpenidaType *g_template_type_dup(const GTemplateType *type)
+{
+    GOpenidaType *result;                   /* Copie à retourner           */
+    GSList *list;                           /* Format de liste à fournir   */
+    size_t i;                               /* Boucle de parcours          */
+
+    list = NULL;
+
+    for (i = 0; i < type->models_count; i++)
+        list = g_slist_prepend(list, type->models[i]);
+
+    result = g_template_type_new(G_CLASS_ENUM_TYPE(type)->name, list);
+
+    g_slist_free(list);
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_template_type_to_string(const GTemplateType *type)
+{
+    char *result;                           /* Valeur à renvoyer           */
+    size_t i;                               /* Boucle de parcours          */
+    char *sub;                              /* Sous-type à décrire         */
+
+    result = g_class_enum_type_to_string(G_CLASS_ENUM_TYPE(type));
+
+    result = stradd(result, "<");
+
+    for (i = 0; i < type->models_count; i++)
+    {
+        if (i > 0) result = stradd(result, ", ");
+
+        sub = g_openida_type_to_string(type->models[i]);
+        result = stradd(result, sub);
+        free(sub);
+
+    }
+
+    result = stradd(result, ">");
+
+    return result;
+
+}
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à mettre à jour.                                 *
+*                list = élements du modèle sur lequel doit reposer le type.   *
+*                                                                             *
+*  Description : Ajoute une série de paramètres à un gabarit.                 *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : La liste doit contenir des éléments dans l'ordre inverse     *
+*                d'apparition. De plus, elle est libérée dans cette fonction. *
+*                                                                             *
+******************************************************************************/
+
+void g_template_type_add_params(GTemplateType *type, GSList *list)
+{
+    GSList *iter;                           /* Boucle de parcours          */
+
+    list = g_slist_reverse(list);
+    for (iter = list; iter != NULL; iter = g_slist_next(iter))
+    {
+        type->models = (GOpenidaType **)realloc(type->models,
+                                                ++type->models_count * sizeof(GOpenidaType *));
+        type->models[type->models_count - 1] = G_OPENIDA_TYPE(iter->data);
+    }
+    g_slist_free(list);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type  = type à consulter.                                    *
+*                index = indice du paramètre à retourner.                     *
+*                                                                             *
+*  Description : Fournit un paramètre donné du gabarit.                       *
+*                                                                             *
+*  Retour      : Type inclus dans le modèle ou NULL si mauvais indice.        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_template_type_get_param(const GTemplateType *type, size_t index)
+{
+    return (index < type->models_count ? type->models[index] : NULL);
+
+}
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        VALEUR LITERALE DES TYPES INSTANCIES                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GLiteralType, g_literal_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des types instanciés avec des valeurs.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_literal_type_class_init(GLiteralTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise l'instance d'un type instancié avec une valeur.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_literal_type_init(GLiteralType *type)
+{
+    GOpenidaType *oida_type;                /* Version basique             */
+
+    oida_type = G_OPENIDA_TYPE(type);
+
+    oida_type->dup = (type_dup_fc)g_literal_type_dup;
+    oida_type->to_string = (type_to_string_fc)g_literal_type_to_string;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : orig  = type d'origine instancié.                            *
+*                value = valeur de l'instanciation.                           *
+*                                                                             *
+*  Description : Crée une représentation de type instancié avec une valeur.   *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_literal_type_new(GOpenidaType *orig, literal_value value)
+{
+    GLiteralType *result;                   /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_LITERAL_TYPE, NULL);
+
+    result->orig = orig;
+    result->value = value;
+
+    g_object_ref(orig);
+
+    return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GOpenidaType *g_literal_type_dup(const GLiteralType *type)
+{
+    GOpenidaType *orig;                     /* Copie du type interne       */
+
+    orig = g_openida_type_dup(type->orig);
+
+    return g_literal_type_new(orig, type->value);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à convertir.                                     *
+*                                                                             *
+*  Description : Décrit le type fourni sous forme de caractères.              *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_literal_type_to_string(const GLiteralType *type)
+{
+    char *result;                           /* Valeur à renvoyer           */
+    size_t max;                             /* Longueur totale du texte    */
+
+    if (G_IS_BASIC_TYPE(type->orig))
+        switch (G_BASIC_TYPE(type->orig)->type)
+        {
+            case BTP_BOOL:
+                result = strdup(type->value.int_val ? "true" : "false");
+                break;
+
+            case BTP_INT:
+                max = strlen("2147483647" /* INT_MAX */) + 1;
+                result = (char *)calloc(max, sizeof(char));
+                snprintf(result, max, "%d", type->value.int_val);
+                break;
+
+            default:
+                result = strdup("TODO");
+                break;
+
+    }
+    else result = strdup("???");
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            COLLECTE ET GESTION DE TYPES                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un gestionnaire de types. */
+G_DEFINE_TYPE(GTypesManager, g_types_manager, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des gestionnaires de types.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_types_manager_class_init(GTypesManagerClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : manager = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise l'instance d'un gestionnaire de types.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_types_manager_init(GTypesManager *manager)
+{
+
+}
diff --git a/src/analysis/type.h b/src/analysis/type.h
new file mode 100644
index 0000000..b127eb3
--- /dev/null
+++ b/src/analysis/type.h
@@ -0,0 +1,312 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * variable.h - prototypes pour la manipulation des variables en tout genre
+ *
+ * Copyright (C) 2009 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_TYPE_H
+#define _ANALYSIS_TYPE_H
+
+
+#include <glib.h>
+#include <glib-object.h>
+
+
+#include "../arch/archbase.h"
+#include "../arch/processor.h"
+
+
+
+/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
+
+
+#define G_TYPE_OPENIDA_TYPE               g_openida_type_get_type()
+#define G_OPENIDA_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_openida_type_get_type(), GOpenidaType))
+#define G_IS_OPENIDA_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_openida_type_get_type()))
+#define G_OPENIDA_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
+#define G_IS_OPENIDA_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_OPENIDA_TYPE))
+#define G_OPENIDA_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
+
+
+/* Description de type quelconque (instance) */
+typedef struct _GOpenidaType GOpenidaType;
+
+/* Description de type quelconque (classe) */
+typedef struct _GOpenidaTypeClass GOpenidaTypeClass;
+
+
+/* Qualificatifs de variables */
+typedef enum _TypeQualifier
+{
+    TQF_RESTRICT    = (1 << 0),             /* restrict (C99)              */
+    TQF_VOLATILE    = (1 << 1),             /* volatile                    */
+    TQF_CONST       = (1 << 2)              /* const                       */
+
+} TypeQualifier;
+
+
+/* Indique le type défini pour un type quelconque. */
+GType g_openida_type_get_type(void);
+
+/* Crée un copie d'un type existant. */
+GOpenidaType *g_openida_type_dup(const GOpenidaType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+char *g_openida_type_to_string(const GOpenidaType *);
+
+/* Ajoute un qualificatif à une instance de type. */
+void g_openida_type_add_qualifier(GOpenidaType *, TypeQualifier);
+
+/* Indique la terminaison de la représentation du type. */
+bool g_openida_type_is_pointer(const GOpenidaType *, bool);
+
+
+
+/* ---------------------------- 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;
+
+
+#define G_TYPE_BASIC_TYPE               g_basic_type_get_type()
+#define G_BASIC_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_basic_type_get_type(), GBasicType))
+#define G_IS_BASIC_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_basic_type_get_type()))
+#define G_BASIC_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BASIC_TYPE, GBasicTypeClass))
+#define G_IS_BASIC_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BASIC_TYPE))
+#define G_BASIC_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BASIC_TYPE, GBasicTypeClass))
+
+
+/* Description de type basique (instance) */
+typedef struct _GBasicType GBasicType;
+
+/* Description de type basique (classe) */
+typedef struct _GBasicTypeClass GBasicTypeClass;
+
+
+/* Indique le type défini pour un type basique. */
+GType g_basic_type_get_type(void);
+
+/* Crée une représentation de type basique. */
+GOpenidaType *g_basic_type_new(BaseType);
+
+
+
+/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
+
+
+#define G_TYPE_ENCAPSULATED_TYPE               g_encapsulated_type_get_type()
+#define G_ENCAPSULATED_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_encapsulated_type_get_type(), GEncapsulatedType))
+#define G_IS_ENCAPSULATED_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_encapsulated_type_get_type()))
+#define G_ENCAPSULATED_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
+#define G_IS_ENCAPSULATED_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ENCAPSULATED_TYPE))
+#define G_ENCAPSULATED_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
+
+
+/* Description de type encapsulé (instance) */
+typedef struct _GEncapsulatedType GEncapsulatedType;
+
+/* Description de type encapsulé (classe) */
+typedef struct _GEncapsulatedTypeClass GEncapsulatedTypeClass;
+
+
+/* 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)         */
+
+    ECT_ROUTINE                             /* Pointeur vers une routine   */
+
+} EncapsulationType;
+
+
+/* Indique le type défini pour un type encapsulé. */
+GType g_encapsulated_type_get_type(void);
+
+/* Crée une représentation de variable dérivée. */
+GOpenidaType *g_encapsulated_type_new(EncapsulationType, ...);
+
+
+
+/* ---------------------- CLASSES / STRUCTURES ET ENUMERATIONS ---------------------- */
+
+
+#define G_TYPE_CLASS_ENUM_TYPE               g_class_enum_type_get_type()
+#define G_CLASS_ENUM_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_class_enum_type_get_type(), GClassEnumType))
+#define G_IS_CLASS_ENUM_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_class_enum_type_get_type()))
+#define G_CLASS_ENUM_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CLASS_ENUM_TYPE, GClassEnumTypeClass))
+#define G_IS_CLASS_ENUM_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CLASS_ENUM_TYPE))
+#define G_CLASS_ENUM_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CLASS_ENUM_TYPE, GClassEnumTypeClass))
+
+
+/* Description de type classe/structure et enumeration (instance) */
+typedef struct _GClassEnumType GClassEnumType;
+
+/* Description de type classe/structure et enumeration (classe) */
+typedef struct _GClassEnumTypeClass GClassEnumTypeClass;
+
+
+/* Type pris en compte */
+typedef enum _ClassEnumType
+{
+    CET_UNKNOWN,                            /* Statut inconnu              */
+    CET_STRUCT,                             /* Structure                   */
+    CET_ENUM,                               /* Enumération                 */
+    CET_CLASS                               /* Classe                      */
+
+} ClassEnumType;
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+GType g_class_enum_type_get_type(void);
+
+/* Crée une représentation de classe, structure ou énumération. */
+GOpenidaType *g_class_enum_type_new(ClassEnumType, const char *);
+
+
+
+/* ----------------------- ELEMENTS REPOSANT SUR DES GABARITS ----------------------- */
+
+
+#define G_TYPE_TEMPLATE_TYPE               g_template_type_get_type()
+#define G_TEMPLATE_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_template_type_get_type(), GTemplateType))
+#define G_IS_TEMPLATE_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_template_type_get_type()))
+#define G_TEMPLATE_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_TEMPLATE_TYPE, GTemplateTypeClass))
+#define G_IS_TEMPLATE_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_TEMPLATE_TYPE))
+#define G_TEMPLATE_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_TEMPLATE_TYPE, GTemplateTypeClass))
+
+
+/* Description de type reposant sur des gabarits (instance) */
+typedef struct _GTemplateType GTemplateType;
+
+/* Description de type reposant sur des gabarits (classe) */
+typedef struct _GTemplateTypeClass GTemplateTypeClass;
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+GType g_template_type_get_type(void);
+
+/* Crée une représentation de type reposant sur des gabarits. */
+GOpenidaType *g_template_type_new(const char *, GSList *);
+
+/* Ajoute une série de paramètres à un gabarit. */
+void g_template_type_add_params(GTemplateType *, GSList *);
+
+/* Fournit un paramètre donné du gabarit. */
+GOpenidaType *g_template_type_get_param(const GTemplateType *, size_t);
+
+
+
+/* ---------------------- VALEUR LITERALE DES TYPES INSTANCIES ---------------------- */
+
+
+#define G_TYPE_LITERAL_TYPE               g_literal_type_get_type()
+#define G_LITERAL_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_literal_type_get_type(), GLiteralType))
+#define G_IS_LITERAL_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_literal_type_get_type()))
+#define G_LITERAL_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_LITERAL_TYPE, GLiteralTypeClass))
+#define G_IS_LITERAL_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_LITERAL_TYPE))
+#define G_LITERAL_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LITERAL_TYPE, GLiteralTypeClass))
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+typedef struct _GLiteralType GLiteralType;
+
+/* Description de type instancié avec une valeur litérale (classe) */
+typedef struct _GLiteralTypeClass GLiteralTypeClass;
+
+
+/* Valeurs instanciées supportées */
+typedef union _literal_value
+{
+    int int_val;                            /* Valeur entière              */
+    float float_val;                        /* Valeur flottante            */
+
+} literal_value;
+
+
+/* Indique le type défini pour un type instancié avec une valeur litérale. */
+GType g_literal_type_get_type(void);
+
+/* Crée une représentation de type instancié avec une valeur. */
+GOpenidaType *g_literal_type_new(GOpenidaType *, literal_value);
+
+
+
+/* -------------------------- COLLECTE ET GESTION DE TYPES -------------------------- */
+
+
+#define G_TYPE_TYPES_MANAGER               g_types_manager_get_type()
+#define G_TYPES_MANAGER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_types_manager_get_type(), GTypesManager))
+#define G_IS_TYPES_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_types_manager_get_type()))
+#define G_TYPES_MANAGER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
+#define G_IS_TYPES_MANAGER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_TYPES_MANAGER))
+#define G_TYPES_MANAGER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
+
+
+/* Description d'un gestionnaire de types (instance) */
+typedef struct _GTypesManager GTypesManager;
+
+/* Description d'un gestionnaire de types (classe) */
+typedef struct _GTypesManagerClass GTypesManagerClass;
+
+
+/* Indique le type défini pour un gestionnaire de types. */
+GType g_types_manager_get_type(void);
+
+
+
+
+
+#endif  /* _ANALYSIS_TYPE_H */
diff --git a/src/analysis/variable.c b/src/analysis/variable.c
index 01c780e..e24f7e1 100644
--- a/src/analysis/variable.c
+++ b/src/analysis/variable.c
@@ -24,6 +24,162 @@
 #include "variable.h"
 
 
+#include "../common/extstr.h"
+
+
+
+/* ------------------- ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION ------------------- */
+
+
+/* Variable typée (instance) */
+struct _GBinVariable
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    GOpenidaType *type;                     /* Type de la variable         */
+    char *name;                             /* Désignation humaine         */
+
+};
+
+/* Variable typée (classe) */
+struct _GBinVariableClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des variables. */
+static void g_binary_variable_class_init(GBinVariableClass *);
+
+/* Initialise l'instande d'une variable. */
+static void g_binary_variable_init(GBinVariable *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                     ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION                     */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une base de variable. */
+G_DEFINE_TYPE(GBinVariable, g_binary_variable, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des variables.                          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_binary_variable_class_init(GBinVariableClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : var = instance à initialiser.                                *
+*                                                                             *
+*  Description : Initialise l'instande d'une variable.                        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_binary_variable_init(GBinVariable *var)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de la variable à mettre en place.                *
+*                                                                             *
+*  Description : Crée une représentation de variable de type donné.           *
+*                                                                             *
+*  Retour      : Variable mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinVariable *g_binary_variable_new(GOpenidaType *type)
+{
+    GBinVariable *result;               /* Variable à retourner        */
+
+    result = g_object_new(G_TYPE_BIN_VARIABLE, NULL);
+
+    result->type = type;
+    g_object_ref(G_OBJECT(type));
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : var = variable à convertir.                                  *
+*                                                                             *
+*  Description : Décrit la variable donnée sous forme de caractères.          *
+*                                                                             *
+*  Retour      : Chaîne à libérer de la mémoire après usage.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_binary_variable_to_string(const GBinVariable *var)
+{
+    char *result;                           /* Valeur à retourner          */
+
+    result = g_openida_type_to_string(var->type);
+
+    if (var->name != NULL)
+    {
+        if (!g_openida_type_is_pointer(var->type, true))
+            result = stradd(result, " ");
+
+        result = stradd(result, var->name);
+
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #include <malloc.h>
 #include <stdint.h>
 #include <string.h>
@@ -34,6 +190,14 @@
 
 
 
+
+
+
+
+
+
+
+
 /* -------------------- BASE DE VARIABLES OU VARIABLES INCONNUES -------------------- */
 
 
diff --git a/src/analysis/variable.h b/src/analysis/variable.h
index f2bbb87..ab5a037 100644
--- a/src/analysis/variable.h
+++ b/src/analysis/variable.h
@@ -29,6 +29,46 @@
 #include <glib-object.h>
 
 
+#include "type.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(GOpenidaType *);
+
+
+
+
+/* Décrit la variable donnée sous forme de caractères. */
+char *g_binary_variable_to_string(const GBinVariable *);
+
+
+
+
+
+
+
 
 /* -------------------- BASE DE VARIABLES OU VARIABLES INCONNUES -------------------- */
 
@@ -79,6 +119,7 @@ typedef struct _variable variable;
 
 
 /* Liste des types de base existants */
+#if 0
 typedef enum _BaseType
 {
     BTP_VOID,                               /* void                        */
@@ -111,7 +152,7 @@ typedef enum _BaseType
     BTP_OTHER                               /* Extension utilisateur       */
 
 } BaseType;
-
+#endif
 
 
 /* Variable repésentant un argument ou un type de retour */
@@ -144,6 +185,7 @@ typedef struct _complex_variable complex_variable;
 
 
 /* Type de ces variables */
+#if 0
 typedef enum _ClassEnumType
 {
     CET_UNKNOWN,                            /* Statut inconnu              */
@@ -152,6 +194,7 @@ typedef enum _ClassEnumType
     CET_CLASS                               /* Classe                      */
 
 } ClassEnumType;
+#endif
 
 
 /* Représentation des classes et des énumérations */
@@ -167,6 +210,7 @@ complex_variable *create_class_enum_var(char *);
 
 
 /* Cas d'encapsulation possibles */
+#if 0
 typedef enum _EncapsulationType
 {
     ECT_POINTER,                            /* Pointeur                    */
@@ -176,6 +220,7 @@ typedef enum _EncapsulationType
     ECT_IMAGINARY                           /* Imaginaire (C 2000)         */
 
 } EncapsulationType;
+#endif
 
 
 /* Représentation des variables dérivées */