Moved the mangling related code.

24 files changed, 6046 insertions, 0 deletions

diff --git a/src/mangling/Makefile.am b/src/mangling/Makefile.am
new file mode 100644
index 0000000..63b25c7
--- /dev/null
+++ b/src/mangling/Makefile.am
@@ -0,0 +1,43 @@
+
+BUILT_SOURCES = libjavamangling_la-java_gram.h
+
+AM_YFLAGS = -d
+
+noinst_LTLIBRARIES = libjavamangling.la libmangling.la
+
+libmangling_la_SOURCES =				\
+	context-int.h						\
+	context.h context.c					\
+	demangler.h demangler.c
+
+libmangling_la_LDFLAGS = 
+
+libmangling_la_LIBADD =					\
+	libjavamangling.la					\
+	dex/libmanglingdex.la				\
+	itanium/libmanglingitanium.la
+
+
+# Partie Java
+
+libjavamangling_la_SOURCES =			\
+	java.h								\
+	java_gram.y							\
+	java_tok.l
+
+libjavamangling_la_YFLAGS = -d -p java_ -o y.tab.c
+
+libjavamangling_la_LFLAGS = -P java_ -o lex.yy.c
+
+
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+
+# Automake fait les choses à moitié
+CLEANFILES = java_gram.h java_gram.c libjavamangling_la-java_tok.c
+
+SUBDIRS = dex itanium
diff --git a/src/mangling/context-int.h b/src/mangling/context-int.h
new file mode 100644
index 0000000..d361ff7
--- /dev/null
+++ b/src/mangling/context-int.h
@@ -0,0 +1,62 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.h - prototypes internes liés aux contextes de décodage
+ *
+ * Copyright (C) 2010-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_CONTEXT_INT_H
+#define _FORMAT_MANGLING_CONTEXT_INT_H
+
+
+#include "context.h"
+
+
+
+/* Procède au décodage d'une chaîne de caractères. */
+typedef bool (* demangle_fc) (GDemanglingContext *, const char *);
+
+
+/* Contexte de décodage (instance) */
+struct _GDemanglingContext
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    union
+    {
+        GObject *gobj;                      /* Utile pour le nettoyage !   */
+        GBinRoutine *routine;               /* Routine décodée             */
+        GDataType *type;                    /* Type décodé                 */
+    };
+
+};
+
+/* Contexte de décodage (classe) */
+struct _GDemanglingContextClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+    demangle_fc demangle_type;              /* Décodage de type            */
+    demangle_fc demangle_routine;           /* Décodage de routine         */
+
+};
+
+
+
+#endif  /* _FORMAT_MANGLING_CONTEXT_INT_H */
diff --git a/src/mangling/context.c b/src/mangling/context.c
new file mode 100644
index 0000000..7a798ac
--- /dev/null
+++ b/src/mangling/context.c
@@ -0,0 +1,192 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.c - fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "context.h"
+
+
+#include "context-int.h"
+
+
+
+/* Initialise la classe des contextes de décodage. */
+static void g_demangling_context_class_init(GDemanglingContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_demangling_context_init(GDemanglingContext *);
+
+/* Supprime toutes les références externes. */
+static void g_demangling_context_dispose(GDemanglingContext *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_demangling_context_finalize(GDemanglingContext *);
+
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GDemanglingContext, g_demangling_context, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_class_init(GDemanglingContextClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_demangling_context_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_demangling_context_finalize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_init(GDemanglingContext *context)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = instance d'objet GLib à traiter.                 *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_dispose(GDemanglingContext *context)
+{
+    if (context->gobj != NULL)
+        g_object_unref(context->gobj);
+
+    G_OBJECT_CLASS(g_demangling_context_parent_class)->dispose(G_OBJECT(context));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = instance d'objet GLib à traiter.                 *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_finalize(GDemanglingContext *context)
+{
+    G_OBJECT_CLASS(g_demangling_context_parent_class)->finalize(G_OBJECT(context));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à consulter.                              *
+*                desc    = chaîne de caractères à décoder.                    *
+*                                                                             *
+*  Description : Fournit la routine créée à l'issue du codage.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinRoutine *g_demangling_context_get_decoded_routine(GDemanglingContext *context, const char *desc)
+{
+    GBinRoutine *result;                    /* Construction à remonter     */
+
+    context->routine = g_binary_routine_new();
+
+    if (G_DEMANGLING_CONTEXT_GET_CLASS(context)->demangle_routine(context, desc))
+    {
+        g_object_ref(context->routine);
+        result = context->routine;
+    }
+
+    else
+        result = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à consulter.                              *
+*                                                                             *
+*  Description : Fournit le type créé à l'issue du codage.                    *
+*                                                                             *
+*  Retour      : Instance en place ou NULL en cas d'erreur fatale.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_demangling_context_get_decoded_type(GDemanglingContext *context, const char *desc)
+{
+    GBinRoutine *result;                    /* Construction à remonter     */
+
+    if (G_DEMANGLING_CONTEXT_GET_CLASS(context)->demangle_type(context, desc))
+    {
+        g_object_ref(context->type);
+        result = context->type;
+    }
+
+    else
+        result = NULL;
+
+    return result;
+
+}
diff --git a/src/mangling/context.h b/src/mangling/context.h
new file mode 100644
index 0000000..705ef83
--- /dev/null
+++ b/src/mangling/context.h
@@ -0,0 +1,61 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.h - prototypes pour la fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_CONTEXT_H
+#define _FORMAT_MANGLING_CONTEXT_H
+
+
+#include <glib-object.h>
+
+
+#include "../analysis/routine.h"
+
+
+
+#define G_TYPE_DEMANGLING_CONTEXT               g_demangling_context_get_type()
+#define G_DEMANGLING_CONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_demangling_context_get_type(), GDemanglingContext))
+#define G_IS_DEMANGLING_CONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_demangling_context_get_type()))
+#define G_DEMANGLING_CONTEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEMANGLING_CONTEXT, GDemanglingContextClass))
+#define G_IS_DEMANGLING_CONTEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEMANGLING_CONTEXT))
+#define G_DEMANGLING_CONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEMANGLING_CONTEXT, GDemanglingContextClass))
+
+
+/* Contexte de décodage (instance) */
+typedef struct _GDemanglingContext GDemanglingContext;
+
+/* Contexte de décodage (classe) */
+typedef struct _GDemanglingContextClass GDemanglingContextClass;
+
+
+/* Indique le type défini pour un contexte de décodage. */
+GType g_demangling_context_get_type(void);
+
+/* Fournit la routine créée à l'issue du codage. */
+GBinRoutine *g_demangling_context_get_decoded_routine(GDemanglingContext *, const char *);
+
+/* Fournit le type créé à l'issue du codage. */
+GDataType *g_demangling_context_get_decoded_type(GDemanglingContext *, const char *);
+
+
+
+#endif  /* _FORMAT_MANGLING_CONTEXT_H */
diff --git a/src/mangling/demangler.c b/src/mangling/demangler.c
new file mode 100644
index 0000000..f673a01
--- /dev/null
+++ b/src/mangling/demangler.c
@@ -0,0 +1,336 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * demangler.c - décodage des noms d'éléments
+ *
+ * Copyright (C) 2009-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "demangler.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+//#include "itanium.h"
+#include "java.h"
+
+
+
+/* Indique si une chaîne peut être traitée par le décodeur. */
+typedef bool (* can_be_demangled_fc) (const char *);
+
+/* Prépare de quoi effectuer un décodage. */
+typedef GDemanglingContext * (* create_context_fc) (void);
+
+/* Procède au décodage d'une chaîne de caractères. */
+typedef bool (* demangle_fc) (GDemanglingContext *, const char *);
+
+
+
+/* Appels liés à un décodeur */
+typedef struct _demangling_properties
+{
+    can_be_demangled_fc can_demangle;       /* Possibilité de traitement   */
+
+    create_context_fc create_context;       /* Création de contextes       */
+
+    demangle_fc demangle_routine;           /* Décodage d'une routine      */
+    demangle_fc demangle_type;              /* Décodage d'un type          */
+
+} demangling_properties;
+
+
+/* Liste des décodeurs */
+static demangling_properties demanglers[/*DGT_COUNT*/] = {
+
+    /*
+    [DGT_ITANIUM] = {
+        .can_demangle = (can_be_demangled_fc)can_be_itanium_demangled,
+        .create_context = (create_context_fc)g_itanium_dcontext_new,
+        .demangle_routine = (demangle_fc)demangle_itanium_routine,
+        .demangle_type = (demangle_fc)NULL
+    },
+    */
+    /*
+    [DGT_JAVA] = {
+        .can_demangle = (can_be_demangled_fc)NULL,
+        .create_context = (create_context_fc)g_java_dcontext_new,
+        .demangle_routine = (demangle_fc)NULL,
+        .demangle_type = (demangle_fc)demangle_java_type
+    }
+    */
+};
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : desc = chaîne de caractères à décoder.                       *
+*                                                                             *
+*  Description : Tente de décoder une chaîne de caractères donnée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinRoutine *try_to_demangle_routine(const char *desc)
+{
+    GBinRoutine *result;                    /* Construction à remonter     */
+
+    result = g_binary_routine_new();
+    g_binary_routine_set_name(result, strdup(desc));
+
+    return result;
+
+
+#if 0
+    GBinRoutine *result;                    /* Construction à remonter     */
+    DemanglerType i;                        /* Boucle de parcours          */
+
+    static int counter = 0;
+
+    result = NULL;
+
+    if (strcmp(desc, "_ZN21IUDFSettingsValidator15IdNotIllegalStdEN13UDFParameters12UDF_STANDARDES1_") == 0
+        || strcmp(desc, "_ZSt12partial_sortIN9__gnu_cxx17__normal_iteratorIP28CPR_MAI_ADPTY_SectorSequenceSt6vectorIS2_SaIS2_EEEEEvT_S8_S8_") == 0
+        || strcmp(desc, "_ZSt22__merge_without_bufferIN9__gnu_cxx17__normal_iteratorIP15CProfStringListSt6vectorIS2_SaIS2_EEEEiEvT_S8_S8_T0_S9_") == 0
+        || strcmp(desc, "_ZSt11__push_heapIN9__gnu_cxx17__normal_iteratorIP8DRIVE_IDSt6vectorIS2_SaIS2_EEEEiS2_EvT_T0_S9_T1_") == 0    // Intéressant
+        //|| strcmp(desc, "") == 0
+        )
+        goto exit;
+
+    for (i = 0; i < DGT_COUNT; i++)
+    {
+        if (demanglers[i].can_demangle == NULL)
+            continue;
+
+        if (!demanglers[i].can_demangle(desc))
+            continue;
+
+        printf("++ [%d] routine :: %s\n", ++counter, desc);
+        fflush(NULL);
+
+        result = demangle_routine(i, desc);
+
+        /* FIXME : à supprimer quand mature */
+        if (result == NULL)
+        {
+            printf("++failed :: %s\n", desc);
+
+            if (strcmp(desc, "_ZN21IUDFSettingsValidator15IdNotIllegalStdEN13UDFParameters12UDF_STANDARDES1_") != 0
+                && strcmp(desc, "_ZSt12partial_sortIN9__gnu_cxx17__normal_iteratorIP28CPR_MAI_ADPTY_SectorSequenceSt6vectorIS2_SaIS2_EEEEEvT_S8_S8_") != 0
+                )
+                exit(-1);
+
+        }
+        else printf(" -->> '%s'\n\n", g_binary_routine_get_name(result));
+
+        if (result != NULL) break;
+
+    }
+
+ exit:
+
+    if (result == NULL)
+    {
+        result = g_binary_routine_new();
+        g_binary_routine_set_name(result, strdup(desc));
+    }
+
+    return result;
+#endif
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de décodeur à utiliser.                          *
+*                desc = chaîne de caractères à décoder.                       *
+*                                                                             *
+*  Description : Tente de décoder une chaîne de caractères donnée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinRoutine *demangle_routine(GType type, const char *desc)
+{
+    GBinRoutine *result;                    /* Construction à remonter     */
+    GDemanglingContext *context;            /* Contexte pour le décodage   */
+
+    context = g_object_new(type, NULL);
+
+    result = g_demangling_context_get_decoded_routine(context, desc);
+
+    g_object_unref(context);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de décodeur à utiliser.                          *
+*                desc = chaîne de caractères à décoder.                       *
+*                                                                             *
+*  Description : Tente de décoder une chaîne de caractères donnée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *demangle_type(GType type, const char *desc)
+{
+    GBinRoutine *result;                    /* Construction à remonter     */
+    GDemanglingContext *context;            /* Contexte pour le décodage   */
+
+    context = g_object_new(type, NULL);
+
+    result = g_demangling_context_get_decoded_type(context, desc);
+
+    g_object_unref(context);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Procède au test de décodages de chaînes de caractères.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#if 0
+void test_itanium_demangling(void)
+{
+    GBinRoutine *routine;
+    char *human;
+    char stop;
+
+#define TEST_ITANIUM_MANGLING(name, ref)                            \
+    do                                                              \
+    {                                                               \
+        printf(" >> %s\n", name);                                   \
+        routine = demangle_routine(DGT_ITANIUM, name);              \
+        if (routine == NULL)                                        \
+        {                                                           \
+            printf("Error with %s\n", name);                        \
+            stop = true;                                            \
+        }                                                           \
+        else                                                        \
+        {                                                           \
+            human = g_binary_routine_to_string(routine);            \
+            printf(" >> %s\n", human);                              \
+            stop = (strcmp(ref, human) != 0);                       \
+            printf(" >> ok ? %s\n", (!stop ? "oui" : "non"));       \
+            if (stop) printf(" >> expected '%s'\n", ref);           \
+            free(human);                                            \
+        }                                                           \
+        if (stop) goto end_of_test;                                 \
+        else printf("\n");                                          \
+    }                                                               \
+    while (0)
+
+    //goto last;
+
+    /**
+     * Tests de :
+     * http://www.codesourcery.com/public/cxx-abi/abi-examples.html#mangling
+     */
+
+    TEST_ITANIUM_MANGLING("_Z1fv", "??? f(void)");
+
+    TEST_ITANIUM_MANGLING("_Z1fi", "??? f(int)");
+
+    TEST_ITANIUM_MANGLING("_Z3foo3bar", "??? foo(bar)");
+
+    TEST_ITANIUM_MANGLING("_Zrm1XS_", "??? %(X, X)");
+
+    TEST_ITANIUM_MANGLING("_ZplR1XS0_", "??? +(X &, X &)");
+
+    TEST_ITANIUM_MANGLING("_ZlsRK1XS1_", "??? <<(const X &, const X &)");
+
+    TEST_ITANIUM_MANGLING("_Z1fIiEvi", "void f<int>(int)");
+
+    TEST_ITANIUM_MANGLING("_Z5firstI3DuoEvS0_", "void first<Duo>(Duo)");
+
+    TEST_ITANIUM_MANGLING("_Z5firstI3DuoEvT_", "void first<Duo>(Duo)");
+
+    TEST_ITANIUM_MANGLING("_Z3fooIiPFidEiEvv", "void foo<int, int (*)(double), int>(void)");
+
+    TEST_ITANIUM_MANGLING("_ZN6System5Sound4beepEv", "??? System::Sound::beep(void)");
+
+    TEST_ITANIUM_MANGLING("_Z1fI1XE vPV N1AIT_E1TE", "void f<X>(volatile A<X>::T *)");
+
+    //// TODO :: TEST_ITANIUM_MANGLING("_ZngILi42EE v N1A I XplT_Li2EE E 1TE", "");
+
+    TEST_ITANIUM_MANGLING("_Z4makeI7FactoryiE T_IT0_E v", "Factory<int> make<Factory, int>(void)");
+
+    TEST_ITANIUM_MANGLING("_ZlsRSoRKSs", "??? <<(std::ostream &, const std::string &)");
+
+    //TEST_ITANIUM_MANGLING("", "");
+
+    /**
+     * Tests de :
+     * http://www.codesourcery.com/public/cxx-abi/abi.html#mangling
+     */
+
+    TEST_ITANIUM_MANGLING("_ZN1N1TIiiE2mfES0_IddE", "??? N::T<int, int>::mf(N::T<double, double>)");
+
+    /**
+     * Tests de :
+     * (nero.so).
+     */
+
+    TEST_ITANIUM_MANGLING("_ZNSt6vectorItSaItEE6insertEN9__gnu_cxx17__normal_iteratorIPtS1_EERKt", "??? std::vector<unsigned short, std::allocator<unsigned short>>::insert(__gnu_cxx::__normal_iterator<unsigned short *, std::vector<unsigned short, std::allocator<unsigned short>>>, const unsigned short &)");
+
+    TEST_ITANIUM_MANGLING("_ZSt26__uninitialized_fill_n_auxIP15CProfStringListiS0_ET_S2_T0_RKT1_12__false_type", "CProfStringList *std::__uninitialized_fill_n_aux<CProfStringList *, int, CProfStringList>(CProfStringList *, int, const CProfStringList &, __false_type)");
+
+    // TODO TEST_ITANIUM_MANGLING("_ZN21IUDFSettingsValidator15IdNotIllegalStdEN13UDFParameters12UDF_STANDARDES1_", "");
+
+    TEST_ITANIUM_MANGLING("_ZNSbI26NeroMediumFeatureSpecifierSt11char_traitsIS_ESaIS_EE4_Rep10_M_destroyERKS2_", "??? std::basic_string<NeroMediumFeatureSpecifier, std::char_traits<NeroMediumFeatureSpecifier>, std::allocator<NeroMediumFeatureSpecifier>>::_Rep::_M_destroy(const std::allocator<NeroMediumFeatureSpecifier> &)");
+
+ last:
+
+    /* 80 */
+    TEST_ITANIUM_MANGLING("_ZNSt6vectorIlSaIlEE6insertEN9__gnu_cxx17__normal_iteratorIPlS1_EERKl", "??? std::vector<long, std::allocator<long>>::insert(__gnu_cxx::__normal_iterator<long *, std::vector<long, std::allocator<long>>>, const long &)");
+
+ end_of_test:
+
+    ;
+
+}
+#endif
diff --git a/src/mangling/demangler.h b/src/mangling/demangler.h
new file mode 100644
index 0000000..00218e4
--- /dev/null
+++ b/src/mangling/demangler.h
@@ -0,0 +1,50 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * demangler.h - prototypes pour le décodage des noms d'éléments
+ *
+ * Copyright (C) 2009-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_DEMANGLER_H
+#define _FORMAT_MANGLING_DEMANGLER_H
+
+
+#include "../analysis/routine.h"
+
+
+
+/* Tente de décoder une chaîne de caractères donnée. */
+GBinRoutine *try_to_demangle_routine(const char *);
+
+/* Tente de décoder une chaîne de caractères donnée. */
+GBinRoutine *demangle_routine(GType, const char *);
+
+/* Tente de décoder une chaîne de caractères donnée. */
+GDataType *demangle_type(GType, const char *);
+
+
+
+/* Procède au test de décodages de chaînes de caractères. */
+#ifdef DEBUG
+void test_itanium_demangling(void);
+#endif
+
+
+
+#endif  /* _FORMAT_MANGLING_DEMANGLER_H */
diff --git a/src/mangling/dex/Makefile.am b/src/mangling/dex/Makefile.am
new file mode 100644
index 0000000..547d686
--- /dev/null
+++ b/src/mangling/dex/Makefile.am
@@ -0,0 +1,46 @@
+
+BUILT_SOURCES = libmanglingdexshorty_la-shorty_gram.h libmanglingdextype_la-type_gram.h
+
+AM_YFLAGS = -d
+
+noinst_LTLIBRARIES = libmanglingdex.la libmanglingdexshorty.la libmanglingdextype.la
+
+libmanglingdex_la_SOURCES =				\
+	context.h context.c
+
+libmanglingdex_la_LDFLAGS = 
+
+libmanglingdex_la_LIBADD =				\
+	libmanglingdexshorty.la				\
+	libmanglingdextype.la
+
+
+libmanglingdexshorty_la_SOURCES =		\
+	shorty_gram.y						\
+	shorty_tok.l
+
+libmanglingdexshorty_la_YFLAGS = -d -p shorty_ -o y.tab.c
+
+libmanglingdexshorty_la_LFLAGS = -P shorty_ -o lex.yy.c
+
+
+libmanglingdextype_la_SOURCES =			\
+	type_gram.y							\
+	type_tok.l
+
+libmanglingdextype_la_YFLAGS = -d -p type_ -o y.tab.c
+
+libmanglingdextype_la_LFLAGS = -P type_ -o lex.yy.c
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+
+# Automake fait les choses à moitié
+CLEANFILES = \
+	libmanglingdexshorty_la-shorty_gram.h libmanglingdexshorty_la-shorty_gram.c \
+	libmanglingdexshorty_la-shorty_tok.c \
+	libmanglingdextype_la-type_gram.h libmanglingdextype_la-type_gram.c \
+	libmanglingdextype_la-type_tok.c
diff --git a/src/mangling/dex/context.c b/src/mangling/dex/context.c
new file mode 100644
index 0000000..9dd9b9c
--- /dev/null
+++ b/src/mangling/dex/context.c
@@ -0,0 +1,154 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.c - contextes de décodage DEX
+ *
+ * Copyright (C) 2015-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "context.h"
+
+
+#include "../context-int.h"
+
+
+
+/* Contexte de décodage DEX (instance) */
+struct _GDexDemangler
+{
+    GDemanglingContext parent;              /* A laisser en premier        */
+
+};
+
+/* Contexte de décodage DEX (classe) */
+struct _GDexDemanglerClass
+{
+    GDemanglingContextClass parent;         /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des contextes de décodage DEX. */
+static void g_dex_demangler_class_init(GDexDemanglerClass *);
+
+/* Initialise une instance de contexte pour décodage DEX. */
+static void g_dex_demangler_init(GDexDemangler *);
+
+/* Supprime toutes les références externes. */
+static void g_dex_demangler_dispose(GDexDemangler *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dex_demangler_finalize(GDexDemangler *);
+
+
+/* Procède au décodage d'une chaîne de caractères. */
+extern bool demangle_dex_routine(GDexDemangler *, const char *);
+
+/* Procède au décodage d'une chaîne de caractères. */
+extern bool demangle_dex_type(GDexDemangler *, const char *);
+
+
+
+/* Indique le type défini pour un contexte de décodage DEX. */
+G_DEFINE_TYPE(GDexDemangler, g_dex_demangler, G_TYPE_DEMANGLING_CONTEXT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage DEX.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dex_demangler_class_init(GDexDemanglerClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GDemanglingContextClass *context;       /* Version parente             */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_dex_demangler_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_dex_demangler_finalize;
+
+    context = G_DEMANGLING_CONTEXT_CLASS(klass);
+
+    context->demangle_type = (demangle_fc)demangle_dex_type;
+    context->demangle_routine = (demangle_fc)demangle_dex_routine;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = instance à initialiser.                          *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage DEX.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dex_demangler_init(GDexDemangler *demangler)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = instance d'objet GLib à traiter.                 *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dex_demangler_dispose(GDexDemangler *demangler)
+{
+    G_OBJECT_CLASS(g_dex_demangler_parent_class)->dispose(G_OBJECT(demangler));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = instance d'objet GLib à traiter.                 *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dex_demangler_finalize(GDexDemangler *demangler)
+{
+    G_OBJECT_CLASS(g_dex_demangler_parent_class)->finalize(G_OBJECT(demangler));
+
+}
diff --git a/src/mangling/dex/context.h b/src/mangling/dex/context.h
new file mode 100644
index 0000000..1af7a9d
--- /dev/null
+++ b/src/mangling/dex/context.h
@@ -0,0 +1,52 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.h - prototypes internes liés aux contextes de décodage DEX
+ *
+ * Copyright (C) 2015-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_DEX_CONTEXT_H
+#define _FORMAT_MANGLING_DEX_CONTEXT_H
+
+
+#include <glib-object.h>
+
+
+
+#define G_TYPE_DEX_DEMANGLER               g_dex_demangler_get_type()
+#define G_DEX_DEMANGLER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dex_demangler_get_type(), GDexDemangler))
+#define G_IS_DEX_DEMANGLER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dex_demangler_get_type()))
+#define G_DEX_DEMANGLER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEX_DEMANGLER, GDexDemanglerClass))
+#define G_IS_DEX_DEMANGLER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEX_DEMANGLER))
+#define G_DEX_DEMANGLER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEX_DEMANGLER, GDexDemanglerClass))
+
+
+/* Contexte de décodage DEX (instance) */
+typedef struct _GDexDemangler GDexDemangler;
+
+/* Contexte de décodage DEX (classe) */
+typedef struct _GDexDemanglerClass GDexDemanglerClass;
+
+
+/* Indique le type défini pour un contexte de décodage DEX. */
+GType g_dex_demangler_get_type(void);
+
+
+
+#endif  /* _FORMAT_MANGLING_DEX_CONTEXT_H */
diff --git a/src/mangling/dex/shorty_gram.y b/src/mangling/dex/shorty_gram.y
new file mode 100644
index 0000000..b688896
--- /dev/null
+++ b/src/mangling/dex/shorty_gram.y
@@ -0,0 +1,138 @@
+
+%{
+
+#include <stdbool.h>
+
+
+#include "context.h"
+#include "../context-int.h"
+
+
+
+/* Affiche un message d'erreur concernant l'analyse. */
+static int shorty_error(GDexDemangler *, char *);
+
+/* Procède au décodage d'une chaîne de caractères. */
+bool demangle_dex_routine(GDexDemangler *, const char *);
+
+
+%}
+
+
+%code requires {
+
+#include "../../analysis/types/basic.h"
+#include "../../analysis/types/cse.h"
+
+}
+
+%union {
+
+    GDataType *type;                        /* Type reconstruit            */
+
+}
+
+
+%parse-param { GDexDemangler *demangler }
+
+%token V Z B S C I J F D L
+
+%type <type> shorty_return_type shorty_field_type
+
+
+%{
+
+/* Déclarations issues de l'analyseur syntaxique... */
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern YY_BUFFER_STATE shorty__scan_string(const char *);
+extern void shorty__delete_buffer(YY_BUFFER_STATE);
+extern int shorty_lex(void);
+
+%}
+
+
+%%
+
+
+shorty_descriptor:
+    shorty_return_type shorty_field_type_list {
+                                                  GBinRoutine *routine;
+                                                  routine = G_DEMANGLING_CONTEXT(demangler)->routine;
+                                                  g_binary_routine_set_return_type(routine, $1);
+                                              }
+
+shorty_field_type_list:
+    /* empty */
+    | shorty_field_type shorty_field_type_list {
+                                                   GBinRoutine *routine;
+                                                   GBinVariable *var;
+                                                   routine = G_DEMANGLING_CONTEXT(demangler)->routine;
+                                                   var = g_binary_variable_new($1);
+                                                   g_binary_routine_add_arg(routine, var);
+                                               }
+
+shorty_return_type:
+    V                                   { $$ = g_basic_type_new(BTP_VOID); }
+    | shorty_field_type                 { $$ = $1; }
+
+shorty_field_type:
+    Z                                   { $$ = g_basic_type_new(BTP_BOOL); }
+	| B                                 { $$ = g_basic_type_new(BTP_UCHAR); }
+	| S                                 { $$ = g_basic_type_new(BTP_SHORT); }
+	| C                                 { $$ = g_basic_type_new(BTP_CHAR); }
+	| I                                 { $$ = g_basic_type_new(BTP_INT); }
+	| J                                 { $$ = g_basic_type_new(BTP_LONG); }
+	| F                                 { $$ = g_basic_type_new(BTP_FLOAT); }
+    | D                                 { $$ = g_basic_type_new(BTP_DOUBLE); }
+    | L                                 { $$ = g_class_enum_type_new(CET_CLASS, ""); }
+
+
+%%
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = contexte associé à la procédure de décodage.     *
+*                msg       = indications humaines sur l'événement.            *
+*                                                                             *
+*  Description : Affiche un message d'erreur concernant l'analyse.            *
+*                                                                             *
+*  Retour      : Valeur historique, ignorée.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+static int shorty_error(GDexDemangler *demangler, char *msg)
+{
+	return -1;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = contexte de décodage à utiliser.                 *
+*                desc      = chaîne de caractères à décoder.                  *
+*                                                                             *
+*  Description : Procède au décodage d'une chaîne de caractères.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool demangle_dex_routine(GDexDemangler *demangler, const char *desc)
+{
+	YY_BUFFER_STATE buffer;                 /* Tampon pour bison           */
+	int ret;                                /* Bilan de l'appel            */
+
+	buffer = shorty__scan_string(desc);
+	ret = yyparse(demangler);
+	shorty__delete_buffer(buffer);
+
+    return (ret == 0);
+
+}
diff --git a/src/mangling/dex/shorty_tok.l b/src/mangling/dex/shorty_tok.l
new file mode 100644
index 0000000..92c264a
--- /dev/null
+++ b/src/mangling/dex/shorty_tok.l
@@ -0,0 +1,28 @@
+
+%{
+
+#include "context.h"
+#include "libformatmanglingdexshorty_la-shorty_gram.h"
+
+%}
+
+
+%option noyywrap
+%option yylineno
+%option nounput
+%option noinput
+
+%%
+
+"V"                     { return V; }
+"Z"                     { return Z; }
+"B"                     { return B; }
+"S"                     { return S; }
+"C"                     { return C; }
+"I"                     { return I; }
+"J"                     { return J; }
+"F"                     { return F; }
+"D"                     { return D; }
+"L"                     { return L; }
+
+%%
diff --git a/src/mangling/dex/type_gram.y b/src/mangling/dex/type_gram.y
new file mode 100644
index 0000000..79c9320
--- /dev/null
+++ b/src/mangling/dex/type_gram.y
@@ -0,0 +1,159 @@
+
+%{
+
+#include <stdbool.h>
+
+
+#include "context.h"
+#include "../context-int.h"
+
+typedef void *yyscan_t;
+
+/* Affiche un message d'erreur concernant l'analyse. */
+static int type_error(GDexDemangler *, yyscan_t, char *);
+
+/* Procède au décodage d'une chaîne de caractères. */
+bool demangle_dex_type(GDexDemangler *, const char *);
+
+
+%}
+
+
+%code requires {
+
+#include "../../analysis/types/basic.h"
+#include "../../analysis/types/cse.h"
+#include "../../common/extstr.h"
+
+}
+
+%union {
+
+    GDataType *type;                        /* Type reconstruit            */
+    size_t adeep;                           /* Dimension d'un tableau      */
+    char *text;                             /* Chaîne de caractères        */
+
+}
+
+
+
+%define api.pure full
+%parse-param { GDexDemangler *demangler } { yyscan_t scanner }
+%lex-param { yyscan_t scanner }
+
+
+%token V Z B S C I J F D
+%token ARRAY
+%token L SEMICOLON
+%token SLASH DOLLAR
+%token TEXT
+
+%type <type> type_descriptor field_type_descriptor non_array_field_type_descriptor full_class_name
+
+%type <text> TEXT simple_name
+
+
+%{
+
+/* Déclarations issues de l'analyseur syntaxique... */
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int type_lex_init(yyscan_t *scanner);
+extern YY_BUFFER_STATE type__scan_string(const char *, yyscan_t);
+extern void type__delete_buffer(YY_BUFFER_STATE, yyscan_t);
+extern int type_lex(YYSTYPE *, yyscan_t);
+extern int type_lex_destroy(yyscan_t);
+
+%}
+
+
+%%
+
+
+input:
+    type_descriptor                     { G_DEMANGLING_CONTEXT(demangler)->type = $1; }
+
+type_descriptor:
+    V                                   { $$ = g_basic_type_new(BTP_VOID); }
+    | field_type_descriptor             { $$ = $1; }
+
+field_type_descriptor:
+	non_array_field_type_descriptor             { $$ = $1; }
+	| ARRAY non_array_field_type_descriptor     { $$ = $2; }
+
+non_array_field_type_descriptor:
+	Z                                   { $$ = g_basic_type_new(BTP_BOOL); }
+	| B                                 { $$ = g_basic_type_new(BTP_UCHAR); }
+	| S                                 { $$ = g_basic_type_new(BTP_SHORT); }
+	| C                                 { $$ = g_basic_type_new(BTP_CHAR); }
+	| I                                 { $$ = g_basic_type_new(BTP_INT); }
+	| J                                 { $$ = g_basic_type_new(BTP_LONG); }
+	| F                                 { $$ = g_basic_type_new(BTP_FLOAT); }
+	| D                                 { $$ = g_basic_type_new(BTP_DOUBLE); }
+	| L full_class_name SEMICOLON       { $$ = $2; }
+
+full_class_name:
+    simple_name                         { $$ = g_class_enum_type_new(CET_CLASS, $1); }
+    | full_class_name SLASH simple_name {
+                                            $$ = g_class_enum_type_new(CET_CLASS, $3);
+                                            g_data_type_set_namespace($$, $1);
+                                            g_object_unref($1);
+                                        }
+simple_name:
+    TEXT                                { $$ = strdup($1); }
+    | simple_name TEXT                  { $$ = stradd($1, $2); }
+
+%%
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = contexte associé à la procédure de décodage.     *
+*                scanner   = données internes aux analyseurs.                 *
+*                msg       = indications humaines sur l'événement.            *
+*                                                                             *
+*  Description : Affiche un message d'erreur concernant l'analyse.            *
+*                                                                             *
+*  Retour      : Valeur historique, ignorée.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+static int type_error(GDexDemangler *demangler, yyscan_t scanner, char *msg)
+{
+	return -1;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : demangler = contexte de décodage à utiliser.                 *
+*                desc      = chaîne de caractères à décoder.                  *
+*                                                                             *
+*  Description : Procède au décodage d'une chaîne de caractères.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool demangle_dex_type(GDexDemangler *demangler, const char *desc)
+{
+    yyscan_t scanner;                       /* Données internes            */
+	YY_BUFFER_STATE buffer;                 /* Tampon pour bison           */
+	int ret;                                /* Bilan de l'appel            */
+
+    type_lex_init(&scanner);
+
+    buffer = type__scan_string(desc, scanner);
+	ret = yyparse(demangler, scanner);
+	type__delete_buffer(buffer, scanner);
+
+    type_lex_destroy(scanner);
+
+    return (ret == 0);
+
+}
diff --git a/src/mangling/dex/type_tok.l b/src/mangling/dex/type_tok.l
new file mode 100644
index 0000000..918846a
--- /dev/null
+++ b/src/mangling/dex/type_tok.l
@@ -0,0 +1,150 @@
+
+%{
+
+#include "context.h"
+#include "libformatmanglingdextype_la-type_gram.h"
+
+/* See lemoda.net/c/reentrant-parser */
+
+%}
+
+
+%option noyywrap
+%option yylineno
+%option nounput
+/*%option noinput*/
+%option reentrant
+%option bison-bridge
+
+%x string
+
+ASCII       [A-Za-z0-9]
+SIMPLE      {ASCII}|"$"|"-"|"_"
+
+%%
+
+"V"                     { return V; }
+"Z"                     { return Z; }
+"B"                     { return B; }
+"S"                     { return S; }
+"C"                     { return C; }
+"I"                     { return I; }
+"J"                     { return J; }
+"F"                     { return F; }
+"D"                     { return D; }
+"L"                     { BEGIN(string); return L; }
+"["*                    { yylval->adeep = strlen(yytext); return ARRAY; }
+<string>"/"             { return SLASH; }
+<string>";"             { BEGIN(INITIAL); return SEMICOLON; }
+
+<string>{SIMPLE}*       { yylval->text = yytext; return TEXT; }
+
+<string>.               {
+                            unsigned char next;
+                            char mutf8[4];
+
+                            switch ((unsigned char)yytext[0])
+                            {
+                                /* U+00a1 ... U+1fff */
+                                case 0x00 ... 0x1f:
+
+                                    next = input(yyscanner);
+
+                                    if (yytext[0] == 0x00 && next < 0xa1)
+                                    {
+                                        REJECT;
+                                    }
+
+                                    else
+                                    {
+                                        mutf8[0] = yytext[0];
+                                        mutf8[1] = next;
+                                        mutf8[2] = '\0';
+
+                                        strcpy(yylval->text, mutf8); return TEXT;
+
+                                    }
+
+                                    break;
+
+                                /* U+2010 ... U+2027 / U+2030 ... U+d7ff */
+                                case 0x20:
+
+                                    next = input(yyscanner);
+
+                                    switch (next)
+                                    {
+                                        case 0x10 ... 0x27:
+                                        case 0x30 ... 0xff:
+
+                                            mutf8[0] = yytext[0];
+                                            mutf8[1] = next;
+                                            mutf8[2] = '\0';
+
+                                            strcpy(yylval->text, mutf8); return TEXT;
+                                            break;
+
+                                        default:
+                                            REJECT;
+                                            break;
+
+                                    }
+
+                                    break;
+
+                                /* ~ U+2030 ... U+d7ff */
+                                case 0x21 ... 0xd7:
+
+                                    next = input(yyscanner);
+
+                                    mutf8[0] = yytext[0];
+                                    mutf8[1] = next;
+                                    mutf8[2] = '\0';
+
+                                    strcpy(yylval->text, mutf8); return TEXT;
+                                    break;
+
+                                /* U+e000 ... U+ffef */
+                                case 0xe0 ... 0xff:
+
+                                    next = input(yyscanner);
+
+                                    if (yytext[0] == 0xff && next > 0xef)
+                                    {
+                                        REJECT;
+                                    }
+
+                                    else
+                                    {
+                                        mutf8[0] = yytext[0];
+                                        mutf8[1] = next;
+                                        mutf8[2] = '\0';
+
+                                        strcpy(yylval->text, mutf8); return TEXT;
+
+                                    }
+
+                                    break;
+
+                                /* U+10000 ... U+10ffff */
+                                /*
+                                case 0x10:
+
+                                    mutf8[0] = yytext[0];
+                                    mutf8[1] = input(yyscanner);
+                                    mutf8[2] = input(yyscanner);
+                                    mutf8[3] = '\0';
+
+                                    strcpy(yylval->text, mutf8); return TEXT;
+                                    break;
+                                */
+
+                                default:
+                                    REJECT;
+                                    break;
+
+                            }
+
+                        }
+
+%%
diff --git a/src/mangling/itanium/Makefile.am b/src/mangling/itanium/Makefile.am
new file mode 100755
index 0000000..216788b
--- /dev/null
+++ b/src/mangling/itanium/Makefile.am
@@ -0,0 +1,19 @@
+
+noinst_LTLIBRARIES  = libmanglingitanium.la
+
+libmanglingitanium_la_SOURCES =			\
+	abi.h abi.c							\
+	component-int.h						\
+	component.h component.c				\
+	context.h context.c
+
+libmanglingitanium_la_LIBADD = 
+
+libmanglingitanium_la_LDFLAGS = 
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS = 
diff --git a/src/mangling/itanium/abi.c b/src/mangling/itanium/abi.c
new file mode 100644
index 0000000..3970482
--- /dev/null
+++ b/src/mangling/itanium/abi.c
@@ -0,0 +1,2444 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * abi.c - décodage des noms d'éléments selon l'ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "abi.h"
+
+
+#include <ctype.h>
+#include <stdlib.h>
+
+
+
+#include "../../analysis/types/basic.h"
+#include "../../common/cpp.h"
+
+
+
+/* Liste des opérateurs reconnus */
+
+#define IDT_NL(s) s, sizeof(s) - 1
+
+const itanium_operator_info itanium_demangle_operators[] = {
+
+    { "aN", IDT_NL("&="),               2 },
+    { "aS", IDT_NL("="),                2 },
+    { "aa", IDT_NL("&&"),               2 },
+    { "ad", IDT_NL("&"),                1 },
+    { "an", IDT_NL("&"),                2 },
+    { "at", IDT_NL("alignof "),         1 },
+    { "az", IDT_NL("alignof "),         1 },
+    { "cc", IDT_NL("const_cast"),       2 },
+    { "cl", IDT_NL("()"),               2 },
+    { "cm", IDT_NL(","),                2 },
+    { "co", IDT_NL("~"),                1 },
+    { "dV", IDT_NL("/="),               2 },
+    { "da", IDT_NL("delete[] "),        1 },
+    { "dc", IDT_NL("dynamic_cast"),     2 },
+    { "de", IDT_NL("*"),                1 },
+    { "dl", IDT_NL("delete "),          1 },
+    { "ds", IDT_NL(".*"),               2 },
+    { "dt", IDT_NL("."),                2 },
+    { "dv", IDT_NL("/"),                2 },
+    { "eO", IDT_NL("^="),               2 },
+    { "eo", IDT_NL("^"),                2 },
+    { "eq", IDT_NL("=="),               2 },
+    { "ge", IDT_NL(">="),               2 },
+    { "gs", IDT_NL("::"),	            1 },
+    { "gt", IDT_NL(">"),                2 },
+    { "ix", IDT_NL("[]"),               2 },
+    { "lS", IDT_NL("<<="),              2 },
+    { "le", IDT_NL("<="),               2 },
+    { "li", IDT_NL("operator\"\" "),    1 },
+    { "ls", IDT_NL("<<"),               2 },
+    { "lt", IDT_NL("<"),                2 },
+    { "mI", IDT_NL("-="),               2 },
+    { "mL", IDT_NL("*="),               2 },
+    { "mi", IDT_NL("-"),                2 },
+    { "ml", IDT_NL("*"),                2 },
+    { "mm", IDT_NL("--"),               1 },
+    { "na", IDT_NL("new[]"),            3 },
+    { "ne", IDT_NL("!="),               2 },
+    { "ng", IDT_NL("-"),                1 },
+    { "nt", IDT_NL("!"),                1 },
+    { "nw", IDT_NL("new"),              3 },
+    { "oR", IDT_NL("|="),               2 },
+    { "oo", IDT_NL("||"),               2 },
+    { "or", IDT_NL("|"),                2 },
+    { "pL", IDT_NL("+="),               2 },
+    { "pl", IDT_NL("+"),                2 },
+    { "pm", IDT_NL("->*"),              2 },
+    { "pp", IDT_NL("++"),               1 },
+    { "ps", IDT_NL("+"),                1 },
+    { "pt", IDT_NL("->"),               2 },
+    { "qu", IDT_NL("?"),                3 },
+    { "rM", IDT_NL("%="),               2 },
+    { "rS", IDT_NL(">>="),              2 },
+    { "rc", IDT_NL("reinterpret_cast"), 2 },
+    { "rm", IDT_NL("%"),                2 },
+    { "rs", IDT_NL(">>"),               2 },
+    { "sc", IDT_NL("static_cast"),      2 },
+    { "st", IDT_NL("sizeof "),          1 },
+    { "sz", IDT_NL("sizeof "),          1 },
+    { "tr", IDT_NL("throw"),            0 },
+    { "tw", IDT_NL("throw "),           1 }
+};
+
+/* Substitutions standards */
+
+typedef struct _itanium_std_subst_info
+{
+    char code;                              /* Identifiant associé         */
+
+    const char *simple;                     /* Représentation simple       */
+    size_t simple_len;                      /* Taille de cette représentat°*/
+
+    const char *full;                       /* Représentation complète     */
+    size_t full_len;                        /* Taille de cette représentat°*/
+
+    const char *last_name;                  /* Pour les (con|de)structeurs */
+    size_t last_name_len;                   /* Taille de cette indication  */
+
+} itanium_std_subst_info;
+
+const itanium_std_subst_info itanium_standard_substitutions[] = {
+
+    {
+        't',
+        IDT_NL("std"),
+        IDT_NL("std"),
+        NULL,
+        0
+    },
+    {
+        'a',
+        IDT_NL("std::allocator"),
+        IDT_NL("std::allocator"),
+        IDT_NL("allocator")
+    },
+    {
+        'b',
+        IDT_NL("std::basic_string"),
+        IDT_NL("std::basic_string"),
+        IDT_NL("basic_string")
+    },
+    {
+        's',
+        IDT_NL("std::string"),
+        IDT_NL("std::basic_string<char, std::char_traits<char>, std::allocator<char>>"),
+        IDT_NL("basic_string")
+    },
+    {
+        'i',
+        IDT_NL("std::istream"),
+        IDT_NL("std::basic_istream<char, std::char_traits<char>>"),
+        IDT_NL("basic_istream")
+    },
+    {
+        'o',
+        IDT_NL("std::ostream"),
+        IDT_NL("std::basic_ostream<char, std::char_traits<char>>"),
+        IDT_NL("basic_ostream")
+    },
+    {
+        'd',
+        IDT_NL("std::iostream"),
+        IDT_NL("std::basic_iostream<char, std::char_traits<char>>"),
+        IDT_NL("basic_iostream")
+    }
+
+};
+
+
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_encoding(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_unscoped_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_unscoped_template_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_nested_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_prefix(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_template_prefix(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_unqualified_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_source_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static bool itd_number(GItaniumDContext *, ssize_t *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_identifier(GItaniumDContext *, size_t);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_operator_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_special_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_call_offset(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_nv_offset(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_v_offset(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_ctor_dtor_name(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_type(GItaniumDContext *);
+
+/* Extrait une propriété de composant pour un contexte Itanium. */
+static TypeQualifier itd_cv_qualifiers(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_builtin_type(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_bare_function_type(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_class_enum_type(GItaniumDContext *);
+
+
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_template_args(GItaniumDContext *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_template_arg(GItaniumDContext *);
+
+
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_value_to_string(GItaniumDContext *, bool);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_expr_primary(GItaniumDContext *);
+
+
+
+
+/* Extrait un composant dans un contexte Itanium. */
+static bool itd_seq_id(GItaniumDContext *, char, size_t *);
+
+/* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_substitution(GItaniumDContext *);
+
+
+
+
+
+
+#define itd_template_param(ctx) NULL
+
+
+#define itd_local_name(ctx) NULL
+
+
+
+
+#define itd_expression(ctx) NULL
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_mangled_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <mangled-name> ::= _Z <encoding>
+     *
+     */
+
+    if (!g_itanium_dcontext_check_char(context, '_'))
+        return NULL;
+
+    if (!g_itanium_dcontext_check_char(context, 'Z'))
+        return NULL;
+
+    result = itd_encoding(context);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_encoding(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *func;                /* Composant 'function name'   */
+    itanium_component *types;               /* Composant 'bare-function...'*/
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <encoding> ::= <function name> <bare-function-type>
+     *            ::= <data name>
+     *            ::= <special-name>
+     *
+     */
+
+    result = NULL;
+    g_itanium_dcontext_push_state(context, &saved);
+
+    func = itd_name(context);
+
+    if (func != NULL)
+    {
+        types = itd_bare_function_type(context);
+
+        if (types != NULL)
+            result = itd_make_binary(context, ICT_FUNCTION_ENCODING, func, types);
+        else
+            itd_unref_comp(func);
+
+    }
+    /*
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_name(context);
+    }
+    */
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_special_name(context);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *tname;               /* Composant '...template-name'*/
+    itanium_component *targs;               /* Composant 'template-args'   */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <name> ::= <nested-name>
+     *        ::= <unscoped-name>
+     *        ::= <unscoped-template-name> <template-args>
+     *        ::= <local-name>
+     *
+     */
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    result = itd_nested_name(context);
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+
+        tname = itd_unscoped_template_name(context);
+
+        if (tname != NULL)
+        {
+            targs = itd_template_args(context);
+
+            if (targs != NULL)
+            {
+                g_itanium_dcontext_add_substitution(context, tname);
+                result = itd_make_binary(context, ICT_TEMPLATE_NAME_ARGS, tname, targs);
+            }
+
+            else
+                itd_unref_comp(tname);
+
+        }
+
+    }
+
+    /**
+     * La règle <unscoped-name> doit être traitée après <unscoped-template-name>,
+     * car ces deux dernières ont une base commune et la seconde peut avoir besoin
+     * d'aller plus loin avec la règle <template-args>.
+     *
+     * On termine donc par moins gourmand si la règle la plus complexe n'a pas abouti.
+     */
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_unscoped_name(context);
+    }
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_local_name(context);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_unscoped_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <unscoped-name> ::= <unqualified-name>
+     *                 ::= St <unqualified-name>   # ::std::
+     *
+     */
+
+
+    /* TODO : 'St' */
+
+
+    result = itd_unqualified_name(context);
+
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_unscoped_template_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <unscoped-template-name> ::= <unscoped-name>
+     *                          ::= <substitution>
+     *
+     */
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    result = itd_unscoped_name(context);
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_substitution(context);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_nested_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    TypeQualifier qualifier;                /* Propriétés supplémentaires  */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *left;                /* Première partie             */
+    itanium_component *right;               /* Seconde partie              */
+
+    static int inner = 0;
+
+    int val = inner++;
+
+    printf("\n ### (%d) NESTED>> '%s'\n", val,
+           g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
+     *               ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
+     *
+     */
+
+    if (!g_itanium_dcontext_check_char(context, 'N'))
+        return NULL;
+
+    qualifier = itd_cv_qualifiers(context);
+
+    result = NULL;
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+
+    printf("\n ----- (%d) nested prefix '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+
+
+    left = itd_prefix(context);
+
+    if (left != NULL)
+    {
+        if (itd_get_component_type(left) != ICT_EMPTY)
+            g_itanium_dcontext_add_substitution(context, left);
+
+        right = itd_unqualified_name(context);
+
+        if (right != NULL)
+        {
+            if (g_itanium_dcontext_check_char(context, 'E'))
+                result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
+            else
+                printf("=== (%d) nested/prefix : BAD E\n\n", val);
+
+            //result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
+
+        }
+        else
+            itd_unref_comp(left);
+
+        printf(" ---- (%d) nested prefix --> %p\n\n", val, result);
+
+    }
+
+
+    if (result == NULL)
+    {
+        printf("\n ----- (%d) nested template_arg '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+        g_itanium_dcontext_pop_state(context, &saved);
+
+        left = itd_template_prefix(context);
+
+        if (left != NULL)
+        {
+            g_itanium_dcontext_add_substitution(context, left);
+
+            right = itd_template_args(context);
+
+            if (right != NULL)
+            {
+                if (g_itanium_dcontext_check_char(context, 'E'))
+                    result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
+                else
+                    printf("=== (%d) nested/prefix : BAD E\n\n", val);
+            }
+            else
+                itd_unref_comp(left);
+
+        }
+
+        printf(" ---- (%d) nested template_arg --> %p\n\n", val, result);
+
+    }
+
+
+
+    printf("(%d)   nested/E >> '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+    /*
+    if (!g_itanium_dcontext_check_char(context, 'E'))
+    {
+        printf("=== (%d) NESTED : BAD E\n\n", val);
+
+        if (result != NULL)
+            itd_unref_comp(result);
+        return NULL;
+    }
+    */
+
+    if (result != NULL)
+    printf("=== (%d) NESTED OK (%p)\n\n", val, result);
+
+    inner--;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_prefix(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itanium_component *looping_rule;        /* Extraction d'une boucle     */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *left;                /* Première partie             */
+    itanium_component *right;               /* Seconde partie              */
+
+    itd_state next_name_saved;              /* Position d'analyse courante */
+    itanium_component *next_name;           /* Eventuel complément #1      */
+    itd_state next_targs_saved;             /* Position d'analyse courante */
+    itanium_component *next_targs;          /* Eventuel complément #2      */
+
+
+
+    itd_state expected_saved;               /* Position d'analyse suivante */
+    itanium_component *expected;            /* Nom non-qualifié en réserve */
+
+
+
+    /**
+     * Les deux règles traitées ici sont les suivantes :
+     *
+     * <prefix> ::= <prefix> <unqualified-name>
+     *          ::= <template-prefix> <template-args>
+     *          ::= <template-param>
+     *          ::= # empty
+     *          ::= <substitution>
+     *
+     * <template-prefix> ::= <prefix> <template unqualified-name>
+     *                   ::= <template-param>
+     *                   ::= <substitution>
+     *
+     * Pour éviter une récursivité qui ferait exploser la pile, on les fusionne
+     * en une nouvelle règle <prefix> étendue :
+     *
+     * <prefix> ::= <prefix> <unqualified-name>
+     *          ::= <prefix> <unqualified-name> <template-args>
+     *          ::= <template-param> <template-args>
+     *          ::= <substitution> <template-args>
+     *          ::= <template-param>
+     *          ::= # empty
+     *          ::= <substitution>
+     *
+     * On découpe ainsi les traitements en deux parties :
+     *  - extraction du socle non récursif.
+     *  - extraction éventuelle d'un complément <unqualified-name> [<template-args>]
+     */
+
+    result = NULL;
+
+    while (1)
+    {
+        printf("loop....\n");
+
+        looping_rule = NULL;
+
+        /**
+         * Première partie.
+         */
+
+        g_itanium_dcontext_push_state(context, &saved);
+
+        /* <template-param> <template-args> */
+
+        left = itd_template_param(context);
+
+        if (left != NULL)
+        {
+            g_itanium_dcontext_add_substitution(context, left);
+
+            right = itd_template_args(context);
+
+            if (right != NULL)
+                looping_rule = itd_make_binary(context, ICT_PREFIX_BINARY, left, right);
+            else
+                itd_unref_comp(left);
+
+        }
+
+        /* <substitution> <template-args> */
+
+        if (looping_rule != NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved);
+
+            left = itd_substitution(context);
+
+            if (left != NULL)
+            {
+                right = itd_template_args(context);
+
+                if (right != NULL)
+                    looping_rule = itd_make_binary(context, ICT_PREFIX_BINARY, left, right);
+                else
+                    itd_unref_comp(left);
+
+            }
+
+        }
+
+        /* <template-param> */
+
+        if (looping_rule == NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved);
+            looping_rule = itd_template_param(context);
+        }
+
+        /* <substitution> */
+
+        if (looping_rule == NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved);
+            looping_rule = itd_substitution(context);
+        }
+
+        printf("looping_rule = %p\n", looping_rule);
+
+        if (looping_rule != NULL)
+        {
+            if (result == NULL)
+                result = looping_rule;
+            else
+                result = itd_make_binary(context, ICT_PREFIX_BINARY, result, looping_rule);
+        }
+
+        /**
+         * Seconde partie (1/3) : recherche d'un éventuel complément.
+         */
+
+        if (looping_rule == NULL)
+            g_itanium_dcontext_pop_state(context, &saved);
+
+        /* <unqualified-name> */
+
+        g_itanium_dcontext_push_state(context, &next_name_saved);
+
+        next_name = itd_unqualified_name(context);
+
+        if (next_name == NULL)
+        {
+            /**
+             * Si on n'obtient pas de <unqualified-name> ici, rien ne sert de
+             * continuer. On se dirige donc vers la sortie avec ce que l'on a.
+             */
+
+            return NULL;
+
+            break;
+
+        }
+
+        /* <template-args> */
+
+        g_itanium_dcontext_push_state(context, &next_targs_saved);
+
+        next_targs = itd_template_args(context);
+
+        g_itanium_dcontext_pop_state(context, &next_targs_saved);
+
+        /**
+         * Seconde partie (2/3) : validation de la présence d'un jeton
+         * <unqualified-name> en réserve pour la règle <nested-name> parente.
+         */
+
+        g_itanium_dcontext_push_state(context, &expected_saved);
+
+        expected = itd_unqualified_name(context);
+
+        if (expected == NULL)
+        {
+            /**
+             * La lecture a été trop loin ici.
+             *
+             * Le dernier <unqualified-name> valide pour la règle parente est
+             * donc celui lu à une fin de recherche de complément.
+             *
+             * On revient donc à ce stade avant de se diriger vers la sortie.
+             */
+
+            itd_unref_comp(next_name);
+
+            if (next_targs != NULL)
+                itd_unref_comp(next_targs);
+
+            g_itanium_dcontext_pop_state(context, &next_name_saved);
+
+            break;
+
+        }
+
+        g_itanium_dcontext_pop_state(context, &expected_saved);
+
+        /**
+         * Seconde partie (3/3) : pleine inscription des composants extraits.
+         *
+         * On s'est manifestement retrouvé dans un des deux cas suivants :
+         * - <prefix> ::= <prefix> <unqualified-name>
+         * - <prefix> ::= <prefix> <template unqualified-name> <template-args>
+         *
+         * Or <prefix> est un candidat pour des substitutions futures, donc on
+         * procède à son enregistrement, s'il n'est pas nul.
+         */
+
+        if (result != NULL)
+            g_itanium_dcontext_add_substitution(context, result);
+
+        printf("result = %p  -  next_name = %p\n", result, next_name);
+
+
+        if (result == NULL)
+            result = next_name;
+        else
+            result = itd_make_binary(context, ICT_PREFIX_BINARY, result, next_name);
+
+        if (next_targs != NULL)
+            result = itd_make_binary(context, ICT_PREFIX_BINARY, result, next_targs);
+
+
+        printf(" > result = %p\n", result);
+
+    }
+
+    if (result == NULL)
+        result = itd_make_empty(context);
+    /*
+    if (itd_get_component_type(result) != ICT_PREFIX_BINARY)
+        result = itd_make_unary(context, ICT_PREFIX_UNARY, result);
+    */
+    //printf("<prefix> : %p\n", result);
+
+    printf("### FIN DE PREFIX ### '%s'\n",
+           g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_template_prefix(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *prefix;              /* Premier d'un couple de comp.*/
+    itanium_component *name;                /* Second d'un couple de comp. */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <template-prefix> ::= <prefix> <template unqualified-name>
+     *                   ::= <template-param>
+     *                   ::= <substitution>
+     *
+     */
+
+    result = NULL;
+    g_itanium_dcontext_push_state(context, &saved);
+
+    prefix = itd_prefix(context);
+
+    if (prefix != NULL)
+    {
+        name = itd_unqualified_name(context);
+
+        if (name != NULL)
+            result = itd_make_binary(context, ICT_TPREFIX_BINARY, prefix, name);
+        else
+            itd_unref_comp(prefix);
+
+    }
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_template_param(context);
+    }
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_substitution(context);
+    }
+
+    if (result != NULL && itd_get_component_type(result) != ICT_TPREFIX_BINARY)
+        result = itd_make_unary(context, ICT_TPREFIX_UNARY, result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_unqualified_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <unqualified-name> ::= <operator-name>
+     *                    ::= <ctor-dtor-name>
+     *                    ::= <source-name>
+     *
+     */
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    result = itd_operator_name(context);
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_ctor_dtor_name(context);
+    }
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_source_name(context);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_source_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    ssize_t number;                         /* Taille positive             */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <source-name> ::= <positive length number> <identifier>
+     *
+     */
+
+    if (!itd_number(context, &number))
+        return NULL;
+
+    if (number <= 0)
+        return NULL;
+
+    result = itd_identifier(context, number);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                size    = taille positive ou non lue. [OUT]                  *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Bilan de l'opération (un chifre lu au moins).                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool itd_number(GItaniumDContext *context, ssize_t *size)
+{
+    bool result;                            /* Validité à renvoyer         */
+    bool negative;                          /* Taille négative ?           */
+    char peek;                              /* Prochain caractère lu       */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <number> ::= [n] <non-negative decimal integer>
+     *
+     */
+
+    result = false;
+
+    negative = false;
+
+    peek = g_itanium_dcontext_peek_char(context);
+
+    if (peek == 'n')
+    {
+        negative = true;
+        g_itanium_dcontext_advance(context, 1);
+        peek = g_itanium_dcontext_peek_char(context);
+    }
+
+    *size = 0;
+
+    while (isdigit(peek))
+    {
+        result = true;
+        *size = *size * 10 + peek - '0';
+        g_itanium_dcontext_advance(context, 1);
+        peek = g_itanium_dcontext_peek_char(context);
+    }
+
+    if (negative)
+        *size *= -1;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                length  = taille de l'identifiant à retrouver.               *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_identifier(GItaniumDContext *context, size_t length)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    const char *data;                       /* Données restantes           */
+    size_t remaining;                       /* Quantité d'octets           */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <identifier> ::= <unqualified source code identifier>
+     *
+     */
+
+    data = g_itanium_dcontext_get_string(context, &remaining);
+
+    if (length > remaining)
+        return NULL;
+
+    result = itd_make_name(context, data, length);
+
+    if (result != NULL)
+        g_itanium_dcontext_advance(context, length);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_operator_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    char code[2];                           /* Code à venir lire           */
+    itanium_operator_info info;             /* Clef des informations       */
+    itanium_operator_info *found;           /* Informations complètes      */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <operator-name> ::= nw    # new           
+     *                 ::= na    # new[]
+     *                 ::= dl    # delete        
+     *                 ::= da    # delete[]      
+     *                 ::= ps    # + (unary)
+     *                 ::= ng    # - (unary)     
+     *                 ::= ad    # & (unary)     
+     *                 ::= de    # * (unary)     
+     *                 ::= co    # ~             
+     *                 ::= pl    # +             
+     *                 ::= mi    # -             
+     *                 ::= ml    # *             
+     *                 ::= dv    # /             
+     *                 ::= rm    # %             
+     *                 ::= an    # &             
+     *                 ::= or    # |             
+     *                 ::= eo    # ^             
+     *                 ::= aS    # =             
+     *                 ::= pL    # +=            
+     *                 ::= mI    # -=            
+     *                 ::= mL    # *=            
+     *                 ::= dV    # /=            
+     *                 ::= rM    # %=            
+     *                 ::= aN    # &=            
+     *                 ::= oR    # |=            
+     *                 ::= eO    # ^=            
+     *                 ::= ls    # <<            
+     *                 ::= rs    # >>            
+     *                 ::= lS    # <<=           
+     *                 ::= rS    # >>=           
+     *                 ::= eq    # ==            
+     *                 ::= ne    # !=            
+     *                 ::= lt    # <             
+     *                 ::= gt    # >             
+     *                 ::= le    # <=            
+     *                 ::= ge    # >=            
+     *                 ::= nt    # !             
+     *                 ::= aa    # &&            
+     *                 ::= oo    # ||            
+     *                 ::= pp    # ++            
+     *                 ::= mm    # --            
+     *                 ::= cm    # ,             
+     *                 ::= pm    # ->*           
+     *                 ::= pt    # ->            
+     *                 ::= cl    # ()            
+     *                 ::= ix    # []            
+     *                 ::= qu    # ?             
+     *                 ::= st    # sizeof (a type)
+     *                 ::= sz    # sizeof (an expression)
+     *                 ::= cv <type> # (cast)        
+     *                 ::= v <digit> <source-name>   # vendor extended operator
+     *
+     */
+
+    result = NULL;
+
+    code[0] = g_itanium_dcontext_next_char(context);
+
+    if (code[0] == 'v')
+    {
+
+        result = NULL;  /* TODO */
+
+        goto itd_operator_name_exit;
+
+
+    }
+
+    code[1] = g_itanium_dcontext_next_char(context);
+
+    if (code[0] == 'c' && code[1] == 'v')
+    {
+
+        result = NULL;  /* TODO */
+
+        goto itd_operator_name_exit;
+
+
+    }
+
+    /* Recherche dans la liste des opérateurs reconnus */
+
+    info.code = code;
+
+    int comp_itanium_operators(const itanium_operator_info *a, const itanium_operator_info *b)
+    {
+        int result;                         /* Bilan à renvoyer            */
+
+        if (a->code[0] < b->code[0])
+            result = -1;
+        else if (a->code[0] > b->code[0])
+            result = 1;
+        else
+        {
+            if (a->code[1] < b->code[1])
+                result = -1;
+            else if (a->code[1] > b->code[1])
+                result = 1;
+            else
+                result = 0;
+        }
+
+        return result;
+
+    }
+
+    found = bsearch(&info, itanium_demangle_operators,
+                    ARRAY_SIZE(itanium_demangle_operators),
+                    sizeof(itanium_operator_info), (__compar_fn_t)comp_itanium_operators);
+
+    if (found != NULL)
+        result = itd_make_operator(context, found);
+
+ itd_operator_name_exit:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_special_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    char next;                              /* Caractère suivant           */
+    char peek;                              /* Prochain caractère lu       */
+    itanium_component *offset1;             /* Décalage extrait #1         */
+    itanium_component *encoding;            /* Encodage suivant            */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <special-name> ::= T <call-offset> <base encoding>
+     *                   # base is the nominal target function of thunk
+     */
+
+    result = NULL;
+
+    next = g_itanium_dcontext_next_char(context);
+
+    if (next == 'T')
+    {
+        peek = g_itanium_dcontext_peek_char(context);
+
+        switch (peek)
+        {
+            case 'V':
+                result = NULL; /* TODO */
+                break;
+
+            case 'T':
+                result = NULL; /* TODO */
+                break;
+
+            case 'I':
+                result = NULL; /* TODO */
+                break;
+
+            case 'S':
+                result = NULL; /* TODO */
+                break;
+
+            case 'c':
+                result = NULL; /* TODO */
+                break;
+
+
+            default:
+
+                offset1 = itd_call_offset(context);
+                if (offset1 == NULL) break;
+
+                encoding = itd_encoding(context);
+
+                if (encoding == NULL)
+                    itd_unref_comp(offset1);
+                else
+                    result = itd_make_binary(context, ICT_FUNCTION_THUNK, offset1, encoding);
+
+                break;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_call_offset(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    char next;                              /* Caractère suivant           */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <call-offset> ::= h <nv-offset> _
+     *               ::= v <v-offset> _
+     */
+
+    next = g_itanium_dcontext_next_char(context);
+
+    switch (next)
+    {
+        case 'h':
+            result = itd_nv_offset(context);
+            break;
+
+        case 'v':
+            result = itd_v_offset(context);
+            break;
+
+        default:
+            result = NULL;
+            break;
+
+    }
+
+    if (result != NULL && !g_itanium_dcontext_check_char(context, '_'))
+    {
+        itd_unref_comp(result);
+        result = NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_nv_offset(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    ssize_t offset;                         /* Décalage obtenu             */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <nv-offset> ::= <offset number>
+     *                     # non-virtual base override
+     */
+
+    if (!itd_number(context, &offset))
+        return NULL;
+
+    result = itd_make_offset(context, ICT_NON_VIRTUAL_OFFSET, offset);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_v_offset(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    ssize_t offset;                         /* Décalage obtenu #1          */
+    ssize_t voffset;                        /* Décalage obtenu #2          */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <v-offset>  ::= <offset number> _ <virtual offset number>
+     *                     # virtual base override, with vcall offset
+     */
+
+    if (!itd_number(context, &offset))
+        return NULL;
+
+    if (!g_itanium_dcontext_check_char(context, '_'))
+        return NULL;
+
+    if (!itd_number(context, &voffset))
+        return NULL;
+
+    result = itd_make_binary(context, ICT_VIRTUAL_OFFSET,
+                             itd_make_offset(context, ICT_NON_VIRTUAL_OFFSET, offset),
+                             itd_make_offset(context, ICT_VIRTUAL_OFFSET, voffset));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_ctor_dtor_name(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    char next;                              /* Caractère suivant           */
+    ItaniumComponentType type;              /* Type de composant           */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <ctor-dtor-name> ::= C1   # complete object constructor
+     *                  ::= C2   # base object constructor
+     *                  ::= C3   # complete object allocating constructor
+     *                  ::= D0   # deleting destructor
+     *                  ::= D1   # complete object destructor
+     *                  ::= D2   # base object destructor
+     */
+
+    next = g_itanium_dcontext_peek_char(context);
+
+    if (next == 'C')
+        type = ICT_CONSTRUCTOR;
+    else if (next == 'D')
+        type = ICT_DESSTRUCTOR;
+    else
+        return NULL;
+
+    g_itanium_dcontext_advance(context, 1);
+
+    next = g_itanium_dcontext_peek_char(context);
+
+    if (next != '0' && next != '1' && next != '2')
+        return NULL;
+
+    g_itanium_dcontext_advance(context, 1);
+
+    result = itd_make_empty(context);
+    itd_set_type(result, type);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_type(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    TypeQualifier qualifier;                /* Propriétés supplémentaires  */
+    itanium_component *sub;                 /* Sous-type lié à associer    */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <type> ::= <builtin-type>
+     *        ::= <function-type>
+     *        ::= <class-enum-type>
+     *        ::= <array-type>
+     *        ::= <pointer-to-member-type>
+     *        ::= <template-param>
+     *        ::= <template-template-param> <template-args>
+     *        ::= <substitution> # See Compression below
+     *        ::= <CV-qualifiers> <type>
+     *        ::= P <type>   # pointer-to
+     *        ::= R <type>   # reference-to
+     *        ::= O <type>   # rvalue reference-to (C++0x)
+     *        ::= C <type>   # complex pair (C 2000)
+     *        ::= G <type>   # imaginary (C 2000)
+     *        ::= U <source-name> <type> # vendor extended type qualifier
+     *
+     */
+
+    result = NULL;
+
+    qualifier = itd_cv_qualifiers(context);
+
+    switch (g_itanium_dcontext_peek_char(context))
+    {
+        case 'P':
+
+            g_itanium_dcontext_advance(context, 1);
+
+            sub = itd_type(context);
+            if (sub == NULL) return NULL;
+
+            result = itd_make_unary(context, ICT_POINTER_TO, sub);
+            break;
+
+        case 'R':
+
+            g_itanium_dcontext_advance(context, 1);
+
+            sub = itd_type(context);
+            if (sub == NULL) return NULL;
+
+            result = itd_make_unary(context, ICT_REFERENCE_TO, sub);
+            break;
+
+        case 'O':
+
+            g_itanium_dcontext_advance(context, 1);
+
+            sub = itd_type(context);
+            if (sub == NULL) return NULL;
+
+            result = itd_make_unary(context, ICT_RVALUE_REFERENCE_TO, sub);
+            break;
+
+        case 'C':
+
+            g_itanium_dcontext_advance(context, 1);
+
+            sub = itd_type(context);
+            if (sub == NULL) return NULL;
+
+            result = itd_make_unary(context, ICT_COMPLEX_PAIR, sub);
+            break;
+
+        case 'G':
+
+            g_itanium_dcontext_advance(context, 1);
+
+            sub = itd_type(context);
+            if (sub == NULL) return NULL;
+
+            result = itd_make_unary(context, ICT_IMAGINARY, sub);
+            break;
+
+        case 'U':
+
+            g_itanium_dcontext_advance(context, 1);
+            /* TODO */
+            return NULL;
+            break;
+
+        }
+
+    if (result != NULL) goto itd_type_end;
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    result = itd_builtin_type(context);
+    if (result != NULL) goto itd_type_end;
+
+    g_itanium_dcontext_pop_state(context, &saved);
+
+    result = itd_class_enum_type(context);
+    if (result != NULL) goto itd_type_end;
+
+
+    g_itanium_dcontext_pop_state(context, &saved);
+
+    result = itd_substitution(context);
+    if (result != NULL) goto itd_type_end;
+
+
+
+
+ itd_type_end:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait une propriété de composant pour un contexte Itanium. *
+*                                                                             *
+*  Retour      : Indication extraite.                                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static TypeQualifier itd_cv_qualifiers(GItaniumDContext *context)
+{
+    TypeQualifier result;                   /* Valeur à remonter           */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <CV-qualifiers> ::= [r] [V] [K] 	# restrict (C99), volatile, const
+     *
+     */
+
+    result = TQF_NONE;
+
+    while (1)
+        switch (g_itanium_dcontext_peek_char(context))
+        {
+            case 'r':
+                result = TQF_RESTRICT;
+                g_itanium_dcontext_advance(context, 1);
+                break;
+
+            case 'V':
+                result = TQF_VOLATILE;
+                g_itanium_dcontext_advance(context, 1);
+                break;
+
+            case 'K':
+                result = TQF_CONST;
+                g_itanium_dcontext_advance(context, 1);
+                break;
+
+            default:
+                goto itd_cv_qualifiers_exit;
+                break;
+
+        }
+
+ itd_cv_qualifiers_exit:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_builtin_type(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    BaseType type;                          /* Type reconnu ou BTP_INVALID */
+    GDataType *builtin;                     /* Type construit              */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <builtin-type> ::= v  # void
+     *                ::= w  # wchar_t
+     *                ::= b  # bool
+     *                ::= c  # char
+     *                ::= a  # signed char
+     *                ::= h  # unsigned char
+     *                ::= s  # short
+     *                ::= t  # unsigned short
+     *                ::= i  # int
+     *                ::= j  # unsigned int
+     *                ::= l  # long
+     *                ::= m  # unsigned long
+     *                ::= x  # long long, __int64
+     *                ::= y  # unsigned long long, __int64
+     *                ::= n  # __int128
+     *                ::= o  # unsigned __int128
+     *                ::= f  # float
+     *                ::= d  # double
+     *                ::= e  # long double, __float80
+     *                ::= g  # __float128
+     *                ::= z  # ellipsis
+     *                ::= u <source-name>    # vendor extended type
+     *
+     */
+
+    switch (g_itanium_dcontext_peek_char(context))
+    {
+        case 'v':
+            type = BTP_VOID;
+            break;
+        case 'w':
+            type = BTP_WCHAR_T;
+            break;
+        case 'b':
+            type = BTP_BOOL;
+            break;
+        case 'c':
+            type = BTP_CHAR;
+            break;
+        case 'a':
+            type = BTP_SCHAR;
+            break;
+        case 'h':
+            type = BTP_UCHAR;
+            break;
+        case 's':
+            type = BTP_SHORT;
+            break;
+        case 't':
+            type = BTP_USHORT;
+            break;
+        case 'i':
+            type = BTP_INT;
+            break;
+        case 'j':
+            type = BTP_UINT;
+            break;
+        case 'l':
+            type = BTP_LONG;
+            break;
+        case 'm':
+            type = BTP_ULONG;
+            break;
+        case 'x':
+            type = BTP_LONG_LONG;
+            break;
+        case 'y':
+            type = BTP_ULONG_LONG;
+            break;
+        case 'n':
+            type = BTP_INT128;
+            break;
+        case 'o':
+            type = BTP_UINT128;
+            break;
+        case 'f':
+            type = BTP_FLOAT;
+            break;
+        case 'd':
+            type = BTP_DOUBLE;
+            break;
+        case 'e':
+            type = BTP_LONG_DOUBLE;
+            break;
+        case 'g':
+            type = BTP_FLOAT128;
+            break;
+        case 'z':
+            type = BTP_ELLIPSIS;
+            break;
+        case 'u':
+            type = BTP_OTHER;
+            /* FIXME */
+            /*  <source-name>    # vendor extended type */
+            break;
+        default:
+            type = BTP_INVALID;
+            break;
+    }
+
+    if (type != BTP_INVALID)
+    {
+        builtin = g_basic_type_new(type);
+        result = itd_make_type(context, builtin);
+        g_itanium_dcontext_advance(context, 1);
+    }
+    else
+        result = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_bare_function_type(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itanium_component *type;                /* Nouvel élément à intégrer   */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <bare-function-type> ::= <signature type>+
+     *       # types are possible return type, then parameter types
+     *
+     */
+
+    type = itd_type(context);
+    if (type == NULL) return NULL;
+
+    result = itd_append_right_to_binary(context, ICT_TYPES_LIST, NULL, type);
+
+    while (1)
+    {
+        g_itanium_dcontext_push_state(context, &saved);
+
+        type = itd_type(context);
+        if (type == NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved);
+            break;
+        }
+
+        result = itd_append_right_to_binary(context, ICT_TYPES_LIST, result, type);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_class_enum_type(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <class-enum-type> ::= <name>
+     *
+     */
+
+    result = itd_name(context);
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_template_args(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itanium_component *arg;                 /* Nouvel argument extrait     */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    printf(">>> TA>> '%s'\n", g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <template-args> ::= I <template-arg>+ E
+     *
+     */
+
+    if (!g_itanium_dcontext_check_char(context, 'I'))
+        return NULL;
+
+    arg = itd_template_arg(context);
+    if (arg == NULL) return NULL;
+
+    result = itd_append_right_to_binary(context, ICT_TYPES_LIST, NULL, arg);
+
+    while (1)
+    {
+        g_itanium_dcontext_push_state(context, &saved);
+
+        arg = itd_template_arg(context);
+        if (arg == NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved);
+            break;
+        }
+
+        result = itd_append_right_to_binary(context, ICT_TYPES_LIST, result, arg);
+
+    }
+
+    //printf("  ta/E >> '%s'\n", g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
+
+    if (!g_itanium_dcontext_check_char(context, 'E'))
+    {
+        //printf("=== TA : BAD E\n\n");
+
+        if (result != NULL)
+            itd_unref_comp(result);
+        return NULL;
+    }
+
+    //printf("=== TA >> %p\n\n", result);
+
+    result = itd_make_unary(context, ICT_TEMPLATE_ARGS, result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_template_arg(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <template-arg> ::= <type>                     # type or template
+     *                ::= X <expression> E           # expression
+     *                ::= <expr-primary>             # simple expressions
+     *
+     */
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    result = itd_type(context);
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+
+        if (g_itanium_dcontext_check_char(context, 'X'))
+        {
+            result = itd_expression(context);
+
+            if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
+            {
+                itd_unref_comp(result);
+                result = NULL;
+            }
+
+        }
+
+    }
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_expr_primary(context);
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                hex     = prise en compte des caractères hexadécimaux ?      *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_value_to_string(GItaniumDContext *context, bool hex)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    const char *data;                       /* Données restantes           */
+    itd_state saved;                        /* Position d'analyse initiale */
+    itd_state cur;                          /* Position d'analyse courante */
+    char peek;                              /* Prochain caractère lu       */
+
+    /**
+     * Les règles traitées ici sont les suivantes :
+     *
+     * <value number>  # integer literal
+     * <value float>   # floating literal
+     *
+     */
+
+    result = NULL;
+
+    data = g_itanium_dcontext_get_string(context, (size_t []) { 0 });
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    while (1)
+    {
+        peek = g_itanium_dcontext_peek_char(context);
+
+        switch (peek)
+        {
+            case '0' ... '9':
+                g_itanium_dcontext_advance(context, 1);
+                break;
+
+            case 'a' ... 'f':
+                if (hex)
+                    g_itanium_dcontext_advance(context, 1);
+                else
+                    goto exit_iits;
+                break;
+
+            case 'E':
+                goto exit_loop;
+                break;
+
+            default:
+                goto exit_iits;
+
+        }
+
+    }
+
+ exit_loop:
+
+    g_itanium_dcontext_push_state(context, &cur);
+
+    if ((cur.pos - saved.pos) > 0)
+        result = itd_make_name(context, data, cur.pos - saved.pos);
+
+ exit_iits:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_expr_primary(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    itd_state saved;                        /* Position d'analyse courante */
+    itanium_component *type;                /* Type de valeur extrait      */
+    itd_state saved_value;                  /* Position d'analyse courante */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <expr-primary> ::= L <type> <value number> E  # integer literal
+     *                ::= L <type> <value float> E   # floating literal
+     *                ::= L <mangled-name> E         # external name
+     *
+     */
+
+    printf("PRIMARY :: no L\n");
+
+    if (!g_itanium_dcontext_check_char(context, 'L'))
+        return NULL;
+
+    g_itanium_dcontext_push_state(context, &saved);
+
+    type = itd_type(context);
+
+    if (type != NULL)
+    {
+        g_itanium_dcontext_push_state(context, &saved_value);
+
+        /* Règle <type> <value number> */
+
+        result = itd_value_to_string(context, false);
+
+        if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
+        {
+            itd_unref_comp(result);
+            result = NULL;
+        }
+
+        /* Règle <type> <value float> */
+
+        if (result == NULL)
+        {
+            g_itanium_dcontext_pop_state(context, &saved_value);
+
+            result = itd_value_to_string(context, true);
+
+            if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
+            {
+                itd_unref_comp(result);
+                result = NULL;
+            }
+
+        }
+
+        itd_unref_comp(type);
+
+    }
+    else
+        result = NULL;
+
+    /* Règle <mangled-name> */
+
+    if (result == NULL)
+    {
+        g_itanium_dcontext_pop_state(context, &saved);
+        result = itd_mangled_name(context);
+
+        if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
+        {
+            itd_unref_comp(result);
+            result = NULL;
+        }
+
+    }
+
+    printf("PRIMARY :: %p\n", result);
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                cur     = caractère courant.                                 *
+*                id      = identifiant lu en cas de succès. [OUT]             *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool itd_seq_id(GItaniumDContext *context, char cur, size_t *id)
+{
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <seq-id>
+     *
+     */
+
+    *id = 0;
+
+    /**
+     * La fonction n'est appelée que si un début de séquence est détecté.
+     * (ie, cur == '_' || isdigit(cur) || isupper(cur)).
+     */
+
+    if (cur != '_')
+    {
+        do
+        {
+            if (isdigit(cur))
+                *id = *id * 36 + cur - '0';
+            else if (isupper(cur))
+                *id = *id * 36 + cur - 'A' + 10;
+            else
+                return false;
+
+            cur = g_itanium_dcontext_next_char(context);
+
+        }
+        while (cur != '_');
+
+        (*id)++;
+
+    }
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Extrait un composant dans un contexte Itanium.               *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static itanium_component *itd_substitution(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
+    char cur;                               /* Caractère analysé           */
+    size_t id;                              /* Identifiant de substitution */
+    char peek;                              /* Prochain caractère lu       */
+    bool verbose;                           /* Sélection du rendu idéal    */
+    size_t i;                               /* Boucle de parcours          */
+
+    /**
+     * La règle traitée ici est la suivante :
+     *
+     * <substitution> ::= S <seq-id> _
+     *                ::= S_
+     *                ::= St # ::std::
+     *                ::= Sa # ::std::allocator
+     *                ::= Sb # ::std::basic_string
+     *                ::= Ss # ::std::basic_string<char, ::std::char_traits<char>, ::std::allocator<char>>
+     *                ::= Si # ::std::basic_istream<char, std::char_traits<char>>
+     *                ::= So # ::std::basic_ostream<char, std::char_traits<char>>
+     *                ::= Sd # ::std::basic_iostream<char, std::char_traits<char>>
+     *
+     */
+
+    peek = g_itanium_dcontext_peek_char(context);
+
+    if (!g_itanium_dcontext_check_char(context, 'S'))
+        return NULL;
+
+    cur = g_itanium_dcontext_next_char(context);
+
+    if (cur == '_' || isdigit(cur) || isupper(cur))
+    {
+        if (!itd_seq_id(context, cur, &id))
+            return NULL;
+
+        printf("requesting... %zu\n", id);
+
+        result = g_itanium_dcontext_get_substitution(context, id);
+
+    }
+    else
+    {
+        result = NULL;
+
+        peek = g_itanium_dcontext_peek_char(context);
+        verbose = (peek == 'C' || peek == 'D'); /* TODO : prefixe ? */
+
+        for (i = 0; i < ARRAY_SIZE(itanium_standard_substitutions); i++)
+            if (itanium_standard_substitutions[i].code == cur)
+            {
+                /* TODO : constructeur... */
+
+                if (verbose)
+                    result = itd_make_name(context,
+                                           itanium_standard_substitutions[i].full,
+                                           itanium_standard_substitutions[i].full_len);
+                else
+                    result = itd_make_name(context,
+                                           itanium_standard_substitutions[i].simple,
+                                           itanium_standard_substitutions[i].simple_len);
+
+                itd_set_type(result, ICT_STD_SUBST);
+
+                break;
+
+            }
+
+    }
+
+    return result;
+
+}
diff --git a/src/mangling/itanium/abi.h b/src/mangling/itanium/abi.h
new file mode 100644
index 0000000..1ed21f3
--- /dev/null
+++ b/src/mangling/itanium/abi.h
@@ -0,0 +1,38 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * abi.h - prototypes pour le décodage des noms d'éléments selon l'ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_ITANIUM_ABI_H
+#define _FORMAT_MANGLING_ITANIUM_ABI_H
+
+
+#include "component.h"
+#include "context.h"
+
+
+
+/* Extrait un composant dans un contexte Itanium. */
+itanium_component *itd_mangled_name(GItaniumDContext *);
+
+
+
+#endif  /* _FORMAT_MANGLING_ITANIUM_ABI_H */
diff --git a/src/mangling/itanium/component-int.h b/src/mangling/itanium/component-int.h
new file mode 100644
index 0000000..3d4c1d0
--- /dev/null
+++ b/src/mangling/itanium/component-int.h
@@ -0,0 +1,79 @@
+
+
+#ifndef _FORMAT_MANGLING_ITANIUM_ABI2_H
+#define _FORMAT_MANGLING_ITANIUM_ABI2_H
+
+
+#include "component.h"
+
+
+
+/* Composant extrait de l'encodage */
+struct _itanium_component
+{
+    ItaniumComponentType type;              /* Type de composant           */
+
+    GItaniumDContext *context;              /* Regroupement de composants  */
+    unsigned int refcount;                  /* Compteur de références      */
+
+    fnv64_t hash;                           /* Empreinte en cache          */
+
+    union
+    {
+        /* ICT_NAME */
+        struct
+        {
+            const char *str;
+            size_t len;
+
+        } s_name;
+
+        /* ICT_OPERATOR_NAME */
+        struct
+        {
+            ItaniumOperatorType otype;      /* Sélection dans l'union      */
+
+            union
+            {
+                itanium_operator_info info; /* Opérateur simple            */
+
+
+            };
+
+        } operator;
+
+        /* ICT_NON_VIRTUAL_OFFSET */
+        /* ICT_VIRTUAL_OFFSET */
+        ssize_t offset;                     /* Décalage de fonction        */
+
+        /* ICT_TYPE */
+        GDataType *dtype;                   /* Type instancié              */
+
+
+        /* ICT_* */
+        struct
+        {
+            itanium_component *left;        /* Elément premier             */
+            itanium_component *right;       /* Elément second              */
+
+        } binary;
+
+        /* ICT_* */
+        struct
+        {
+            itanium_component *first;       /* Elément premier             */
+            itanium_component *second;      /* Elément second              */
+            itanium_component *third;       /* Elément troisième           */
+
+        } ternary;
+
+        /* ICT_* */
+        itanium_component *unary;           /* Sous-élément                */
+
+    };
+
+};
+
+
+
+#endif  /* _FORMAT_MANGLING_ITANIUM_ABI2_H */
diff --git a/src/mangling/itanium/component.c b/src/mangling/itanium/component.c
new file mode 100644
index 0000000..e3f3f23
--- /dev/null
+++ b/src/mangling/itanium/component.c
@@ -0,0 +1,717 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * component.c - représentation des composants extraits de l'ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "component.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "component-int.h"
+#include "../../common/extstr.h"
+#include "../../common/fnv1a.h"
+
+
+
+
+/* Procédure à appliquer sur un composant visité */
+typedef void (* visit_comp_fc) (itanium_component *);
+
+
+
+#define reset_comp_hash(c) c->hash = 0
+
+/* Visite les composants en présence. */
+static void visit_comp(itanium_component *, visit_comp_fc);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp    = composant à traiter.                               *
+*                visitor = fonction à appliquer sur les composants présents.  *
+*                                                                             *
+*  Description : Visite les composants en présence.                           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void visit_comp(itanium_component *comp, visit_comp_fc visitor)
+{
+    itanium_component *sub;                 /* Sous-partie de composant    */
+
+    switch (comp->type)
+    {
+        case ICT_NESTED_NAME:
+        case ICT_TEMPLATE_NAME_ARGS:
+            visit_comp(comp->binary.left, visitor);
+            visit_comp(comp->binary.right, visitor);
+            break;
+
+        case ICT_PREFIX_UNARY:
+        case ICT_TPREFIX_UNARY:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_PREFIX_BINARY:
+        case ICT_TPREFIX_BINARY:
+            visit_comp(comp->binary.left, visitor);
+            visit_comp(comp->binary.right, visitor);
+            break;
+
+        case ICT_FUNCTION_THUNK:
+            visit_comp(comp->binary.left, visitor);
+            visit_comp(comp->binary.right, visitor);
+            break;
+
+        case ICT_FUNCTION_COVARIANT_THUNK:
+            visit_comp(comp->ternary.first, visitor);
+            visit_comp(comp->ternary.second, visitor);
+            visit_comp(comp->ternary.third, visitor);
+            break;
+
+        case ICT_POINTER_TO:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_REFERENCE_TO:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_RVALUE_REFERENCE_TO:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_COMPLEX_PAIR:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_IMAGINARY:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_FUNCTION_ENCODING:
+
+            /* Retour ? */
+
+            sub = NULL;//IT_BINARY_COMP(IT_BINARY_COMP(comp).right).left;
+
+            if (sub != NULL)
+                visit_comp(sub, visitor);
+
+            /* Nom de la fonction */
+            visit_comp(comp->binary.left, visitor);
+
+            visit_comp(comp->binary.right, visitor);
+
+            break;
+
+        case ICT_TEMPLATE_ARGS:
+            visit_comp(comp->unary, visitor);
+            break;
+
+        case ICT_TYPES_LIST:
+
+            visit_comp(comp->binary.left, visitor);
+
+            if (comp->binary.right != NULL)
+                visit_comp(comp->binary.right, visitor);
+
+            break;
+
+        default:
+            break;
+
+    }
+
+    visitor(comp);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp = composant à mettre à jour.                            *
+*                                                                             *
+*  Description : Incrémente le nombre d'utilisation du composant.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void itd_ref_comp(itanium_component *comp)
+{
+    void visit_for_ref(itanium_component *comp)
+    {
+        comp->refcount++;
+
+    }
+
+    visit_comp(comp, visit_for_ref);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp = composant à mettre à jour.                            *
+*                                                                             *
+*  Description : Décrémente le nombre d'utilisation du composant.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void itd_unref_comp(itanium_component *comp)
+{
+    return;
+
+    void visit_for_unref(itanium_component *comp)
+    {
+        if (--comp->refcount == 0)
+        {
+            if (comp->type == ICT_TYPE)
+                g_object_unref(G_OBJECT(comp->dtype));
+
+            g_itanium_dcontext_mark_component_as_free(comp->context, comp);
+
+        }
+
+    }
+
+    visit_comp(comp, visit_for_unref);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp = composant à manipuler.                                *
+*                                                                             *
+*  Description : Détermine ou fournit l'empreinte d'un composant.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+fnv64_t itd_hash_comp(itanium_component *comp)
+{
+    char *desc;                             /* Description du composant    */
+
+    if (comp->hash == 0)
+    {
+        desc = itd_translate_component(comp->context, comp, NULL);
+        comp->hash = fnv_64a_hash(desc);
+        free(desc);
+    }
+
+    return comp->hash;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_empty(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = ICT_EMPTY;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                str     = chaîne de caractères à conserver.                  *
+*                len     = taille de l'identifiant à retrouver.               *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_name(GItaniumDContext *context, const char *str, size_t len)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = ICT_NAME;
+    result->s_name.str = str;
+    result->s_name.len = len;
+
+    return result;
+
+}
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                info    = information de base sur l'opérateur manipulé.      *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_operator(GItaniumDContext *context, const itanium_operator_info *info)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = ICT_OPERATOR_NAME;
+    result->operator.otype = IOT_SIMPLE;
+    result->operator.info = *info;
+
+    return result;
+
+}
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                type    = type exacte de décalage.                           *
+*                offset  = décalage extrait de l'encodage.                    *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_offset(GItaniumDContext *context, ItaniumComponentType type, ssize_t offset)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = type;
+    result->offset = offset;
+
+    return result;
+
+}
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                dtype   = instance de type en place à conserver.             *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_type(GItaniumDContext *context, GDataType *dtype)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = ICT_TYPE;
+    result->dtype = dtype;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                type    = type du composant à mettre en place.               *
+*                left    = premier composant à associer.                      *
+*                right   = second composant à associer.                       *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_binary(GItaniumDContext *context, ItaniumComponentType type, itanium_component *left, itanium_component *right)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = type;
+    result->binary.left = left;
+    result->binary.right = right;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                type    = type du composant à mettre en place.               *
+*                left    = second composant à associer.                       *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_append_right_to_binary(GItaniumDContext *context, ItaniumComponentType type, itanium_component *parent, itanium_component *left)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+    itanium_component *iter;                /* Boucle de parcours          */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = type;
+    result->binary.left = left;
+
+    if (parent != NULL)
+    {
+        for (iter = parent; iter->binary.right != NULL; iter = iter->binary.right)
+            reset_comp_hash(iter);
+        iter->binary.right = result;
+    }
+
+    return (parent != NULL ? parent : result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                type    = type du composant à mettre en place.               *
+*                unary   = sous-composant à associer.                         *
+*                                                                             *
+*  Description : Construit un composant dans un contexte Itanium.             *
+*                                                                             *
+*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *itd_make_unary(GItaniumDContext *context, ItaniumComponentType type, itanium_component *unary)
+{
+    itanium_component *result;              /* Composant à renvoyer        */
+
+    result = g_itanium_dcontext_get_empty_component(context);
+
+    result->type = type;
+    result->unary = unary;
+
+    return result;
+
+}
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp = composant à mettre à jour.                            *
+*                type = type à redéfinir pour le composant.                   *
+*                                                                             *
+*  Description : Modifie légèrement le type d'un composant donné.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void itd_set_type(itanium_component *comp, ItaniumComponentType type)
+{
+    comp->type = type;
+
+    reset_comp_hash(comp);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comp = composant à consulter.                                *
+*                                                                             *
+*  Description : Fournit le type d'un composant issu d'un contexte Itanium.   *
+*                                                                             *
+*  Retour      : Type enregistré.                                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+ItaniumComponentType itd_get_component_type(const itanium_component *comp)
+{
+    return comp->type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                comp    = second composant à associer.                       *
+*                base    = éventuelle base à compléter ou NULL si aucune.     *
+*                                                                             *
+*  Description : Traduit les composants de contexte Itanium.                  *
+*                                                                             *
+*  Retour      : Traduction en format humainement lisible effectuée.          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *itd_translate_component(GItaniumDContext *context, const itanium_component *comp, char *base)
+{
+    char *result;                           /* Chaîne à retourner          */
+    char *name;                             /* Désignation à copier        */
+    const itanium_component *sub;           /* Sous-partie de composant    */
+
+    //if (base != NULL)
+    //printf(".... %s\n", base);
+
+    switch (comp->type)
+    {
+        case ICT_EMPTY:
+            result = base;
+            break;
+
+        case ICT_NAME:
+        case ICT_STD_SUBST:
+            result = strnadd(base, comp->s_name.str, comp->s_name.len);
+            break;
+
+        case ICT_NESTED_NAME:
+            result = itd_translate_component(context, comp->binary.left, base);
+            if (comp->binary.right->type != ICT_TEMPLATE_ARGS)
+                result = stradd(result, "::");
+            result = itd_translate_component(context, comp->binary.right, result);
+            break;
+
+        case ICT_TEMPLATE_NAME_ARGS:
+            result = itd_translate_component(context, comp->binary.left, base);
+            result = itd_translate_component(context, comp->binary.right, result);
+            break;
+
+        case ICT_PREFIX_UNARY:
+        case ICT_TPREFIX_UNARY:
+            result = stradd(base, "::");
+            result = itd_translate_component(context, comp->unary, result);
+            break;
+
+        case ICT_PREFIX_BINARY:
+        case ICT_TPREFIX_BINARY:
+            result = itd_translate_component(context, comp->binary.left, base);
+            result = stradd(result, "::");
+            result = itd_translate_component(context, comp->binary.right, result);
+            break;
+
+
+        case ICT_OPERATOR_NAME:
+            switch (comp->operator.otype)
+            {
+                case IOT_SIMPLE:
+                    result = stradd(base, comp->operator.info.name);
+                    break;
+                case IOT_CAST:
+                    result = stradd(base, "TODO_CAST");
+                    break;
+                case IOT_VENDOR:
+                    result = stradd(base, "TODO_VENDOR");
+                    break;
+                default:
+                    result = NULL;
+                    break;
+            }
+            break;
+
+
+        case ICT_FUNCTION_THUNK:
+            result = itd_translate_component(context, comp->binary.right, base);
+            break;
+
+        case ICT_FUNCTION_COVARIANT_THUNK:
+            result = itd_translate_component(context, comp->ternary.third, base);
+            break;
+
+
+        case ICT_CONSTRUCTOR:
+            result = stradd(base, "<ctor>");
+            break;
+
+        case ICT_DESSTRUCTOR:
+            result = stradd(base, "<dtor>");
+            break;
+
+        case ICT_TYPE:
+
+            name = g_data_type_to_string(comp->dtype);
+
+            result = stradd(base, name);
+
+            free(name);
+
+            break;
+
+        case ICT_POINTER_TO:
+            result = itd_translate_component(context, comp->unary, base);
+            result = stradd(result, " *");
+            break;
+
+        case ICT_REFERENCE_TO:
+            result = itd_translate_component(context, comp->unary, base);
+            result = stradd(result, " &");
+            break;
+
+        case ICT_RVALUE_REFERENCE_TO:
+            result = itd_translate_component(context, comp->unary, base);
+            result = stradd(result, " &");
+            break;
+
+        case ICT_COMPLEX_PAIR:
+            result = stradd(base, "<?>");
+            result = itd_translate_component(context, comp->unary, result);
+            break;
+
+        case ICT_IMAGINARY:
+            result = stradd(base, "<?>");
+            result = itd_translate_component(context, comp->unary, result);
+            break;
+
+
+        case ICT_FUNCTION_ENCODING:
+
+            result = base;
+
+            /* Retour ? */
+
+            sub = NULL;//IT_BINARY_COMP(IT_BINARY_COMP(comp).right).left;
+
+            if (sub != NULL)
+                result = itd_translate_component(context, sub, result);
+            else
+                result = stradd(result, "???");
+
+            result = stradd(result, " ");
+
+            /* Nom de la fonction */
+            result = itd_translate_component(context, comp->binary.left, result);
+
+            result = stradd(result, "(");
+
+            result = itd_translate_component(context, comp->binary.right, result);
+
+            result = stradd(result, ")");
+
+
+            break;
+
+        case ICT_TEMPLATE_ARGS:
+            result = stradd(base, "<");
+            result = itd_translate_component(context, comp->unary, result);
+            result = stradd(result, ">");
+            break;
+
+        case ICT_TYPES_LIST:
+
+            result = itd_translate_component(context, comp->binary.left, base);
+
+            if (comp->binary.right != NULL)
+            {
+                result = stradd(result, ", ");
+                result = itd_translate_component(context, comp->binary.right, result);
+            }
+
+
+            //sub = IT_BINARY_COMP(IT_BINARY_COMP(comp).right).right;
+
+
+            break;
+
+
+        default: /* ICT_* */
+            result = base;
+            break;
+
+    }
+
+
+
+    return result;
+
+
+}
diff --git a/src/mangling/itanium/component.h b/src/mangling/itanium/component.h
new file mode 100644
index 0000000..7ab2521
--- /dev/null
+++ b/src/mangling/itanium/component.h
@@ -0,0 +1,213 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * component.h - prototypes pour la représentation des composants extraits de l'ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_ITANIUM_COMPONENT_H
+#define _FORMAT_MANGLING_ITANIUM_COMPONENT_H
+
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <sys/types.h>
+
+
+#include "context.h"
+#include "../../analysis/type.h"
+#include "../../common/fnv1a.h"
+
+
+
+/* Type de composants */
+typedef enum _ItaniumComponentType
+{
+    /**
+     * Représentation d'une règle vide.
+     */
+    ICT_EMPTY,
+
+    /**
+     * Chaîne de caractère, terminée par un octet nul.
+     */
+    ICT_NAME,
+    ICT_STD_SUBST,
+
+    /**
+     * Noms imbriqués, en deux parties : 'binary'.
+     */
+    ICT_NESTED_NAME,
+    ICT_TEMPLATE_NAME_ARGS,
+
+    /**
+     * Deux types de préfixes : un ou deux éléments.
+     *  -> 'unary' ou 'binary'
+     */
+    ICT_PREFIX_UNARY,
+    ICT_PREFIX_BINARY,
+    ICT_TPREFIX_UNARY,
+    ICT_TPREFIX_BINARY,
+
+    /**
+     * Encodage d'un nom d'opérateur, consigné dans 'operator'.
+     */
+    ICT_OPERATOR_NAME,
+
+
+    /**
+     * Fonctions virtuelles.
+     *  -> décalage : 'offset'.
+     *  -> fonctions simples : 'binary'.
+     *  -> fonctions complexes : 'ternary'.
+     */
+    ICT_NON_VIRTUAL_OFFSET,
+    ICT_VIRTUAL_OFFSET,
+    ICT_FUNCTION_THUNK,
+    ICT_FUNCTION_COVARIANT_THUNK,
+
+    /**
+     * Constructeur ou destructeur, sans plus de détail.
+     */
+    ICT_CONSTRUCTOR,
+    ICT_DESSTRUCTOR,
+
+    /**
+     * Type instanciable dans le programme.
+     */
+    ICT_TYPE,
+
+    /**
+     * Différentes références vers un sous-type.
+     * Le champ impacté est 'unary'.
+     */
+    ICT_POINTER_TO,
+    ICT_REFERENCE_TO,
+    ICT_RVALUE_REFERENCE_TO,
+    ICT_COMPLEX_PAIR,
+    ICT_IMAGINARY,
+
+    /**
+     * Fonction (nom + retour/paramètres), sous forme binaire :
+     *  -> left = function name
+     *  -> right = bare-function-type
+     */
+    ICT_FUNCTION_ENCODING,
+
+    /**
+     * Liste d'arguments pour templates, à encadrer par des chevrons.
+     * 'unary' pointe vers la liste des éléments.
+     */
+    ICT_TEMPLATE_ARGS,
+
+    /**
+     * Liste de types, sous forme binaire :
+     *  -> left = élément de la liste de types.
+     *  -> right = reste de la liste de types.
+     */
+    ICT_TYPES_LIST,
+
+    ICT_COUNT
+
+} ItaniumComponentType;
+
+
+/* Catégories d'opérateurs */
+typedef enum _ItaniumOperatorType
+{
+    IOT_SIMPLE,                             /* Présent dans la liste       */
+    IOT_CAST,                               /* Conversion forcée           */
+    IOT_VENDOR                              /* Défini par un vendeur       */
+
+} ItaniumOperatorType;
+
+
+/* Enregistrement des opérateurs */
+typedef struct _itanium_operator_info
+{
+    const char *code;                       /* Nom encodé                  */
+    const char *name;                       /* Désignation humaine         */
+    size_t name_len;                        /* Taille du nom humain        */
+    int args;                               /* Nombre d'arguments          */
+
+} itanium_operator_info;
+
+
+/* Composant extrait de l'encodage */
+typedef struct _itanium_component itanium_component;
+
+
+
+/* Incrémente le nombre d'utilisation du composant. */
+void itd_ref_comp(itanium_component *);
+
+/* Décrémente le nombre d'utilisation du composant. */
+void itd_unref_comp(itanium_component *);
+
+/* Détermine ou fournit l'empreinte d'un composant. */
+fnv64_t itd_hash_comp(itanium_component *);
+
+
+
+/* Marque un composant comme étant disponible pour un usage. */
+void itd_free_comp(GItaniumDContext *, itanium_component *);
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_empty(GItaniumDContext *);
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_name(GItaniumDContext *, const char *, size_t);
+
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_operator(GItaniumDContext *, const itanium_operator_info *);
+
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_offset(GItaniumDContext *, ItaniumComponentType, ssize_t);
+
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_type(GItaniumDContext *, GDataType *);
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_binary(GItaniumDContext *, ItaniumComponentType, itanium_component *, itanium_component *);
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_append_right_to_binary(GItaniumDContext *, ItaniumComponentType, itanium_component *, itanium_component *);
+
+/* Construit un composant dans un contexte Itanium. */
+itanium_component *itd_make_unary(GItaniumDContext *, ItaniumComponentType, itanium_component *);
+
+
+
+/* Modifie légèrement le type d'un composant donné. */
+void itd_set_type(itanium_component *, ItaniumComponentType);
+
+/* Fournit le type d'un composant issu d'un contexte Itanium. */
+ItaniumComponentType itd_get_component_type(const itanium_component *);
+
+/* Traduit les composants de contexte Itanium. */
+char *itd_translate_component(GItaniumDContext *, const itanium_component *, char *);
+
+
+
+#endif  /* _FORMAT_MANGLING_ITANIUM_COMPONENT_H */
diff --git a/src/mangling/itanium/context.c b/src/mangling/itanium/context.c
new file mode 100644
index 0000000..d0a0664
--- /dev/null
+++ b/src/mangling/itanium/context.c
@@ -0,0 +1,571 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.c - contexte de décodage à la sauce ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "context.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "abi.h"
+#include "component-int.h"
+#include "../context-int.h"
+
+
+
+/* Taille des extensions d'allocation */
+#define ITCOMP_ALLOC_BULK 200
+
+/* Marqueur de fin pour les disponibilités */
+#define ITCOMP_INVALID ((size_t)-1)
+
+
+/* Contexte de décodage Itanium (instance) */
+struct _GItaniumDContext
+{
+    GDemanglingContext parent;              /* A laisser en premier        */
+
+    char *mangled;                          /* Caractères à traiter        */
+    size_t len;                             /* Quantité de caractères      */
+    size_t pos;                             /* Position d'analyse          */
+
+    itanium_component *components;          /* Tableaux des composants     */
+    size_t *next_links;                     /* Chemins d'allocation        */
+    size_t length;                          /* Taille allouée              */
+    size_t last_used;                       /* Lien vers la disponibilité  */
+
+    itanium_component **substitutions;      /* Table de substitutions      */
+    size_t subst_count;                     /* Quantité utilisée           */
+
+};
+
+/* Contexte de décodage Itanium (classe) */
+struct _GItaniumDContextClass
+{
+    GDemanglingContextClass parent;         /* A laisser en premier        */
+
+};
+
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GItaniumDContext, g_itanium_dcontext, G_TYPE_DEMANGLING_CONTEXT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_itanium_dcontext_class_init(GItaniumDContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_itanium_dcontext_init(GItaniumDContext *context)
+{
+    context->last_used = ITCOMP_INVALID;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Prépare de quoi effectuer un décodage Itanium.               *
+*                                                                             *
+*  Retour      : Instance du contexte mis en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDemanglingContext *g_itanium_dcontext_new(void)
+{
+    GDemanglingContext *result;             /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_ITANIUM_DCONTEXT, NULL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage sur lequel s'appuyer.         *
+*                desc    = chaîne de caractères à décoder.                    *
+*                                                                             *
+*  Description : Tente de décoder une chaîne de caractères donnée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void /*GBinRoutine **/g_itanium_dcontext_demangle_routine(GItaniumDContext *context, const char *desc)
+{
+    itanium_component *comp;
+
+    char *str;
+
+    printf("<<== %s\n", desc);
+
+    context->mangled = strdup(desc);
+    context->len = strlen(desc);
+    context->pos = 0;
+
+
+    /**
+     * On part du principe qu'il n'y aura jamais plus de substitutions
+     * à enregistrer que de caractères dans la chaîne à traiter.
+     * Du coup, on peut tout allouer d'un coup !
+     */
+    context->substitutions = (itanium_component **)calloc(context->len, sizeof(itanium_component *));
+
+
+    comp = itd_mangled_name(context);
+
+
+    printf("Got :: %p\n", comp);
+
+    str = itd_translate_component(context, comp, NULL);
+
+    printf("==>> %s\n", str);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                state   = état courant à sauvegarder. [OUT]                  *
+*                                                                             *
+*  Description : Fournit l'état courant à une fin de retour en arrière.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_itanium_dcontext_push_state(const GItaniumDContext *context, itd_state *state)
+{
+    state->pos = context->pos;
+    state->subst_count = context->subst_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                state   = état courant à restaurer.                          *
+*                                                                             *
+*  Description : Définit l'état courant suite à un retour en arrière.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_itanium_dcontext_pop_state(GItaniumDContext *context, const itd_state *state)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    /*
+    printf("--deleting subst-- from %zu to %zu\n",
+           state->subst_count, context->subst_count);
+    */
+
+    for (i = state->subst_count; i < context->subst_count; i++)
+        itd_unref_comp(context->substitutions[i]);
+
+    context->pos = state->pos;
+    context->subst_count = state->subst_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Fournit la valeur du caractère courant.                      *
+*                                                                             *
+*  Retour      : Caractère courant.                                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char g_itanium_dcontext_peek_char(const GItaniumDContext *context)
+{
+    return *(context->mangled + context->pos);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context  = contexte de décodage à utiliser.                  *
+*                quantity = quantié de caractères à marquer comme traités.    *
+*                                                                             *
+*  Description : Avance la tête de lecture courante.                          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_itanium_dcontext_advance(GItaniumDContext *context, size_t quantity)
+{
+    context->pos += quantity;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Fournit et avance la tête de lecture courante.               *
+*                                                                             *
+*  Retour      : Caractère courant.                                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char g_itanium_dcontext_next_char(GItaniumDContext *context)
+{
+    return *(context->mangled + context->pos++);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                c       = caractère à retrouver.                             *
+*                                                                             *
+*  Description : Vérifie la nature du caractère courant.                      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_itanium_dcontext_check_char(GItaniumDContext *context, char c)
+{
+    bool result;                            /* Validation à retourner      */
+
+    if (g_itanium_dcontext_peek_char(context) == c)
+    {
+        result = true;
+        g_itanium_dcontext_advance(context, 1);
+    }
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context   = contexte de décodage à utiliser.                 *
+*                remaining = taille de la chaîne retournée. [OUT]             *
+*                                                                             *
+*  Description : Fournit la chaîne de caractère restant à traiter.            *
+*                                                                             *
+*  Retour      : Pointeur vers les données courantes.                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_itanium_dcontext_get_string(const GItaniumDContext *context, size_t *remaining)
+{
+    const char *result;                     /* Données à renvoyer          */
+
+    *remaining = context->len - context->pos;
+
+    result = &context->mangled[context->pos];
+
+    return result;
+
+}
+
+
+
+
+
+/*
+
+################define d_peek_char(di) (*((di)->n))
+#define d_peek_next_char(di) ((di)->n[1])
+################define d_advance(di, i) ((di)->n += (i))
+################define d_check_char(di, c) (d_peek_char(di) == c ? ((di)->n++, 1) : 0)
+#define d_next_char(di) (d_peek_char(di) == '\0' ? '\0' : *((di)->n++))
+################define d_str(di) ((di)->n)
+
+
+*/
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                                                                             *
+*  Description : Fournit un nouveau composant vierge.                         *
+*                                                                             *
+*  Retour      : Composant prêt à être défini.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *g_itanium_dcontext_get_empty_component(GItaniumDContext *context)
+{
+    itanium_component *result;              /* Disponibilité à retourner   */
+    size_t i;                               /* Boucle de parcours          */
+    size_t next;                            /* Indice de disponibilité     */
+
+    if (context->last_used == ITCOMP_INVALID
+        || context->next_links[context->last_used] == ITCOMP_INVALID)
+    {
+        /* Création d'extensions */
+
+        context->components = (itanium_component *)
+            realloc(context->components,
+                    (context->length + ITCOMP_ALLOC_BULK) * sizeof(itanium_component));
+
+        context->next_links = (size_t *)
+            realloc(context->next_links, (context->length + ITCOMP_ALLOC_BULK) * sizeof(size_t));
+
+        /* Inscription des liens d'allocation */
+
+        for (i = context->length; i < (context->length + ITCOMP_ALLOC_BULK - 1); i++)
+            context->next_links[i] = i + 1;
+
+        context->next_links[context->length + ITCOMP_ALLOC_BULK - 1] = ITCOMP_INVALID;
+
+        if (context->last_used != ITCOMP_INVALID)
+            context->next_links[context->last_used] = context->length;
+
+        /* Mise à jour globale */
+
+        context->length += ITCOMP_ALLOC_BULK;
+
+    }
+
+    /* Extraction d'un composant disponible */
+
+    if (context->last_used == ITCOMP_INVALID)
+        next = 0;
+    else
+        next = context->next_links[context->last_used];
+
+    result = &context->components[next];
+    context->last_used = next;
+
+    memset(result, 0, sizeof(itanium_component));
+
+    result->context = context;
+    g_object_ref(G_OBJECT(result->context));
+    result->refcount = 1;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                comp    = composant à libérer.                               *
+*                                                                             *
+*  Description : Marque un composant comme étant disponible pour un usage.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_itanium_dcontext_mark_component_as_free(GItaniumDContext *context, itanium_component *comp)
+{
+    size_t index;                           /* Indice du composant concerné*/
+
+    /*BUG_ON(comp->refcount != 0);*/
+
+    g_object_unref(G_OBJECT(comp->context));
+
+    index = comp - context->components;
+
+    context->next_links[index] = context->next_links[context->last_used];
+    context->next_links[context->last_used] = index;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                comp    = composant à conserver en mémoire.                  *
+*                                                                             *
+*  Description : Indexe un composant comme future substitution potentielle.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_itanium_dcontext_add_substitution(GItaniumDContext *context, itanium_component *comp)
+{
+    fnv64_t hash;                           /* Empreinte du candidat       */
+    size_t i;                               /* Boucle de parcours          */
+
+    hash = itd_hash_comp(comp);
+
+    for (i = 0; i < context->subst_count; i++)
+        if (cmp_fnv_64a(itd_hash_comp(context->substitutions[i]), hash) == 0)
+            break;
+
+    if (i == context->subst_count)
+    {
+
+        printf("[ADDING SUBST] [%zu] '%s'\n",
+               context->subst_count,
+               itd_translate_component(context, comp, NULL));
+
+
+        context->substitutions[context->subst_count++] = comp;
+        itd_ref_comp(comp);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à manipuler.                  *
+*                index   = indice de la substitution visée.                   *
+*                                                                             *
+*  Description : Fournit un composant en place pour une substitution.         *
+*                                                                             *
+*  Retour      : Composant déjà extrait et conservé.                          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+itanium_component *g_itanium_dcontext_get_substitution(GItaniumDContext *context, size_t index)
+{
+    itanium_component *result;              /* Composant à retourner       */
+
+    if (index < context->subst_count)
+    {
+        result = context->substitutions[index];
+        itd_ref_comp(result);
+    }
+    else
+        result = NULL;
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void test_itanium(void)
+{
+
+
+
+
+#define TEST_DEMANG(v)                                          \
+    do                                                          \
+    {                                                           \
+        GDemanglingContext *ctx;                                \
+        /*char *str;*/                                          \
+        ctx = g_itanium_dcontext_new();     \
+    /*str = */g_itanium_dcontext_demangle_routine(G_ITANIUM_DCONTEXT(ctx), v); \
+        /*printf("==> %s\n", str);*/                            \
+    }                                                           \
+    while (0)
+
+
+    TEST_DEMANG("_Z3fooILi2EEvRAplT_Li1E_i");
+
+    exit(0);
+
+    TEST_DEMANG("_Z1fv");
+    TEST_DEMANG("_Z3foo3bar");
+
+
+}
diff --git a/src/mangling/itanium/context.h b/src/mangling/itanium/context.h
new file mode 100644
index 0000000..13ec1f4
--- /dev/null
+++ b/src/mangling/itanium/context.h
@@ -0,0 +1,117 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * context.h - prototypes pour le contexte de décodage à la sauce ABI C++ Itanium
+ *
+ * Copyright (C) 2013-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_ITANIUM_CONTEXT_H
+#define _FORMAT_MANGLING_ITANIUM_CONTEXT_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+#include "../context.h"
+
+
+
+#define G_TYPE_ITANIUM_DCONTEXT               g_itanium_dcontext_get_type()
+#define G_ITANIUM_DCONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_itanium_dcontext_get_type(), GItaniumDContext))
+#define G_IS_ITANIUM_DCONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_itanium_dcontext_get_type()))
+#define G_ITANIUM_DCONTEXT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_itanium_dcontext_get_type(), GItaniumDContextIface))
+#define G_ITANIUM_DCONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ITANIUM_DCONTEXT, GItaniumDContextClass))
+
+
+/* Contexte de décodage Itanium (instance) */
+typedef struct _GItaniumDContext GItaniumDContext;
+
+/* Contexte de décodage Itanium (classe) */
+typedef struct _GItaniumDContextClass GItaniumDContextClass;
+
+
+/* Indique le type défini pour un contexte de décodage. */
+GType g_itanium_dcontext_get_type(void);
+
+/* Prépare de quoi effectuer un décodage Itanium. */
+GDemanglingContext *g_itanium_dcontext_new(void);
+
+/* Tente de décoder une chaîne de caractères donnée. */
+void /*GBinRoutine **/g_itanium_dcontext_demangle_routine(GItaniumDContext *, const char *);
+
+/* Sauvegarde d'un état courant */
+typedef struct _itd_state
+{
+    size_t pos;                             /* Position courante           */
+    size_t subst_count;                     /* Nombre de substitutions     */
+
+} itd_state;
+
+/* Fournit l'état courant à une fin de retour en arrière. */
+void g_itanium_dcontext_push_state(const GItaniumDContext *, itd_state *);
+
+/* Définit l'état courant suite à un retour en arrière. */
+void g_itanium_dcontext_pop_state(GItaniumDContext *, const itd_state *);
+
+/* Fournit la valeur du caractère courant. */
+char g_itanium_dcontext_peek_char(const GItaniumDContext *);
+
+/* Avance la tête de lecture courante. */
+void g_itanium_dcontext_advance(GItaniumDContext *, size_t);
+
+/* Fournit et avance la tête de lecture courante. */
+char g_itanium_dcontext_next_char(GItaniumDContext *);
+
+/* Vérifie la nature du caractère courant. */
+bool g_itanium_dcontext_check_char(GItaniumDContext *, char);
+
+/* Fournit la chaîne de caractère restant à traiter. */
+const char *g_itanium_dcontext_get_string(const GItaniumDContext *, size_t *);
+
+
+
+
+/* Composant extrait de l'encodage */
+typedef struct _itanium_component itanium_component;
+
+
+/* Fournit un nouveau composant vierge. */
+itanium_component *g_itanium_dcontext_get_empty_component(GItaniumDContext *);
+
+/* Marque un composant comme étant disponible pour un usage. */
+void g_itanium_dcontext_mark_component_as_free(GItaniumDContext *, itanium_component *);
+
+/* Indexe un composant comme future substitution potentielle. */
+void g_itanium_dcontext_add_substitution(GItaniumDContext *, itanium_component *);
+
+/* Fournit un composant en place pour une substitution. */
+itanium_component *g_itanium_dcontext_get_substitution(GItaniumDContext *, size_t);
+
+
+
+
+
+
+void test_itanium(void);
+
+
+
+
+
+#endif  /* _FORMAT_MANGLING_ITANIUM_CONTEXT_H */
diff --git a/src/mangling/java.h b/src/mangling/java.h
new file mode 100644
index 0000000..ee7f21d
--- /dev/null
+++ b/src/mangling/java.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * java.h - prototypes pour le décodage des noms d'éléments selon Java
+ *
+ * Copyright (C) 2010-2017 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_JAVA_H
+#define _FORMAT_MANGLING_JAVA_H
+
+
+#include <stdbool.h>
+
+
+#include "context.h"
+#include "demangler.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+/* Contexte de décodage Java (instance) */
+typedef struct _GJavaDContext GJavaDContext;
+
+/* Contexte de décodage Java (classe) */
+typedef struct _GJavaDContextClass GJavaDContextClass;
+
+
+/* Prépare de quoi effectuer un décodage Java. */
+GDemanglingContext *g_java_dcontext_new(void);
+
+
+
+/* ----------------------- TRAITEMENT DE L'ENCODAGE TYPE JAVA ----------------------- */
+
+
+/* Procède au décodage d'une chaîne de caractères. */
+bool demangle_java_type(GJavaDContext *, const char *);
+
+
+
+#endif  /* _FORMAT_MANGLING_JAVA_H */
diff --git a/src/mangling/java_gram.y b/src/mangling/java_gram.y
new file mode 100644
index 0000000..cb60d82
--- /dev/null
+++ b/src/mangling/java_gram.y
@@ -0,0 +1,281 @@
+
+%{
+
+
+
+#include "context-int.h"
+#include "java.h"
+#include "../analysis/types/cse.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+#define G_TYPE_JAVA_DCONTEXT               g_java_dcontext_get_type()
+#define G_JAVA_DCONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_java_dcontext_get_type(), GJavaDContext))
+#define G_IS_JAVA_DCONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_java_dcontext_get_type()))
+#define G_JAVA_DCONTEXT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_java_dcontext_get_type(), GJavaDContextIface))
+#define G_JAVA_DCONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_JAVA_DCONTEXT, GJavaDContextClass))
+
+
+/* Contexte de décodage Java (instance) */
+struct _GJavaDContext
+{
+    GDemanglingContext parent;              /* A laisser en premier        */
+
+};
+
+/* Contexte de décodage Java (classe) */
+struct _GJavaDContextClass
+{
+    GDemanglingContextClass parent;         /* A laisser en premier        */
+
+};
+
+
+/* Indique le type défini pour un contexte de décodage. */
+static GType g_java_dcontext_get_type(void);
+
+/* Initialise la classe des contextes de décodage. */
+static void g_java_dcontext_class_init(GJavaDContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_java_dcontext_init(GJavaDContext *);
+
+/* Affiche un message d'erreur concernant l'analyse. */
+static int java_error(/*const YYLTYPE *yyloc, bool hunt, char **ucode, unsigned char *index, */GJavaDContext *, char *);
+
+
+
+
+
+
+%}
+
+
+%union {
+
+    void /*GDataType*/ *type;
+
+    size_t adeep;                           /* Dimension d'un tableau      */
+
+    char *text;                             /* Chaîne de caractères        */
+
+}
+
+%parse-param { GJavaDContext *context }
+
+%token V Z B S C I J F D
+%token ARRAY
+%token L SEMICOLON
+%token SLASH DOLLAR
+%token TEXT
+
+%type <type> type_descriptor field_type_descriptor non_array_field_type_descriptor full_class_name
+
+%type <text> TEXT
+
+
+%{
+
+/* De lexi.c... */
+/*int yylex(YYSTYPE *, YYLTYPE *);*/
+void java_restart(FILE *);
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+extern YY_BUFFER_STATE java__scan_string(const char *);
+extern void java__delete_buffer(YY_BUFFER_STATE);
+
+ extern int java_lex (void);
+
+
+/* Affiche un message d'erreur concernant l'analyse. */
+/*int yyerror(const YYLTYPE *, bool, char **, unsigned char *, char *);*/
+
+%}
+
+
+%%
+
+
+input:
+    type_descriptor                     { G_DEMANGLING_CONTEXT(context)->type = $1; }
+	;
+
+type_descriptor:
+    V                                   { $$ = g_basic_type_new(BTP_VOID); }
+    | field_type_descriptor             { $$ = $1; }
+    ;
+
+field_type_descriptor:
+	non_array_field_type_descriptor             { $$ = $1; }
+	| ARRAY non_array_field_type_descriptor     { $$ = $2; }
+    ;
+
+non_array_field_type_descriptor:
+	Z                                   { $$ = g_basic_type_new(BTP_BOOL); }
+	| B                                 { $$ = g_basic_type_new(BTP_UCHAR); }
+	| S                                 { $$ = g_basic_type_new(BTP_SHORT); }
+	| C                                 { $$ = g_basic_type_new(BTP_CHAR); }
+	| I                                 { $$ = g_basic_type_new(BTP_INT); }
+	| J                                 { $$ = g_basic_type_new(BTP_LONG); }
+	| F                                 { $$ = g_basic_type_new(BTP_FLOAT); }
+	| D                                 { $$ = g_basic_type_new(BTP_DOUBLE); }
+	| L full_class_name SEMICOLON       { $$ = $2; }
+    ;
+
+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_data_type_set_namespace($$, $1);
+                                            g_object_unref($1);
+                                        }
+    | full_class_name DOLLAR TEXT       {
+                                            $$ = g_class_enum_type_new(CET_CLASS, $3);
+                                            g_data_type_set_namespace($$, $1);
+                                            g_object_unref($1);
+                                        }
+    ;
+
+
+%%
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           CONTEXTE POUR LE DECODAGE JAVA                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GJavaDContext, g_java_dcontext, G_TYPE_DEMANGLING_CONTEXT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_dcontext_class_init(GJavaDContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_dcontext_init(GJavaDContext *context)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Prépare de quoi effectuer un décodage Java.                  *
+*                                                                             *
+*  Retour      : Instance du contexte mis en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDemanglingContext *g_java_dcontext_new(void)
+{
+    GDemanglingContext *result;             /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_JAVA_DCONTEXT, NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         TRAITEMENT DE L'ENCODAGE TYPE JAVA                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Affiche un message d'erreur concernant l'analyse.
+ * @param yyloc informations concernant les coordonnées du soucis.
+ * @param hunt indique le type de passe réalisée.
+ * @param ucode code résultant compilé.
+ * @param index indice de commande à mettre à jour.
+ * @param msg indications humaines sur l'événement.
+ * @return 0.
+ */
+static int java_error(/*const YYLTYPE *yyloc, bool hunt, char **ucode, unsigned char *index, */GJavaDContext *context, char *msg)
+{
+
+
+
+	fprintf(stderr, "ERREUR !\n");
+	fprintf(stderr, "%s\n", msg);
+
+	return -1;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                desc    = chaîne de caractères à décoder.                    *
+*                                                                             *
+*  Description : Procède au décodage d'une chaîne de caractères.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool demangle_java_type(GJavaDContext *context, const char *desc)
+{
+	YY_BUFFER_STATE buffer;                 /* Tampon pour bison           */
+	int ret;                                /* Bilan de l'appel            */
+
+	buffer = java__scan_string(desc);
+	ret = yyparse(context);
+	java__delete_buffer(buffer);
+
+    return (ret == 0);
+
+}
diff --git a/src/mangling/java_tok.l b/src/mangling/java_tok.l
new file mode 100644
index 0000000..4adf623
--- /dev/null
+++ b/src/mangling/java_tok.l
@@ -0,0 +1,37 @@
+
+%{
+
+#include "java.h"
+#include "libjavamangling_la-java_gram.h" 
+
+%}
+
+
+%option noyywrap
+%option yylineno
+%option nounput
+%option noinput
+
+%x string
+
+
+%%
+
+V                       { return V; }
+Z                       { return Z; }
+B                       { return B; }
+S                       { return S; }
+C                       { return C; }
+I                       { return I; }
+J                       { return J; }
+F                       { return F; }
+D                       { return D; }
+L                       { BEGIN(string); return L; }
+[[]*                    { java_lval.adeep = strlen(yytext); return ARRAY; }
+<string>[/]             { return SLASH; }
+<string>[$]             { return DOLLAR; }
+<string>[;]             { BEGIN(INITIAL); return SEMICOLON; }
+
+<string>[A-Za-z0-9]*    { java_lval.text = yytext; return TEXT; }
+
+%%