Improved the Itanium C++ demangling.

2 files changed, 232 insertions, 3 deletions

diff --git a/src/common/ibuf.c b/src/common/ibuf.c
index f0ea0ac..5d90eb4 100644
--- a/src/common/ibuf.c
+++ b/src/common/ibuf.c
@@ -50,6 +50,28 @@ void init_text_input_buffer(input_buffer *ibuf, const char *text)
 
 }
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à consulter.                        *
+*                                                                             *
+*  Description : Fournit la taille totale du tampon constitué.                *
+*                                                                             *
+*  Retour      : Valeur positive (ou nulle !).                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t get_input_buffer_size(const input_buffer *ibuf)
+{
+    size_t result;                          /* Quantité à retourner        */
+
+    result = ibuf->len;
+
+    return result;
+
+}
+
 
 /******************************************************************************
 *                                                                             *
@@ -65,10 +87,47 @@ void init_text_input_buffer(input_buffer *ibuf, const char *text)
 
 size_t count_input_buffer_remaining(const input_buffer *ibuf)
 {
-    return ibuf->len - ibuf->pos;
+    size_t result;                          /* Quantité à renvoyer         */
+
+    assert(ibuf->pos <= (ibuf->len + 1));
+
+    if (ibuf->pos > ibuf->len)
+        result = 0;
+
+    else
+        result = ibuf->len - ibuf->pos;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à consulter.                        *
+*                                                                             *
+*  Description : Détermine s'il reste encore des données disponibles.         *
+*                                                                             *
+*  Retour      : true si des données sont encore présentes, false sinon.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool input_buffer_contain_data(const input_buffer *ibuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    size_t remaining;                       /* Quantité restante           */
+
+    remaining = count_input_buffer_remaining(ibuf);
+
+    result = (remaining > 0);
+
+    return result;
 
 }
 
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : ibuf  = tampon de données à modifier.                        *
@@ -84,7 +143,7 @@ size_t count_input_buffer_remaining(const input_buffer *ibuf)
 
 void advance_input_buffer(input_buffer *ibuf, size_t count)
 {
-    assert((ibuf->pos + count) <= ibuf->len);
+    assert((ibuf->pos + count) <= (ibuf->len + 1));
 
     ibuf->pos += count;
 
@@ -112,6 +171,84 @@ const char *get_input_buffer_text_access(const input_buffer *ibuf)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : ibuf = tampon de données à consulter.                        *
+*                remaining = taille de la chaîne retournée. [OUT]             *
+*                                                                             *
+*  Description : Fournit la chaîne de caractère restant à traiter.            *
+*                                                                             *
+*  Retour      : Pointeur vers les données courantes.                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *get_input_buffer_string(const input_buffer *ibuf, size_t *remaining)
+{
+    const char *result;                     /* Pointeur à retourner        */
+
+    assert(ibuf->pos <= ibuf->len);
+
+    result = ibuf->text + ibuf->pos;
+
+    *remaining = ibuf->len - ibuf->pos;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à parcourir.                        *
+*                                                                             *
+*  Description : Fournit le caractère courant à la tête de lecture courante.  *
+*                                                                             *
+*  Retour      : Caractère courant.                                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char peek_input_buffer_char(const input_buffer *ibuf)
+{
+    assert(ibuf->pos <= ibuf->len);
+
+    return *(ibuf->text + ibuf->pos);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à parcourir.                        *
+*                                                                             *
+*  Description : Fournit le caractère suivant la tête de lecture courante.    *
+*                                                                             *
+*  Retour      : Caractère courant.                                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char peek_input_buffer_next_char(const input_buffer *ibuf)
+{
+    char result;                            /* Valeur à retourner          */
+
+    assert(ibuf->pos <= ibuf->len);
+
+    if (ibuf->pos == ibuf->len)
+        result = '\0';
+
+    else
+        result = *(ibuf->text + ibuf->pos + 1);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : ibuf = tampon de données à parcourir.                        *
 *                                                                             *
 *  Description : Fournit et avance la tête de lecture courante.               *
@@ -124,9 +261,79 @@ const char *get_input_buffer_text_access(const input_buffer *ibuf)
 
 char text_input_buffer_next_char(input_buffer *ibuf)
 {
+    char result;                            /* Valeur à retourner          */
+
+    assert(ibuf->pos <= ibuf->len);
+
+    result = *(ibuf->text + ibuf->pos);
+
+    advance_input_buffer(ibuf, 1);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à parcourir.                        *
+*                out  = caractère courant, s'il existe.                       *
+*                                                                             *
+*  Description : Fournit et avance la tête de lecture courante, si possible.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool get_input_buffer_next_char_carefully(input_buffer *ibuf, char *out)
+{
+    char result;                            /* Valeur à retourner          */
+
     assert(ibuf->pos <= ibuf->len);
 
-    return *(ibuf->text + ibuf->pos++);
+    result = input_buffer_contain_data(ibuf);
+
+    if (result)
+    {
+        *out = *(ibuf->text + ibuf->pos);
+
+        advance_input_buffer(ibuf, 1);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ibuf = tampon de données à parcourir.                        *
+*                c    = caractère à retrouver.                                *
+*                                                                             *
+*  Description : Vérifie la nature du caractère courant.                      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool check_input_buffer_char(input_buffer *ibuf, char c)
+{
+    bool result;                            /* Validation à retourner      */
+
+    if (peek_input_buffer_char(ibuf) == c)
+    {
+        result = true;
+        advance_input_buffer(ibuf, 1);
+    }
+    else
+        result = false;
+
+    return result;
 
 }
 
diff --git a/src/common/ibuf.h b/src/common/ibuf.h
index 3d0d5d1..ecd8814 100644
--- a/src/common/ibuf.h
+++ b/src/common/ibuf.h
@@ -25,6 +25,7 @@
 #define _COMMON_IBUF_H
 
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <sys/types.h>
 
@@ -48,18 +49,39 @@ typedef struct _input_buffer
 /* Initialise un contenu textuel pour une lecture ultérieure. */
 void init_text_input_buffer(input_buffer *, const char *);
 
+/* Fournit la taille totale du tampon constitué. */
+size_t get_input_buffer_size(const input_buffer *);
+
 /* Compte le nombre d'octets encore non lus. */
 size_t count_input_buffer_remaining(const input_buffer *);
 
+/* Détermine s'il reste encore des données disponibles. */
+bool input_buffer_contain_data(const input_buffer *);
+
 /* Avance la tête de lecture dans le tampon de données. */
 void advance_input_buffer(input_buffer *, size_t);
 
 /* Fournit un accès brut au niveau de la tête de lecture. */
 const char *get_input_buffer_text_access(const input_buffer *);
 
+/* Fournit la chaîne de caractère restant à traiter. */
+const char *get_input_buffer_string(const input_buffer *, size_t *);
+
+/* Fournit le caractère courant à la tête de lecture courante. */
+char peek_input_buffer_char(const input_buffer *);
+
+/* Fournit le caractère suivant la tête de lecture courante. */
+char peek_input_buffer_next_char(const input_buffer *);
+
 /* Fournit et avance la tête de lecture courante. */
 char text_input_buffer_next_char(input_buffer *);
 
+/* Fournit et avance la tête de lecture courante, si possible. */
+bool get_input_buffer_next_char_carefully(input_buffer *, char *);
+
+/* Vérifie la nature du caractère courant. */
+bool check_input_buffer_char(input_buffer *, char);
+
 /* Note la position courante de la tête de lecture. */
 void save_input_buffer_pos(const input_buffer *, size_t *);