Extented the types definitions.

1 files changed, 150 insertions, 63 deletions

diff --git a/src/analysis/type.c b/src/analysis/type.c
index 6d09f4b..cc446cb 100644
--- a/src/analysis/type.c
+++ b/src/analysis/type.c
@@ -24,29 +24,26 @@
 #include "type.h"
 
 
-#include <stdarg.h>
+#include <malloc.h>
 
 
-#include "routine.h"
 #include "type-int.h"
 #include "../common/extstr.h"
 
 
 
-/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
-
-
 /* Initialise la classe des types quelconques. */
 static void g_data_type_class_init(GDataTypeClass *);
 
 /* Initialise l'instance d'un type quelconque. */
 static void g_data_type_init(GDataType *);
 
+/* Supprime toutes les références externes. */
+static void g_data_type_dispose(GDataType *);
 
+/* Procède à la libération totale de la mémoire. */
+static void g_data_type_finalize(GDataType *);
 
-/* ---------------------------------------------------------------------------------- */
-/*                          REPRESENTATION INTERNE DES TYPES                          */
-/* ---------------------------------------------------------------------------------- */
 
 
 /* Indique le type défini pour un type quelconque. */
@@ -67,6 +64,14 @@ G_DEFINE_TYPE(GDataType, g_data_type, G_TYPE_OBJECT);
 
 static void g_data_type_class_init(GDataTypeClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_data_type_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_data_type_finalize;
+
+    klass->handle_ns = true;
 
 }
 
@@ -91,29 +96,31 @@ static void g_data_type_init(GDataType *type)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type = type à dupliquer.                                     *
+*  Paramètres  : type = instance d'objet GLib à traiter.                      *
 *                                                                             *
-*  Description : Crée un copie d'un type existant.                            *
+*  Description : Supprime toutes les références externes.                     *
 *                                                                             *
