Extented the types definitions.

1 files changed, 138 insertions, 100 deletions

diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c
index 36dc71a..dc1bb3e 100644
--- a/src/analysis/types/encaps.c
+++ b/src/analysis/types/encaps.c
@@ -25,9 +25,9 @@
 
 
 #include <assert.h>
+#include <malloc.h>
 
 
-#include "../routine.h"
 #include "../type-int.h"
 #include "../../common/extstr.h"
 
@@ -40,7 +40,6 @@ struct _GEncapsulatedType
 
     EncapsulationType type;                 /* Encapsulation utilisée      */
     GDataType *child;                       /* Sous-type encadré           */
-    GBinRoutine *routine;                   /* Routine pointée             */
 
     size_t dimension;                       /* Dimension quand applicable  */
 
@@ -60,14 +59,23 @@ static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *);
 /* Initialise l'instance d'un type encapsulé. */
 static void g_encapsulated_type_init(GEncapsulatedType *);
 
+/* Supprime toutes les références externes. */
+static void g_encapsulated_type_dispose(GEncapsulatedType *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_encapsulated_type_finalize(GEncapsulatedType *);
+
 /* Crée un copie d'un type existant. */
 static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *);
 
 /* Décrit le type fourni sous forme de caractères. */
-static char *g_encapsulated_type_to_string(const GEncapsulatedType *);
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *, bool);
 
-/* Procède à l'impression de la description d'un type. */
-//static void g_encapsulated_type_output(const GEncapsulatedType *, GLangOutput *, GBufferLine *, bool, bool);
+/* Indique si le type est un pointeur. */
+static bool g_encapsulated_type_is_pointer(const GEncapsulatedType *);
+
+/* Indique si le type est une référence. */
+static bool g_encapsulated_type_is_reference(const GEncapsulatedType *);
 
 
 
@@ -89,6 +97,21 @@ G_DEFINE_TYPE(GEncapsulatedType, g_encapsulated_type, G_TYPE_DATA_TYPE);
 
 static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GDataTypeClass *type;                   /* Version parente et basique  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_encapsulated_type_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_encapsulated_type_finalize;
+
+    type = G_DATA_TYPE_CLASS(klass);
+
+    type->dup = (type_dup_fc)g_encapsulated_type_dup;
+    type->to_string = (type_to_string_fc)g_encapsulated_type_to_string;
+
+    type->is_pointer = (type_is_pointer_fc)g_encapsulated_type_is_pointer;
+    type->is_reference = (type_is_reference_fc)g_encapsulated_type_is_reference;
 
 }
 
@@ -107,13 +130,51 @@ static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass)
 
 static void g_encapsulated_type_init(GEncapsulatedType *type)
 {
-    GDataType *data_type;                   /* Version basique             */
+    type->type = ECT_COUNT;
+    type->child = NULL;
+
+    type->dimension = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_encapsulated_type_dispose(GEncapsulatedType *type)
+{
+    if (type->child != NULL)
+        g_object_unref(G_OBJECT(type->child));
+
+    G_OBJECT_CLASS(g_encapsulated_type_parent_class)->dispose(G_OBJECT(type));
+
+}
 
-    data_type = G_DATA_TYPE(type);
 
-    data_type->dup = (type_dup_fc)g_encapsulated_type_dup;
-    data_type->to_string = (type_to_string_fc)g_encapsulated_type_to_string;
-    //data_type->output = (output_type_fc)g_encapsulated_type_output;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_encapsulated_type_finalize(GEncapsulatedType *type)
+{
+    G_OBJECT_CLASS(g_encapsulated_type_parent_class)->finalize(G_OBJECT(type));
 
 }
 
@@ -121,7 +182,7 @@ static void g_encapsulated_type_init(GEncapsulatedType *type)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : type  = type d'extension à représenter.                      *
-*                child = variable dont on doit dériver.                       *
+*                child = base dont on doit dériver.                           *
 *                                                                             *
 *  Description : Crée une représentation de variable dérivée.                 *
 *                                                                             *
@@ -131,33 +192,14 @@ static void g_encapsulated_type_init(GEncapsulatedType *type)
 *                                                                             *
 ******************************************************************************/
 
-GDataType *g_encapsulated_type_new(EncapsulationType type, ...)
+GDataType *g_encapsulated_type_new(EncapsulationType type, GDataType *child)
 {
     GEncapsulatedType *result;              /* Structure à retourner       */
-    va_list ap;                             /* Liste variable d'arguments  */
 
     result = g_object_new(G_TYPE_ENCAPSULATED_TYPE, NULL);
 
     result->type = type;
-
-    va_start(ap, type);
-
-    switch (type)
-    {
-        case ECT_ROUTINE:
-            result->routine = va_arg(ap, GBinRoutine *);
-            assert(result->routine != NULL);
-            g_binary_routine_set_name(result->routine, "(*)");
-            break;
-
-        default:
-            result->child = va_arg(ap, GDataType *);
-            assert(result->child != NULL);
-            break;
-
-    }
-
-    va_end(ap);
+    result->child = child;
 
     return G_DATA_TYPE(result);
 
@@ -181,19 +223,8 @@ static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *type)
     GDataType *result;                      /* Nouvelle instance à renvoyer*/
     GDataType *child;                       /* Copie du type interne       */
 
