Refined the whole share system for operands.

3 files changed, 351 insertions, 169 deletions

diff --git a/src/arch/dalvik/operands/args.c b/src/arch/dalvik/operands/args.c
index 8a687db..2092e6b 100644
--- a/src/arch/dalvik/operands/args.c
+++ b/src/arch/dalvik/operands/args.c
@@ -69,10 +69,16 @@ static void g_dalvik_args_operand_dispose(GDalvikArgsOperand *);
 static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *);
 
 /* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *, const GDalvikArgsOperand *);
+static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *, const GDalvikArgsOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
+
+/* Libère la mémoire utilisée par un patron d'instance. */
+static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
 
 /* Compare un opérande avec un autre. */
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *, const GDalvikArgsOperand * const *);
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine *, AsmSyntax);
@@ -86,6 +92,10 @@ static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine
 static GShareManager *_dalvik_args_operand_manager = NULL;
 
 
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_args_operand_share_manager(void);
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
@@ -119,7 +129,11 @@ static void g_dalvik_args_operand_class_init(GDalvikArgsOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_args_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dalvik_args_operand_finalize;
 
-    operand->init = (operand_do_init_fc)g_dalvik_args_operand_do_init;
+    operand->get_manager = (get_operand_manager_fc)get_dalvik_args_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_dalvik_args_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_dalvik_args_operand_define_template;
+    operand->free_template = (free_operand_template_fc)g_dalvik_args_operand_free_template;
 
     operand->compare = (operand_compare_fc)g_dalvik_args_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_args_operand_print;
@@ -190,62 +204,95 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un réceptacle pour opérandes Dalvik servant d'arguments.*
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_dalvik_args_operand_new(void)
+static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *operand, const GDalvikArgsOperand *template)
 {
-    GArchOperand *result;                   /* Structure à retourner       */
+    size_t i;                               /* Boucle de parcours          */
+
+    if (template == NULL)
+    {
+        operand->args = NULL;
+        operand->count = 0;
+    }
 
-    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_args_operand_manager, NULL));
+    else
+    {
+        g_dalvik_args_operand_define_template(template, operand);
 
-    return result;
+        for (i = 0; i < operand->count; i++)
+            g_object_ref(G_OBJECT(operand->args[i]));
+
+    }
+
+    return true;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = objet partagé à initialiser.                       *
-*                fake    = coquille vide contenant les infos à enregistrer.   *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *operand, const GDalvikArgsOperand *fake)
+static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
 {
     size_t i;                               /* Boucle de parcours          */
 
-    if (fake == NULL)
+    if (operand->count == 0)
     {
-        operand->args = NULL;
-        operand->count = 0;
+        template->args = NULL;
+        template->count = 0;
     }
 
     else
     {
-        operand->args = (GArchOperand **)calloc(fake->count, sizeof(GArchOperand *));
+        template->args = (GArchOperand **)calloc(operand->count, sizeof(GArchOperand *));
 
-        for (i = 0; i < fake->count; i++)
-            operand->args[i] = fake->args[i];
+        for (i = 0; i < operand->count; i++)
+            template->args[i] = operand->args[i];
 
-        operand->count = fake->count;
+        template->count = operand->count;
 
     }
 
-    return true;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations dont le contenu est à libérer.       *
+*                                                                             *
+*  Description : Libère la mémoire utilisée par un patron d'instance.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
+{
+    if (template != NULL && template->args != NULL)
+        free(template->args);
 
 }
 
@@ -263,26 +310,21 @@ static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *operand, const GDa
 *                                                                             *
 ******************************************************************************/
 
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *a, const GDalvikArgsOperand * const *b)
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDalvikArgsOperand *b)
 {
     int result;                             /* Bilan à renvoyer            */
-    const GDalvikArgsOperand *_a;           /* Accès rapide à l'élément A  */
-    const GDalvikArgsOperand *_b;           /* Accès rapide à l'élément B  */
     size_t i;                               /* Boucle de parcours          */
 
-    _a = *a;
-    _b = *b;
-
-    if (_b == NULL)
-        result = sort_unsigned_long(_a->count, 0);
+    /* Création de l'objet... */
+    if (b == NULL)
+        result = 1;
 
     else
     {
-        result = sort_unsigned_long(_a->count, _b->count);
+        result = sort_unsigned_long(a->count, b->count);
 
-        for (i = 0; i < _a->count && result == 0; i++)
-            result = g_arch_operand_compare((const GArchOperand * const *)&_a->args[i],
-                                            (const GArchOperand * const *)&_b->args[i]);
+        for (i = 0; i < a->count && result == 0; i++)
+            result = g_arch_operand_compare(a->args[i], b->args[i]);
 
     }
 
@@ -333,6 +375,29 @@ static void g_dalvik_args_operand_print(const GDalvikArgsOperand *operand, GBuff
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un réceptacle pour opérandes Dalvik servant d'arguments.*
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_dalvik_args_operand_new(void)
+{
+    GArchOperand *result;                   /* Structure à retourner       */
+
+    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_args_operand_manager, NULL));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à compléter.                              *
 *                arg     = nouvel argument pour un appel.                     *
 *                                                                             *
@@ -419,6 +484,25 @@ GArchOperand *g_dalvik_args_operand_get(const GDalvikArgsOperand *operand, size_
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
+*  Description : Fournit le gestionnaire de partages attribué à un type.      *
+*                                                                             *
+*  Retour      : Gestionnaire de partages en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GShareManager *get_dalvik_args_operand_share_manager(void)
+{
+    return _dalvik_args_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
 *  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index fa7ed54..d97c93b 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -74,10 +74,13 @@ static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *);
 static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *);
 
 /* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *, const GDalvikPoolOperand *);
+static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *, const GDalvikPoolOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *, GDalvikPoolOperand *);
 
 /* Compare un opérande avec un autre. */
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *, const GDalvikPoolOperand * const *);
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *, AsmSyntax);
@@ -91,6 +94,10 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine
 static GShareManager *_dalvik_pool_operand_manager = NULL;
 
 
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_pool_operand_share_manager(void);
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
@@ -125,7 +132,11 @@ static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *klass)
 
     operand = G_ARCH_OPERAND_CLASS(klass);
 
