Improved Itanium demangling.

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

4 files changed, 190 insertions, 5 deletions

diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 7709fa4..0c8d83a 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -437,7 +437,7 @@ void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *typ
 *                                                                             *
 ******************************************************************************/
 
-const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
+GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
 {
     return routine->full_name;
 
@@ -472,6 +472,25 @@ void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : routine = routine à consulter.                               *
+*                                                                             *
+*  Description : Fournit le type de retour d'une routine.                     *
+*                                                                             *
+*  Retour      : Indication sur le type de retour en place.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *routine)
+{
+    return routine->ret_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : routine = routine à mettre à jour.                           *
 *                var     = variable représentant un argument supplémentaire.  *
 *                                                                             *
@@ -490,6 +509,7 @@ void g_binary_routine_add_arg(GBinRoutine *routine, GBinVariable *var)
     routine->args = (GBinVariable **)realloc(routine->args,
                                              routine->args_count * sizeof(GBinVariable *));
 
+    g_object_ref(G_OBJECT(var));
     routine->args[routine->args_count - 1] = var;
 
 }
@@ -497,6 +517,74 @@ void g_binary_routine_add_arg(GBinRoutine *routine, GBinVariable *var)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : routine = routine à mettre à consulter.                      *
+*                                                                             *
+*  Description : Indique le nombre d'arguments associés à une routine.        *
+*                                                                             *
+*  Retour      : Nombre d'arguments présents.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_binary_routine_get_args_count(const GBinRoutine *routine)
+{
+    return routine->args_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à consulter.                               *
+*                index   = indice de l'argument demandé.                      *
+*                                                                             *
+*  Description : Fournit un argument d'une routine.                           *
+*                                                                             *
+*  Retour      : Argument demandé.                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinVariable *g_binary_routine_get_arg(GBinRoutine *routine, size_t index)
+{
+    return routine->args[index];
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à mettre à jour.                           *
+*                index   = indice de l'argument à retirer;                    *
+*                                                                             *
+*  Description : Retire un argument d'une routine.                            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_routine_remove_arg(GBinRoutine *routine, size_t index)
+{
+    g_object_unref(G_OBJECT(routine->args[index]));
+
+    if ((index + 1) < routine->args_count)
+        memmove(&routine->args[index], &routine->args[index + 1],
+                (routine->args_count - index - 1) * sizeof(GBinVariable *));
+
+    routine->args_count--;
+
+    routine->args = (GBinVariable **)realloc(routine->args,
+                                             routine->args_count * sizeof(GBinVariable *));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : routine = routine à mettre à jour.                           *
 *                offset  = position abstraite à retrouver.                    *
 *                local   = indique le type de variable à manipuler.           *
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index cd17bf3..e2ea1cc 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -112,14 +112,26 @@ const char *g_binary_routine_get_name(const GBinRoutine *);
 void g_binary_routine_set_name_from_type(GBinRoutine *, GOpenidaType *);
 
 /* Fournit le type construisant le nom humain d'une routine. */
-const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
+GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
 
 /* Définit le type de retour d'une routine. */
 void g_binary_routine_set_return_type(GBinRoutine *, GOpenidaType *);
 
+/* Fournit le type de retour d'une routine. */
+GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *);
+
 /* Ajoute un argument à une routine. */
 void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
 
+/* Indique le nombre d'arguments associés à une routine. */
+size_t g_binary_routine_get_args_count(const GBinRoutine *);
+
+/* Fournit un argument d'une routine. */
+GBinVariable *g_binary_routine_get_arg(GBinRoutine *, size_t);
+
+/* Retire un argument d'une routine. */
+void g_binary_routine_remove_arg(GBinRoutine *, size_t);
+
 /* S'assure qu'une variable est bien associée à une routine. */
 void g_binary_routine_register_if_needed(GBinRoutine *, size_t, bool);
 
diff --git a/src/analysis/type.c b/src/analysis/type.c
index d16917f..0cd021e 100644
--- a/src/analysis/type.c
+++ b/src/analysis/type.c
@@ -888,6 +888,7 @@ static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
             result = stradd(result, " imaginary");
             break;
 
+        case ECT_ROUTINE:   /* Pour GCC */
         default:
             break;
 
@@ -898,6 +899,65 @@ static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Fournit le type d'encapsulation gérée par le type.           *
+*                                                                             *
+*  Retour      : Type d'encapsulation gérée.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *type)
+{
+    return type->type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                ...  = sous-type ou routine encapsulée dans le type. [OUT]   *
+*                                                                             *
+*  Description : Fournit la routine encapsulée dans le type.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
+{
+    va_list ap;                             /* Liste variable d'arguments  */
+    GOpenidaType **child;                   /* Adresse pour sous-type      */
+    GBinRoutine **routine;                  /* Adresse pour routine        */
+
+    va_start(ap, type);
+
+    switch (type->type)
+    {
+        case ECT_ROUTINE:
+            routine = va_arg(ap, GBinRoutine **);
+            *routine = type->routine;
+            break;
+
+        default:
+            child = va_arg(ap, GOpenidaType **);
+            *child = type->child;
+            break;
+
+    }
+
+    va_end(ap);
+
+}
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                        CLASSES / STRUCTURES ET ENUMERATIONS                        */
@@ -1125,8 +1185,6 @@ static GOpenidaType *g_template_type_dup(const GTemplateType *type)
 
     result = g_template_type_new(G_CLASS_ENUM_TYPE(type)->name, list);
 
-    g_slist_free(list);
-
     return G_OPENIDA_TYPE(result);
 
 }
@@ -1171,7 +1229,6 @@ static char *g_template_type_to_string(const GTemplateType *type)
 }
 
 
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : type = type à mettre à jour.                                 *
@@ -1204,6 +1261,25 @@ void g_template_type_add_params(GTemplateType *type, GSList *list)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Indique le nombre de paramètres associés du gabarit.         *
+*                                                                             *
+*  Retour      : Nombre de paramètres inclus dans le gabarit.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_template_type_count_param(const GTemplateType *type)
+{
+    return type->models_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : type  = type à consulter.                                    *
 *                index = indice du paramètre à retourner.                     *
 *                                                                             *
diff --git a/src/analysis/type.h b/src/analysis/type.h
index ac17235..77f3ace 100644
--- a/src/analysis/type.h
+++ b/src/analysis/type.h
@@ -183,6 +183,12 @@ GType g_encapsulated_type_get_type(void);
 /* Crée une représentation de variable dérivée. */
 GOpenidaType *g_encapsulated_type_new(EncapsulationType, ...);
 
+/* Fournit le type d'encapsulation gérée par le type. */
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *);
+
+/* Fournit la routine encapsulée dans le type. */
+void g_encapsulated_type_get_item(const GEncapsulatedType *, ...);
+
 
 
 /* ---------------------- CLASSES / STRUCTURES ET ENUMERATIONS ---------------------- */
@@ -249,6 +255,9 @@ GOpenidaType *g_template_type_new(const char *, GSList *);
 /* Ajoute une série de paramètres à un gabarit. */
 void g_template_type_add_params(GTemplateType *, GSList *);
 
+/* Indique le nombre de paramètres associés du gabarit. */
+size_t g_template_type_count_param(const GTemplateType *);
+
 /* Fournit un paramètre donné du gabarit. */
 GOpenidaType *g_template_type_get_param(const GTemplateType *, size_t);