Reorganized types definitions.

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

41 files changed, 1923 insertions, 1534 deletions

diff --git a/ChangeLog b/ChangeLog
index e2c92d1..0acfbff 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,54 @@
+12-10-12  Cyrille Bagard <nocbos@gmail.com>
+
+	* configure.ac:
+	Add the new Makfiles from the src/analysis/types directory to
+	AC_CONFIG_FILES.
+
+	* plugins/dexresolver/operand.c:
+	* src/analysis/Makefile.am:
+	* src/analysis/routine.c:
+	* src/analysis/routine.h:
+	* src/analysis/type.c:
+	* src/analysis/type.h:
+	Update code.
+
+	* src/analysis/types/basic.c:
+	* src/analysis/types/basic.h:
+	* src/analysis/types/cse.c:
+	* src/analysis/types/cse.h:
+	* src/analysis/types/cse-int.h:
+	* src/analysis/types/encaps.c:
+	* src/analysis/types/encaps.h:
+	* src/analysis/types/literal.c:
+	* src/analysis/types/literal.h:
+	* src/analysis/types/Makefile.am:
+	* src/analysis/types/template.c:
+	* src/analysis/types/template.h:
+	New entries: reorganize types definitions.
+
+	* src/analysis/variable.c:
+	* src/analysis/variable.h:
+	* src/arch/dalvik/decomp/new.c:
+	* src/arch/dalvik/operands/pool.c:
+	* src/decomp/lang/asm.c:
+	* src/decomp/lang/java.c:
+	* src/decomp/output.c:
+	* src/decomp/output.h:
+	* src/decomp/output-int.h:
+	* src/format/dex/class.c:
+	* src/format/dex/dex.c:
+	* src/format/dex/pool.c:
+	* src/format/dex/pool.h:
+	* src/format/mangling/context.c:
+	* src/format/mangling/context.h:
+	* src/format/mangling/context-int.h:
+	* src/format/mangling/demangler.c:
+	* src/format/mangling/demangler.h:
+	* src/format/mangling/itanium_gram.y:
+	* src/format/mangling/java_gram.y:
+	* src/gui/panels/symbols.c:
+	Update code.
+
 12-10-08  Cyrille Bagard <nocbos@gmail.com>
 
 	* plugins/python/androperms/android.png:
