Fixed some mistakes in the Itanium prefixes demangling.

2 files changed, 273 insertions, 195 deletions

diff --git a/plugins/itanium/abi.c b/plugins/itanium/abi.c
index 7094aa4..0e7ce27 100644
--- a/plugins/itanium/abi.c
+++ b/plugins/itanium/abi.c
@@ -147,9 +147,6 @@ static itanium_component *itd_nested_name(GItaniumDemangling *);
 static itanium_component *itd_prefix(GItaniumDemangling *);
 
 /* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_prefix_rec(GItaniumDemangling *, itanium_component *);
-
-/* Extrait un composant dans un contexte Itanium. */
 static itanium_component *itd_template_prefix(GItaniumDemangling *);
 
 /* Détermine si le composant suivant correspond à un type donné. */
@@ -215,6 +212,9 @@ static itanium_component *itd_template_param(GItaniumDemangling *);
 /* Extrait un composant dans un contexte Itanium. */
 static itanium_component *itd_template_template_param(GItaniumDemangling *);
 
+/* Détermine si le composant suivant correspond à un type donné. */
+static bool is_itd_template_args(GItaniumDemangling *);
+
 /* Extrait un composant dans un contexte Itanium. */
 static itanium_component *itd_template_args(GItaniumDemangling *);
 
@@ -231,6 +231,9 @@ static itanium_component *itd_value_to_string(GItaniumDemangling *, bool);
 static itanium_component *itd_expr_primary(GItaniumDemangling *);
 
 /* Extrait un composant dans un contexte Itanium. */
+static itanium_component *itd_data_member_prefix(GItaniumDemangling *);
+
+/* Extrait un composant dans un contexte Itanium. */
 static bool itd_seq_id(GItaniumDemangling *, char, size_t *);
 
 /* Extrait un composant dans un contexte Itanium. */
