Serialize registers when needed.

2 files changed, 88 insertions, 110 deletions

diff --git a/plugins/dalvik/register.c b/plugins/dalvik/register.c
index 87babfb..b350b04 100644
--- a/plugins/dalvik/register.c
+++ b/plugins/dalvik/register.c
@@ -70,25 +70,28 @@ static void g_dalvik_register_dispose(GDalvikRegister *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_register_finalize(GDalvikRegister *);
 
-/* Produit une empreinte à partir d'un registre. */
-static guint g_dalvik_register_hash(const GDalvikRegister *);
-
-/* Traduit un registre en version humainement lisible. */
-static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *);
-
 /* Crée une réprésentation de registre Dalvik. */
 static GArchRegister *_g_dalvik_register_new(uint16_t);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Produit une empreinte à partir d'un registre. */
+static guint g_dalvik_register_hash(const GDalvikRegister *);
 
+/* Compare un registre avec un autre. */
+static int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
+
+/* Traduit un registre en version humainement lisible. */
+static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_dalvik_register_load(GDalvikRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_dalvik_register_serialize(const GDalvikRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_dalvik_register_store(GDalvikRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -130,20 +133,21 @@ G_DEFINE_TYPE(GDalvikRegister, g_dalvik_register, G_TYPE_ARCH_REGISTER);
 static void g_dalvik_register_class_init(GDalvikRegisterClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GArchRegisterClass *reg_class;          /* Classe de haut niveau       */
+    GArchRegisterClass *reg;                /* Classe de haut niveau       */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_register_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dalvik_register_finalize;
 
-    reg_class = G_ARCH_REGISTER_CLASS(klass);
+    reg = G_ARCH_REGISTER_CLASS(klass);
+
+    reg->hash = (reg_hash_fc)g_dalvik_register_hash;
+    reg->compare = (reg_compare_fc)g_dalvik_register_compare;
+    reg->print = (reg_print_fc)g_dalvik_register_print;
 
-    reg_class->hash = (reg_hash_fc)g_dalvik_register_hash;
-    reg_class->compare = (reg_compare_fc)g_dalvik_register_compare;
-    reg_class->print = (reg_print_fc)g_dalvik_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_dalvik_register_unserialize;
-    reg_class->serialize = (reg_serialize_fc)g_dalvik_register_serialize;
+    reg->load = (load_register_fc)g_dalvik_register_load;
+    reg->store = (store_register_fc)g_dalvik_register_store;
 
 }
 
@@ -206,50 +210,6 @@ static void g_dalvik_register_finalize(GDalvikRegister *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg = opérande à consulter pour le calcul.                   *
-*                                                                             *
-*  Description : Produit une empreinte à partir d'un registre.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static guint g_dalvik_register_hash(const GDalvikRegister *reg)
-{
-    return reg->index;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg  = registre à transcrire.                                *
-*                line = ligne tampon où imprimer l'opérande donné.            *
-*                                                                             *
-*  Description : Traduit un registre en version humainement lisible.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *line)
-{
-    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
-    size_t klen;                            /* Taille de ce mot clef       */
-
-    klen = snprintf(key, MAX_REGNAME_LEN, "v%hu", reg->index);
-
-    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : index = indice du registre correspondant.                    *
 *                                                                             *
 *  Description : Crée une réprésentation de registre Dalvik.                  *
@@ -315,6 +275,31 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg = opérande à consulter pour le calcul.                   *
+*                                                                             *
+*  Description : Produit une empreinte à partir d'un registre.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static guint g_dalvik_register_hash(const GDalvikRegister *reg)
+{
+    return reg->index;
+
+}
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
@@ -328,7 +313,7 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
+static int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
 {
     int result;                             /* Bilan à retourner           */
 
@@ -339,57 +324,56 @@ int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg  = registre à transcrire.                                *
+*                line = ligne tampon où imprimer l'opérande donné.            *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Traduit un registre en version humainement lisible.          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *line)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint16_t index;                         /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
+    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
+    size_t klen;                            /* Taille de ce mot clef       */
 
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint16_t), true);
+    klen = snprintf(key, MAX_REGNAME_LEN, "v%hu", reg->index);
 
-    if (status)
-    {
-        result = get_dalvik_register(index);
+    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
 
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
+}
 
-    }
 
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
+*                                                                             *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
+static bool g_dalvik_register_load(GDalvikRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-        result = parent->unserialize(result, storage, pbuf);
+    parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
 
-    }
+    result = parent->load(G_ARCH_REGISTER(reg), storage, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
 
     return result;
 
@@ -398,11 +382,11 @@ static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmSt
 
 /******************************************************************************
 *                                                                             *
-*  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.                                        *
 *                                                                             *
@@ -410,20 +394,17 @@ static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmSt
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_register_serialize(const GDalvikRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_dalvik_register_store(GDalvikRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-    result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
+    parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
 
-    if (result)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
+    result = parent->store(G_ARCH_REGISTER(reg), storage, pbuf);
 
-        result = parent->serialize(G_ARCH_REGISTER(reg), storage, pbuf);
-
-    }
+    if (result)
+        result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
 
     return result;
 
diff --git a/plugins/dalvik/register.h b/plugins/dalvik/register.h
index 586d242..8c664a5 100644
--- a/plugins/dalvik/register.h
+++ b/plugins/dalvik/register.h
@@ -60,9 +60,6 @@ GArchRegister *g_dalvik_register_new(uint16_t);
 /* Fournit l'indice d'un registre Dalvik. */
 uint16_t g_dalvik_register_get_index(const GDalvikRegister *);
 
-/* Compare un registre avec un autre. */
-int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
-
 
 
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */