From a79d209385fca4e74a6a85b2386be71ec23057bb Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Wed, 24 Feb 2021 00:34:25 +0100 Subject: Prepare mechanisms to load and store data types. --- plugins/pychrysalide/analysis/type.c | 4 + src/analysis/storage/serialize-int.h | 3 + src/analysis/storage/serialize.c | 4 +- src/analysis/storage/serialize.h | 1 - src/analysis/type-int.h | 16 +- src/analysis/type.c | 295 +++++++++++++++++++++++++++++------ src/analysis/type.h | 18 +-- src/analysis/types/array.c | 118 ++++++++++++++ src/analysis/types/basic.c | 69 ++++++++ src/analysis/types/cse.c | 88 +++++++++++ src/analysis/types/encaps.c | 87 +++++++++++ src/analysis/types/expr.c | 81 ++++++++++ src/analysis/types/literal.c | 81 ++++++++++ src/analysis/types/override.c | 120 ++++++++++++++ src/analysis/types/proto.c | 98 ++++++++++++ src/analysis/types/template.c | 107 +++++++++++++ 16 files changed, 1127 insertions(+), 63 deletions(-) diff --git a/plugins/pychrysalide/analysis/type.c b/plugins/pychrysalide/analysis/type.c index d2801bf..1e4ec06 100644 --- a/plugins/pychrysalide/analysis/type.c +++ b/plugins/pychrysalide/analysis/type.c @@ -38,6 +38,7 @@ #include "constants.h" +#include "storage/serialize.h" #include "../access.h" #include "../helpers.h" @@ -1077,6 +1078,9 @@ bool ensure_python_data_type_is_registered(void) if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) { + if (!ensure_python_serializable_object_is_registered()) + return false; + module = get_access_to_python_module("pychrysalide.analysis"); dict = PyModule_GetDict(module); diff --git a/src/analysis/storage/serialize-int.h b/src/analysis/storage/serialize-int.h index e7690d5..b4eb815 100644 --- a/src/analysis/storage/serialize-int.h +++ b/src/analysis/storage/serialize-int.h @@ -28,6 +28,9 @@ #include "serialize.h" +#include "storage.h" + + /* Charge un objet depuis une mémoire tampon. */ typedef bool (* load_serializable_object_cb) (GSerializableObject *, GObjectStorage *, packed_buffer *); diff --git a/src/analysis/storage/serialize.c b/src/analysis/storage/serialize.c index 43a231a..bee8fe4 100644 --- a/src/analysis/storage/serialize.c +++ b/src/analysis/storage/serialize.c @@ -57,7 +57,7 @@ static void g_serializable_object_default_init(GSerializableObjectInterface *ifa /****************************************************************************** * * -* Paramètres : object = instruction d'assemblage à consulter. * +* Paramètres : object = élément GLib à constuire. * * storage = conservateur de données à manipuler ou NULL. * * pbuf = zone tampon à remplir. * * * @@ -85,7 +85,7 @@ bool g_serializable_object_load(GSerializableObject *object, GObjectStorage *sto /****************************************************************************** * * -* Paramètres : object = instruction d'assemblage à consulter. * +* Paramètres : object = élément GLib à consulter. * * storage = conservateur de données à manipuler ou NULL. * * pbuf = zone tampon à remplir. * * * diff --git a/src/analysis/storage/serialize.h b/src/analysis/storage/serialize.h index 96234c1..e218c84 100644 --- a/src/analysis/storage/serialize.h +++ b/src/analysis/storage/serialize.h @@ -28,7 +28,6 @@ #include -#include "tpmem.h" #include "../../common/packed.h" diff --git a/src/analysis/type-int.h b/src/analysis/type-int.h index 2c70c7b..e14d209 100644 --- a/src/analysis/type-int.h +++ b/src/analysis/type-int.h @@ -28,6 +28,15 @@ #include "type.h" +#include "storage/serialize-int.h" + + + +/* Charge un objet depuis une mémoire tampon. */ +typedef bool (* type_load_fc) (GDataType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +typedef bool (* type_store_fc) (const GDataType *, GObjectStorage *, packed_buffer *); /* Calcule une empreinte pour un type de données. */ typedef guint (* type_hash_fc) (const GDataType *); @@ -54,11 +63,11 @@ struct _GDataType { GObject parent; /* A laisser en premier */ + TypeQualifier qualifiers; /* Eventuels qualificatifs */ + GDataType *namespace; /* Espace de noms / classe */ char *ns_sep; /* Séparateur d'éléments */ - TypeQualifier qualifiers; /* Eventuels qualificatifs */ - }; /* Description de type quelconque (classe) */ @@ -66,6 +75,9 @@ struct _GDataTypeClass { GObjectClass parent; /* A laisser en premier */ + type_load_fc load; /* Chargement */ + type_store_fc store; /* Enregistrement */ + type_hash_fc hash; /* Prise d'empreinte */ type_dup_fc dup; /* Copie d'instance existante */ type_to_string_fc to_string; /* Conversion au format texte */ diff --git a/src/analysis/type.c b/src/analysis/type.c index 350b4e2..a5cc46c 100644 --- a/src/analysis/type.c +++ b/src/analysis/type.c @@ -29,6 +29,7 @@ #include "type-int.h" +#include "storage/serialize.h" #include "../common/extstr.h" @@ -39,16 +40,32 @@ static void g_data_type_class_init(GDataTypeClass *); /* Initialise l'instance d'un type quelconque. */ static void g_data_type_init(GDataType *); +/* Procède à l'initialisation de l'interface de sérialisation. */ +static void g_serializable_object_interface_init(GSerializableObjectIface *); + /* 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 *); +/* Charge un objet depuis une mémoire tampon. */ +static bool _g_data_type_load(GDataType *, GObjectStorage *, packed_buffer *); + +/* Charge un objet depuis une mémoire tampon. */ +static bool g_data_type_load(GDataType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool _g_data_type_store(const GDataType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_data_type_store(const GDataType *, GObjectStorage *, packed_buffer *); + /* Indique le type défini pour un type quelconque. */ -G_DEFINE_TYPE(GDataType, g_data_type, G_TYPE_OBJECT); +G_DEFINE_TYPE_WITH_CODE(GDataType, g_data_type, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_serializable_object_interface_init)); /****************************************************************************** @@ -72,6 +89,9 @@ static void g_data_type_class_init(GDataTypeClass *klass) object->dispose = (GObjectFinalizeFunc/* ! */)g_data_type_dispose; object->finalize = (GObjectFinalizeFunc)g_data_type_finalize; + klass->load = (type_load_fc)_g_data_type_load; + klass->store = (type_store_fc)_g_data_type_store; + } @@ -89,6 +109,30 @@ static void g_data_type_class_init(GDataTypeClass *klass) static void g_data_type_init(GDataType *type) { + g_data_type_set_qualifiers(type, TQF_NONE); + + type->namespace = NULL; + type->ns_sep = NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : iface = interface GLib à initialiser. * +* * +* Description : Procède à l'initialisation de l'interface de sérialisation. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_serializable_object_interface_init(GSerializableObjectIface *iface) +{ + iface->load = (load_serializable_object_cb)g_data_type_load; + iface->store = (store_serializable_object_cb)g_data_type_store; } @@ -138,6 +182,159 @@ static void g_data_type_finalize(GDataType *type) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool _g_data_type_load(GDataType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uint8_t has_ns; /* Association d'un espace ? */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + g_data_type_set_qualifiers(type, value); + + result = extract_packed_buffer(pbuf, &has_ns, sizeof(uint8_t), false); + if (!result) goto exit; + + if (has_ns == 0x01) + { + result = g_data_type_load(type->namespace, storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->ns_sep = calloc(value, sizeof(char)); + result = extract_packed_buffer(pbuf, type->ns_sep, value, false); + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_data_type_load(GDataType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + GDataTypeClass *class; /* Classe du type */ + + class = G_DATA_TYPE_GET_CLASS(type); + + result = class->load(type, storage, pbuf); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool _g_data_type_store(const GDataType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uint8_t has_ns; /* Association d'un espace ? */ + size_t ns_sep_len; /* Taille du séparateur */ + + result = pack_uleb128((uleb128_t []){ g_data_type_get_qualifiers(type) }, pbuf); + if (!result) goto exit; + + has_ns = (type->namespace != NULL ? 0x01 : 0x00); + + result = extend_packed_buffer(pbuf, &has_ns, sizeof(uint8_t), false); + if (!result) goto exit; + + if (type->namespace != NULL) + { + result = g_data_type_store(type->namespace, storage, pbuf); + if (!result) goto exit; + + ns_sep_len = strlen(type->ns_sep); + + result = pack_uleb128((uleb128_t []){ ns_sep_len }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, type->ns_sep, ns_sep_len, false); + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_data_type_store(const GDataType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + GDataTypeClass *class; /* Classe du type */ + + class = G_DATA_TYPE_GET_CLASS(type); + + result = class->store(type, storage, pbuf); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * @@ -259,11 +456,10 @@ char *g_data_type_to_string(const GDataType *type, bool include) /****************************************************************************** * * -* Paramètres : type = type à mettre à jour. * -* namespace = instance d'appartenance. * -* sep = séparateur à utiliser entre les éléments. * +* Paramètres : type = instance à mettre à jour. * +* qualifiers = nouveaux qualificatifs pour la variable. * * * -* Description : Définit le groupe d'appartenance d'un type donné. * +* Description : Définit l'ensemble des qualificatifs d'une instance de type. * * * * Retour : - * * * @@ -271,63 +467,50 @@ char *g_data_type_to_string(const GDataType *type, bool include) * * ******************************************************************************/ -void g_data_type_set_namespace(GDataType *type, GDataType *namespace, char *sep) +void g_data_type_set_qualifiers(GDataType *type, TypeQualifier qualifiers) { - if (type->namespace != NULL) - g_object_unref(G_OBJECT(type->namespace)); - - if (type->ns_sep != NULL) - free(type->ns_sep); - - type->namespace = namespace; - type->ns_sep = sep; + type->qualifiers = qualifiers; } /****************************************************************************** * * -* Paramètres : type = type à consulter. * +* Paramètres : type = instance à mettre à jour. * +* qualifier = nouveau qualificatif pour la variable. * * * -* Description : Fournit le groupe d'appartenance d'un type donné. * +* Description : Ajoute un qualificatif à une instance de type. * * * -* Retour : Eventuelle instance d'appartenance ou NULL. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GDataType *g_data_type_get_namespace(const GDataType *type) +void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier) { - GDataType *result; /* Espace à renvoyer */ - - result = type->namespace; - - if (result != NULL) - g_object_ref(G_OBJECT(result)); - - return result; + type->qualifiers |= qualifier; } /****************************************************************************** * * -* Paramètres : type = type à consulter. * +* Paramètres : type = instance à consulter. * * * -* Description : Fournit la chaîne de séparation entre deux entités. * +* Description : Fournit les qualificatifs associés à une instance de type. * * * -* Retour : Eventuelle chaîne de séparation ou NULL. * +* Retour : Qualificatifs éventuels. * * * * Remarques : - * * * ******************************************************************************/ -const char *g_data_type_get_namespace_separator(const GDataType *type) +TypeQualifier g_data_type_get_qualifiers(const GDataType *type) { - char *result; /* Séparateur à retourner */ + TypeQualifier result; /* Qualificatifs à renvoyer */ - result = type->ns_sep; + result = type->qualifiers; return result; @@ -336,10 +519,11 @@ const char *g_data_type_get_namespace_separator(const GDataType *type) /****************************************************************************** * * -* Paramètres : type = instance à mettre à jour. * -* qualifiers = nouveaux qualificatifs pour la variable. * +* Paramètres : type = type à mettre à jour. * +* namespace = instance d'appartenance. * +* sep = séparateur à utiliser entre les éléments. * * * -* Description : Définit l'ensemble des qualificatifs d'une instance de type. * +* Description : Définit le groupe d'appartenance d'un type donné. * * * * Retour : - * * * @@ -347,50 +531,63 @@ const char *g_data_type_get_namespace_separator(const GDataType *type) * * ******************************************************************************/ -void g_data_type_set_qualifiers(GDataType *type, TypeQualifier qualifiers) +void g_data_type_set_namespace(GDataType *type, GDataType *namespace, char *sep) { - type->qualifiers = qualifiers; + if (type->namespace != NULL) + g_object_unref(G_OBJECT(type->namespace)); + + if (type->ns_sep != NULL) + free(type->ns_sep); + + type->namespace = namespace; + type->ns_sep = sep; } /****************************************************************************** * * -* Paramètres : type = instance à mettre à jour. * -* qualifier = nouveau qualificatif pour la variable. * +* Paramètres : type = type à consulter. * * * -* Description : Ajoute un qualificatif à une instance de type. * +* Description : Fournit le groupe d'appartenance d'un type donné. * * * -* Retour : - * +* Retour : Eventuelle instance d'appartenance ou NULL. * * * * Remarques : - * * * ******************************************************************************/ -void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier) +GDataType *g_data_type_get_namespace(const GDataType *type) { - type->qualifiers |= qualifier; + GDataType *result; /* Espace à renvoyer */ + + result = type->namespace; + + if (result != NULL) + g_object_ref(G_OBJECT(result)); + + return result; } /****************************************************************************** * * -* Paramètres : type = instance à consulter. * +* Paramètres : type = type à consulter. * * * -* Description : Fournit les qualificatifs associés à une instance de type. * +* Description : Fournit la chaîne de séparation entre deux entités. * * * -* Retour : Qualificatifs éventuels. * +* Retour : Eventuelle chaîne de séparation ou NULL. * * * * Remarques : - * * * ******************************************************************************/ -TypeQualifier g_data_type_get_qualifiers(const GDataType *type) +const char *g_data_type_get_namespace_separator(const GDataType *type) { - TypeQualifier result; /* Qualificatifs à renvoyer */ + char *result; /* Séparateur à retourner */ - result = type->qualifiers; + result = type->ns_sep; return result; diff --git a/src/analysis/type.h b/src/analysis/type.h index 8fccbb5..f21c008 100644 --- a/src/analysis/type.h +++ b/src/analysis/type.h @@ -72,15 +72,6 @@ GDataType *g_data_type_dup(const GDataType *); /* Décrit le type fourni sous forme de caractères. */ char *g_data_type_to_string(const GDataType *, bool); -/* Définit le groupe d'appartenance d'un type donné. */ -void g_data_type_set_namespace(GDataType *, GDataType *, char *); - -/* Fournit le groupe d'appartenance d'un type donné. */ -GDataType *g_data_type_get_namespace(const GDataType *); - -/* Fournit la chaîne de séparation entre deux entités. */ -const char *g_data_type_get_namespace_separator(const GDataType *); - /* Définit l'ensemble des qualificatifs d'une instance de type. */ void g_data_type_set_qualifiers(GDataType *, TypeQualifier); @@ -90,6 +81,15 @@ void g_data_type_add_qualifier(GDataType *, TypeQualifier); /* Fournit les qualificatifs associés à une instance de type. */ TypeQualifier g_data_type_get_qualifiers(const GDataType *); +/* Définit le groupe d'appartenance d'un type donné. */ +void g_data_type_set_namespace(GDataType *, GDataType *, char *); + +/* Fournit le groupe d'appartenance d'un type donné. */ +GDataType *g_data_type_get_namespace(const GDataType *); + +/* Fournit la chaîne de séparation entre deux entités. */ +const char *g_data_type_get_namespace_separator(const GDataType *); + /* Indique si le type assure une gestion des espaces de noms. */ bool g_data_type_handle_namespaces(const GDataType *); diff --git a/src/analysis/types/array.c b/src/analysis/types/array.c index 5ea4179..b8321a2 100644 --- a/src/analysis/types/array.c +++ b/src/analysis/types/array.c @@ -72,6 +72,12 @@ static void g_array_type_dispose(GArrayType *); /* Procède à la libération totale de la mémoire. */ static void g_array_type_finalize(GArrayType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_array_type_load(GArrayType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_array_type_store(const GArrayType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_array_type_hash(const GArrayType *); @@ -111,6 +117,9 @@ static void g_array_type_class_init(GArrayTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_array_type_load; + type->store = (type_store_fc)g_array_type_store; + type->hash = (type_hash_fc)g_array_type_hash; type->dup = (type_dup_fc)g_array_type_dup; type->to_string = (type_to_string_fc)g_array_type_to_string; @@ -210,6 +219,115 @@ GDataType *g_array_type_new(GDataType *members) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_array_type_load(GArrayType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + bool numbered; /* Choix de la dimension */ + leb128_t number; /* Valeur LEB128 à charger */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = G_DATA_TYPE_CLASS(g_array_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = extract_packed_buffer(pbuf, &numbered, sizeof(uint8_t), false); + if (!result) goto exit; + + type->numbered = (numbered == 0x01); + + if (type->numbered) + { + result = unpack_leb128(&number, pbuf); + if (!result) goto exit; + + type->dim_number = number; + + } + else + { + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->dim_expr = calloc(value, sizeof(char)); + result = extract_packed_buffer(pbuf, type->dim_expr, value, false); + if (!result) goto exit; + + } + + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->members), storage, pbuf); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_array_type_store(const GArrayType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t len; /* Taille d'une chaîne */ + + result = G_DATA_TYPE_CLASS(g_array_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, (uint8_t []){ type->numbered ? 0x01 : 0x00 }, sizeof(uint8_t), false); + if (!result) goto exit; + + if (type->numbered) + { + result = pack_leb128((leb128_t []){ type->dim_number }, pbuf); + if (!result) goto exit; + + } + else + { + len = strlen(type->dim_expr); + + result = pack_uleb128((uleb128_t []){ len }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, type->dim_expr, len, false); + if (!result) goto exit; + + } + + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->members), storage, pbuf); + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/basic.c b/src/analysis/types/basic.c index 038bfb0..3932ce4 100644 --- a/src/analysis/types/basic.c +++ b/src/analysis/types/basic.c @@ -61,6 +61,12 @@ static void g_basic_type_dispose(GBasicType *); /* Procède à la libération totale de la mémoire. */ static void g_basic_type_finalize(GBasicType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_basic_type_load(GBasicType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_basic_type_store(const GBasicType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_basic_type_hash(const GBasicType *); @@ -100,6 +106,9 @@ static void g_basic_type_class_init(GBasicTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_basic_type_load; + type->store = (type_store_fc)g_basic_type_store; + type->hash = (type_hash_fc)g_basic_type_hash; type->dup = (type_dup_fc)g_basic_type_dup; type->to_string = (type_to_string_fc)g_basic_type_to_string; @@ -191,6 +200,66 @@ GDataType *g_basic_type_new(BaseType type) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_basic_type_load(GBasicType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = G_DATA_TYPE_CLASS(g_basic_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + + if (result) + result = unpack_uleb128(&value, pbuf); + + if (result) + type->type = value; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_basic_type_store(const GBasicType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + + result = G_DATA_TYPE_CLASS(g_basic_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + + if (result) + result = pack_uleb128((uleb128_t []){ type->type }, pbuf); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/cse.c b/src/analysis/types/cse.c index c79ea72..78db252 100644 --- a/src/analysis/types/cse.c +++ b/src/analysis/types/cse.c @@ -62,6 +62,12 @@ static void g_class_enum_type_dispose(GClassEnumType *); /* Procède à la libération totale de la mémoire. */ static void g_class_enum_type_finalize(GClassEnumType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_class_enum_type_load(GClassEnumType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_class_enum_type_store(const GClassEnumType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_class_enum_type_hash(const GClassEnumType *); @@ -101,6 +107,9 @@ static void g_class_enum_type_class_init(GClassEnumTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_class_enum_type_load; + type->store = (type_store_fc)g_class_enum_type_store; + type->hash = (type_hash_fc)g_class_enum_type_hash; type->dup = (type_dup_fc)g_class_enum_type_dup; type->to_string = (type_to_string_fc)g_class_enum_type_to_string; @@ -198,6 +207,85 @@ GDataType *g_class_enum_type_new(ClassEnumKind kind, char *name) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_class_enum_type_load(GClassEnumType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = G_DATA_TYPE_CLASS(g_class_enum_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->kind = value; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->name = calloc(value, sizeof(char)); + result = extract_packed_buffer(pbuf, type->name, value, false); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_class_enum_type_store(const GClassEnumType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t len; /* Taille d'une chaîne */ + + result = G_DATA_TYPE_CLASS(g_class_enum_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = pack_uleb128((uleb128_t []){ g_class_enum_type_get_kind(type) }, pbuf); + if (!result) goto exit; + + len = strlen(type->name); + + result = pack_uleb128((uleb128_t []){ len }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, type->name, len, false); + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c index 8e2641f..bfb4e57 100644 --- a/src/analysis/types/encaps.c +++ b/src/analysis/types/encaps.c @@ -65,6 +65,12 @@ static void g_encapsulated_type_dispose(GEncapsulatedType *); /* Procède à la libération totale de la mémoire. */ static void g_encapsulated_type_finalize(GEncapsulatedType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_encapsulated_type_load(GEncapsulatedType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_encapsulated_type_store(const GEncapsulatedType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_encapsulated_type_hash(const GEncapsulatedType *); @@ -110,6 +116,9 @@ static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_encapsulated_type_load; + type->store = (type_store_fc)g_encapsulated_type_store; + type->hash = (type_hash_fc)g_encapsulated_type_hash; type->dup = (type_dup_fc)g_encapsulated_type_dup; type->to_string = (type_to_string_fc)g_encapsulated_type_to_string; @@ -212,6 +221,84 @@ GDataType *g_encapsulated_type_new(EncapsulationType type, GDataType *child) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_encapsulated_type_load(GEncapsulatedType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = G_DATA_TYPE_CLASS(g_encapsulated_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->type = value; + + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->child), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->dimension = value; + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_encapsulated_type_store(const GEncapsulatedType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + + result = G_DATA_TYPE_CLASS(g_encapsulated_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = pack_uleb128((uleb128_t []){ g_encapsulated_type_get_etype(type) }, pbuf); + if (!result) goto exit; + + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->child), storage, pbuf); + if (!result) goto exit; + + result = pack_uleb128((uleb128_t []){ type->dimension }, pbuf); + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/expr.c b/src/analysis/types/expr.c index 1119ab6..a98e039 100644 --- a/src/analysis/types/expr.c +++ b/src/analysis/types/expr.c @@ -61,6 +61,12 @@ static void g_expr_type_dispose(GExprType *); /* Procède à la libération totale de la mémoire. */ static void g_expr_type_finalize(GExprType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_expr_type_load(GExprType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_expr_type_store(const GExprType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_expr_type_hash(const GExprType *); @@ -100,6 +106,9 @@ static void g_expr_type_class_init(GExprTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_expr_type_load; + type->store = (type_store_fc)g_expr_type_store; + type->hash = (type_hash_fc)g_expr_type_hash; type->dup = (type_dup_fc)g_expr_type_dup; type->to_string = (type_to_string_fc)g_expr_type_to_string; @@ -194,6 +203,78 @@ GDataType *g_expr_type_new(const char *value) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_expr_type_load(GExprType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + + result = G_DATA_TYPE_CLASS(g_expr_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->value = calloc(value, sizeof(char)); + result = extract_packed_buffer(pbuf, type->value, value, false); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_expr_type_store(const GExprType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t len; /* Taille d'une chaîne */ + + result = G_DATA_TYPE_CLASS(g_expr_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + len = strlen(type->value); + + result = pack_uleb128((uleb128_t []){ len }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, type->value, len, false); + if (!result) goto exit; + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/literal.c b/src/analysis/types/literal.c index addab5a..2a4aa45 100644 --- a/src/analysis/types/literal.c +++ b/src/analysis/types/literal.c @@ -64,6 +64,12 @@ static void g_literal_type_dispose(GLiteralType *); /* Procède à la libération totale de la mémoire. */ static void g_literal_type_finalize(GLiteralType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_literal_type_load(GLiteralType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_literal_type_store(const GLiteralType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_literal_type_hash(const GLiteralType *); @@ -103,6 +109,9 @@ static void g_literal_type_class_init(GLiteralTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_literal_type_load; + type->store = (type_store_fc)g_literal_type_store; + type->hash = (type_hash_fc)g_literal_type_hash; type->dup = (type_dup_fc)g_literal_type_dup; type->to_string = (type_to_string_fc)g_literal_type_to_string; @@ -206,6 +215,78 @@ GDataType *g_literal_type_new(GDataType *orig, const literal_value *value) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_literal_type_load(GLiteralType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + + result = G_DATA_TYPE_CLASS(g_literal_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->orig), storage, pbuf); + if (!result) goto exit; + + if (g_basic_type_get_base(G_BASIC_TYPE(type->orig)) == BTP_FLOAT) + result = extract_packed_buffer(pbuf, (uint64_t *)&type->value.float_val, sizeof(uint64_t), true); + else + result = extract_packed_buffer(pbuf, (uint32_t *)&type->value.int_val, sizeof(uint32_t), true); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_literal_type_store(const GLiteralType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + + result = G_DATA_TYPE_CLASS(g_literal_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->orig), storage, pbuf); + if (!result) goto exit; + + if (g_basic_type_get_base(G_BASIC_TYPE(type->orig)) == BTP_FLOAT) + result = extend_packed_buffer(pbuf, (uint64_t []){ type->value.float_val }, sizeof(uint64_t), true); + else + result = extend_packed_buffer(pbuf, (uint32_t []){ type->value.int_val }, sizeof(uint32_t), true); + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/override.c b/src/analysis/types/override.c index 841f10c..2beb934 100644 --- a/src/analysis/types/override.c +++ b/src/analysis/types/override.c @@ -65,6 +65,12 @@ static void g_override_type_dispose(GOverrideType *); /* Procède à la libération totale de la mémoire. */ static void g_override_type_finalize(GOverrideType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_override_type_load(GOverrideType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_override_type_store(const GOverrideType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_override_type_hash(const GOverrideType *); @@ -104,6 +110,9 @@ static void g_override_type_class_init(GOverrideTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_override_type_load; + type->store = (type_store_fc)g_override_type_store; + type->hash = (type_hash_fc)g_override_type_hash; type->dup = (type_dup_fc)g_override_type_dup; type->to_string = (type_to_string_fc)g_override_type_to_string; @@ -233,6 +242,117 @@ GDataType *g_override_type_new_with_covariant(GDataType *base, const call_offset /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_override_type_load(GOverrideType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t i; /* Boucle de parcours */ + call_offset_t *offset; /* Décalage à traiter */ + leb128_t value; /* Valeur à dépiler */ + bool status; /* Valeur booléenne */ + + result = G_DATA_TYPE_CLASS(g_override_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->base), storage, pbuf); + if (!result) goto exit; + + for (i = 0; i < 2; i++) + { + offset = &type->offsets[i]; + + result = unpack_leb128(&value, pbuf); + if (!result) goto exit; + + offset->values[0] = value; + + result = unpack_leb128(&value, pbuf); + if (!result) goto exit; + + offset->values[1] = value; + + result = extract_packed_buffer(pbuf, &status, sizeof(uint8_t), false); + if (!result) goto exit; + + offset->virtual = (status == 0x01); + + } + + result = extract_packed_buffer(pbuf, &status, sizeof(uint8_t), false); + if (!result) goto exit; + + type->with_covariant = (status == 0x01); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_override_type_store(const GOverrideType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t i; /* Boucle de parcours */ + const call_offset_t *offset; /* Décalage à traiter */ + + result = G_DATA_TYPE_CLASS(g_override_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->base), storage, pbuf); + if (!result) goto exit; + + for (i = 0; i < 2; i++) + { + offset = &type->offsets[i]; + + result = pack_leb128((leb128_t []){ offset->values[0] }, pbuf); + if (!result) goto exit; + + result = pack_leb128((leb128_t []){ offset->values[1] }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, (uint8_t []){ offset->virtual ? 0x01 : 0x00 }, sizeof(uint8_t), false); + if (!result) goto exit; + + } + + result = extend_packed_buffer(pbuf, (uint8_t []){ type->with_covariant ? 0x01 : 0x00 }, sizeof(uint8_t), false); + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/proto.c b/src/analysis/types/proto.c index 135c15a..aa096d8 100644 --- a/src/analysis/types/proto.c +++ b/src/analysis/types/proto.c @@ -66,6 +66,12 @@ static void g_proto_type_dispose(GProtoType *); /* Procède à la libération totale de la mémoire. */ static void g_proto_type_finalize(GProtoType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_proto_type_load(GProtoType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_proto_type_store(const GProtoType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_proto_type_hash(const GProtoType *); @@ -108,6 +114,9 @@ static void g_proto_type_class_init(GProtoTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_proto_type_load; + type->store = (type_store_fc)g_proto_type_store; + type->hash = (type_hash_fc)g_proto_type_hash; type->dup = (type_dup_fc)g_proto_type_dup; type->to_string = (type_to_string_fc)g_proto_type_to_string; @@ -213,6 +222,95 @@ GDataType *g_proto_type_new(void) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_proto_type_load(GProtoType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + size_t i; /* Boucle de parcours */ + + result = G_DATA_TYPE_CLASS(g_proto_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->ret_type), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->count = value; + + type->args = calloc(value, sizeof(GDataType *)); + + for (i = 0; i < type->count; i++) + { + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->args[i]), storage, pbuf); + if (!result) goto exit; + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_proto_type_store(const GProtoType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t i; /* Boucle de parcours */ + + result = G_DATA_TYPE_CLASS(g_proto_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->ret_type), storage, pbuf); + if (!result) goto exit; + + result = pack_uleb128((uleb128_t []){ type->count }, pbuf); + if (!result) goto exit; + + for (i = 0; i < type->count; i++) + { + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->args[i]), storage, pbuf); + if (!result) goto exit; + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à consulter. * * * * Description : Calcule une empreinte pour un type de données. * diff --git a/src/analysis/types/template.c b/src/analysis/types/template.c index 3a58169..05f7a2f 100644 --- a/src/analysis/types/template.c +++ b/src/analysis/types/template.c @@ -66,6 +66,12 @@ static void g_template_type_dispose(GTemplateType *); /* Procède à la libération totale de la mémoire. */ static void g_template_type_finalize(GTemplateType *); +/* Charge un objet depuis une mémoire tampon. */ +static bool g_template_type_load(GTemplateType *, GObjectStorage *, packed_buffer *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool g_template_type_store(const GTemplateType *, GObjectStorage *, packed_buffer *); + /* Calcule une empreinte pour un type de données. */ static guint g_template_type_hash(const GTemplateType *); @@ -105,6 +111,9 @@ static void g_template_type_class_init(GTemplateTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->load = (type_load_fc)g_template_type_load; + type->store = (type_store_fc)g_template_type_store; + type->hash = (type_hash_fc)g_template_type_hash; type->dup = (type_dup_fc)g_template_type_dup; type->to_string = (type_to_string_fc)g_template_type_to_string; @@ -208,6 +217,104 @@ GDataType *g_template_type_new(void) /****************************************************************************** * * +* Paramètres : type = type de données à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_template_type_load(GTemplateType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t value; /* Valeur ULEB128 à charger */ + size_t i; /* Boucle de parcours */ + + result = G_DATA_TYPE_CLASS(g_template_type_parent_class)->load(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->name = calloc(value, sizeof(char)); + result = extract_packed_buffer(pbuf, type->name, value, false); + + result = unpack_uleb128(&value, pbuf); + if (!result) goto exit; + + type->count = value; + + type->params = calloc(value, sizeof(GDataType *)); + + for (i = 0; i < type->count; i++) + { + result = g_serializable_object_load(G_SERIALIZABLE_OBJECT(type->params[i]), storage, pbuf); + if (!result) goto exit; + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de données à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_template_type_store(const GTemplateType *type, GObjectStorage *storage, packed_buffer *pbuf) +{ + bool result; /* Bilan à retourner */ + size_t len; /* Taille d'une chaîne */ + size_t i; /* Boucle de parcours */ + + result = G_DATA_TYPE_CLASS(g_template_type_parent_class)->store(G_DATA_TYPE(type), storage, pbuf); + if (!result) goto exit; + + len = strlen(type->name); + + result = pack_uleb128((uleb128_t []){ len }, pbuf); + if (!result) goto exit; + + result = extend_packed_buffer(pbuf, type->name, len, false); + if (!result) goto exit; + + result = pack_uleb128((uleb128_t []){ type->count }, pbuf); + if (!result) goto exit; + + for (i = 0; i < type->count; i++) + { + result = g_serializable_object_store(G_SERIALIZABLE_OBJECT(type->params[i]), storage, pbuf); + if (!result) goto exit; + + } + + exit: + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type base sur des gabarits à modifier. * * * * Description : Indique la désignation principale du type. * -- cgit v0.11.2-87-g4458