diff --git a/configure.ac b/configure.ac
index 23804fb..8cef052 100644
--- a/configure.ac
+++ b/configure.ac
@@ -255,6 +255,7 @@ AC_CONFIG_FILES([Makefile
                  src/analysis/binaries/Makefile
                  src/analysis/decomp/Makefile
                  src/analysis/disass/Makefile
+                 src/analysis/types/Makefile
                  src/arch/Makefile
                  src/arch/arm/Makefile
                  src/arch/dalvik/Makefile
diff --git a/plugins/dexresolver/operand.c b/plugins/dexresolver/operand.c
index 17adaf6..7293599 100644
--- a/plugins/dexresolver/operand.c
+++ b/plugins/dexresolver/operand.c
@@ -205,7 +205,7 @@ static void g_dalvik_hpool_operand_to_buffer(/*const */GDalvikHPoolOperand *oper
     GContentExporter *exporter;             /* Autre vision de l'opérande  */
     uint32_t index;                         /* Indice de l'élément visé    */
     const char *string;                     /* Chaîne à afficher           */
-    GOpenidaType *type;                     /* Type quelconque             */
+    GDataType *type;                        /* Type quelconque             */
     char *tmp;                              /* Chaîne à afficher & libérer */
 
     exporter = G_CONTENT_EXPORTER(operand);
@@ -248,7 +248,7 @@ static void g_dalvik_hpool_operand_to_buffer(/*const */GDalvikHPoolOperand *oper
             else
             {
                 type = g_binary_variable_get_vtype(operand->cache.field);
-                tmp = g_openida_type_to_string(type);
+                tmp = g_data_type_to_string(type);
 
                 g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
                                                       tmp, strlen(tmp), RTT_VAR_NAME);
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index b5b345f..1c3950f 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -12,13 +12,15 @@ libanalysis_la_SOURCES =				\
 	line_prologue.h line_prologue.c		\
 	roptions.h roptions.c				\
 	routine.h routine.c					\
+	type-int.h							\
 	type.h type.c						\
 	variable.h variable.c
 
 libanalysis_la_LIBADD =					\
 	binaries/libanalysisbinaries.la		\
 	decomp/libanalysisdecomp.la			\
-	disass/libanalysisdisass.la
+	disass/libanalysisdisass.la			\
+	types/libanalysistypes.la
 
 libanalysis_la_LDFLAGS = 
 
@@ -29,4 +31,4 @@ AM_CPPFLAGS =
 
 AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
-SUBDIRS = binaries decomp disass
+SUBDIRS = binaries decomp disass types
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 7151fdc..c26886f 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -43,11 +43,11 @@ struct _GBinRoutine
 
     RoutineType type;                       /* Type de routine             */
 
-    GOpenidaType *ret_type;                 /* Type retourné               */
+    GDataType *ret_type;                    /* Type retourné               */
 
-    GOpenidaType *namespace;                /* Espace de noms / classe     */
+    GDataType *namespace;                   /* Espace de noms / classe     */
     char *name;                             /* Désignation humaine         */
-    GOpenidaType *full_name;                /* Désignation très complète   */
+    GDataType *full_name;                   /* Désignation très complète   */
 
     GBinVariable **args;                    /* Arguments de la routines    */
     size_t args_count;                      /* Nombre d'arguments          */
@@ -153,13 +153,13 @@ GBinRoutine *g_binary_routine_new(void)
 *                                                                             *
 ******************************************************************************/
 
-GBinRoutine *g_binary_routine_new_constructor(GOpenidaType *type)
+GBinRoutine *g_binary_routine_new_constructor(GDataType *type)
 {
     GBinRoutine *result;                    /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_BIN_ROUTINE, NULL);
 
-    g_binary_routine_set_name(result, _g_openida_type_to_string(type, true));
+    g_binary_routine_set_name(result, _g_data_type_to_string(type, true));
 
     return result;
 
@@ -360,7 +360,7 @@ void g_binary_routine_set_type(GBinRoutine *routine, RoutineType type)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_routine_set_namespace(GBinRoutine *routine, GOpenidaType *namespace)
+void g_binary_routine_set_namespace(GBinRoutine *routine, GDataType *namespace)
 {
     routine->namespace = namespace;
 
@@ -379,7 +379,7 @@ void g_binary_routine_set_namespace(GBinRoutine *routine, GOpenidaType *namespac
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_binary_routine_get_namespace(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_namespace(const GBinRoutine *routine)
 {
     return routine->namespace;
 
@@ -424,7 +424,7 @@ 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));
+        g_binary_routine_set_name(routine, g_data_type_to_string(routine->full_name));
 
     return routine->name;
 
@@ -444,7 +444,7 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *type)
+void g_binary_routine_set_name_from_type(GBinRoutine *routine, GDataType *type)
 {
     if (routine->full_name != NULL)
          g_object_unref(G_OBJECT(routine->full_name));
@@ -466,7 +466,7 @@ void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *typ
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
 {
     return routine->full_name;
 
@@ -486,7 +486,7 @@ GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
+void g_binary_routine_set_return_type(GBinRoutine *routine, GDataType *type)
 {
     if (routine->ret_type != NULL)
         g_object_unref(G_OBJECT(routine->ret_type));
@@ -511,7 +511,7 @@ void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_return_type(const GBinRoutine *routine)
 {
     return routine->ret_type;
 
@@ -757,8 +757,8 @@ char *_g_binary_routine_to_string(const GBinRoutine *routine, Routine2StringOpti
             if (routine->ret_type == NULL) result = strdup("??? ");
             else
             {
-                result = _g_openida_type_to_string(routine->ret_type, !(options & RSO_LONG_TYPE));
-                if (!g_openida_type_is_pointer(routine->ret_type, true))
+                result = _g_data_type_to_string(routine->ret_type, !(options & RSO_LONG_TYPE));
+                if (!g_data_type_is_pointer(routine->ret_type, true))
                     result = stradd(result, " ");
             }
             break;
@@ -769,7 +769,7 @@ char *_g_binary_routine_to_string(const GBinRoutine *routine, Routine2StringOpti
 
     if (options & RSO_NAMESPACE && routine->namespace != NULL)
     {
-        namespace = g_openida_type_to_string(routine->namespace);
+        namespace = g_data_type_to_string(routine->namespace);
 
         result = stradd(result, namespace);
         result = stradd(result, "." /* FIXME */);
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 8a5085b..3622630 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -77,7 +77,7 @@ GType g_bin_routine_get_type(void);
 GBinRoutine *g_binary_routine_new(void);
 
 /* Crée une représentation de routine construisant une instance. */
-GBinRoutine *g_binary_routine_new_constructor(GOpenidaType *);
+GBinRoutine *g_binary_routine_new_constructor(GDataType *);
 
 /* Etablit la comparaison ascendante entre deux routines. */
 int g_binary_routine_compare(const GBinRoutine **, const GBinRoutine **);
@@ -101,10 +101,10 @@ off_t g_binary_routine_get_size(const GBinRoutine *);
 void g_binary_routine_set_type(GBinRoutine *, RoutineType);
 
 /* Définit le groupe d'appartenance d'une routine donnée. */
-void g_binary_routine_set_namespace(GBinRoutine *, GOpenidaType *);
+void g_binary_routine_set_namespace(GBinRoutine *, GDataType *);
 
 /* Fournit le groupe d'appartenance d'une routine donnée. */
-GOpenidaType *g_binary_routine_get_namespace(const GBinRoutine *);
+GDataType *g_binary_routine_get_namespace(const GBinRoutine *);
 
 /* Définit le nom humain d'une routine. */
 void g_binary_routine_set_name(GBinRoutine *, char *);
@@ -113,16 +113,16 @@ void g_binary_routine_set_name(GBinRoutine *, char *);
 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 *);
+void g_binary_routine_set_name_from_type(GBinRoutine *, GDataType *);
 
 /* Fournit le type construisant le nom humain d'une routine. */
-GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
+GDataType *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 *, GOpenidaType *);
+void g_binary_routine_set_return_type(GBinRoutine *, GDataType *);
 
 /* Fournit le type de retour d'une routine. */
-GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *);
+GDataType *g_binary_routine_get_return_type(const GBinRoutine *);
 
 /* Ajoute un argument à une routine. */
 void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
diff --git a/src/analysis/type.c b/src/analysis/type.c
index d04e7ce..ef75080 100644
--- a/src/analysis/type.c
+++ b/src/analysis/type.c
@@ -1,8 +1,8 @@
 
 /* OpenIDA - Outil d'analyse de fichiers binaires
- * variable.h - prototypes pour la manipulation des variables en tout genre
+ * type.h - prototypes pour la manipulation des types en tout genre
  *
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
@@ -24,12 +24,11 @@
 #include "type.h"
 
 
-#include <malloc.h>
 #include <stdarg.h>
-#include <string.h>
 
 
 #include "routine.h"
+#include "type-int.h"
 #include "../common/extstr.h"
 
 
@@ -37,216 +36,11 @@
 /* ------------------------ 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  */
-
-    GOpenidaType *namespace;                /* Espace de noms / classe     */
-    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 *);
+static void g_data_type_class_init(GDataTypeClass *);
 
 /* 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 *);
+static void g_data_type_init(GDataType *);
 
 
 
@@ -284,7 +78,7 @@ static void g_types_manager_init(GTypesManager *manager);
 
 
 /* Indique le type défini pour un type quelconque. */
-G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GDataType, g_data_type, G_TYPE_OBJECT);
 
 
 /******************************************************************************
@@ -299,7 +93,7 @@ G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
 *                                                                             *
 ******************************************************************************/
 
-static void g_openida_type_class_init(GOpenidaTypeClass *klass)
+static void g_data_type_class_init(GDataTypeClass *klass)
 {
 
 }
@@ -317,7 +111,7 @@ static void g_openida_type_class_init(GOpenidaTypeClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_openida_type_init(GOpenidaType *type)
+static void g_data_type_init(GDataType *type)
 {
 
 }
@@ -335,7 +129,7 @@ static void g_openida_type_init(GOpenidaType *type)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
+GDataType *g_data_type_dup(const GDataType *type)
 {
     return type->dup(type);
 
@@ -355,7 +149,7 @@ GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
 *                                                                             *
 ******************************************************************************/
 
-void g_openida_type_set_namespace(GOpenidaType *type, GOpenidaType *namespace)
+void g_data_type_set_namespace(GDataType *type, GDataType *namespace)
 {
     g_object_ref(G_OBJECT(namespace));
 
@@ -377,7 +171,7 @@ void g_openida_type_set_namespace(GOpenidaType *type, GOpenidaType *namespace)
 *                                                                             *
 ******************************************************************************/
 
-char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
+char *_g_data_type_to_string(const GDataType *type, bool simple)
 {
     char *result;                           /* Chaîne à retourner          */
     char *namespace;                        /* Groupe d'appartenance       */
@@ -386,7 +180,7 @@ char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
 
     if (!simple && type->namespace != NULL)
     {
-        namespace = g_openida_type_to_string(type->namespace);
+        namespace = g_data_type_to_string(type->namespace);
 
         result = strprep(result, "." /* FIXME */);
         result = strprep(result, namespace);
@@ -422,7 +216,7 @@ char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
 *                                                                             *
 ******************************************************************************/
 
-void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
+void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier)
 {
     type->qualifiers |= qualifier;
 
@@ -442,14 +236,14 @@ void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
 *                                                                             *
 ******************************************************************************/
 
-bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
+bool g_data_type_is_pointer(const GDataType *type, bool large)
 {
     bool result;                            /* Bilan à retourner           */
 
     result = G_IS_ENCAPSULATED_TYPE(type);
 
     if (result)
-        switch (G_ENCAPSULATED_TYPE(type)->type)
+        switch (g_encapsulated_type_get_etype(G_ENCAPSULATED_TYPE(type)))
         {
             case ECT_POINTER:
                 result = true;
@@ -470,981 +264,6 @@ bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                              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;
-
-        case ECT_ROUTINE:   /* Pour GCC */
-        default:
-            break;
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : type = type à consulter.                                     *
-*                                                                             *
-*  Description : Fournit le type d'encapsulation gérée par le type.           *
-*                                                                             *
-*  Retour      : Type d'encapsulation gérée.                                  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *type)
-{
-    return type->type;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : type = type à consulter.                                     *
-*                ...  = sous-type ou routine encapsulée dans le type. [OUT]   *
-*                                                                             *
-*  Description : Fournit la routine encapsulée dans le type.                  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
-{
-    va_list ap;                             /* Liste variable d'arguments  */
-    GOpenidaType **child;                   /* Adresse pour sous-type      */
-    GBinRoutine **routine;                  /* Adresse pour routine        */
-
-    va_start(ap, type);
-
-    switch (type->type)
-    {
-        case ECT_ROUTINE:
-            routine = va_arg(ap, GBinRoutine **);
-            *routine = type->routine;
-            break;
-
-        default:
-            child = va_arg(ap, GOpenidaType **);
-            *child = type->child;
-            break;
-
-    }
-
-    va_end(ap);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                        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);
-
-    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.                                     *
-*                                                                             *
-*  Description : Indique le nombre de paramètres associés du gabarit.         *
-*                                                                             *
-*  Retour      : Nombre de paramètres inclus dans le gabarit.                 *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-size_t g_template_type_count_param(const GTemplateType *type)
-{
-    return type->models_count;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  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                            */
 /* ---------------------------------------------------------------------------------- */
 
diff --git a/src/analysis/type.h b/src/analysis/type.h
index 72b64d1..dde256e 100644
--- a/src/analysis/type.h
+++ b/src/analysis/type.h
@@ -1,8 +1,8 @@
 
 /* OpenIDA - Outil d'analyse de fichiers binaires
- * variable.h - prototypes pour la manipulation des variables en tout genre
+ * type.h - prototypes pour la manipulation des types en tout genre
  *
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
@@ -37,19 +37,19 @@
 /* ------------------------ 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))
+#define G_TYPE_DATA_TYPE               g_data_type_get_type()
+#define G_DATA_TYPE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_data_type_get_type(), GDataType))
+#define G_IS_DATA_TYPE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_data_type_get_type()))
+#define G_DATA_TYPE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DATA_TYPE, GDataTypeClass))
+#define G_IS_DATA_TYPE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DATA_TYPE))
+#define G_DATA_TYPE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DATA_TYPE, GDataTypeClass))
 
 
 /* Description de type quelconque (instance) */
-typedef struct _GOpenidaType GOpenidaType;
+typedef struct _GDataType GDataType;
 
 /* Description de type quelconque (classe) */
-typedef struct _GOpenidaTypeClass GOpenidaTypeClass;
+typedef struct _GDataTypeClass GDataTypeClass;
 
 
 /* Qualificatifs de variables */
@@ -63,239 +63,27 @@ typedef enum _TypeQualifier
 
 
 /* Indique le type défini pour un type quelconque. */
-GType g_openida_type_get_type(void);
+GType g_data_type_get_type(void);
 
 /* Crée un copie d'un type existant. */
-GOpenidaType *g_openida_type_dup(const GOpenidaType *);
+GDataType *g_data_type_dup(const GDataType *);
 
 /* Définit le groupe d'appartenance d'un type donné. */
-void g_openida_type_set_namespace(GOpenidaType *, GOpenidaType *);
+void g_data_type_set_namespace(GDataType *, GDataType *);
 
 /* Décrit le type fourni sous forme de caractères. */
-char *_g_openida_type_to_string(const GOpenidaType *, bool);
+char *_g_data_type_to_string(const GDataType *, bool);
 
-#define g_openida_type_to_string(t) _g_openida_type_to_string((t), false)
+#define g_data_type_to_string(t) _g_data_type_to_string((t), false)
 
 /* Ajoute un qualificatif à une instance de type. */
-void g_openida_type_add_qualifier(GOpenidaType *, TypeQualifier);
+void g_data_type_add_qualifier(GDataType *, TypeQualifier);
 
 /* Indique la terminaison de la représentation du type. */
-bool g_openida_type_is_pointer(const GOpenidaType *, bool);
+bool g_data_type_is_pointer(const GDataType *, 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, ...);
-
-/* Fournit le type d'encapsulation gérée par le type. */
-EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *);
-
-/* Fournit la routine encapsulée dans le type. */
-void g_encapsulated_type_get_item(const GEncapsulatedType *, ...);
-
-
-
-/* ---------------------- 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 *);
-
-/* Indique le nombre de paramètres associés du gabarit. */
-size_t g_template_type_count_param(const GTemplateType *);
-
-/* 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 -------------------------- */
diff --git a/src/analysis/types/Makefile.am b/src/analysis/types/Makefile.am
new file mode 100755
index 0000000..25a8a38
--- /dev/null
+++ b/src/analysis/types/Makefile.am
@@ -0,0 +1,23 @@
+
+noinst_LTLIBRARIES  = libanalysistypes.la
+
+libanalysistypes_la_SOURCES =			\
+	basic.h basic.c						\
+	cse-int.h							\
+	cse.h cse.c							\
+	encaps.h encaps.c					\
+	literal.h literal.c					\
+	template.h template.c
+
+libanalysistypes_la_LIBADD =	
+
+libanalysistypes_la_LDFLAGS = 
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS = 
diff --git a/src/analysis/types/basic.c b/src/analysis/types/basic.c
new file mode 100644
index 0000000..436b04e
--- /dev/null
+++ b/src/analysis/types/basic.c
@@ -0,0 +1,309 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * basic.c - manipulation des types de données de base
+ *
+ * Copyright (C) 2012 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 "basic.h"
+
+
+#include <string.h>
+
+
+#include "../type-int.h"
+
+
+
+/* Description de type basique (instance) */
+struct _GBasicType
+{
+    GDataType parent;                       /* A laisser en premier        */
+
+    BaseType type;                          /* Type représenté si connu    */
+
+};
+
+/* Description de type basique (classe) */
+struct _GBasicTypeClass
+{
+    GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type basique. */
+G_DEFINE_TYPE(GBasicType, g_basic_type, G_TYPE_DATA_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)
+{
+    GDataType *data_type;                   /* Version basique             */
+
+    data_type = G_DATA_TYPE(type);
+
+    data_type->dup = (type_dup_fc)g_basic_type_dup;
+    data_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_basic_type_new(BaseType type)
+{
+    GBasicType *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_BASIC_TYPE, NULL);
+
+    result->type = type;
+
+    return G_DATA_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 GDataType *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);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Fournit le type de base géré par le type.                    *
+*                                                                             *
+*  Retour      : Type basique.                                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+BaseType g_basic_type_get_btype(const GBasicType *type)
+{
+    return type->type;
+
+}
diff --git a/src/analysis/types/basic.h b/src/analysis/types/basic.h
new file mode 100644
index 0000000..b58e242
--- /dev/null
+++ b/src/analysis/types/basic.h
@@ -0,0 +1,96 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * basic.h - prototypes pour la manipulation des types de données de base
+ *
+ * Copyright (C) 2012 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_TYPES_BASIC_H
+#define _ANALYSIS_TYPES_BASIC_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+/* 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. */
+GDataType *g_basic_type_new(BaseType);
+
+/* Fournit le type de base géré par le type. */
+BaseType g_basic_type_get_btype(const GBasicType *);
+
+
+
+#endif  /* _ANALYSIS_TYPES_BASIC_H */
diff --git a/src/analysis/types/cse-int.h b/src/analysis/types/cse-int.h
new file mode 100644
index 0000000..2599329
--- /dev/null
+++ b/src/analysis/types/cse-int.h
@@ -0,0 +1,56 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse-int.h - prototypes pour la définition interne des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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_TYPES_CSE_INT_H
+#define _ANALYSIS_TYPES_CSE_INT_H
+
+
+#include "cse.h"
+#include "../type-int.h"
+
+
+
+/* Description de type classe/structure et enumeration (instance) */
+struct _GClassEnumType
+{
+    GDataType 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
+{
+    GDataTypeClass parent;                  /* A laisser en premier        */
+
+};
+
+
+/* Décrit le type fourni sous forme de caractères. */
+char *g_class_enum_type_to_string(const GClassEnumType *);
+
+
+
+#endif  /* _ANALYSIS_TYPES_CSE_INT_H */
diff --git a/src/analysis/types/cse.c b/src/analysis/types/cse.c
new file mode 100644
index 0000000..40d726e
--- /dev/null
+++ b/src/analysis/types/cse.c
@@ -0,0 +1,153 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse.c - manipulation des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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 "cse.h"
+
+
+#include <string.h>
+
+
+#include "cse-int.h"
+
+
+
+/* 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 GDataType *g_class_enum_type_dup(const GClassEnumType *);
+
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+G_DEFINE_TYPE(GClassEnumType, g_class_enum_type, G_TYPE_DATA_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)
+{
+    GDataType *data_type;                   /* Version basique             */
+
+    data_type = G_DATA_TYPE(type);
+
+    data_type->dup = (type_dup_fc)g_class_enum_type_dup;
+    data_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *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_DATA_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 GDataType *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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_class_enum_type_to_string(const GClassEnumType *type)
+{
+    return strdup(type->name);
+
+}
diff --git a/src/analysis/types/cse.h b/src/analysis/types/cse.h
new file mode 100644
index 0000000..b7dc669
--- /dev/null
+++ b/src/analysis/types/cse.h
@@ -0,0 +1,69 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse.h - prototypes pour la manipulation des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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_TYPES_CSE_H
+#define _ANALYSIS_TYPES_CSE_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_class_enum_type_new(ClassEnumType, const char *);
+
+
+
+#endif  /* _ANALYSIS_TYPES_CSE_H */
diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c
new file mode 100644
index 0000000..492fd46
--- /dev/null
+++ b/src/analysis/types/encaps.c
@@ -0,0 +1,313 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * encaps.c - manipulation des types de données encapsulés
+ *
+ * Copyright (C) 2012 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 "encaps.h"
+
+
+#include "../routine.h"
+#include "../type-int.h"
+#include "../../common/extstr.h"
+
+
+
+/* Description de type encapsulé (instance) */
+struct _GEncapsulatedType
+{
+    GDataType parent;                       /* A laisser en premier        */
+
+    EncapsulationType type;                 /* Encapsulation utilisée      */
+    GDataType *child;                       /* Sous-type encadré           */
+    GBinRoutine *routine;                   /* Routine pointée             */
+
+};
+
+/* Description de type encapsulé (classe) */
+struct _GEncapsulatedTypeClass
+{
+    GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type encapsulé. */
+G_DEFINE_TYPE(GEncapsulatedType, g_encapsulated_type, G_TYPE_DATA_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)
+{
+    GDataType *data_type;                   /* Version basique             */
+
+    data_type = G_DATA_TYPE(type);
+
+    data_type->dup = (type_dup_fc)g_encapsulated_type_dup;
+    data_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *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, GDataType *);
+            break;
+
+    }
+
+    va_end(ap);
+
+    return G_DATA_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 GDataType *g_encapsulated_type_dup(const GEncapsulatedType *type)
+{
+    GDataType *result;                      /* Nouvelle instance à renvoyer*/
+    GDataType *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_data_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_data_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_data_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;
+
+        case ECT_ROUTINE:   /* Pour GCC */
+        default:
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Fournit le type d'encapsulation gérée par le type.           *
+*                                                                             *
+*  Retour      : Type d'encapsulation gérée.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *type)
+{
+    return type->type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                ...  = sous-type ou routine encapsulée dans le type. [OUT]   *
+*                                                                             *
+*  Description : Fournit la routine encapsulée dans le type.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
+{
+    va_list ap;                             /* Liste variable d'arguments  */
+    GDataType **child;                      /* Adresse pour sous-type      */
+    GBinRoutine **routine;                  /* Adresse pour routine        */
+
+    va_start(ap, type);
+
+    switch (type->type)
+    {
+        case ECT_ROUTINE:
+            routine = va_arg(ap, GBinRoutine **);
+            *routine = type->routine;
+            break;
+
+        default:
+            child = va_arg(ap, GDataType **);
+            *child = type->child;
+            break;
+
+    }
+
+    va_end(ap);
+
+}
diff --git a/src/analysis/types/encaps.h b/src/analysis/types/encaps.h
new file mode 100644
index 0000000..c06767e
--- /dev/null
+++ b/src/analysis/types/encaps.h
@@ -0,0 +1,78 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * encaps.h - prototypes pour la manipulation des types de données encapsulés
+ *
+ * Copyright (C) 2012 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_TYPES_ENCAPS_H
+#define _ANALYSIS_TYPES_ENCAPS_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_encapsulated_type_new(EncapsulationType, ...);
+
+/* Fournit le type d'encapsulation gérée par le type. */
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *);
+
+/* Fournit la routine encapsulée dans le type. */
+void g_encapsulated_type_get_item(const GEncapsulatedType *, ...);
+
+
+
+#endif  /* _ANALYSIS_TYPES_ENCAPS_H */
diff --git a/src/analysis/types/literal.c b/src/analysis/types/literal.c
new file mode 100644
index 0000000..92c8254
--- /dev/null
+++ b/src/analysis/types/literal.c
@@ -0,0 +1,205 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * literal.c - manipulation des valeurs littérales de types instanciés
+ *
+ * Copyright (C) 2012 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 "literal.h"
+
+
+#include <stdio.h>
+#include <string.h>
+
+
+#include "basic.h"
+#include "../type-int.h"
+
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+struct _GLiteralType
+{
+    GDataType parent;                       /* A laisser en premier        */
+
+    GDataType *orig;                        /* Type instancié              */
+    literal_value value;                    /* Valeur d'instance           */
+
+};
+
+/* Description de type instancié avec une valeur litérale (classe) */
+struct _GLiteralTypeClass
+{
+    GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GLiteralType, g_literal_type, G_TYPE_DATA_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)
+{
+    GDataType *data_type;                   /* Version basique             */
+
+    data_type = G_DATA_TYPE(type);
+
+    data_type->dup = (type_dup_fc)g_literal_type_dup;
+    data_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_literal_type_new(GDataType *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_DATA_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 GDataType *g_literal_type_dup(const GLiteralType *type)
+{
+    GDataType *orig;                        /* Copie du type interne       */
+
+    orig = g_data_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_get_btype(G_BASIC_TYPE(type->orig)))
+        {
+            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;
+
+}
diff --git a/src/analysis/types/literal.h b/src/analysis/types/literal.h
new file mode 100644
index 0000000..df279cd
--- /dev/null
+++ b/src/analysis/types/literal.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * literal.h - prototypes pour la manipulation des valeurs littérales de types instanciés
+ *
+ * Copyright (C) 2012 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_TYPES_LITERAL_H
+#define _ANALYSIS_TYPES_LITERAL_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_literal_type_new(GDataType *, literal_value);
+
+
+
+#endif  /* _ANALYSIS_TYPES_LITERAL_H */
diff --git a/src/analysis/types/template.c b/src/analysis/types/template.c
new file mode 100644
index 0000000..29d39bc
--- /dev/null
+++ b/src/analysis/types/template.c
@@ -0,0 +1,283 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * template.c - manipulation des types reposant sur des gabarits
+ *
+ * Copyright (C) 2012 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 "template.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "cse-int.h"
+#include "../type-int.h"
+#include "../../common/extstr.h"
+
+
+
+/* Description de type reposant sur des gabarits (instance) */
+struct _GTemplateType
+{
+    GClassEnumType parent;                  /* A laisser en premier        */
+
+    GDataType **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 GDataType *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 *);
+
+
+
+/* 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)
+{
+    GDataType *data_type;                   /* Version basique             */
+    GClassEnumType *ce_type;                /* Version basique #2          */
+
+    data_type = G_DATA_TYPE(type);
+
+    data_type->dup = (type_dup_fc)g_template_type_dup;
+    data_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *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_DATA_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 GDataType *g_template_type_dup(const GTemplateType *type)
+{
+    GDataType *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);
+
+    return G_DATA_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_data_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 = (GDataType **)realloc(type->models,
+                                                ++type->models_count * sizeof(GDataType *));
+        type->models[type->models_count - 1] = G_DATA_TYPE(iter->data);
+    }
+    g_slist_free(list);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Indique le nombre de paramètres associés du gabarit.         *
+*                                                                             *
+*  Retour      : Nombre de paramètres inclus dans le gabarit.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_template_type_count_param(const GTemplateType *type)
+{
+    return type->models_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_template_type_get_param(const GTemplateType *type, size_t index)
+{
+    return (index < type->models_count ? type->models[index] : NULL);
+
+}
diff --git a/src/analysis/types/template.h b/src/analysis/types/template.h
new file mode 100644
index 0000000..8c43a03
--- /dev/null
+++ b/src/analysis/types/template.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * template.h - prototypes pour la manipulation des types reposant sur des gabarits
+ *
+ * Copyright (C) 2012 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_TYPES_TEMPLATE_H
+#define _ANALYSIS_TYPES_TEMPLATE_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_template_type_new(const char *, GSList *);
+
+/* Ajoute une série de paramètres à un gabarit. */
+void g_template_type_add_params(GTemplateType *, GSList *);
+
+/* Indique le nombre de paramètres associés du gabarit. */
+size_t g_template_type_count_param(const GTemplateType *);
+
+/* Fournit un paramètre donné du gabarit. */
+GDataType *g_template_type_get_param(const GTemplateType *, size_t);
+
+
+
+#endif  /* _ANALYSIS_TYPES_TEMPLATE_H */
diff --git a/src/analysis/variable.c b/src/analysis/variable.c
index 2da691d..7ecf793 100644
--- a/src/analysis/variable.c
+++ b/src/analysis/variable.c
@@ -24,9 +24,11 @@
 #include "variable.h"
 
 
+#include <malloc.h>
 #include <string.h>
 
 
+#include "types/cse.h"
 #include "../common/extstr.h"
 
 
@@ -39,10 +41,10 @@ struct _GBinVariable
 {
     GObject parent;                         /* A laisser en premier        */
 
-    GOpenidaType *type;                     /* Type de la variable         */
+    GDataType *type;                        /* Type de la variable         */
     char *name;                             /* Désignation humaine         */
 
-    GOpenidaType *owner;                    /* Zone d'appartenance         */
+    GDataType *owner;                       /* Zone d'appartenance         */
 
 };
 
@@ -119,7 +121,7 @@ static void g_binary_variable_init(GBinVariable *var)
 *                                                                             *
 ******************************************************************************/
 
-GBinVariable *g_binary_variable_new(GOpenidaType *type)
+GBinVariable *g_binary_variable_new(GDataType *type)
 {
     GBinVariable *result;               /* Variable à retourner        */
 
@@ -145,7 +147,7 @@ GBinVariable *g_binary_variable_new(GOpenidaType *type)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_binary_variable_get_vtype(const GBinVariable *var)
+GDataType *g_binary_variable_get_vtype(const GBinVariable *var)
 {
     return var->type;
 
@@ -207,7 +209,7 @@ void g_binary_variable_set_name(GBinVariable *var, const char *name)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_binary_variable_get_owner(const GBinVariable *var)
+GDataType *g_binary_variable_get_owner(const GBinVariable *var)
 {
     return var->owner;
 
@@ -227,7 +229,7 @@ GOpenidaType *g_binary_variable_get_owner(const GBinVariable *var)
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_variable_set_owner(GBinVariable *var, GOpenidaType *owner)
+void g_binary_variable_set_owner(GBinVariable *var, GDataType *owner)
 {
     var->owner = owner;
 
@@ -251,11 +253,11 @@ char *g_binary_variable_to_string(const GBinVariable *var, bool simple)
 {
     char *result;                           /* Valeur à retourner          */
 
-    result = strdup(""); /* FIXME : arg _g_openida_type_to_string(var->type, simple);*/
+    result = strdup(""); /* FIXME : arg _g_data_type_to_string(var->type, simple);*/
 
     if (var->name != NULL)
     {
-        if (!g_openida_type_is_pointer(var->type, true))
+        if (!g_data_type_is_pointer(var->type, true))
             /*result = stradd(result, " ")*/;
 
         result = stradd(result, var->name);
@@ -1052,6 +1054,9 @@ char *encapsulated_var_to_string(const encapsulated_variable *var)
         case ECT_IMAGINARY:
             result = stradd(result, " imaginary");
             break;
+        case ECT_ROUTINE:
+            result = stradd(result, "< routine ? TODO ! >");
+            break;
     }
 
     return result;
diff --git a/src/analysis/variable.h b/src/analysis/variable.h
index 63e8361..a68eac2 100644
--- a/src/analysis/variable.h
+++ b/src/analysis/variable.h
@@ -29,7 +29,8 @@
 #include <glib-object.h>
 
 
-#include "type.h"
+#include "types/basic.h"
+#include "types/encaps.h"
 
 
 
@@ -55,10 +56,10 @@ typedef struct _GBinVariableClass GBinVariableClass;
 GType g_binary_variable_get_type(void);
 
 /* Crée une représentation de variable de type donné. */
-GBinVariable *g_binary_variable_new(GOpenidaType *);
+GBinVariable *g_binary_variable_new(GDataType *);
 
 /* Fournit le type d'une variable donnée. */
-GOpenidaType *g_binary_variable_get_vtype(const GBinVariable *);
+GDataType *g_binary_variable_get_vtype(const GBinVariable *);
 
 /* Fournit le nom d'une variable donnée. */
 const char *g_binary_variable_get_name(const GBinVariable *);
@@ -67,10 +68,10 @@ const char *g_binary_variable_get_name(const GBinVariable *);
 void g_binary_variable_set_name(GBinVariable *, const char *);
 
 /* Fournit la zone d'appartenance d'une variable donnée. */
-GOpenidaType *g_binary_variable_get_owner(const GBinVariable *);
+GDataType *g_binary_variable_get_owner(const GBinVariable *);
 
 /* Définit la zone d'appartenance d'une variable donnée. */
-void g_binary_variable_set_owner(GBinVariable *, GOpenidaType *);
+void g_binary_variable_set_owner(GBinVariable *, GDataType *);
 
 /* Décrit la variable donnée sous forme de caractères. */
 char *g_binary_variable_to_string(const GBinVariable *, bool);
diff --git a/src/arch/dalvik/decomp/new.c b/src/arch/dalvik/decomp/new.c
index 65da469..ff80411 100644
--- a/src/arch/dalvik/decomp/new.c
+++ b/src/arch/dalvik/decomp/new.c
@@ -49,7 +49,7 @@ GDecInstruction *dalvik_decomp_instr_new_instance(const GArchInstruction *instr,
     GArchOperand *operand;                  /* Opérande de l'instruction   */
     uint32_t index;                         /* Indice dans la table        */
     GDexFormat *format;                     /* Accès aux constantes        */
-    GOpenidaType *type;                     /* Type concerné par l'opérat° */
+    GDataType *type;                        /* Type concerné par l'opérat° */
     GBinRoutine *constructor;               /* Constructeur reconstruit    */
     GDecInstruction *call;                  /* Appel au constructeur       */
     GDecInstruction *dest;                  /* Registre de destination     */
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index 7ec370c..803d173 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -180,7 +180,7 @@ GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType
 static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBufferLine *line, AsmSyntax syntax)
 {
     const char *string;                     /* Chaîne de caractères #1     */
-    GOpenidaType *type;                     /* Type à représenter          */
+    GDataType *type;                        /* Type à représenter          */
     char *tmp;                              /* Chaîne de caractères #2     */
     GBinVariable *field;                    /* Champ à représenter         */
     GBinRoutine *routine;                   /* Routine à représenter       */
@@ -203,7 +203,7 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
 
             if (type != NULL)
             {
-                tmp = g_openida_type_to_string(type);
+                tmp = g_data_type_to_string(type);
                 g_object_unref(G_OBJECT(type));
             }
             else
diff --git a/src/decomp/lang/asm.c b/src/decomp/lang/asm.c
index ab71cc0..30c56cc 100644
--- a/src/decomp/lang/asm.c
+++ b/src/decomp/lang/asm.c
@@ -57,7 +57,7 @@ static GBufferLine *g_asm_output_write_comments(GAsmOutput *, GCodeBuffer *, con
 static void g_asm_output_write_comp_sign(GAsmOutput *, GBufferLine *, CompSignType);
 
 /* Débute la définition d'une routine. */
-static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *, GCodeBuffer *, const GOpenidaType *);
+static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *, GCodeBuffer *, const GDataType *);
 
 /* Termine la définition d'une routine. */
 static void g_asm_output_end_routine_prototype(GAsmOutput *, GCodeBuffer *, GBufferLine *);
@@ -231,7 +231,7 @@ static void g_asm_output_write_comp_sign(GAsmOutput *output, GBufferLine *line,
 *                                                                             *
 ******************************************************************************/
 
-static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret)
+static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *output, GCodeBuffer *buffer, const GDataType *ret)
 {
     GBufferLine *result;                    /* Adresse nouvelle à remonter */
 
diff --git a/src/decomp/lang/java.c b/src/decomp/lang/java.c
index 21da3af..5092f32 100644
--- a/src/decomp/lang/java.c
+++ b/src/decomp/lang/java.c
@@ -66,13 +66,13 @@ static GBufferLine *g_java_output_write_comments(GJavaOutput *, GCodeBuffer *, c
 static void g_java_output_write_comp_sign(GJavaOutput *, GBufferLine *, CompSignType);
 
 /* Débute la définition d'une classe. */
-static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GOpenidaType *);
+static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GDataType *);
 
 /* Termine la définition d'une classe. */
 static void g_java_output_end_class(GJavaOutput *, GCodeBuffer *);
 
 /* Débute la définition d'une routine. */
-static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GOpenidaType *);
+static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GDataType *);
 
 /* Termine la définition d'une routine. */
 static void g_java_output_end_routine_prototype(GJavaOutput *, GCodeBuffer *, GBufferLine *);
@@ -343,7 +343,7 @@ static void g_java_output_write_comp_sign(GJavaOutput *output, GBufferLine *line
 *                                                                             *
 ******************************************************************************/
 
-static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *type)
+static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *type)
 {
     GBufferLine *result;                    /* Adresse nouvelle à remonter */
     char *name;                             /* Désignation humaine         */
@@ -353,7 +353,7 @@ static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *
     g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "class", 5, RTT_KEY_WORD);
     g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW);
 
-    name = _g_openida_type_to_string(type, true);
+    name = _g_data_type_to_string(type, true);
     g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, name, strlen(name), RTT_RAW);
     free(name);
 
@@ -413,7 +413,7 @@ static void g_java_output_end_class(GJavaOutput *output, GCodeBuffer *buffer)
 *                                                                             *
 ******************************************************************************/
 
-static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret)
+static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *ret)
 {
     GBufferLine *result;                    /* Adresse nouvelle à remonter */
 
diff --git a/src/decomp/output-int.h b/src/decomp/output-int.h
index 885d9ca..be057af 100644
--- a/src/decomp/output-int.h
+++ b/src/decomp/output-int.h
@@ -39,7 +39,7 @@ typedef GBufferLine * (* write_comments_fc) (GLangOutput *, GCodeBuffer *, const
 typedef void (* write_comp_sign_fc) (GLangOutput *, GBufferLine *, CompSignType);
 
 /* Xxx. */
-typedef GBufferLine * (* rlgbuftp_fc) (GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+typedef GBufferLine * (* rlgbuftp_fc) (GLangOutput *, GCodeBuffer *, const GDataType *);
 
 /* Xxx. */
 typedef void (* lgbuf_fc) (GLangOutput *, GCodeBuffer *);
diff --git a/src/decomp/output.c b/src/decomp/output.c
index 99d1912..698ce0d 100644
--- a/src/decomp/output.c
+++ b/src/decomp/output.c
@@ -216,7 +216,7 @@ void g_lang_output_write_comp_sign(GLangOutput *output, GBufferLine *line, CompS
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_lang_output_start_class(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *type)
+GBufferLine *g_lang_output_start_class(GLangOutput *output, GCodeBuffer *buffer, const GDataType *type)
 {
     GBufferLine *result;                    /* Adresse nouvelle à remonter */
 
@@ -265,7 +265,7 @@ void g_lang_output_end_class(GLangOutput *output, GCodeBuffer *buffer)
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret)
+GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, const GDataType *ret)
 {
     GBufferLine *result;                    /* Adresse nouvelle à remonter */
 
diff --git a/src/decomp/output.h b/src/decomp/output.h
index 6a1c4a1..7eac6d8 100644
--- a/src/decomp/output.h
+++ b/src/decomp/output.h
@@ -80,13 +80,13 @@ void g_lang_output_write_comp_sign(GLangOutput *, GBufferLine *, CompSignType);
 
 
 /* Débute la définition d'une classe. */
-GBufferLine *g_lang_output_start_class(GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+GBufferLine *g_lang_output_start_class(GLangOutput *, GCodeBuffer *, const GDataType *);
 
 /* Termine la définition d'une classe. */
 void g_lang_output_end_class(GLangOutput *, GCodeBuffer *);
 
 /* Définit le prototype d'une routine. */
-GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *, GCodeBuffer *, const GDataType *);
 
 /* Marque la fin du prototype d'une routine. */
 void g_lang_output_end_routine_prototype(GLangOutput *, GCodeBuffer *, GBufferLine *);
diff --git a/src/format/dex/class.c b/src/format/dex/class.c
index cdf6c2c..52389c4 100644
--- a/src/format/dex/class.c
+++ b/src/format/dex/class.c
@@ -370,7 +370,7 @@ void g_dex_class_decompile(const GDexClass *class, GLangOutput *lang, GCodeBuffe
 {
 
 
-    GOpenidaType *type;
+    GDataType *type;
 
 
     size_t i;                               /* Boucle de parcours          */
@@ -392,7 +392,7 @@ GBufferLine *line, GLangOutput *output)
 
     //g_buffer_line_insert_text(line, BLC_ASSEMBLY, "{", 3, RTT_SIGNS);
 
-    //printf("Output :: %s\n", _g_openida_type_to_string(type, true));
+    //printf("Output :: %s\n", _g_data_type_to_string(type, true));
 
 
 
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
index 7075929..821da7a 100755
--- a/src/format/dex/dex.c
+++ b/src/format/dex/dex.c
@@ -304,7 +304,7 @@ static void g_dex_format_decompile(const GDexFormat *format, GCodeBuffer *buffer
 
 
 #if 0
-        GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
+        GDataType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
 
 
  Décrit le type fourni sous forme de caractères.              *
@@ -315,7 +315,7 @@ static void g_dex_format_decompile(const GDexFormat *format, GCodeBuffer *buffer
 *                                                                             *
 ******************************************************************************/
 
-char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
+char *_g_data_type_to_string(const GDataType *type, bool simple)
 
 #endif
 
diff --git a/src/format/dex/pool.c b/src/format/dex/pool.c
index d82144f..9237839 100644
--- a/src/format/dex/pool.c
+++ b/src/format/dex/pool.c
@@ -84,7 +84,7 @@ const char *get_string_from_dex_pool(const GDexFormat *format, uint32_t index)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
+GDataType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
 {
     off_t pos;                              /* Tête de lecture             */
     type_id_item type_id;                   /* Définition de la classe     */
@@ -141,9 +141,9 @@ GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *get_class_from_dex_pool(const GDexFormat *format, uint32_t index)
+GDataType *get_class_from_dex_pool(const GDexFormat *format, uint32_t index)
 {
-    GOpenidaType *result;                   /* Instance à retourner        */
+    GDataType *result;                      /* Instance à retourner        */
     off_t pos;                              /* Tête de lecture             */
     class_def_item class_def;               /* Définition de la classe     */
 
@@ -185,9 +185,9 @@ GBinVariable *get_field_from_dex_pool(const GDexFormat *format, uint32_t index)
     GBinVariable *result;                   /* Instance à retourner        */
     off_t pos;                              /* Tête de lecture             */
     field_id_item field_id;                 /* Description du champ        */
-    GOpenidaType *type;                     /* Type du champ               */
+    GDataType *type;                        /* Type du champ               */
     const char *name;                       /* Désignation humaine         */
-    GOpenidaType *owner;                    /* Propriétaire du champ       */
+    GDataType *owner;                       /* Propriétaire du champ       */
 
     if (index >= format->header.field_ids_size)
         return NULL;
@@ -250,7 +250,7 @@ GBinRoutine *get_routine_from_dex_pool(const GDexFormat *format, uint32_t index)
     method_id_item meth_id;                 /* Description de la méthode   */
 
 
-    GOpenidaType *type;
+    GDataType *type;
 
     string_id_item str_id;                  /* Identifiant de chaîne       */
     string_data_item str_data;              /* Description de chaîne       */
@@ -281,7 +281,7 @@ GBinRoutine *get_routine_from_dex_pool(const GDexFormat *format, uint32_t index)
         printf("class is nil\n");
 
     else
-        printf("class = '%s'\n", g_openida_type_to_string(type));
+        printf("class = '%s'\n", g_data_type_to_string(type));
     */
 
     /* Nom de la méthode */
diff --git a/src/format/dex/pool.h b/src/format/dex/pool.h
index 56fd99c..6894da1 100644
--- a/src/format/dex/pool.h
+++ b/src/format/dex/pool.h
@@ -34,11 +34,11 @@
 const char *get_string_from_dex_pool(const GDexFormat *, uint32_t);
 
 /* Extrait une représentation de type d'une table DEX. */
-GOpenidaType *get_type_from_dex_pool(const GDexFormat *, uint16_t);
+GDataType *get_type_from_dex_pool(const GDexFormat *, uint16_t);
 
 
 /* Extrait une représentation de classe d'une table DEX. */
-GOpenidaType *get_class_from_dex_pool(const GDexFormat *, uint32_t);
+GDataType *get_class_from_dex_pool(const GDexFormat *, uint32_t);
 
 
 
diff --git a/src/format/mangling/context-int.h b/src/format/mangling/context-int.h
index ba4a1a9..1cf0359 100644
--- a/src/format/mangling/context-int.h
+++ b/src/format/mangling/context-int.h
@@ -37,7 +37,7 @@ struct _GDemanglingContext
     union
     {
         GBinRoutine *routine;               /* Routine décodée             */
-        GOpenidaType *type;                 /* Type décodé                 */
+        GDataType *type;                    /* Type décodé                 */
     };
 
 };
diff --git a/src/format/mangling/context.c b/src/format/mangling/context.c
index 05fc9a2..7180995 100644
--- a/src/format/mangling/context.c
+++ b/src/format/mangling/context.c
@@ -108,7 +108,7 @@ GBinRoutine *g_demangling_context_get_decoded_routine(const GDemanglingContext *
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *context)
+GDataType *g_demangling_context_get_decoded_type(const GDemanglingContext *context)
 {
     return context->type;
 
diff --git a/src/format/mangling/context.h b/src/format/mangling/context.h
index c584838..767d231 100644
--- a/src/format/mangling/context.h
+++ b/src/format/mangling/context.h
@@ -53,7 +53,7 @@ GType g_demangling_context_get_type(void);
 GBinRoutine *g_demangling_context_get_decoded_routine(const GDemanglingContext *);
 
 /* Fournit le type créé à l'issue du codage. */
-GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *);
+GDataType *g_demangling_context_get_decoded_type(const GDemanglingContext *);
 
 
 
diff --git a/src/format/mangling/demangler.c b/src/format/mangling/demangler.c
index 012c736..52dad54 100644
--- a/src/format/mangling/demangler.c
+++ b/src/format/mangling/demangler.c
@@ -202,9 +202,9 @@ GBinRoutine *demangle_routine(DemanglerType type, const char *desc)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaType *demangle_type(DemanglerType type, const char *desc)
+GDataType *demangle_type(DemanglerType type, const char *desc)
 {
-    GOpenidaType *result;                   /* Construction à remonter     */
+    GDataType *result;                      /* Construction à remonter     */
     GDemanglingContext *context;            /* Contexte pour le décodage   */
 
     result = NULL;
diff --git a/src/format/mangling/demangler.h b/src/format/mangling/demangler.h
index 7fe5850..8b1c160 100644
--- a/src/format/mangling/demangler.h
+++ b/src/format/mangling/demangler.h
@@ -47,7 +47,7 @@ GBinRoutine *try_to_demangle_routine(const char *);
 GBinRoutine *demangle_routine(DemanglerType, const char *);
 
 /* Tente de décoder une chaîne de caractères donnée. */
-GOpenidaType *demangle_type(DemanglerType, const char *);
+GDataType *demangle_type(DemanglerType, const char *);
 
 
 
diff --git a/src/format/mangling/itanium_gram.y b/src/format/mangling/itanium_gram.y
index ab59ac7..0fd3b2b 100644
--- a/src/format/mangling/itanium_gram.y
+++ b/src/format/mangling/itanium_gram.y
@@ -10,6 +10,8 @@
 #include "context-int.h"
 #include "itanium.h"
 #include "../../common/extstr.h"
+#include "../../analysis/types/cse.h"
+#include "../../analysis/types/template.h"
 
 
 
@@ -87,10 +89,10 @@ static GBinRoutine *g_itanium_dcontext_push_routine(GItaniumDContext *, GBinRout
 static GBinRoutine *g_itanium_dcontext_pop_routine(GItaniumDContext *);
 
 /* Ajoute un élément dans une liste de substitutions. */
-static void g_itanium_dcontext_add_item(GItaniumDContext *, GOpenidaType *);
+static void g_itanium_dcontext_add_item(GItaniumDContext *, GDataType *);
 
 /* Fournit le nième élément d'une liste de substitutions. */
-static GOpenidaType *g_itanium_dcontext_get_item(GItaniumDContext *, guint);
+static GDataType *g_itanium_dcontext_get_item(GItaniumDContext *, guint);
 
 /* Autorise ou non le dépilement des opérateurs. */
 static void g_itanium_dcontext_update(GItaniumDContext *);
@@ -104,7 +106,7 @@ static void g_itanium_dcontext_update(GItaniumDContext *);
 static void compute_routine_itanium_ret_type(GBinRoutine *);
 
 /* Recherche et fait sauter les premiers arguments rencontrés. */
-static void update_itanium_ret_type(GOpenidaType *);
+static void update_itanium_ret_type(GDataType *);
 
 
 
@@ -164,7 +166,7 @@ char *strmerge(char *str1, const char *sep, char *str2);
         union
         {
             char *str;
-            void/*GOpenidaType*/ *type;
+            void/*GDataType*/ *type;
         };
         int/*bool*/ is_string;
 
@@ -175,7 +177,7 @@ char *strmerge(char *str1, const char *sep, char *str2);
     unsigned int val;
 	short/*s16_t*/ s16_val;
 
-    void /*GOpenidaType*/ *type;
+    void /*GDataType*/ *type;
     void /*GTemplateType*/ *templtype;
 
     void/*simple_variable*/ *simple;
@@ -339,7 +341,7 @@ name:
         {
             char *tmp;
 
-            tmp = g_openida_type_to_string($1);
+            tmp = g_data_type_to_string($1);
 
             $$.type = g_template_type_new(tmp, $2);
             $$.is_string = false;
@@ -350,7 +352,7 @@ name:
         }
 
         //g_template_type_add_params($1, $2);
-        printf(" [name tmp:: %s]\n", g_openida_type_to_string($$.type));
+        printf(" [name tmp:: %s]\n", g_data_type_to_string($$.type));
     }
     ;
 
@@ -374,8 +376,8 @@ nested_name:
                                                 $$ = ($4 != NULL ? strmerge($3, "::", $4) : $3); printf("passage nested p+uq = '%s'\n", $$);
                                                 $$ = g_class_enum_type_new(CET_UNKNOWN, $$); g_itanium_dcontext_add_item(context, $$);
                                             }
-    | NN registered_template_prefix template_args EE   { $$ = $2; g_template_type_add_params($2, $3); printf(" [nested tmp:: %s]\n", g_openida_type_to_string($$)); }
-    | NN qualifiers registered_template_prefix template_args EE   { $$ = $3; g_template_type_add_params($3, $4); printf(" [nested tmp:: %s]\n", g_openida_type_to_string($$)); }
+    | NN registered_template_prefix template_args EE   { $$ = $2; g_template_type_add_params($2, $3); printf(" [nested tmp:: %s]\n", g_data_type_to_string($$)); }
+    | NN qualifiers registered_template_prefix template_args EE   { $$ = $3; g_template_type_add_params($3, $4); printf(" [nested tmp:: %s]\n", g_data_type_to_string($$)); }
     ;
 
 
@@ -386,19 +388,19 @@ registered_prefix:
         else
         {
             g_itanium_dcontext_add_item(context, $1);
-            $$ = g_openida_type_to_string($1);
+            $$ = g_data_type_to_string($1);
         }
     }
     | substitution                  {
-        $$ = g_openida_type_to_string($1);
-        printf("prefix substi :: %s\n", g_openida_type_to_string($1));
+        $$ = g_data_type_to_string($1);
+        printf("prefix substi :: %s\n", g_data_type_to_string($1));
     }
     ;
 
 prefix:
     /* vide */                      { $$ = NULL; }
-    | registered_prefix unqualified_name       { $$ = ($2 != NULL ? g_class_enum_type_new(CET_CLASS, strmerge($1, "::", $2)) : $1); printf("passage p+uq = '%s'\n", g_openida_type_to_string($$)); }
-    | registered_template_prefix template_args     { $$ = $1; g_template_type_add_params($1, $2); printf("passage p_tmp = '%s'\n", g_openida_type_to_string($$)); }
+    | registered_prefix unqualified_name       { $$ = ($2 != NULL ? g_class_enum_type_new(CET_CLASS, strmerge($1, "::", $2)) : $1); printf("passage p+uq = '%s'\n", g_data_type_to_string($$)); }
+    | registered_template_prefix template_args     { $$ = $1; g_template_type_add_params($1, $2); printf("passage p_tmp = '%s'\n", g_data_type_to_string($$)); }
     ;
 
 registered_template_prefix:
@@ -414,12 +416,12 @@ template_prefix:
         g_itanium_dcontext_add_item(context, g_class_enum_type_new(CET_CLASS, $$));
     }
     | template_param                        {
-                                                $$ = g_openida_type_to_string($1);
+                                                $$ = g_data_type_to_string($1);
                                                 printf("[[ tmp param %s ]]\n", $$);
                                                 g_object_unref(G_OBJECT($1));
                                             }
     | substitution                  {
-        $$ = g_openida_type_to_string($1);
+        $$ = g_data_type_to_string($1);
         printf("template_prefix substi :: %s\n", $$);
         g_object_unref(G_OBJECT($1));
     }
@@ -526,20 +528,20 @@ function_type:
 
 
 type:
-    builtin_type                    { $$ = $1; printf("builtin '%s'\n", g_openida_type_to_string($1)); }
+    builtin_type                    { $$ = $1; printf("builtin '%s'\n", g_data_type_to_string($1)); }
     | class_enum_type               { $$ = $1; printf("type :: %p\n", $1); fflush(NULL); g_itanium_dcontext_add_item(context, $1); }
     | substitution                  { $$ = $1; }
     | template_param                { $$ = $1; }
     | template_template_param template_args {
-                                                $$ = g_template_type_new(g_openida_type_to_string($1), NULL);
+                                                $$ = g_template_type_new(g_data_type_to_string($1), NULL);
                                                 g_object_unref($1);
                                                 g_template_type_add_params($$, $2);
-                                                 printf(" [type tmp:: %s]\n", g_openida_type_to_string($$));
+                                                 printf(" [type tmp:: %s]\n", g_data_type_to_string($$));
                                             }
     | function_type                 { $$ = $1; }
     | qualifiers type               {
-                                        $$ = g_openida_type_dup($2);
-                                        g_openida_type_add_qualifier($$, $1);
+                                        $$ = g_data_type_dup($2);
+                                        g_data_type_add_qualifier($$, $1);
                                         g_itanium_dcontext_add_item(context, $$);
                                     }
     | TP type                       { $$ = g_encapsulated_type_new(ECT_POINTER, $2); g_itanium_dcontext_add_item(context, $$); }
@@ -604,14 +606,14 @@ class_enum_type:
 
 template_param:
     TPARAM_FIRST                    {
-                                        const GOpenidaType *type = g_binary_routine_get_type_from_name(routine);
+                                        const GDataType *type = g_binary_routine_get_type_from_name(routine);
                                         if (G_IS_TEMPLATE_TYPE(type))
                                             $$ = g_template_type_get_param(G_TEMPLATE_TYPE(type), 0);
                                         else $$ = NULL;
                                         if ($$ == NULL) YYERROR; if (!G_IS_BASIC_TYPE($$)) g_itanium_dcontext_add_item(context, $$);
                                     }
     | TPARAM_N                      {
-                                        const GOpenidaType *type = g_binary_routine_get_type_from_name(routine);
+                                        const GDataType *type = g_binary_routine_get_type_from_name(routine);
                                         if (G_IS_TEMPLATE_TYPE(type))
                                             $$ = g_template_type_get_param(G_TEMPLATE_TYPE(type), $1 + 1);
                                         else $$ = NULL;
@@ -929,11 +931,11 @@ static GBinRoutine *g_itanium_dcontext_pop_routine(GItaniumDContext *context)
 *                                                                             *
 ******************************************************************************/
 
-static void g_itanium_dcontext_add_item(GItaniumDContext *context, GOpenidaType *type)
+static void g_itanium_dcontext_add_item(GItaniumDContext *context, GDataType *type)
 {
     g_object_ref(G_OBJECT(type));
 
-    printf(" [[ %u ]] PUSH '%s' (%p)\n", g_slist_length(context->substitutions) - 1, g_openida_type_to_string(type), type);
+    printf(" [[ %u ]] PUSH '%s' (%p)\n", g_slist_length(context->substitutions) - 1, g_data_type_to_string(type), type);
 
     context->substitutions = g_slist_append(context->substitutions, type);
 
@@ -953,11 +955,11 @@ static void g_itanium_dcontext_add_item(GItaniumDContext *context, GOpenidaType
 *                                                                             *
 ******************************************************************************/
 
-static GOpenidaType *g_itanium_dcontext_get_item(GItaniumDContext *context, guint n)
+static GDataType *g_itanium_dcontext_get_item(GItaniumDContext *context, guint n)
 {
     printf("get [%u] == %p\n", n, g_slist_nth_data(context->substitutions, n + 1));
 
-    return G_OPENIDA_TYPE(g_slist_nth_data(context->substitutions, n + 1));
+    return G_DATA_TYPE(g_slist_nth_data(context->substitutions, n + 1));
 
 }
 
@@ -1072,7 +1074,7 @@ bool demangle_itanium_routine(GItaniumDContext *context, const char *desc)
     GBinRoutine *routine;                   /* Routine à construire        */
 	YY_BUFFER_STATE buffer;                 /* Tampon pour bison           */
 	int ret;                                /* Bilan de l'appel            */
-    GOpenidaType *name_type;                /* Nom basé sur un type ?      */
+    GDataType *name_type;                   /* Nom basé sur un type ?      */
 
     routine = g_demangling_context_get_decoded_routine(G_DEMANGLING_CONTEXT(context));
 
@@ -1113,7 +1115,7 @@ static void compute_routine_itanium_ret_type(GBinRoutine *routine)
     size_t count;                           /* Nombre d'arguments présents */
     size_t i;                               /* Boucle de parcours          */
     GBinVariable *arg;                      /* Argument de la routine      */
-    GOpenidaType *type;                     /* Type associé à l'argument   */
+    GDataType *type;                        /* Type associé à l'argument   */
 
     /* Traitement récursif des arguments */
 
@@ -1173,12 +1175,12 @@ static void compute_routine_itanium_ret_type(GBinRoutine *routine)
 *                                                                             *
 ******************************************************************************/
 
-static void update_itanium_ret_type(GOpenidaType *type)
+static void update_itanium_ret_type(GDataType *type)
 {
     GTemplateType *template;                /* Gabarit à analyser          */
     size_t max;                             /* Nombre d'itérations         */
     size_t i;                               /* Boucle de parcours          */
-    GOpenidaType *subtype;                  /* Type à traiter              */
+    GDataType *subtype;                     /* Type à traiter              */
     GEncapsulatedType *encaps;              /* Encapsulation quelconque    */
     GBinRoutine *routine;                   /* Routine à traiter           */
 
diff --git a/src/format/mangling/java_gram.y b/src/format/mangling/java_gram.y
index 25d5ffb..bbd2de3 100644
--- a/src/format/mangling/java_gram.y
+++ b/src/format/mangling/java_gram.y
@@ -5,6 +5,7 @@
 
 #include "context-int.h"
 #include "java.h"
+#include "../../analysis/types/cse.h"
 
 
 
@@ -53,7 +54,7 @@ static void g_java_dcontext_init(GJavaDContext *);
 
 %union {
 
-    void /*GOpenidaType*/ *type;
+    void /*GDataType*/ *type;
 
     size_t adeep;                           /* Dimension d'un tableau      */
 
@@ -125,12 +126,12 @@ full_class_name:
     TEXT                                { $$ = g_class_enum_type_new(CET_CLASS, $1); }
     | full_class_name SLASH TEXT        {
                                             $$ = g_class_enum_type_new(CET_CLASS, $3);
-                                            g_openida_type_set_namespace($$, $1);
+                                            g_data_type_set_namespace($$, $1);
                                             g_object_unref($1);
                                         }
     | full_class_name DOLLAR TEXT       {
                                             $$ = g_class_enum_type_new(CET_CLASS, $3);
-                                            g_openida_type_set_namespace($$, $1);
+                                            g_data_type_set_namespace($$, $1);
                                             g_object_unref($1);
                                         }
     ;
diff --git a/src/gui/panels/symbols.c b/src/gui/panels/symbols.c
index 63864d3..c51b2d1 100644
--- a/src/gui/panels/symbols.c
+++ b/src/gui/panels/symbols.c
@@ -542,7 +542,7 @@ static GtkTreeIter ensure_symbol_node_exist(GtkTreeStore *store, GtkTreeIter *pa
 
 static bool find_parent_for_routine(GtkTreeStore *store, const GBinRoutine *routine, GtkTreeIter *parent)
 {
-    GOpenidaType *namespace;                /* Espace d'appartenance       */
+    GDataType *namespace;                   /* Espace d'appartenance       */
     char *string;                           /* Conversion en chaîne        */
     char *iter;                             /* Boucle de parcours          */
     char *token;                            /* Partie de texte isolée      */ 
@@ -551,7 +551,7 @@ static bool find_parent_for_routine(GtkTreeStore *store, const GBinRoutine *rout
     namespace = g_binary_routine_get_namespace(routine);
     if (namespace == NULL) return false;
 
-    string = g_openida_type_to_string(namespace);
+    string = g_data_type_to_string(namespace);
 
     for (iter = string; ; iter = NULL)
     {