Prepare mechanisms to load and store data types.

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 <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.                   *