Read raw Dex items by extending the API.

9 files changed, 1004 insertions, 98 deletions

diff --git a/plugins/dex/method.c b/plugins/dex/method.c
index f35858e..75293b7 100644
--- a/plugins/dex/method.c
+++ b/plugins/dex/method.c
@@ -54,6 +54,7 @@ struct _GDexMethod
     bool already_defined;                   /* Vérification d'unicité      */
 #endif
 
+    method_id_item id_item;                 /* Définition de la méthode    */
     encoded_method info;                    /* Propriétés de la méthode    */
     bool has_body;                          /* Indication de présence      */
     code_item body;                         /* Corps de la méthode         */
@@ -257,8 +258,8 @@ GDexMethod *g_dex_method_new_defined(GDexFormat *format, const encoded_method *s
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : format    = représentation interne du format DEX à consulter.*
-*                method_id = informations de base quant à la méthode.         *
+*  Paramètres  : format  = représentation interne du format DEX à consulter.*
+*                id_item = informations de base quant à la méthode.         *
 *                                                                             *
 *  Description : Crée une nouvelle représentation de methode vide.            *
 *                                                                             *
@@ -268,7 +269,7 @@ GDexMethod *g_dex_method_new_defined(GDexFormat *format, const encoded_method *s
 *                                                                             *
 ******************************************************************************/
 
-GDexMethod *g_dex_method_new_callable(GDexFormat *format, const method_id_item *method_id)
+GDexMethod *g_dex_method_new_callable(GDexFormat *format, const method_id_item *id_item)
 {
     GDexMethod *result;                     /* Composant à retourner       */
     GDexPool *pool;                         /* Table de ressources         */
@@ -280,12 +281,12 @@ GDexMethod *g_dex_method_new_callable(GDexFormat *format, const method_id_item *
 
     pool = g_dex_format_get_pool(format);
 
-    ns = g_dex_pool_get_type_(pool, method_id->class_idx);
+    ns = g_dex_pool_get_type_(pool, id_item->class_idx);
 
-    name = g_dex_pool_get_string(pool, method_id->name_idx, NULL);
+    name = g_dex_pool_get_string(pool, id_item->name_idx, NULL);
     if (name == NULL) goto gdmne_exit;
 
-    routine = g_dex_pool_get_prototype(pool, method_id->proto_idx);
+    routine = g_dex_pool_get_prototype(pool, id_item->proto_idx);
     if (routine == NULL) goto gdmne_exit;
 
     if (ns != NULL)
@@ -299,6 +300,8 @@ GDexMethod *g_dex_method_new_callable(GDexFormat *format, const method_id_item *
 
     g_dex_routine_attach_method(G_DEX_ROUTINE(routine), result);
 
+    result->id_item = *id_item;
+
  gdmne_exit:
 
     g_object_unref(G_OBJECT(pool));
@@ -312,6 +315,25 @@ GDexMethod *g_dex_method_new_callable(GDexFormat *format, const method_id_item *
 *                                                                             *
 *  Paramètres  : method = représentation interne de la méthode à consulter.   *
 *                                                                             *
+*  Description : Fournit les identifiants Dex concernant la méthode.          *
+*                                                                             *
+*  Retour      : Données brutes du binaire.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const method_id_item *g_dex_method_get_dex_id_item(const GDexMethod *method)
+{
+    return &method->id_item;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : method = représentation interne de la méthode à consulter.   *
+*                                                                             *
 *  Description : Fournit les indications Dex concernant la méthode.           *
 *                                                                             *
 *  Retour      : Données brutes du binaire.                                   *
diff --git a/plugins/dex/method.h b/plugins/dex/method.h
index e567832..acb6b5b 100644
--- a/plugins/dex/method.h
+++ b/plugins/dex/method.h
@@ -75,6 +75,9 @@ GDexMethod *g_dex_method_new_defined(GDexFormat *, const encoded_method *, uleb1
 /* Crée une nouvelle représentation de methode vide. */
 GDexMethod *g_dex_method_new_callable(GDexFormat *, const method_id_item *);
 
+/* Fournit les identifiants Dex concernant la méthode. */
+const method_id_item *g_dex_method_get_dex_id_item(const GDexMethod *);
+
 /* Fournit les indications Dex concernant la méthode. */
 const encoded_method *g_dex_method_get_dex_info(const GDexMethod *);
 
diff --git a/plugins/dex/pool.c b/plugins/dex/pool.c
index 6905c3b..e7dd205 100644
--- a/plugins/dex/pool.c
+++ b/plugins/dex/pool.c
@@ -492,6 +492,48 @@ uint32_t g_dex_pool_count_types(const GDexPool *pool)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : pool    = table de resources pour format Dex à consulter.    *
+*                index   = index du type recherché.                           *
+*                type_id = élément ciblé à constituer. [OUT]                  *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'un type Dex.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_dex_pool_get_raw_type(GDexPool *pool, uint32_t index, type_id_item *type_id)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t count;                         /* Nombre d'éléments présents  */
+    GDexFormat *format;                     /* Format associé à la table   */
+    phys_t pos;                             /* Tête de lecture             */
+    vmpa2t addr;                            /* Tête de lecture générique   */
+
+    result = false;
+
+    count = g_dex_pool_count_types(pool);
+
+    if (index < count)
+    {
+        format = pool->format;
+
+        pos = format->header.type_ids_off + index * sizeof(type_id_item);
+        init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
+
+        result = read_dex_type_id_item(format, &addr, type_id);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
 *                index = index du type recherché.                             *
 *                                                                             *
@@ -506,42 +548,33 @@ uint32_t g_dex_pool_count_types(const GDexPool *pool)
 GDataType *g_dex_pool_get_type_(GDexPool *pool, uint32_t index)
 {
     GDataType *result;                      /* Instance à retourner        */
-    uint32_t count;                         /* Nombre d'éléments présents  */
+    type_id_item type_id;                   /* Définition de la classe     */
     GDexFormat *format;                     /* Format associé à la table   */
     phys_t pos;                             /* Tête de lecture             */
     vmpa2t addr;                            /* Tête de lecture générique   */
-    type_id_item type_id;                   /* Définition de la classe     */
     string_id_item str_id;                  /* Identifiant de chaîne       */
     string_data_item str_data;              /* Description de chaîne       */
 
     result = NULL;
 
-    count = g_dex_pool_count_types(pool);
-
-    if (index >= count)
-        goto gtfdp_error;
-
     if (pool->types[index] == NULL)
     {
-        format = pool->format;
+        if (!g_dex_pool_get_raw_type(pool, index, &type_id))
+            goto no_type_id;
 
-        pos = format->header.type_ids_off + index * sizeof(type_id_item);
-        init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
-
-        if (!read_dex_type_id_item(format, &addr, &type_id))
-            goto gtfdp_error;
+        format = pool->format;
 
         pos = format->header.string_ids_off + type_id.descriptor_idx * sizeof(string_id_item);
         init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
 
         if (!read_dex_string_id_item(format, &addr, &str_id))
-            goto gtfdp_error;
+            goto type_error;
 
         pos = str_id.string_data_off;
         init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
 
         if (!read_dex_string_data_item(format, &addr, NULL, &str_data))
-            goto gtfdp_error;
+            goto type_error;
 
         pool->types[index] = g_binary_format_decode_type(G_BIN_FORMAT(format), (char *)str_data.data);
 
@@ -552,7 +585,9 @@ GDataType *g_dex_pool_get_type_(GDexPool *pool, uint32_t index)
     if (result != NULL)
         g_object_ref(G_OBJECT(result));
 
- gtfdp_error:
+ type_error:
+
+ no_type_id:
 
     return result;
 
@@ -653,6 +688,48 @@ uint32_t g_dex_pool_count_fields(const GDexPool *pool)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : pool     = table de resources pour format Dex à consulter.   *
+*                index    = index du type recherché.                          *
+*                field_id = élément ciblé à constituer. [OUT]                 *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'un champ Dex.               *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_dex_pool_get_raw_field(GDexPool *pool, uint32_t index, field_id_item *field_id)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t count;                         /* Nombre d'éléments présents  */
+    GDexFormat *format;                     /* Format associé à la table   */
+    phys_t pos;                             /* Tête de lecture             */
+    vmpa2t addr;                            /* Tête de lecture générique   */
+
+    result = false;
+
+    count = g_dex_pool_count_fields(pool);
+
+    if (index < count)
+    {
+        format = pool->format;
+
+        pos = format->header.field_ids_off + index * sizeof(field_id_item);
+        init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
+
+        result = read_dex_field_id_item(format, &addr, field_id);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
 *                index = index du champ recherché.                            *
 *                                                                             *
@@ -667,10 +744,6 @@ uint32_t g_dex_pool_count_fields(const GDexPool *pool)
 GBinVariable *g_dex_pool_get_field(GDexPool *pool, uint32_t index)
 {
     GBinVariable *result;                   /* Instance à retourner        */
-    uint32_t count;                         /* Nombre d'éléments présents  */
-    GDexFormat *format;                     /* Format associé à la table   */
-    phys_t pos;                             /* Tête de lecture             */
-    vmpa2t addr;                            /* Tête de lecture générique   */
     field_id_item field_id;                 /* Description du champ        */
     GDataType *type;                        /* Type du champ               */
     const char *name;                       /* Désignation humaine         */
@@ -679,26 +752,16 @@ GBinVariable *g_dex_pool_get_field(GDexPool *pool, uint32_t index)
 
     result = NULL;
 
-    count = g_dex_pool_count_fields(pool);
-
-    if (index >= count)
-        goto gffdp_error;
-
     if (pool->fields[index] == NULL)
     {
-        format = pool->format;
-
-        pos = format->header.field_ids_off + index * sizeof(field_id_item);
-        init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
-
-        if (!read_dex_field_id_item(format, &addr, &field_id))
-            goto gffdp_error;
+        if (!g_dex_pool_get_raw_field(pool, index, &field_id))
+            goto no_field_id;
 
         type = g_dex_pool_get_type_(pool, field_id.type_idx);
-        if (type == NULL) goto gffdp_error;
+        if (type == NULL) goto type_error;
 
         name = g_dex_pool_get_string(pool, field_id.name_idx, NULL);
-        if (name == NULL) goto gffdp_bad_name;
+        if (name == NULL) goto bad_name;
   
         field = g_binary_variable_new(type);
         g_binary_variable_set_name(field, name);
@@ -706,7 +769,7 @@ GBinVariable *g_dex_pool_get_field(GDexPool *pool, uint32_t index)
         if (field_id.class_idx != NO_INDEX)
         {
             owner = g_dex_pool_get_type_(pool, field_id.class_idx);
-            if (owner == NULL) goto gffdp_bad_owner;
+            if (owner == NULL) goto bad_owner;
 
             g_binary_variable_set_owner(field, owner);
 
@@ -721,15 +784,17 @@ GBinVariable *g_dex_pool_get_field(GDexPool *pool, uint32_t index)
     if (result != NULL)
         g_object_ref(G_OBJECT(result));
 
- gffdp_error:
+ type_error:
+
+ no_field_id:
 
     return result;
 
- gffdp_bad_owner:
+ bad_owner:
 
     g_object_unref(G_OBJECT(field));
 
- gffdp_bad_name:
+ bad_name:
 
     g_object_unref(G_OBJECT(type));
 
@@ -763,6 +828,48 @@ uint32_t g_dex_pool_count_prototypes(const GDexPool *pool)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : pool     = table de resources pour format Dex à consulter.   *
+*                index    = index de la routine recherchée.                   *
+*                proto_id = élément ciblé à constituer. [OUT]                 *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'une routine Dex.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_dex_pool_get_raw_prototype(GDexPool *pool, uint32_t index, proto_id_item *proto_id)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t count;                         /* Nombre d'éléments présents  */
+    GDexFormat *format;                     /* Format associé à la table   */
+    phys_t pos;                             /* Tête de lecture             */
+    vmpa2t addr;                            /* Tête de lecture générique   */
+
+    result = false;
+
+    count = g_dex_pool_count_prototypes(pool);
+
+    if (index < count)
+    {
+        format = pool->format;
+
+        pos = format->header.proto_ids_off + index * sizeof(proto_id_item);
+        init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
+
+        result = read_dex_proto_id_item(format, &addr, proto_id);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
 *                index = index de la routine recherchée.                      *
 *                                                                             *
@@ -777,12 +884,10 @@ uint32_t g_dex_pool_count_prototypes(const GDexPool *pool)
 GBinRoutine *g_dex_pool_get_prototype(GDexPool *pool, uint32_t index)
 {
     GBinRoutine *result;                    /* Instance à retourner        */
-    uint32_t count;                         /* Nombre d'éléments présents  */
-    GDexFormat *format;                     /* Format associé à la table   */
-    phys_t pos;                             /* Tête de lecture             */
-    vmpa2t addr;                            /* Tête de lecture générique   */
     proto_id_item proto_id;                 /* Prototype de routine        */
     GDataType *type;                        /* Type de retour              */
+    phys_t pos;                             /* Tête de lecture             */
+    vmpa2t addr;                            /* Tête de lecture générique   */
     type_list args;                         /* Liste des arguments         */
     uint32_t i;                             /* Boucle de parcours          */
     GBinVariable *arg;                      /* Argument reconstitué        */
@@ -795,21 +900,11 @@ GBinRoutine *g_dex_pool_get_prototype(GDexPool *pool, uint32_t index)
      * les autres éléments de la table des constantes.
      */
 
-    count = g_dex_pool_count_prototypes(pool);
-
-    if (index >= count)
-        goto grfdp_error;
-
-    format = pool->format;
-
-    pos = format->header.proto_ids_off + index * sizeof(proto_id_item);
-    init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
-
-    if (!read_dex_proto_id_item(format, &addr, &proto_id))
-        goto grfdp_error;
+    if (!g_dex_pool_get_raw_prototype(pool, index, &proto_id))
+        goto no_proto_id;
 
     /**
-     * On choisit d'ignore le champ proto_id.shorty_idx : c'est un descripteur
+     * On choisit d'ignorer le champ proto_id.shorty_idx : c'est un descripteur
      * qui doit correspondre au retour et aux paramètres précisés avec les
      * autres champs de la structure, donc l'information paraît redondante.
      */
@@ -817,7 +912,7 @@ GBinRoutine *g_dex_pool_get_prototype(GDexPool *pool, uint32_t index)
     /* Type de retour */
 
     type = g_dex_pool_get_type_(pool, proto_id.return_type_idx);
-    if (type == NULL) goto grfdp_error;
+    if (type == NULL) goto type_error;
 
     result = G_BIN_ROUTINE(g_dex_routine_new());
 
@@ -831,13 +926,13 @@ GBinRoutine *g_dex_pool_get_prototype(GDexPool *pool, uint32_t index)
     {
         init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
 
-        if (!read_dex_type_list(format, &addr, &args))
-            goto grfdp_error;
+        if (!read_dex_type_list(pool->format, &addr, &args))
+            goto arg_error;
 
         for (i = 0; i < args.size; i++)
         {
             type = g_dex_pool_get_type_(pool, args.list[i].type_idx);
-            if (type == NULL) goto grfdp_error;
+            if (type == NULL) goto arg_error;
 
             arg = g_binary_variable_new(type);
             g_binary_routine_add_arg(result, arg);
@@ -848,11 +943,15 @@ GBinRoutine *g_dex_pool_get_prototype(GDexPool *pool, uint32_t index)
 
     return result;
 
- grfdp_error:
+ arg_error:
 
     if (result != NULL)
         g_object_unref(G_OBJECT(result));
 
+ type_error:
+
+ no_proto_id:
+
     return NULL;
 
 }
@@ -970,44 +1069,72 @@ uint32_t g_dex_pool_count_methods(const GDexPool *pool)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
-*                index = index de la méthode recherchée.                      *
+*  Paramètres  : pool     = table de resources pour format Dex à consulter.   *
+*                index    = index du type recherché.                          *
+*                field_id = élément ciblé à constituer. [OUT]                 *
 *                                                                             *
-*  Description : Extrait une représentation de méthode d'une table DEX.       *
+*  Description : Reconstitue les éléments bruts d'une méthode Dex.            *
 *                                                                             *
-*  Retour      : Composant GLib créé.                                         *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GDexMethod *g_dex_pool_get_method(GDexPool *pool, uint32_t index)
+bool g_dex_pool_get_raw_method(GDexPool *pool, uint32_t index, method_id_item *method_id)
 {
-    GDexMethod *result;                     /* Instance à retourner        */
+    bool result;                            /* Bilan à retourner           */
     uint32_t count;                         /* Nombre d'éléments présents  */
     GDexFormat *format;                     /* Format associé à la table   */
     phys_t pos;                             /* Tête de lecture             */
     vmpa2t addr;                            /* Tête de lecture générique   */
-    method_id_item method_id;               /* Définition de la méthode    */
 
-    result = NULL;
+    result = false;
 
     count = g_dex_pool_count_methods(pool);
 
-    if (index >= count)
-        goto gmfdp_error;
-
-    if (pool->methods[index] == NULL)
+    if (index < count)
     {
         format = pool->format;
 
         pos = format->header.method_ids_off + index * sizeof(method_id_item);
         init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
 
-        if (!read_dex_method_id_item(format, &addr, &method_id))
-            goto gmfdp_error;
+        result = read_dex_method_id_item(format, &addr, method_id);
 
-        pool->methods[index] = g_dex_method_new_callable(format, &method_id);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
+*                index = index de la méthode recherchée.                      *
+*                                                                             *
+*  Description : Extrait une représentation de méthode d'une table DEX.       *
+*                                                                             *
+*  Retour      : Composant GLib créé.                                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexMethod *g_dex_pool_get_method(GDexPool *pool, uint32_t index)
+{
+    GDexMethod *result;                     /* Instance à retourner        */
+    method_id_item method_id;               /* Définition de la méthode    */
+
+    result = NULL;
+
+    if (pool->methods[index] == NULL)
+    {
+        if (!g_dex_pool_get_raw_method(pool, index, &method_id))
+            goto no_method_id;
+
+        pool->methods[index] = g_dex_method_new_callable(pool->format, &method_id);
 
     }
 
@@ -1016,7 +1143,7 @@ GDexMethod *g_dex_pool_get_method(GDexPool *pool, uint32_t index)
     if (result != NULL)
         g_object_ref(G_OBJECT(result));
 
- gmfdp_error:
+ no_method_id:
 
     return result;
 
@@ -1116,44 +1243,72 @@ uint32_t g_dex_pool_count_classes(const GDexPool *pool)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
-*                index = index de la classe recherchée.                       *
+*  Paramètres  : pool      = table de resources pour format Dex à consulter.  *
+*                index     = index du type recherché.                         *
+*                class_def = élément ciblé à constituer. [OUT]                *
 *                                                                             *
-*  Description : Extrait une représentation de classe d'une table DEX.        *
+*  Description : Reconstitue les éléments bruts d'une classe Dex.             *
 *                                                                             *
-*  Retour      : Composant GLib créé.                                         *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GDexClass *g_dex_pool_get_class(GDexPool *pool, uint32_t index)
+bool g_dex_pool_get_raw_class(GDexPool *pool, uint32_t index, class_def_item *class_def)
 {
-    GDexClass *result;                      /* Instance à retourner        */
+    bool result;                            /* Bilan à retourner           */
     uint32_t count;                         /* Nombre d'éléments présents  */
     GDexFormat *format;                     /* Format associé à la table   */
     phys_t pos;                             /* Tête de lecture             */
     vmpa2t addr;                            /* Tête de lecture générique   */
-    class_def_item class_def;               /* Définition de la classe     */
 
-    result = NULL;
+    result = false;
 
     count = g_dex_pool_count_classes(pool);
 
-    if (index >= count)
-        goto gcfdp_error;
-
-    if (pool->classes[index] == NULL)
+    if (index < count)
     {
         format = pool->format;
 
         pos = format->header.class_defs_off + index * sizeof(class_def_item);
         init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
 
-        if (!read_dex_class_def_item(format, &addr, &class_def))
-            goto gcfdp_error;
+        result = read_dex_class_def_item(format, &addr, class_def);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : pool  = table de resources pour format Dex à consulter.      *
+*                index = index de la classe recherchée.                       *
+*                                                                             *
+*  Description : Extrait une représentation de classe d'une table DEX.        *
+*                                                                             *
+*  Retour      : Composant GLib créé.                                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexClass *g_dex_pool_get_class(GDexPool *pool, uint32_t index)
+{
+    GDexClass *result;                      /* Instance à retourner        */
+    class_def_item class_def;               /* Définition de la classe     */
+
+    result = NULL;
+
+    if (pool->classes[index] == NULL)
+    {
+        if (!g_dex_pool_get_raw_class(pool, index, &class_def))
+            goto no_class_def;
 
-        pool->classes[index] = g_dex_class_new(format, &class_def);
+        pool->classes[index] = g_dex_class_new(pool->format, &class_def);
 
     }
 
@@ -1162,7 +1317,7 @@ GDexClass *g_dex_pool_get_class(GDexPool *pool, uint32_t index)
     if (result != NULL)
         g_object_ref(G_OBJECT(result));
 
- gcfdp_error:
+ no_class_def:
 
     return result;
 
diff --git a/plugins/dex/pool.h b/plugins/dex/pool.h
index 26c11d6..c8f9b01 100644
--- a/plugins/dex/pool.h
+++ b/plugins/dex/pool.h
@@ -74,6 +74,9 @@ bool g_dex_pool_load_all_types(GDexPool *, wgroup_id_t, GtkStatusStack *);
 /* Compte le nombre de types dans une table DEX. */
 uint32_t g_dex_pool_count_types(const GDexPool *);
 
+/* Reconstitue les éléments bruts d'un type Dex. */
+bool g_dex_pool_get_raw_type(GDexPool *, uint32_t, type_id_item *);
+
 /* Extrait une représentation de type d'une table DEX. */
 GDataType *g_dex_pool_get_type_(GDexPool *, uint32_t);
 
@@ -83,12 +86,18 @@ bool g_dex_pool_load_all_fields(GDexPool *, wgroup_id_t, GtkStatusStack *);
 /* Compte le nombre de champs dans une table DEX. */
 uint32_t g_dex_pool_count_fields(const GDexPool *);
 
+/* Reconstitue les éléments bruts d'un champ Dex. */
+bool g_dex_pool_get_raw_field(GDexPool *, uint32_t, field_id_item *);
+
 /* Extrait une représentation de champ d'une table DEX. */
 GBinVariable *g_dex_pool_get_field(GDexPool *, uint32_t);
 
 /* Compte le nombre de prototypes dans une table DEX. */
 uint32_t g_dex_pool_count_prototypes(const GDexPool *);
 
+/* Reconstitue les éléments bruts d'une routine Dex. */
+bool g_dex_pool_get_raw_prototype(GDexPool *, uint32_t, proto_id_item *);
+
 /* Extrait une représentation de routine d'une table DEX. */
 GBinRoutine *g_dex_pool_get_prototype(GDexPool *, uint32_t);
 
@@ -98,6 +107,9 @@ bool g_dex_pool_load_all_methods(GDexPool *, wgroup_id_t, GtkStatusStack *);
 /* Compte le nombre de méthodes dans une table DEX. */
 uint32_t g_dex_pool_count_methods(const GDexPool *);
 
+/* Reconstitue les éléments bruts d'une méthode Dex. */
+bool g_dex_pool_get_raw_method(GDexPool *, uint32_t, method_id_item *);
+
 /* Extrait une représentation de méthode d'une table DEX. */
 GDexMethod *g_dex_pool_get_method(GDexPool *, uint32_t);
 
@@ -107,6 +119,9 @@ bool g_dex_pool_load_all_classes(GDexPool *, wgroup_id_t, GtkStatusStack *);
 /* Dénombre le nombre de classes trouvées. */
 uint32_t g_dex_pool_count_classes(const GDexPool *);
 
+/* Reconstitue les éléments bruts d'une classe Dex. */
+bool g_dex_pool_get_raw_class(GDexPool *, uint32_t, class_def_item *);
+
 /* Extrait une représentation de classe d'une table DEX. */
 GDexClass *g_dex_pool_get_class(GDexPool *, uint32_t);
 
diff --git a/plugins/dex/python/format.c b/plugins/dex/python/format.c
index 77ebef6..9bbbfbd 100644
--- a/plugins/dex/python/format.c
+++ b/plugins/dex/python/format.c
@@ -37,7 +37,9 @@
 
 
 #include "constants.h"
+#include "translate.h"
 #include "../class.h"
+#include "../dex-int.h"
 #include "../format.h"
 
 
@@ -98,6 +100,78 @@ static PyObject *py_dex_format_new(PyTypeObject *type, PyObject *args, PyObject
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : self = objet représentant un format de fichier Dex.          *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Procède à la lecture d'une liste de types DEX.               *
+*                                                                             *
+*  Retour      : Instance mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_format_read_type_list(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int offset;                    /* Position de l'élément visé  */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexFormat *format;                     /* Format de fichier Dex       */
+    vmpa2t addr;                            /* Tête de lecture générique   */
+    type_list list;                         /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+    uint32_t i;                             /* Boucle de parcours          */
+
+#define DEX_POOL_READ_TYPE_LIST_METHOD PYTHON_METHOD_DEF                                        \
+(                                                                                               \
+    "read_type_list", "$self, offset, /",                                                       \
+    METH_VARARGS, py_dex_format_read_type_list,                                                 \
+    "Provide the raw data of a given type list as an array of pychrysalide.PyStructObject"      \
+    " instances."                                                                               \
+    "\n"                                                                                        \
+    "All the items are fields extracted from the Dex *type_list* structure:\n"                  \
+    "* type_idx: index into the *type_ids* list.\n"                                             \
+    "\n"                                                                                        \
+    "In case of error, the function returns None."                                              \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &offset);
+    if (!ret) return NULL;
+
+    format = G_DEX_FORMAT(pygobject_get(self));
+
+    init_vmpa(&addr, offset, VMPA_NO_VIRTUAL);
+
+    status = read_dex_type_list(format, &addr, &list);
+
+    if (status)
+    {
+        result = PyTuple_New(list.size);
+
+        for (i = 0; i < list.size; i++)
+        {
+#ifndef NDEBUG
+            ret = PyTuple_SetItem(result, i, translate_dex_type_item_to_python(&list.list[i]));
+            assert(ret == 0);
+#else
+            PyTuple_SetItem(result, i, translate_dex_type_item_to_python(&list.list[i]));
+#endif
+        }
+
+    }
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
@@ -149,6 +223,7 @@ static PyObject *py_dex_format_get_pool(PyObject *self, void *closure)
 PyTypeObject *get_python_dex_format_type(void)
 {
     static PyMethodDef py_dex_format_methods[] = {
+        DEX_POOL_READ_TYPE_LIST_METHOD,
         { NULL }
     };
 
diff --git a/plugins/dex/python/method.c b/plugins/dex/python/method.c
index 5a06403..1bffbff 100644
--- a/plugins/dex/python/method.c
+++ b/plugins/dex/python/method.c
@@ -36,6 +36,9 @@
 
 
 
+/* Fournit les identifiants Dex concernant la méthode. */
+static PyObject *py_dex_method_get_id_item(PyObject *, void *);
+
 /* Fournit les indications Dex concernant la méthode. */
 static PyObject *py_dex_method_get_encoded(PyObject *, void *);
 
@@ -52,6 +55,47 @@ static PyObject *py_dex_method_get_routine(PyObject *, void *);
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
+*  Description : Fournit les identifiants Dex concernant la méthode.          *
+*                                                                             *
+*  Retour      : Données brutes issues du binaire chargé.                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_method_get_id_item(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GDexMethod *method;                     /* Version native              */
+    const method_id_item *id_item;          /* Elément à traiter           */
+
+#define DEX_METHOD_ID_ITEM_ATTRIB PYTHON_GET_DEF_FULL                                   \
+(                                                                                       \
+    id_item, py_dex_method,                                                             \
+    "pychrysalide.PyStructObject instance of identifiers used by the method.\n"         \
+    "\n"                                                                                \
+    "All the fields are extracted from the Dex *method_id_item* structure:\n"           \
+    "* class_idx: index into the *type_ids* list for the definer of the method ;\n"     \
+    "* proto_idx: index into the *proto_ids* list for the prototype of the method ;\n"  \
+    "* name_idx: index  into the *string_ids* list for the name of the method."         \
+)
+
+    method = G_DEX_METHOD(pygobject_get(self));
+
+    id_item = g_dex_method_get_dex_id_item(method);
+
+    result = translate_dex_method_id_to_python(id_item);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
 *  Description : Fournit les indications Dex concernant la méthode.           *
 *                                                                             *
 *  Retour      : Données brutes issues du binaire chargé.                     *
@@ -165,6 +209,7 @@ PyTypeObject *get_python_dex_method_type(void)
     };
 
     static PyGetSetDef py_dex_method_getseters[] = {
+        DEX_METHOD_ID_ITEM_ATTRIB,
         {
             "encoded", py_dex_method_get_encoded, NULL,
             "Encoded information about the Dex method.", NULL
diff --git a/plugins/dex/python/pool.c b/plugins/dex/python/pool.c
index eae1e86..695e07f 100644
--- a/plugins/dex/python/pool.c
+++ b/plugins/dex/python/pool.c
@@ -36,6 +36,21 @@
 
 
 
+/* Reconstitue les éléments bruts d'un type Dex. */
+static PyObject *py_dex_pool_get_raw_type(PyObject *, PyObject *);
+
+/* Reconstitue les éléments bruts d'un champ Dex. */
+static PyObject *py_dex_pool_get_raw_field(PyObject *, PyObject *);
+
+/* Reconstitue les éléments bruts d'une routine Dex. */
+static PyObject *py_dex_pool_get_raw_prototype(PyObject *, PyObject *);
+
+/* Reconstitue les éléments bruts d'une méthode Dex. */
+static PyObject *py_dex_pool_get_raw_method(PyObject *, PyObject *);
+
+/* Reconstitue les éléments bruts d'une classe Dex. */
+static PyObject *py_dex_pool_get_raw_class(PyObject *, PyObject *);
+
 /* Fournit la liste de toutes les chaînes de la table globale. */
 static PyObject *py_dex_pool_get_strings(PyObject *, void *);
 
@@ -65,6 +80,316 @@ static PyObject *py_dex_pool_get_classes(PyObject *, void *);
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : self = objet représentant une table de ressources Dex.       *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'un type Dex.                *
+*                                                                             *
+*  Retour      : Instance mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_pool_get_raw_type(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int index;                     /* Indice de l'élément visé    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexPool *pool;                         /* Table de ressources Dex     */
+    type_id_item type_id;                 /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+
+#define DEX_POOL_GET_RAW_TYPE_METHOD PYTHON_METHOD_DEF                                          \
+(                                                                                               \
+    "get_raw_type", "$self, index, /",                                                          \
+    METH_VARARGS, py_dex_pool_get_raw_type,                                                     \
+    "Provide the raw data of a given type in the Dex pool as a pychrysalide.PyStructObject"     \
+    " instance."                                                                                \
+    "\n"                                                                                        \
+    "Indexes start at 0.\n"                                                                     \
+    "\n"                                                                                        \
+    "All the fields are extracted from the Dex *type_id_item* structure:\n"                     \
+    "* descriptor_idx: index into the string_ids list for the descriptor string.\n"             \
+    "\n"                                                                                        \
+    "In case of error, the function returns None."                                              \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &index);
+    if (!ret) return NULL;
+
+    pool = G_DEX_POOL(pygobject_get(self));
+
+    status = g_dex_pool_get_raw_type(pool, index, &type_id);
+
+    if (status)
+        result = translate_dex_type_id_to_python(&type_id);
+
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = objet représentant une table de ressources Dex.       *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'un champ Dex.               *
+*                                                                             *
+*  Retour      : Instance mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_pool_get_raw_field(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int index;                     /* Indice de l'élément visé    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexPool *pool;                         /* Table de ressources Dex     */
+    field_id_item field_id;                 /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+
+#define DEX_POOL_GET_RAW_FIELD_METHOD PYTHON_METHOD_DEF                                         \
+(                                                                                               \
+    "get_raw_field", "$self, index, /",                                                         \
+    METH_VARARGS, py_dex_pool_get_raw_field,                                                    \
+    "Provide the raw data of a given field in the Dex pool as a pychrysalide.PyStructObject"    \
+    " instance."                                                                                \
+    "\n"                                                                                        \
+    "Indexes start at 0.\n"                                                                     \
+    "\n"                                                                                        \
+    "All the fields are extracted from the Dex *field_id_item* structure:\n"                    \
+    "* class_idx: index into the type_ids list for the definer of the field ;\n"                \
+    "* type_idx: index into the type_ids list for the type of the field ;\n"                    \
+    "* name_idx: index into the string_ids list for the name of the field.\n"                   \
+    "\n"                                                                                        \
+    "In case of error, the function returns None."                                              \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &index);
+    if (!ret) return NULL;
+
+    pool = G_DEX_POOL(pygobject_get(self));
+
+    status = g_dex_pool_get_raw_field(pool, index, &field_id);
+
+    if (status)
+        result = translate_dex_field_id_to_python(&field_id);
+
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = objet représentant une table de ressources Dex.       *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'une routine Dex.            *
+*                                                                             *
+*  Retour      : Instance mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_pool_get_raw_prototype(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int index;                     /* Indice de l'élément visé    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexPool *pool;                         /* Table de ressources Dex     */
+    proto_id_item proto_id;                 /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+
+#define DEX_POOL_GET_RAW_PROTOTYPE_METHOD PYTHON_METHOD_DEF                                         \
+(                                                                                                   \
+    "get_raw_prototype", "$self, index, /",                                                         \
+    METH_VARARGS, py_dex_pool_get_raw_prototype,                                                    \
+    "Provide the raw data of a given prototype in the Dex pool as a pychrysalide.PyStructObject"    \
+    " instance."                                                                                    \
+    "\n"                                                                                            \
+    "Indexes start at 0.\n"                                                                         \
+    "\n"                                                                                            \
+    "All the fields are extracted from the Dex *proto_id_item* structure:\n"                        \
+    "* shorty_idx: index into the *string_ids* list for the short-form descriptor string ;\n"       \
+    "* return_type_idx: index into the *type_ids* list for the return type ;\n"                     \
+    "* parameters_off: offset from the start of the Dex file to the list of parameter types."       \
+    "\n"                                                                                            \
+    "In case of error, the function returns None."                                                  \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &index);
+    if (!ret) return NULL;
+
+    pool = G_DEX_POOL(pygobject_get(self));
+
+    status = g_dex_pool_get_raw_prototype(pool, index, &proto_id);
+
+    if (status)
+        result = translate_dex_proto_id_to_python(&proto_id);
+
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = objet représentant une table de ressources Dex.       *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'une méthode Dex.            *
+*                                                                             *
+*  Retour      : Instance mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_pool_get_raw_method(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int index;                     /* Indice de l'élément visé    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexPool *pool;                         /* Table de ressources Dex     */
+    method_id_item method_id;                 /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+
+#define DEX_POOL_GET_RAW_METHOD_METHOD PYTHON_METHOD_DEF                                        \
+(                                                                                               \
+    "get_raw_method", "$self, index, /",                                                        \
+    METH_VARARGS, py_dex_pool_get_raw_method,                                                   \
+    "Provide the raw data of a given method in the Dex pool as a pychrysalide.PyStructObject"   \
+    " instance."                                                                                \
+    "\n"                                                                                        \
+    "Indexes start at 0.\n"                                                                     \
+    "\n"                                                                                        \
+    "All the fields are extracted from the Dex *method_id_item* structure:\n"                   \
+    "* class_idx: index into the type_ids list for the definer of the method ;\n"               \
+    "* proto_idx: index into the proto_ids list for the prototype of the method ;\n"            \
+    "* name_idx: index into the string_ids list for the name of the method.\n"                  \
+    "\n"                                                                                        \
+    "In case of error, the function returns None."                                              \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &index);
+    if (!ret) return NULL;
+
+    pool = G_DEX_POOL(pygobject_get(self));
+
+    status = g_dex_pool_get_raw_method(pool, index, &method_id);
+
+    if (status)
+        result = translate_dex_method_id_to_python(&method_id);
+
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = objet représentant une table de ressources Dex.       *
+*                args = arguments fournis pour l'opération.                   *
+*                                                                             *
+*  Description : Reconstitue les éléments bruts d'une classe Dex.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_dex_pool_get_raw_class(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int index;                     /* Indice de l'élément visé    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GDexPool *pool;                         /* Table de ressources Dex     */
+    class_def_item class_def;               /* Elément à transmettre       */
+    bool status;                            /* Bilan de l'opération        */
+
+#define DEX_POOL_GET_RAW_CLASS_METHOD PYTHON_METHOD_DEF                                         \
+(                                                                                               \
+    "get_raw_class", "$self, index, /",                                                         \
+    METH_VARARGS, py_dex_pool_get_raw_class,                                                    \
+    "Provide the raw data of a given class in the Dex pool as a pychrysalide.PyStructObject"    \
+    " instance."                                                                                \
+    "\n"                                                                                        \
+    "Indexes start at 0.\n"                                                                     \
+    "\n"                                                                                        \
+    "All the fields are extracted from the Dex *class_def_item* structure:\n"                   \
+    "* class_idx: index into the type_ids list for this class ;\n"                              \
+    "* access_flags: access flags for the class (public, final, etc.) ;\n"                      \
+    "* superclass_idx: index into the type_ids list for the superclass, or the constant value"  \
+    " NO_INDEX if the class has no superclass ;\n"                                              \
+    "* interfaces_off: offset from the start of the file to the list of interfaces, or 0"       \
+    " if there are none ;\n"                                                                    \
+    "* source_file_idx: index into the string_ids list for the name of the file containing"     \
+    " the original source for (at least most of) this class, or the special value NO_INDEX to"  \
+    " represent a lack of this information ;\n"                                                 \
+    "* annotations_off: offset from the start of the file to the annotations structure, or 0"   \
+    " if there are no annotation ;\n"                                                           \
+    "* class_data_off: offset from the start of the file to the associated class data, or 0"    \
+    " if there is no class data ;\n"                                                            \
+    "* static_values_off: offset from the start of the file to the list of initial values"      \
+    " for static fields, or 0 if there are none.\n"                                             \
+    "\n"                                                                                        \
+    "In case of error, the function returns None."                                              \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &index);
+    if (!ret) return NULL;
+
+    pool = G_DEX_POOL(pygobject_get(self));
+
+    status = g_dex_pool_get_raw_class(pool, index, &class_def);
+
+    if (status)
+        result = translate_dex_class_definition_to_python(&class_def);
+
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
@@ -437,6 +762,11 @@ static PyObject *py_dex_pool_get_classes(PyObject *self, void *closure)
 PyTypeObject *get_python_dex_pool_type(void)
 {
     static PyMethodDef py_dex_pool_methods[] = {
+        DEX_POOL_GET_RAW_TYPE_METHOD,
+        DEX_POOL_GET_RAW_FIELD_METHOD,
+        DEX_POOL_GET_RAW_PROTOTYPE_METHOD,
+        DEX_POOL_GET_RAW_METHOD_METHOD,
+        DEX_POOL_GET_RAW_CLASS_METHOD,
         { NULL }
     };
 
diff --git a/plugins/dex/python/translate.c b/plugins/dex/python/translate.c
index eb80c43..3d73616 100644
--- a/plugins/dex/python/translate.c
+++ b/plugins/dex/python/translate.c
@@ -39,6 +39,152 @@
 *                                                                             *
 *  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
 *                                                                             *
+*  Description : Traduit des informations de type Dex en Python.              *
+*                                                                             *
+*  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *translate_dex_type_id_to_python(const type_id_item *info)
+{
+    PyObject *result;                       /* Construction à retourner    */
+    PyTypeObject *base;                     /* Modèle d'objet à créer      */
+    PyObject *attrib;                       /* Attribut à constituer       */
+    int ret;                                /* Bilan d'une mise en place   */
+
+    base = get_python_py_struct_type();
+
+    result = PyObject_CallFunction((PyObject *)base, NULL);
+    assert(result != NULL);
+
+    /* Champs réguliers */
+
+#define TRANSLATE_ENCODED_TYPE_PROP(_f)                     \
+    do                                                      \
+    {                                                       \
+        attrib = PyLong_FromUnsignedLongLong(info->_f);     \
+        ret = PyDict_SetItemString(result, #_f, attrib);    \
+        if (ret != 0) goto tdcdtp_failed;                   \
+    }                                                       \
+    while (0);
+
+    TRANSLATE_ENCODED_TYPE_PROP(descriptor_idx);
+
+    return result;
+
+ tdcdtp_failed:
+
+    Py_DECREF(result);
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
+*                                                                             *
+*  Description : Traduit des informations de type Dex en Python.              *
+*                                                                             *
+*  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *translate_dex_type_item_to_python(const type_item *info)
+{
+    PyObject *result;                       /* Construction à retourner    */
+    PyTypeObject *base;                     /* Modèle d'objet à créer      */
+    PyObject *attrib;                       /* Attribut à constituer       */
+    int ret;                                /* Bilan d'une mise en place   */
+
+    base = get_python_py_struct_type();
+
+    result = PyObject_CallFunction((PyObject *)base, NULL);
+    assert(result != NULL);
+
+    /* Champs réguliers */
+
+#define TRANSLATE_ENCODED_TYPE_PROP(_f)                     \
+    do                                                      \
+    {                                                       \
+        attrib = PyLong_FromUnsignedLongLong(info->_f);     \
+        ret = PyDict_SetItemString(result, #_f, attrib);    \
+        if (ret != 0) goto tdcdtp_failed;                   \
+    }                                                       \
+    while (0);
+
+    TRANSLATE_ENCODED_TYPE_PROP(type_idx);
+
+    return result;
+
+ tdcdtp_failed:
+
+    Py_DECREF(result);
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
+*                                                                             *
+*  Description : Traduit des informations de champ Dex en Python.             *
+*                                                                             *
+*  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *translate_dex_field_id_to_python(const field_id_item *info)
+{
+    PyObject *result;                       /* Construction à retourner    */
+    PyTypeObject *base;                     /* Modèle d'objet à créer      */
+    PyObject *attrib;                       /* Attribut à constituer       */
+    int ret;                                /* Bilan d'une mise en place   */
+
+    base = get_python_py_struct_type();
+
+    result = PyObject_CallFunction((PyObject *)base, NULL);
+    assert(result != NULL);
+
+    /* Champs réguliers */
+
+#define TRANSLATE_ENCODED_FIELD_PROP(_f)                    \
+    do                                                      \
+    {                                                       \
+        attrib = PyLong_FromUnsignedLongLong(info->_f);     \
+        ret = PyDict_SetItemString(result, #_f, attrib);    \
+        if (ret != 0) goto tdcdtp_failed;                   \
+    }                                                       \
+    while (0);
+
+    TRANSLATE_ENCODED_FIELD_PROP(class_idx);
+    TRANSLATE_ENCODED_FIELD_PROP(type_idx);
+    TRANSLATE_ENCODED_FIELD_PROP(name_idx);
+
+    return result;
+
+ tdcdtp_failed:
+
+    Py_DECREF(result);
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
+*                                                                             *
 *  Description : Traduit des informations de champ de classe Dex en Python.   *
 *                                                                             *
 *  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
@@ -88,6 +234,106 @@ PyObject *translate_dex_field_info_to_python(const encoded_field *info)
 *                                                                             *
 *  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
 *                                                                             *
+*  Description : Traduit des identifiants de prototype Dex en Python.         *
+*                                                                             *
+*  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *translate_dex_proto_id_to_python(const proto_id_item *info)
+{
+    PyObject *result;                       /* Construction à retourner    */
+    PyTypeObject *base;                     /* Modèle d'objet à créer      */
+    PyObject *attrib;                       /* Attribut à constituer       */
+    int ret;                                /* Bilan d'une mise en place   */
+
+    base = get_python_py_struct_type();
+
+    result = PyObject_CallFunction((PyObject *)base, NULL);
+    assert(result != NULL);
+
+    /* Champs réguliers */
+
+#define TRANSLATE_ID_PROTO_PROP(_f)                         \
+    do                                                      \
+    {                                                       \
+        attrib = PyLong_FromUnsignedLongLong(info->_f);     \
+        ret = PyDict_SetItemString(result, #_f, attrib);    \
+        if (ret != 0) goto failed;                          \
+    }                                                       \
+    while (0);
+
+    TRANSLATE_ID_PROTO_PROP(shorty_idx);
+    TRANSLATE_ID_PROTO_PROP(return_type_idx);
+    TRANSLATE_ID_PROTO_PROP(parameters_off);
+
+    return result;
+
+ failed:
+
+    Py_DECREF(result);
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
+*                                                                             *
+*  Description : Traduit des identifiants de méthode Dex en Python.           *
+*                                                                             *
+*  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *translate_dex_method_id_to_python(const method_id_item *info)
+{
+    PyObject *result;                       /* Construction à retourner    */
+    PyTypeObject *base;                     /* Modèle d'objet à créer      */
+    PyObject *attrib;                       /* Attribut à constituer       */
+    int ret;                                /* Bilan d'une mise en place   */
+
+    base = get_python_py_struct_type();
+
+    result = PyObject_CallFunction((PyObject *)base, NULL);
+    assert(result != NULL);
+
+    /* Champs réguliers */
+
+#define TRANSLATE_ID_METHOD_PROP(_f)                        \
+    do                                                      \
+    {                                                       \
+        attrib = PyLong_FromUnsignedLongLong(info->_f);     \
+        ret = PyDict_SetItemString(result, #_f, attrib);    \
+        if (ret != 0) goto tdcdtp_failed;                   \
+    }                                                       \
+    while (0);
+
+    TRANSLATE_ID_METHOD_PROP(class_idx);
+    TRANSLATE_ID_METHOD_PROP(proto_idx);
+    TRANSLATE_ID_METHOD_PROP(name_idx);
+
+    return result;
+
+ tdcdtp_failed:
+
+    Py_DECREF(result);
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = ensemble d'informations Dex à décrire en Python.      *
+*                                                                             *
 *  Description : Traduit des informations de méthode Dex en Python.           *
 *                                                                             *
 *  Retour      : Structure mise en place ou NULL en cas d'erreur.             *
diff --git a/plugins/dex/python/translate.h b/plugins/dex/python/translate.h
index 29a0155..b360618 100644
--- a/plugins/dex/python/translate.h
+++ b/plugins/dex/python/translate.h
@@ -33,9 +33,24 @@
 
 
 
+/* Traduit des informations de type Dex en Python. */
+PyObject *translate_dex_type_id_to_python(const type_id_item *);
+
+/* Traduit des informations de type Dex en Python. */
+PyObject *translate_dex_type_item_to_python(const type_item *);
+
+/* Traduit des informations de champ Dex en Python. */
+PyObject *translate_dex_field_id_to_python(const field_id_item *);
+
 /* Traduit des informations de champ de classe Dex en Python. */
 PyObject *translate_dex_field_info_to_python(const encoded_field *);
 
+/* Traduit des identifiants de prototype Dex en Python. */
+PyObject *translate_dex_proto_id_to_python(const proto_id_item *);
+
+/* Traduit des identifiants de méthode Dex en Python. */
+PyObject *translate_dex_method_id_to_python(const method_id_item *);
+
 /* Traduit des informations de méthode Dex en Python. */
 PyObject *translate_dex_method_info_to_python(const encoded_method *);