diff options
Diffstat (limited to 'src/analysis/types/encaps.c')
-rw-r--r-- | src/analysis/types/encaps.c | 238 |
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; } |