-    operand->init = (operand_do_init_fc)g_dalvik_pool_operand_do_init;
+    operand->get_manager = (get_operand_manager_fc)get_dalvik_pool_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_dalvik_pool_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_dalvik_pool_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
 
     operand->compare = (operand_compare_fc)g_dalvik_pool_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_pool_operand_print;
@@ -193,82 +204,47 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format  = format du fichier contenant le code.               *
-*                type    = type de table visée avec la référence.             *
-*                content = flux de données à analyser.                        *
-*                pos     = position courante dans ce flux. [OUT]              *
-*                size    = taille de l'opérande, et donc du registre.         *
-*                endian  = ordre des bits dans la source.                     *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un opérande visant un élément constant Dalvik.          *
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
+static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *operand, const GDalvikPoolOperand *template)
 {
-    GArchOperand *result;                   /* Structure à retourner       */
-    uint8_t index8;                         /* Indice sur 8 bits           */
-    uint16_t index16;                       /* Indice sur 16 bits          */
-    bool test;                              /* Bilan de lecture            */
-    GDalvikPoolOperand fake;                /* Transport d'informations    */
+    g_dalvik_pool_operand_define_template(template, operand);
 
-    result = NULL;
+    g_object_ref(G_OBJECT(operand->format));
 
-    switch (size)
-    {
-        case MDS_8_BITS:
-            test = g_binary_content_read_u8(content, pos, &index8);
-            break;
-        case MDS_16_BITS:
-            test = g_binary_content_read_u16(content, pos, endian, &index16);
-            break;
-        default:
-            test = false;
-            break;
-    }
-
-    if (!test)
-        goto gdpon_exit;
-
-    fake.format = format;
-    fake.type = type;
-    fake.index = (size == MDS_8_BITS ? index8 : index16);
-
-    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
-
- gdpon_exit:
-
-    return result;
+    return true;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = objet partagé à initialiser.                       *
-*                fake    = coquille vide contenant les infos à enregistrer.   *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *operand, const GDalvikPoolOperand *fake)
+static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *operand, GDalvikPoolOperand *template)
 {
-    operand->format = fake->format;
-    g_object_ref(G_OBJECT(fake->format));
-
-    operand->type = fake->type;
-    operand->index = fake->index;
+    template->format = operand->format;
 
-    return true;
+    template->type = operand->type;
+    template->index = operand->index;
 
 }
 