-*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GDataType *g_data_type_dup(const GDataType *type)
+static void g_data_type_dispose(GDataType *type)
 {
-    return type->dup(type);
+    if (type->namespace != NULL)
+        g_object_unref(G_OBJECT(type->namespace));
+
+    G_OBJECT_CLASS(g_data_type_parent_class)->dispose(G_OBJECT(type));
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type      = type à mettre à jour.                            *
-*                namespace = instance d'appartenance.                         *
+*  Paramètres  : type = instance d'objet GLib à traiter.                      *
 *                                                                             *
-*  Description : Définit le groupe d'appartenance d'un type donné.            *
+*  Description : Procède à la libération totale de la mémoire.                *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -121,19 +128,52 @@ GDataType *g_data_type_dup(const GDataType *type)
 *                                                                             *
 ******************************************************************************/
 
-void g_data_type_set_namespace(GDataType *type, GDataType *namespace)
+static void g_data_type_finalize(GDataType *type)
 {
-    g_object_ref(G_OBJECT(namespace));
+    G_OBJECT_CLASS(g_data_type_parent_class)->finalize(G_OBJECT(type));
 
-    type->namespace = namespace;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à dupliquer.                                     *
+*                                                                             *
+*  Description : Crée un copie d'un type existant.                            *
+*                                                                             *
+*  Retour      : Nouvelle instance de type identique à celle fournie.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_data_type_dup(const GDataType *type)
+{
+    GDataType *result;                      /* Copie à retourner           */
+    GDataTypeClass *class;                  /* Classe du type              */
+    GDataType *ns;                          /* Eventuel espace de noms     */
+
+    class = G_DATA_TYPE_GET_CLASS(type);
+
+    result = class->dup(type);
+
+    if (type->namespace != NULL)
+    {
+        ns = g_data_type_dup(type->namespace);
+        g_data_type_set_namespace(result, ns, type->ns_sep);
+    }
+
+    result->qualifiers = type->qualifiers;
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type   = type à convertir.                                   *
-*                simple = indique si l'espace de noms doit être exclus ou non.*
+*  Paramètres  : type    = type à convertir.                                  *
+*                include = doit-on inclure les espaces de noms ?              *
 *                                                                             *
 *  Description : Décrit le type fourni sous forme de caractères.              *
 *                                                                             *
@@ -143,25 +183,26 @@ void g_data_type_set_namespace(GDataType *type, GDataType *namespace)
 *                                                                             *
 ******************************************************************************/
 
-char *_g_data_type_to_string(const GDataType *type, bool simple)
+char *g_data_type_to_string(const GDataType *type, bool include)
 {
     char *result;                           /* Chaîne à retourner          */
-    const GDataType *parent;                /* Espace supérieur            */
+    GDataTypeClass *class;                  /* Classe du type              */
     char *namespace;                        /* Groupe d'appartenance       */
 
-    result = type->to_string(type);
+    class = G_DATA_TYPE_GET_CLASS(type);
+
+    result = class->to_string(type, include);
 
-    if (!simple)
-        for (parent = type->namespace; parent != NULL; parent = parent->namespace)
-        {
-            namespace = g_data_type_to_string(parent);
+    if (include && type->namespace != NULL && class->handle_ns)
+    {
+        namespace = g_data_type_to_string(type->namespace, true);
 
-            result = strprep(result, "." /* FIXME */);
-            result = strprep(result, namespace);
+        result = strprep(result, type->ns_sep);
+        result = strprep(result, namespace);
 
-            free(namespace);
+        free(namespace);
 
-        }
+    }
 
     if (type->qualifiers & TQF_RESTRICT)
         result = strprep(result, "restrict ");
@@ -179,26 +220,53 @@ char *_g_data_type_to_string(const GDataType *type, bool simple)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type   = routine à afficher.                                 *
-*                lang   = langage à utiliser pour la sortie humaine.          *
-*                buffer = tampon mis à disposition pour la sortie.            *
-*                info   = nature du cadre de destination.                     *
-*                full   = besoin de descriptions étendues ?                   *
+*  Paramètres  : type      = type à mettre à jour.                            *
+*                namespace = instance d'appartenance.                         *
+*                sep       = séparateur à utiliser entre les éléments.        *
 *                                                                             *
-*  Description : Procède à l'impression de la description d'un type.          *
+*  Description : Définit le groupe d'appartenance d'un type donné.            *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-/*
-void g_data_type_output(const GDataType *type, GLangOutput *lang, GBufferLine *line, bool info, bool full)
+
+void g_data_type_set_namespace(GDataType *type, GDataType *namespace, const char *sep)
 {
-    type->output(type, lang, line, info, full);
+    if (type->namespace != NULL)
+        g_object_unref(G_OBJECT(type->namespace));
+
+    type->namespace = namespace;
+    type->ns_sep = sep;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Fournit le groupe d'appartenance d'un type donné.            *
+*                                                                             *
+*  Retour      : Eventuelle instance d'appartenance ou NULL.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDataType *g_data_type_get_namespace(const GDataType *type)
+{
+    GDataType *result;                      /* Espace à renvoyer           */
+
+    result = type->namespace;
+
+    if (result != NULL)
+        g_object_ref(G_OBJECT(result));
+
+    return result;
 
 }
-*/
 
 
 /******************************************************************************
@@ -223,37 +291,56 @@ void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type = type à analyser.                                      *
-*                large = doit-on aussi inclure les types 'référence' ?        *
+*  Paramètres  : type = type à consulter.                                     *
 *                                                                             *
-*  Description : Indique la terminaison de la représentation du type.         *
+*  Description : Indique si le type est un pointeur.                          *
 *                                                                             *
-*  Retour      : true ou false, selon le type fourni.                         *
+*  Retour      : Bilan de la consultation.                                    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool g_data_type_is_pointer(const GDataType *type, bool large)
+bool g_data_type_is_pointer(const GDataType *type)
 {
     bool result;                            /* Bilan à retourner           */
+    GDataTypeClass *class;                  /* Classe du type              */
+
+    class = G_DATA_TYPE_GET_CLASS(type);
+
+    if (class->is_pointer != NULL)
+        result = class->is_pointer(type);
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Indique si le type est une référence.                        *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_data_type_is_reference(const GDataType *type)
+{
+    bool result;                            /* Bilan à retourner           */
+    GDataTypeClass *class;                  /* Classe du type              */
+
+    class = G_DATA_TYPE_GET_CLASS(type);
 
-    result = G_IS_ENCAPSULATED_TYPE(type);
-
-    if (result)
-        switch (g_encapsulated_type_get_etype(G_ENCAPSULATED_TYPE(type)))
-        {
-            case ECT_POINTER:
-                result = true;
-                break;
-            case ECT_REFERENCE:
-            case ECT_RVALUE_REF:
-                result = large;
-                break;
-            default:
-                result = false;
-                break;
-        }
+    if (class->is_reference != NULL)
+        result = class->is_reference(type);
+    else
+        result = false;
 
     return result;