Serialize registers when needed.

4 files changed, 77 insertions, 74 deletions

diff --git a/src/arch/operands/register.c b/src/arch/operands/register.c
index 9c0a337..8cfe39f 100644
--- a/src/arch/operands/register.c
+++ b/src/arch/operands/register.c
@@ -338,7 +338,7 @@ static bool g_register_operand_unserialize(GRegisterOperand *operand, GAsmStorag
 
         if (result)
         {
-            reg = g_arch_register_load(storage, &reg_pbuf);
+            reg = NULL;//g_arch_register_load(storage, &reg_pbuf);
             result = (reg != NULL);
         }
 
@@ -383,7 +383,7 @@ static bool g_register_operand_serialize(const GRegisterOperand *operand, GAsmSt
     {
         init_packed_buffer(&reg_pbuf);
 
-        result = g_arch_register_store(operand->reg, storage, &reg_pbuf);
+        result = false;//g_arch_register_store(operand->reg, storage, &reg_pbuf);
 
         if (result)
             result = g_asm_storage_store_register_data(storage, &reg_pbuf, &pos);
diff --git a/src/arch/register-int.h b/src/arch/register-int.h
index a162435..4bff491 100644
--- a/src/arch/register-int.h
+++ b/src/arch/register-int.h
@@ -26,9 +26,7 @@
 
 
 #include "register.h"
-
-
-#include "operand-int.h"
+#include "../analysis/storage/storage.h"
 
 
 
@@ -47,11 +45,11 @@ typedef bool (* reg_is_base_pointer_fc) (const GArchRegister *);
 /* Indique si le registre correspond à esp ou similaire. */
 typedef bool (* reg_is_stack_pointer_fc) (const GArchRegister *);
 
-/* Charge un registre depuis une mémoire tampon. */
-typedef GArchRegister * (* reg_unserialize_fc) (GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+typedef bool (* load_register_fc) (GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-typedef bool (* reg_serialize_fc) (const GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+typedef bool (* store_register_fc) (GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 /* Représentation d'un registre (instance) */
@@ -72,8 +70,8 @@ struct _GArchRegisterClass
     reg_is_base_pointer_fc is_bp;           /* Correspondance avec ebp     */
     reg_is_stack_pointer_fc is_sp;          /* Correspondance avec esp     */
 
-    reg_unserialize_fc unserialize;         /* Chargement depuis un tampon */
-    reg_serialize_fc serialize;             /* Conservation dans un tampon */
+    load_register_fc load;                  /* Chargement depuis un tampon */
+    store_register_fc store;                /* Conservation dans un tampon */
 
 };
 
diff --git a/src/arch/register.c b/src/arch/register.c
index 740a06b..112492c 100644
--- a/src/arch/register.c
+++ b/src/arch/register.c
@@ -25,7 +25,7 @@
 
 
 #include "register-int.h"
-#include "storage.h"
+#include "../analysis/storage/serialize-int.h"
 
 
 
@@ -38,6 +38,9 @@ static void g_arch_register_class_init(GArchRegisterClass *);
 /* Initialise une instance de registre. */
 static void g_arch_register_init(GArchRegister *);
 
+/* Procède à l'initialisation de l'interface de sérialisation. */
+static void g_arch_register_serializable_init(GSerializableObjectInterface *);
+
 /* Supprime toutes les références externes. */
 static void g_arch_register_dispose(GArchRegister *);
 
@@ -46,14 +49,20 @@ static void g_arch_register_finalize(GArchRegister *);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */
+
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool _g_arch_register_load(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_arch_register_unserialize(GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_arch_register_load(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_arch_register_serialize(const GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool _g_arch_register_store(GArchRegister *, GObjectStorage *, packed_buffer_t *);
+
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_arch_register_store(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -63,7 +72,8 @@ static bool g_arch_register_serialize(const GArchRegister *, GAsmStorage *, pack
 
 
 /* Indique le type défini pour une représentation d'un registre. */
-G_DEFINE_TYPE(GArchRegister, g_arch_register, G_TYPE_OBJECT);
+G_DEFINE_TYPE_WITH_CODE(GArchRegister, g_arch_register, G_TYPE_OBJECT,
+                        G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_arch_register_serializable_init));
 
 
 /******************************************************************************
@@ -87,8 +97,8 @@ static void g_arch_register_class_init(GArchRegisterClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_arch_register_dispose;
     object->finalize = (GObjectFinalizeFunc)g_arch_register_finalize;
 
-    klass->unserialize = (reg_unserialize_fc)g_arch_register_unserialize;
-    klass->serialize = (reg_serialize_fc)g_arch_register_serialize;
+    klass->load = (load_register_fc)_g_arch_register_load;
+    klass->store = (store_register_fc)_g_arch_register_store;
 
 }
 
@@ -113,6 +123,26 @@ static void g_arch_register_init(GArchRegister *reg)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de sérialisation.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arch_register_serializable_init(GSerializableObjectInterface *iface)
+{
+    iface->load = (load_serializable_object_cb)g_arch_register_load;
+    iface->store = (store_serializable_object_cb)g_arch_register_store;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : reg = instance d'objet GLib à traiter.                       *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
@@ -262,17 +292,17 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *reg)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES REGISTRES                       */
+/*                      CONSERVATION ET RECHARGEMENT DES DONNEES                      */
 /* ---------------------------------------------------------------------------------- */
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -280,11 +310,11 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_arch_register_unserialize(GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool _g_arch_register_load(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
+    bool result;                            /* Bilan à retourner           */
 
-    result = reg;
+    result = true;
 
     return result;
 
@@ -293,36 +323,26 @@ static GArchRegister *g_arch_register_unserialize(GArchRegister *reg, GAsmStorag
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
-*  Retour      : Registre d'architecture constitué ou NULL en cas d'échec.    *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arch_register_load(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
-    GArchRegister *dummy;                   /* Patron du type de registre  */
-
-    dummy = G_ARCH_REGISTER(g_asm_storage_create_object(storage, pbuf));
-
-    if (dummy != NULL)
-    {
-        result = G_ARCH_REGISTER_GET_CLASS(dummy)->unserialize(dummy, storage, pbuf);
-
-        /* Si personne ne l'a fait avant... */
-        if (result != NULL)
-            g_object_unref(G_OBJECT(dummy));
+    bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *class;              /* Classe à activer            */
 
-    }
+    class = G_ARCH_REGISTER_GET_CLASS(reg);
 
-    else
-        result = NULL;
+    result = class->load(reg, storage, pbuf);
 
     return result;
 
@@ -331,11 +351,11 @@ GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -343,7 +363,7 @@ GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool _g_arch_register_store(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -356,11 +376,11 @@ static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *sto
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -368,14 +388,14 @@ static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *sto
 *                                                                             *
 ******************************************************************************/
 
-bool g_arch_register_store(const GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arch_register_store(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *class;              /* Classe à activer            */
 
-    result = g_asm_storage_store_object_gtype(storage, G_OBJECT(reg), pbuf);
+    class = G_ARCH_REGISTER_GET_CLASS(reg);
 
-    if (result)
-        result = G_ARCH_REGISTER_GET_CLASS(reg)->serialize(reg, storage, pbuf);
+    result = class->store(reg, storage, pbuf);
 
     return result;
 
diff --git a/src/arch/register.h b/src/arch/register.h
index 36bd9d9..0265a73 100644
--- a/src/arch/register.h
+++ b/src/arch/register.h
@@ -71,19 +71,4 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Depuis "storage.h" : définition d'une conservation d'instructions d'assemblage (instance) */
-typedef struct _GAsmStorage GAsmStorage;
-
-
-/* Charge un registre depuis une mémoire tampon. */
-GArchRegister *g_arch_register_load(GAsmStorage *, packed_buffer_t *);
-
-/* Sauvegarde un registre dans une mémoire tampon. */
-bool g_arch_register_store(const GArchRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 #endif  /* _ARCH_REGISTER_H */