-    switch (type->type)
-    {
-        case ECT_ROUTINE:
-            g_object_ref(G_OBJECT(type->routine));
-            result = g_encapsulated_type_new(type->type, type->routine);
-            break;
-
-        default:
-            child = g_data_type_dup(type->child);
-            result = g_encapsulated_type_new(type->type, child);
-            break;
-
-    }
+    child = g_data_type_dup(type->child);
+    result = g_encapsulated_type_new(type->type, child);
 
     return result;
 
@@ -202,7 +233,8 @@ static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *type)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type = type à convertir.                                     *
+*  Paramètres  : type    = type à convertir.                                  *
+*                include = doit-on inclure les espaces de noms ?              *
 *                                                                             *
 *  Description : Décrit le type fourni sous forme de caractères.              *
 *                                                                             *
@@ -212,34 +244,20 @@ static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *type)
 *                                                                             *
 ******************************************************************************/
 
-static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *type, bool include)
 {
     char *result;                           /* Chaîne finale à renvoyer    */
     size_t i;                               /* Boucle de parcours          */
 
-    switch (type->type)
-    {
-        case ECT_ROUTINE:
-            result = g_binary_routine_to_string(type->routine);
-            break;
-
-        default:
-            result = g_data_type_to_string(type->child);
-            break;
-
-    }
+    result = g_data_type_to_string(type->child, include);
+    if (result == NULL) goto exit;
 
     switch (type->type)
     {
         case ECT_POINTER:
-
-            if (G_IS_ENCAPSULATED_TYPE(type->child)
-                && G_ENCAPSULATED_TYPE(type->child)->type == ECT_ROUTINE) break;
-
-            if (!g_data_type_is_pointer(type->child, false))
+            if (!g_data_type_is_pointer(type->child))
                 result = stradd(result, " ");
             result = stradd(result, "*");
-
             break;
 
         case ECT_ARRAY:
@@ -247,25 +265,37 @@ static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
             for (i = 0; i < type->dimension; i++)
                 result = stradd(result, "[]");
             break;
+
         case ECT_REFERENCE:
-            result = stradd(result, " &");
+            if (!g_data_type_is_reference(type->child))
+                result = stradd(result, " ");
+            result = stradd(result, "&");
             break;
+
         case ECT_RVALUE_REF:
-            result = stradd(result, " &&");
+            if (!g_data_type_is_reference(type->child))
+                result = stradd(result, " ");
+            result = stradd(result, "&&");
             break;
+
         case ECT_COMPLEX:
             result = stradd(result, " complex");
             break;
+
         case ECT_IMAGINARY:
             result = stradd(result, " imaginary");
             break;
 
-        case ECT_ROUTINE:   /* Pour GCC */
         default:
+            assert(false);
+            free(result);
+            result = NULL;
             break;
 
     }
 
+ exit:
+
     return result;
 
 }
@@ -273,26 +303,48 @@ static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type   = type à 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 à consulter.                                     *
 *                                                                             *
-*  Description : Procède à l'impression de la description d'un type.          *
+*  Description : Indique si le type est un pointeur.                          *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_encapsulated_type_is_pointer(const GEncapsulatedType *type)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = (type->type == ECT_POINTER);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type à consulter.                                     *
+*                                                                             *
+*  Description : Indique si le type est une référence.                        *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-#if 0
-static void g_encapsulated_type_output(const GEncapsulatedType *type, GLangOutput *lang, GBufferLine *line, bool info, bool full)
+
+static bool g_encapsulated_type_is_reference(const GEncapsulatedType *type)
 {
-    g_buffer_line_append_text(line, BLC_LAST_USED, "!TODO!", 6, info ? RTT_COMMENT : RTT_RAW, NULL);
+    bool result;                            /* Bilan à retourner           */
+
+    result = (type->type == ECT_REFERENCE || type->type == ECT_RVALUE_REF);
+
+    return result;
 
 }
-#endif
 
 
 /******************************************************************************
@@ -317,39 +369,25 @@ EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *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.                  *
+*  Description : Fournit le type encapsulée dans le type.                     *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Sous-type encapsulé dans le type.                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
+GDataType *g_encapsulated_type_get_item(const GEncapsulatedType *type)
 {
-    va_list ap;                             /* Liste variable d'arguments  */
-    GDataType **child;                      /* Adresse pour sous-type      */
-    GBinRoutine **routine;                  /* Adresse pour routine        */
+    GDataType *result;                      /* Type à retourner            */
 
-    va_start(ap, type);
+    result = type->child;
 
-    switch (type->type)
-    {
-        case ECT_ROUTINE:
-            routine = va_arg(ap, GBinRoutine **);
-            *routine = type->routine;
-            break;
+    if (result != NULL)
+        g_object_ref(G_OBJECT(result));
 
-        default:
-            child = va_arg(ap, GDataType **);
-            *child = type->child;
-            break;
-
-    }
-
-    va_end(ap);
+    return result;
 
 }