@@ -286,22 +262,17 @@ static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *operand, const GDa
 *                                                                             *
 ******************************************************************************/
 
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *a, const GDalvikPoolOperand * const *b)
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b)
 {
     int result;                             /* Bilan à renvoyer            */
-    const GDalvikPoolOperand *_a;           /* Accès rapide à l'élément A  */
-    const GDalvikPoolOperand *_b;           /* Accès rapide à l'élément B  */
-
-    _a = *a;
-    _b = *b;
 
-    result = sort_unsigned_long((unsigned long)_a->format, (unsigned long)_b->format);
+    result = sort_unsigned_long((unsigned long)a->format, (unsigned long)b->format);
 
     if (result == 0)
-        result = sort_unsigned_long(_a->type, _b->type);
+        result = sort_unsigned_long(a->type, b->type);
 
     if (result == 0)
-        result = sort_unsigned_long(_a->index, _b->index);
+        result = sort_unsigned_long(a->index, b->index);
 
     return result;
 
@@ -471,6 +442,62 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : format  = format du fichier contenant le code.               *
+*                type    = type de table visée avec la référence.             *
+*                content = flux de données à analyser.                        *
+*                pos     = position courante dans ce flux. [OUT]              *
+*                size    = taille de l'opérande, et donc du registre.         *
+*                endian  = ordre des bits dans la source.                     *
+*                                                                             *
+*  Description : Crée un opérande visant un élément constant Dalvik.          *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
+{
+    GArchOperand *result;                   /* Structure à retourner       */
+    uint8_t index8;                         /* Indice sur 8 bits           */
+    uint16_t index16;                       /* Indice sur 16 bits          */
+    bool test;                              /* Bilan de lecture            */
+    GDalvikPoolOperand fake;                /* Transport d'informations    */
+
+    result = NULL;
+
+    switch (size)
+    {
+        case MDS_8_BITS:
+            test = g_binary_content_read_u8(content, pos, &index8);
+            break;
+        case MDS_16_BITS:
+            test = g_binary_content_read_u16(content, pos, endian, &index16);
+            break;
+        default:
+            test = false;
+            break;
+    }
+
+    if (!test)
+        goto gdpon_exit;
+
+    fake.format = format;
+    fake.type = type;
+    fake.index = (size == MDS_8_BITS ? index8 : index16);
+
+    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
+
+ gdpon_exit:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Indique la nature de la table de constantes visée ici.       *
@@ -517,6 +544,25 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
+*  Description : Fournit le gestionnaire de partages attribué à un type.      *
+*                                                                             *
+*  Retour      : Gestionnaire de partages en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GShareManager *get_dalvik_pool_operand_share_manager(void)
+{
+    return _dalvik_pool_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
 *  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index b415d3f..cf29455 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -65,10 +65,13 @@ static void g_dalvik_register_operand_dispose(GDalvikRegisterOperand *);
 static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *);
 
 /* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
+static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *, GDalvikRegisterOperand *);
 
 /* Compare un opérande avec un autre. */
-static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *, const GDalvikRegisterOperand * const *);
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBufferLine *, AsmSyntax);
@@ -82,6 +85,10 @@ static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBuf
 static GShareManager *_dalvik_register_operand_manager = NULL;
 
 
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_register_operand_share_manager(void);
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
@@ -116,7 +123,11 @@ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *kl
 
     operand = G_ARCH_OPERAND_CLASS(klass);
 
-    operand->init = (operand_do_init_fc)g_dalvik_register_operand_do_init;
+    operand->get_manager = (get_operand_manager_fc)get_dalvik_register_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_dalvik_register_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_dalvik_register_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
 
     operand->compare = (operand_compare_fc)g_dalvik_register_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_register_operand_print;
@@ -183,6 +194,95 @@ static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *operand)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
+*                                                                             *
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *template)
+{
+    g_dalvik_register_operand_define_template(template, operand);
+
+    g_object_ref(G_OBJECT(operand->reg));
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
+*                                                                             *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *operand, GDalvikRegisterOperand *template)
+{
+    template->reg = operand->reg;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand *a, const GDalvikRegisterOperand *b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = g_dalvik_register_compare(a->reg, b->reg);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    g_arch_register_print(G_ARCH_REGISTER(operand->reg), line, syntax);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : content = flux de données à analyser.                        *
 *                pos     = position courante dans ce flux. [OUT]              *
 *                low     = position éventuelle des 4 bits visés. [OUT]        *
@@ -275,53 +375,7 @@ GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
 
     fake.reg = reg;
 
-    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = objet partagé à initialiser.                       *
-*                fake    = coquille vide contenant les infos à enregistrer.   *
-*                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *fake)
-{
-    operand->reg = fake->reg;
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : a = premier opérande à consulter.                            *
-*                b = second opérande à consulter.                             *
-*                                                                             *
-*  Description : Compare un opérande avec un autre.                           *
-*                                                                             *
-*  Retour      : Bilan de la comparaison.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *a, const GDalvikRegisterOperand * const *b)
-{
-    int result;                             /* Bilan à retourner           */
-
-    result = g_dalvik_register_compare(&(*a)->reg, &(*b)->reg);
+    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
 
     return result;
 
@@ -330,27 +384,6 @@ static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * cons
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande à traiter.                                *
-*                line    = ligne tampon où imprimer l'opérande donné.         *
-*                syntax  = type de représentation demandée.                   *
-*                                                                             *
-*  Description : Traduit un opérande en version humainement lisible.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
-{
-    g_arch_register_print(G_ARCH_REGISTER(operand->reg), line, syntax);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : operand = opérande représentant un registre.                 *
 *                                                                             *
 *  Description : Fournit le registre Dalvik associé à l'opérande.             *
@@ -416,6 +449,25 @@ bool g_dalvik_register_operand_is_written(const GDalvikRegisterOperand *operand)
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
+*  Description : Fournit le gestionnaire de partages attribué à un type.      *
+*                                                                             *
+*  Retour      : Gestionnaire de partages en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GShareManager *get_dalvik_register_operand_share_manager(void)
+{
+    return _dalvik_register_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
 *  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *