summaryrefslogtreecommitdiff
path: root/src/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis')
-rw-r--r--src/analysis/storage/serialize-int.h3
-rw-r--r--src/analysis/storage/serialize.c4
-rw-r--r--src/analysis/storage/serialize.h1
-rw-r--r--src/analysis/type-int.h16
-rw-r--r--src/analysis/type.c295
-rw-r--r--src/analysis/type.h18
-rw-r--r--src/analysis/types/array.c118
-rw-r--r--src/analysis/types/basic.c69
-rw-r--r--src/analysis/types/cse.c88
-rw-r--r--src/analysis/types/encaps.c87
-rw-r--r--src/analysis/types/expr.c81
-rw-r--r--src/analysis/types/literal.c81
-rw-r--r--src/analysis/types/override.c120
-rw-r--r--src/analysis/types/proto.c98
-rw-r--r--src/analysis/types/template.c107
15 files changed, 1123 insertions, 63 deletions
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 <glib-object.h>
-#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. *
generated by cgit v0.11.2-87-g4458 at 2024-12-25 16:21:43 (GMT)