Moved the mangling related code.

1 files changed, 0 insertions, 2444 deletions

diff --git a/src/format/mangling/itanium/abi.c b/src/format/mangling/itanium/abi.c
deleted file mode 100644
index 5645a05..0000000
--- a/src/format/mangling/itanium/abi.c
+++ /dev/null
@@ -1,2444 +0,0 @@
-
-/* 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;
-
-}