@@ -643,6 +646,13 @@ static itanium_component *itd_nested_name(GItaniumDemangling *context)
 
     if (left != NULL)
     {
+        /**
+         * Quand son traitement est un succès, <template-prefix> doit toujours
+         * se terminer par <template-args>.
+         */
+
+        assert(is_itd_template_args(context));
+
         right = itd_template_args(context);
 
         if (right != NULL)
@@ -728,86 +738,98 @@ static itanium_component *itd_prefix(GItaniumDemangling *context)
     input_buffer *ibuf;                     /* Tampon de texte manipulé    */
     char peek;                              /* Prochain caractère lu       */
     itanium_component *targs;               /* Composant 'template-args'   */
+    bool backup;                            /* Solution de repli existante */
+    bool merge_targs;                       /* Fusion nécessaire ?         */
     itd_state saved;                        /* Position d'analyse courante */
     itanium_component *further;             /* Tentative de progression    */
 
     /**
      * La règle traitée ici est la suivante :
      *
-     * <prefix> ::= <prefix> <unqualified-name>
+     * <prefix> ::= <unqualified-name>
+     *          ::= <prefix> <unqualified-name>
      *          ::= <template-prefix> <template-args>
      *          ::= <template-param>
-     *          ::= # empty
+     *          ::= <decltype>
+     *          ::= <prefix> <data-member-prefix>
      *          ::= <substitution>
      *
-     * On note déjà la jolie petite boucle interne.
+     * Réorganisée, cette règle <prefix> a pour définition :
+     *
+     * <prefix> ::= <unqualified-name>
+     *          ::= <template-param>
+     *          ::= <decltype>
+     *          ::= <substitution>
+     *          ::= <template-prefix> <template-args>
      *
-     * Or on a également la règle voisine suivante :
+     *          ::= <prefix> <unqualified-name>
+     *          ::= <prefix> <data-member-prefix>
+     *
+     * Il existe cependant une boucle infinie avec une règle de <prefix> :
      *
      * <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 :
+     * On déplie donc les règles afin de casser la boucle, quitte à gérer ici
+     * une partie de la règle <template-prefix> :
      *
-     * <prefix> ::= <prefix> <unqualified-name>
-     *          ::= <prefix> <unqualified-name> <template-args>
+     * <prefix> ::= <unqualified-name>
      *          ::= <template-param>
-     *          ::= <template-param> <template-args>
+     *          ::= <decltype>
      *          ::= <substitution>
+     *
+     *          ::= <unqualified-name> <template-args>
+     *          ::= <template-param> <template-args>
      *          ::= <substitution> <template-args>
-     *          ::= # empty
      *
+     *          ::= <prefix> <unqualified-name>
+     *          ::= <prefix> <unqualified-name> <template-args>
+     *          ::= <prefix> <data-member-prefix>
      */
 
-    ibuf = &G_DEMANGLING_CONTEXT(context)->buffer;
-
-    if (is_itd_unqualified_name(context))
-        result = itd_unqualified_name(context);
-
-    else
-    {
-        peek = peek_input_buffer_char(ibuf);
-
-        if (peek == 'T')
-            result = itd_template_param(context);
+    result = NULL;
 
-        else if (peek == 'S')
-            result = itd_substitution(context);
+    ibuf = &G_DEMANGLING_CONTEXT(context)->buffer;
 
-        else
-            result = NULL;
+    peek = peek_input_buffer_char(ibuf);
 
-    }
+    if (peek == 'S')
+        result = itd_substitution(context);
 
-    if (result == NULL)
-        goto prefix_exit;
+    else if (peek == 'T')
+        result = itd_template_param(context);
 
-    g_itanium_demangling_add_substitution(context, result);
+    else if (is_itd_unqualified_name(context))
+        result = itd_unqualified_name(context);
 
     /**
-     * Détection et traitement de <template-args>.
+     * Si le traitement débouche sur une règle <template-args>, c'est qu'il
+     * était en fait potentiellement dans une voie <template-prefix>.
+     *
+     * Cette voie est vérifiée après coup en analysant la suite.
      */
 
-    peek = peek_input_buffer_char(ibuf);
-
-    if (peek == 'I')
+    if (is_itd_template_args(context))
     {
-        /**
-         * Si la détection est avérée, on vient donc de traiter un cas <template-prefix>.
-         * On corrige donc le type au passage.
-         */
-        if (itd_get_component_type(result) == ICT_PREFIX_BINARY)
-            itd_set_type(result, ICT_TPREFIX_BINARY);
+        g_itanium_demangling_push_state(context, &saved);
 
         targs = itd_template_args(context);
 
         if (targs != NULL)
         {
-            result = itd_make_binary(ICT_TEMPLATE_NAME_ARGS, result, targs);
+            if (!is_itd_unqualified_name(context))
+            {
+                g_itanium_demangling_pop_state(context, &saved);
+                itd_unref_comp(targs);
+            }
 
-            g_itanium_demangling_add_substitution(context, result);
+            else
+            {
+                /* Ajout de la substitution tirée de <template-prefix> */
+                g_itanium_demangling_add_substitution(context, result);
+
+                result = itd_make_binary(ICT_TEMPLATE_NAME_ARGS, result, targs);
+
+            }
 
         }
 
@@ -815,175 +837,118 @@ static itanium_component *itd_prefix(GItaniumDemangling *context)
         {
             itd_unref_comp(result);
             result = NULL;
+            goto done;
         }
 
     }
 
     if (result == NULL)
-        goto prefix_exit;
+        goto done;
 
-    /**
-     * Toutes les règles <prefix> sont suivie par un <[template] unqualified-name>.
-     *
-     * On vérifie donc que c'est le cas.
-     */
-
-    if (!is_itd_unqualified_name(context))
-    {
-        itd_unref_comp(result);
-        result = NULL;
-        goto prefix_exit;
-
-    }
-
-    /**
-     * Cette vérification passée, on peut se trouver dans l'un des cas suivants :
-     *
-     * <prefix> ::= <prefix> <unqualified-name>
-     *          ::= <prefix> <template unqualified-name> <template-args>
-     *
-     * On tente donc une itération supplémentaire.
-     */
-
-    g_itanium_demangling_push_state(context, &saved);
+    g_itanium_demangling_add_substitution(context, result);
 
-    further = itd_prefix_rec(context, result);
+    /* Tentative de rebouclage sur la règle <prefix> */
 
-    if (further != NULL)
-        result = further;
+    while (count_input_buffer_remaining(ibuf) > 0)
+    {
+        backup = is_itd_unqualified_name(context);
 
-    else
-        g_itanium_demangling_pop_state(context, &saved);
+        if (backup)
+            g_itanium_demangling_push_state(context, &saved);
 
- prefix_exit:
+        merge_targs = false;
+        targs = NULL;
 
-    return result;
+        /**
+         * Comme <data-member-prefix> commence par une régle <source-name> et
+         * complète ensuite sa définition et comme <unqualified-name> contient
+         * également cette même règle <source-name> sans l'étendre, on commence
+         * par traiter la règle <data-member-prefix>.
+         */
 
-}
+        further = itd_data_member_prefix(context);
 
+        if (further == NULL)
+        {
+            further = itd_unqualified_name(context);
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : context = contexte de décodage à utiliser.                   *
-*                loop    = consigne pour la poursuite de la boucle. [OUT]     *
-*                                                                             *
-*  Description : Extrait un composant dans un contexte Itanium.               *
-*                                                                             *
-*  Retour      : Composant extrait ou NULL en cas d'échec.                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+            if (further != NULL && is_itd_template_args(context))
+            {
+                merge_targs = true;
+                targs = itd_template_args(context);
 
-static itanium_component *itd_prefix_rec(GItaniumDemangling *context, itanium_component *leaf)
-{
-    itanium_component *result;              /* Construction à retourner    */
-    input_buffer *ibuf;                     /* Tampon de texte manipulé    */
-    char peek;                              /* Prochain caractère lu       */
-    itanium_component *targs;               /* Composant 'template-args'   */
-    itd_state saved;                        /* Position d'analyse courante */
-    itanium_component *further;             /* Tentative de progression    */
+                /* Si l'ensemble ne se termine pas par la règle finale attendue, on rétro-pédale */
+                if (targs != NULL && !is_itd_unqualified_name(context))
+                {
+                    itd_unref_comp(targs);
 
-    /**
-     * La règle locale traitée ici est la suivante :
-     *
-     * <prefix> ::= <prefix> <unqualified-name>
-     *          ::= <prefix> <unqualified-name> <template-args>
-     *
-     * Le premier <prefix> des règles est contenu dans l'arguement leaf.
-     */
+                    merge_targs = false;
+                    targs = NULL;
 
-    ibuf = &G_DEMANGLING_CONTEXT(context)->buffer;
+                    g_itanium_demangling_pop_state(context, &saved);
 
-    /**
-     * La présence du <unqualified-name> intial doit être assurée
-     * par l'appelant.
-     *
-     * Mais comme le test ne vaut pas la création, on valide quand même derrière.
-     */
+                    break;
 
-    assert(is_itd_unqualified_name(context));
+                }
 
-    result = itd_unqualified_name(context);
+            }
 
-    if (result == NULL)
-        goto prefix_rec_exit;
+        }
 
-    result = itd_make_binary(ICT_PREFIX_BINARY, leaf, result);
+        if (further == NULL)
+            break;
 
-    g_itanium_demangling_add_substitution(context, result);
+        if (!is_itd_unqualified_name(context))
+        {
+            if (backup)
+                g_itanium_demangling_pop_state(context, &saved);
 
-    /**
-     * Détection et traitement de <template-args>.
-     */
+            itd_unref_comp(further);
 
-    peek = peek_input_buffer_char(ibuf);
+            break;
 
-    if (peek == 'I')
-    {
-        /**
-         * Si la détection est avérée, on vient donc de traiter un cas <template-prefix>.
-         * On corrige donc le type au passage.
-         */
-        if (itd_get_component_type(result) == ICT_PREFIX_BINARY)
-            itd_set_type(result, ICT_TPREFIX_BINARY);
+        }
 
-        targs = itd_template_args(context);
+        result = itd_make_binary(ICT_PREFIX_BINARY, result, further);
 
-        if (targs != NULL)
+        if (merge_targs)
         {
-            result = itd_make_binary(ICT_TEMPLATE_NAME_ARGS, result, targs);
+            if (targs != NULL)
+            {
+                g_itanium_demangling_add_substitution(context, result);
 
-            g_itanium_demangling_add_substitution(context, result);
+                result = itd_make_binary(ICT_TEMPLATE_NAME_ARGS, result, targs);
 
-        }
+            }
+            else
+            {
+                itd_unref_comp(result);
+                result = NULL;
+                goto done;
+            }
 
-        else
-        {
-            itd_ref_comp(leaf);
-            itd_unref_comp(result);
-            result = NULL;
         }
 
+        g_itanium_demangling_add_substitution(context, result);
+
     }
 
-    if (result == NULL)
-        goto prefix_rec_exit;
+ done:
 
     /**
-     * Toutes les règles <prefix> sont suivie par un <[template] unqualified-name>.
-     *
-     * On vérifie donc que c'est le cas.
+     * Quand son traitement est un succès, <prefix> doit toujours
+     * se terminer par <unqualified-name>.
      */
 
-    if (!is_itd_unqualified_name(context))
+    if (result != NULL)
     {
-        itd_ref_comp(leaf);
-        itd_unref_comp(result);
-        result = NULL;
-        goto prefix_rec_exit;
-    }
-
-    /**
-     * Cette vérification passée, on peut se trouver dans l'un des cas suivants :
-     *
-     * <prefix> ::= <prefix> <unqualified-name>
-     *          ::= <prefix> <template unqualified-name> <template-args>
-     *
-     * On tente donc une itération supplémentaire.
-     */
-
-    g_itanium_demangling_push_state(context, &saved);
-
-    further = itd_prefix_rec(context, result);
-
-    if (further != NULL)
-        result = further;
-
-    else
-        g_itanium_demangling_pop_state(context, &saved);
+        if (!is_itd_unqualified_name(context))
+        {
+            itd_unref_comp(result);
+            result = NULL;
+        }
 
- prefix_rec_exit:
+    }
 
     return result;
 
@@ -1005,71 +970,112 @@ static itanium_component *itd_prefix_rec(GItaniumDemangling *context, itanium_co
 static itanium_component *itd_template_prefix(GItaniumDemangling *context)
 {
     itanium_component *result;              /* Construction à retourner    */
+    bool new_subst;                         /* Ajoute d'une substitution ? */
     input_buffer *ibuf;                     /* Tampon de texte manipulé    */
     char peek;                              /* Prochain caractère lu       */
-    itanium_component *prefix;              /* Premier d'un couple de comp.*/
+    itd_state saved;                        /* Position d'analyse courante */
     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-prefix> ::= <template unqualified-name>
+     *                   ::= <prefix> <template unqualified-name>
      *                   ::= <template-param>
      *                   ::= <substitution>
      *
+     * Il existe cependant une boucle infinie avec une règle de <prefix> :
+     *
+     * <prefix> ::= <template-prefix> <template-args>
+     *
+     * On traite donc cette règle de <prefix> en dernier, quand les autres
+     * options ont été épuisées.
      */
 
+    result = NULL;
+
+    new_subst = true;
+
     ibuf = &G_DEMANGLING_CONTEXT(context)->buffer;
 
     peek = peek_input_buffer_char(ibuf);
 
+    g_itanium_demangling_push_state(context, &saved);
+
     if (peek == 'S')
+    {
         result = itd_substitution(context);
+        new_subst = false;
+    }
 
     else if (peek == 'T')
-    {
         result = itd_template_param(context);
 
-        if (result != NULL)
-            g_itanium_demangling_add_substitution(context, result);
+    if (is_itd_unqualified_name(context))
+        result = itd_unqualified_name(context);
 
-    }
+    /* Vérification : a-t-on empiété sur une règle <prefix> ? */
 
-    else
+    if (result != NULL)
     {
-        prefix = itd_prefix(context);
+        if (is_itd_template_args(context))
+            goto done;
+
+        else
+        {
+            new_subst = true;
 
+            itd_unref_comp(result);
+            result = NULL;
+
+            g_itanium_demangling_pop_state(context, &saved);
+
+        }
+
+    }
+
+    /* Tentative avec <prefix> <template unqualified-name> en dernier recours */
+
+    result = itd_prefix(context);
+
+    if (result != NULL)
+    {
         /**
          * Quand son traitement est un succès, <prefix> doit toujours
          * se terminer par <unqualified-name>.
+         *
+         * De même, toutes les règles <template-prefix> se poursuivent avec une
+         * règle <template-args> ; la procédure n'est donc un succès que dans ce cas.
          */
 
-        assert(prefix == NULL || (prefix != NULL && is_itd_unqualified_name(context)));
-
-        /**
-         * Par ailleurs, la règle <prefix> peut être vide, donc on se doit
-         * de tenter un <unqualified-name> dans tous les cas.
-         */
+        assert(is_itd_unqualified_name(context));
 
         name = itd_unqualified_name(context);
 
         if (name != NULL)
-        {
-            result = itd_make_binary(ICT_TPREFIX_BINARY, prefix, name);
-
-            g_itanium_demangling_add_substitution(context, result);
-
-        }
+            result = itd_make_binary(ICT_TPREFIX_BINARY, result, name);
 
         else
         {
+            itd_unref_comp(result);
             result = NULL;
+        }
 
-            if (prefix != NULL)
-                itd_unref_comp(prefix);
+    }
 
+ done:
+
+    if (result != NULL)
+    {
+        if (!is_itd_template_args(context))
+        {
+            itd_unref_comp(result);
+            result = NULL;
         }
 
+        else if (new_subst)
+            g_itanium_demangling_add_substitution(context, result);
+
     }
 
     return result;
@@ -2699,6 +2705,40 @@ static itanium_component *itd_template_template_param(GItaniumDemangling *contex
     return result;
 
 }
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                                                                             *
+*  Description : Détermine si le composant suivant correspond à un type donné.*
+*                                                                             *
+*  Retour      : true si le décodage va à priori réussir, false sinon.        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool is_itd_template_args(GItaniumDemangling *context)
+{
+    bool result;                            /* Bilan à retourner           */
+    input_buffer *ibuf;                     /* Tampon de texte manipulé    */
+    char peek;                              /* Prochain caractère lu       */
+
+    /**
+     * La règle anticipée ici est la suivante :
+     *
+     * <template-args> ::= I <template-arg>+ E
+     *
+     */
+
+    ibuf = &G_DEMANGLING_CONTEXT(context)->buffer;
+
+    peek = peek_input_buffer_char(ibuf);
+
+    result = (peek == 'I');
+
+    return result;
+
+}
 
 
 /******************************************************************************
@@ -3183,10 +3223,27 @@ static itanium_component *itd_expr_primary(GItaniumDemangling *context)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  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_data_member_prefix(GItaniumDemangling *context)
+{
+    itanium_component *result;              /* Construction à retourner    */
 
+    result = NULL;
 
+    return result;
 
+}
 
 
 /******************************************************************************
diff --git a/tests/mangling/itanium.py b/tests/mangling/itanium.py
index 6808a99..57a1129 100644
--- a/tests/mangling/itanium.py
+++ b/tests/mangling/itanium.py
@@ -177,6 +177,24 @@ class TestItaniumMangling(ChrysalideTestCase):
         self.check_demangling(demangled, 'void std::partial_sort<__gnu_cxx::__normal_iterator<CPR_MAI_ADPTY_SectorSequence *, std::vector<CPR_MAI_ADPTY_SectorSequence, std::allocator<CPR_MAI_ADPTY_SectorSequence>>>>(__gnu_cxx::__normal_iterator<CPR_MAI_ADPTY_SectorSequence *, std::vector<CPR_MAI_ADPTY_SectorSequence, std::allocator<CPR_MAI_ADPTY_SectorSequence>>>, __gnu_cxx::__normal_iterator<CPR_MAI_ADPTY_SectorSequence *, std::vector<CPR_MAI_ADPTY_SectorSequence, std::allocator<CPR_MAI_ADPTY_SectorSequence>>>, __gnu_cxx::__normal_iterator<CPR_MAI_ADPTY_SectorSequence *, std::vector<CPR_MAI_ADPTY_SectorSequence, std::allocator<CPR_MAI_ADPTY_SectorSequence>>>)')
 
 
+    def testPrefixLoop(self):
+        """Handle the loop between prefixes defined in the specifications."""
+
+        demangler = ItaniumDemangler()
+
+        demangled = demangler.decode_routine('_ZN2aaIN4ccccIfEEE5dddddEj')
+        self.check_demangling(demangled, '??? aa<cccc<float>>::ddddd(unsigned int)')
+
+        demangled = demangler.decode_routine('_ZN2aaIN4cccc4xxxxIfEEE5dddddEj')
+        self.check_demangling(demangled, '??? aa<cccc::xxxx<float>>::ddddd(unsigned int)')
+
+        demangled = demangler.decode_routine('_ZN3zzz2aaIN4cccc4xxxxIfEEE5dddddEj')
+        self.check_demangling(demangled, '??? zzz::aa<cccc::xxxx<float>>::ddddd(unsigned int)')
+
+        demangled = demangler.decode_routine('_ZN3aaa3bbbINS_3cccIfEEE3dddEj')
+        self.check_demangling(demangled, '??? aaa::bbb<ccc<float>>::ddd(unsigned int)')
+
+
     def testAndroidSystem(self):
         """Check Itanium routine demangling from Android system cases."""
 
@@ -187,3 +205,6 @@ class TestItaniumMangling(ChrysalideTestCase):
 
         demangled = demangler.decode_routine('_ZN6icu_556LocaleaSERKS0_')
         self.check_demangling(demangled, '??? icu_55::Locale::operator=(const icu_55::Locale &)')
+
+        demangled = demangler.decode_routine('_ZNSt3__16vectorIfNS_9allocatorIfEEE8__appendEj')
+        self.check_demangling(demangled, '??? std::__1::vector<float, allocator<float>>::__append(unsigned int)')