Improved the way code is decoded by avoiding to propagate the base address everywhere.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@385 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

57 files changed, 1248 insertions, 772 deletions

diff --git a/src/arch/arm/instruction.c b/src/arch/arm/instruction.c
index 70517b3..77dd621 100644
--- a/src/arch/arm/instruction.c
+++ b/src/arch/arm/instruction.c
@@ -101,7 +101,7 @@ static void g_arm_instruction_init(GArmInstruction *instr)
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux.                       *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                                                                             *
 *  Description : Recherche l'identifiant de la prochaine instruction.         *
 *                                                                             *
@@ -111,7 +111,7 @@ static void g_arm_instruction_init(GArmInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-ArmOpcodes arm_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+ArmOpcodes arm_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
 {
     ArmOpcodes result;                   /* Identifiant à retourner     */
 
diff --git a/src/arch/arm/processor.c b/src/arch/arm/processor.c
index 44dcb19..4bd342f 100644
--- a/src/arch/arm/processor.c
+++ b/src/arch/arm/processor.c
@@ -52,6 +52,12 @@ static void g_arm_processor_class_init(GArmProcessorClass *);
 /* Initialise une instance de processeur ARM. */
 static void g_arm_processor_init(GArmProcessor *);
 
+/* Supprime toutes les références externes. */
+static void g_arm_processor_dispose(GArmProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_arm_processor_finalize(GArmProcessor *);
+
 /* Décode une instruction dans un flux de données. */
 static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *, GProcContext *, const bin_t *, off_t *, off_t, vmpa_t, GBinFormat *);
 
@@ -75,6 +81,17 @@ G_DEFINE_TYPE(GArmProcessor, g_arm_processor, G_TYPE_ARCH_PROCESSOR);
 
 static void g_arm_processor_class_init(GArmProcessorClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchProcessorClass *proc;              /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_arm_processor_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_arm_processor_finalize;
+
+    proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+    proc->decode = (decode_instruction_fc)g_arm_processor_decode_instruction;
 
 }
 
@@ -101,7 +118,43 @@ static void g_arm_processor_init(GArmProcessor *proc)
     parent->memsize = MDS_32_BITS;
     parent->inssize = MDS_32_BITS;
 
-    parent->decode = (decode_instruction_fc)g_arm_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arm_processor_dispose(GArmProcessor *proc)
+{
+    G_OBJECT_CLASS(g_arm_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bookmark = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arm_processor_finalize(GArmProcessor *proc)
+{
+    G_OBJECT_CLASS(g_arm_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }
 
@@ -131,11 +184,11 @@ GArchProcessor *g_arm_processor_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : proc   = architecture visée par la procédure.                  *
-*                ctx    = contexte lié à l'exécution du processeur.             *
+*  Paramètres  : proc   = architecture visée par la procédure.                *
+*                ctx    = contexte lié à l'exécution du processeur.           *
 *                data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                format = format du fichier contenant le code.                *
 *                                                                             *
@@ -149,7 +202,7 @@ GArchProcessor *g_arm_processor_new(void)
 #include "encoding.h"
 extern GArchInstruction *try_to_decode_arm_v456_instr(bin_t *);
 
-static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t len, vmpa_t addr, GBinFormat *format)
+static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GBinFormat *format)
 {
     GArchInstruction *result;               /* Instruction à renvoyer      */
 
diff --git a/src/arch/arm/v456/instruction.c b/src/arch/arm/v456/instruction.c
index 0ab85c0..3ba3c54 100644
--- a/src/arch/arm/v456/instruction.c
+++ b/src/arch/arm/v456/instruction.c
@@ -509,7 +509,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux.                       *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                                                                             *
 *  Description : Recherche l'identifiant de la prochaine instruction.         *
 *                                                                             *
@@ -519,7 +519,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 *                                                                             *
 ******************************************************************************/
 
-DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
 {
     DalvikOpcodes result;                   /* Identifiant à retourner     */
 
diff --git a/src/arch/artificial.c b/src/arch/artificial.c
index 2a78255..6fbd6d9 100644
--- a/src/arch/artificial.c
+++ b/src/arch/artificial.c
@@ -124,7 +124,7 @@ static void g_db_instruction_init(GDbInstruction *instr)
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse, virtuelle ou physique, de l'instruction.     *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
@@ -136,7 +136,7 @@ static void g_db_instruction_init(GDbInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GArchProcessor *proc)
+GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GArchProcessor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     GArchOperand *operand;                  /* Octet non décodé à afficher */
@@ -144,7 +144,7 @@ GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos,
     result = g_object_new(G_TYPE_DB_INSTRUCTION, NULL);
 
     operand = g_imm_operand_new_from_data(g_arch_processor_get_instruction_size(proc),
-                                          data, pos, len,
+                                          data, pos, end,
                                           g_arch_processor_get_endianness(proc));
     if (operand == NULL) goto gdinfd_error;
 
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index b8d0979..83e0e6c 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -489,7 +489,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux.                       *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                                                                             *
 *  Description : Recherche l'identifiant de la prochaine instruction.         *
 *                                                                             *
@@ -499,7 +499,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 *                                                                             *
 ******************************************************************************/
 
-DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
 {
     DalvikOpcodes result;                   /* Identifiant à retourner     */
 
diff --git a/src/arch/dalvik/opcodes/add.c b/src/arch/dalvik/opcodes/add.c
index 9b34677..4d93df9 100644
--- a/src/arch/dalvik/opcodes/add.c
+++ b/src/arch/dalvik/opcodes/add.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/aget.c b/src/arch/dalvik/opcodes/aget.c
index a1a3211..e5033aa 100644
--- a/src/arch/dalvik/opcodes/aget.c
+++ b/src/arch/dalvik/opcodes/aget.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/and.c b/src/arch/dalvik/opcodes/and.c
index f8b96b0..d5162bf 100644
--- a/src/arch/dalvik/opcodes/and.c
+++ b/src/arch/dalvik/opcodes/and.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/aput.c b/src/arch/dalvik/opcodes/aput.c
index 126f480..6cdde65 100644
--- a/src/arch/dalvik/opcodes/aput.c
+++ b/src/arch/dalvik/opcodes/aput.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/array.c b/src/arch/dalvik/opcodes/array.c
index f40d6b8..efa40b7 100644
--- a/src/arch/dalvik/opcodes/array.c
+++ b/src/arch/dalvik/opcodes/array.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -109,7 +109,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -122,7 +122,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -131,7 +131,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -146,7 +146,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -159,7 +159,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -168,7 +168,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/check.c b/src/arch/dalvik/opcodes/check.c
index dc32e30..725f336 100644
--- a/src/arch/dalvik/opcodes/check.c
+++ b/src/arch/dalvik/opcodes/check.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/cmp.c b/src/arch/dalvik/opcodes/cmp.c
index c7b4b83..e6de13c 100644
--- a/src/arch/dalvik/opcodes/cmp.c
+++ b/src/arch/dalvik/opcodes/cmp.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/const.c b/src/arch/dalvik/opcodes/const.c
index af5f504..5097804 100644
--- a/src/arch/dalvik/opcodes/const.c
+++ b/src/arch/dalvik/opcodes/const.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31I))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11N))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11N))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21H))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_STRING)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_STRING)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31C | DALVIK_OP_POOL(DPT_STRING)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31C | DALVIK_OP_POOL(DPT_STRING)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_51L))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_51L))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31I))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21H))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/div.c b/src/arch/dalvik/opcodes/div.c
index af047f8..a20968b 100644
--- a/src/arch/dalvik/opcodes/div.c
+++ b/src/arch/dalvik/opcodes/div.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/goto.c b/src/arch/dalvik/opcodes/goto.c
index 739155b..f74774a 100644
--- a/src/arch/dalvik/opcodes/goto.c
+++ b/src/arch/dalvik/opcodes/goto.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_20T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_20T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_30T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_30T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/if.c b/src/arch/dalvik/opcodes/if.c
index 3e6f319..ad8b49a 100644
--- a/src/arch/dalvik/opcodes/if.c
+++ b/src/arch/dalvik/opcodes/if.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -292,7 +292,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -305,7 +305,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -314,7 +314,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -329,7 +329,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -342,7 +342,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -351,7 +351,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -366,7 +366,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -379,7 +379,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -388,7 +388,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -403,7 +403,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -416,7 +416,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -425,7 +425,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -440,7 +440,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -453,7 +453,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/iget.c b/src/arch/dalvik/opcodes/iget.c
index 8fca24f..f83bb96 100644
--- a/src/arch/dalvik/opcodes/iget.c
+++ b/src/arch/dalvik/opcodes/iget.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/instanceof.c b/src/arch/dalvik/opcodes/instanceof.c
index 2054ca5..d65c6bd 100644
--- a/src/arch/dalvik/opcodes/instanceof.c
+++ b/src/arch/dalvik/opcodes/instanceof.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/invoke.c b/src/arch/dalvik/opcodes/invoke.c
index 1f38d18..9133e79 100644
--- a/src/arch/dalvik/opcodes/invoke.c
+++ b/src/arch/dalvik/opcodes/invoke.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -292,7 +292,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -305,7 +305,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -314,7 +314,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -329,7 +329,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -342,7 +342,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -351,7 +351,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -366,7 +366,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -379,7 +379,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -388,7 +388,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/iput.c b/src/arch/dalvik/opcodes/iput.c
index ff99bae..434eec7 100644
--- a/src/arch/dalvik/opcodes/iput.c
+++ b/src/arch/dalvik/opcodes/iput.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/monitor.c b/src/arch/dalvik/opcodes/monitor.c
index 6f4bd34..866e984 100644
--- a/src/arch/dalvik/opcodes/monitor.c
+++ b/src/arch/dalvik/opcodes/monitor.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/move.c b/src/arch/dalvik/opcodes/move.c
index 0cb49f8..ba2d89b 100644
--- a/src/arch/dalvik/opcodes/move.c
+++ b/src/arch/dalvik/opcodes/move.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -475,7 +475,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -484,7 +484,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -501,7 +501,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -514,7 +514,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -523,7 +523,7 @@ GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/mul.c b/src/arch/dalvik/opcodes/mul.c
index 443df5e..67a343b 100644
--- a/src/arch/dalvik/opcodes/mul.c
+++ b/src/arch/dalvik/opcodes/mul.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/neg.c b/src/arch/dalvik/opcodes/neg.c
index 6b41259..5f9a985 100644
--- a/src/arch/dalvik/opcodes/neg.c
+++ b/src/arch/dalvik/opcodes/neg.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/new.c b/src/arch/dalvik/opcodes/new.c
index 8f632f6..3320540 100644
--- a/src/arch/dalvik/opcodes/new.c
+++ b/src/arch/dalvik/opcodes/new.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/nop.c b/src/arch/dalvik/opcodes/nop.c
index 38dd193..b90c350 100644
--- a/src/arch/dalvik/opcodes/nop.c
+++ b/src/arch/dalvik/opcodes/nop.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t len
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/not.c b/src/arch/dalvik/opcodes/not.c
index 91f69cf..41ae2d4 100644
--- a/src/arch/dalvik/opcodes/not.c
+++ b/src/arch/dalvik/opcodes/not.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/or.c b/src/arch/dalvik/opcodes/or.c
index 57d3119..8904f48 100644
--- a/src/arch/dalvik/opcodes/or.c
+++ b/src/arch/dalvik/opcodes/or.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/rem.c b/src/arch/dalvik/opcodes/rem.c
index 54537f8..0ba12de 100644
--- a/src/arch/dalvik/opcodes/rem.c
+++ b/src/arch/dalvik/opcodes/rem.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/ret.c b/src/arch/dalvik/opcodes/ret.c
index 0fc27a2..7e53ada 100644
--- a/src/arch/dalvik/opcodes/ret.c
+++ b/src/arch/dalvik/opcodes/ret.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/rsub.c b/src/arch/dalvik/opcodes/rsub.c
index 73010a2..9ee9331 100644
--- a/src/arch/dalvik/opcodes/rsub.c
+++ b/src/arch/dalvik/opcodes/rsub.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/sget.c b/src/arch/dalvik/opcodes/sget.c
index d95f44f..bc1aca0 100644
--- a/src/arch/dalvik/opcodes/sget.c
+++ b/src/arch/dalvik/opcodes/sget.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/shl.c b/src/arch/dalvik/opcodes/shl.c
index 8c3e220..3ee88b8 100644
--- a/src/arch/dalvik/opcodes/shl.c
+++ b/src/arch/dalvik/opcodes/shl.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/shr.c b/src/arch/dalvik/opcodes/shr.c
index f29a9d4..1656164 100644
--- a/src/arch/dalvik/opcodes/shr.c
+++ b/src/arch/dalvik/opcodes/shr.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/sput.c b/src/arch/dalvik/opcodes/sput.c
index c281ea5..281df25 100644
--- a/src/arch/dalvik/opcodes/sput.c
+++ b/src/arch/dalvik/opcodes/sput.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/sub.c b/src/arch/dalvik/opcodes/sub.c
index 2f2a6c8..98af25e 100644
--- a/src/arch/dalvik/opcodes/sub.c
+++ b/src/arch/dalvik/opcodes/sub.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/switch.c b/src/arch/dalvik/opcodes/switch.c
index 905ce74..8b3c7a6 100644
--- a/src/arch/dalvik/opcodes/switch.c
+++ b/src/arch/dalvik/opcodes/switch.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/throw.c b/src/arch/dalvik/opcodes/throw.c
index 196f986..18602bc 100644
--- a/src/arch/dalvik/opcodes/throw.c
+++ b/src/arch/dalvik/opcodes/throw.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t l
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/to.c b/src/arch/dalvik/opcodes/to.c
index be0c8c9..a8d3962 100644
--- a/src/arch/dalvik/opcodes/to.c
+++ b/src/arch/dalvik/opcodes/to.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -475,7 +475,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -484,7 +484,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -501,7 +501,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -514,7 +514,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -523,7 +523,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -540,7 +540,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -553,7 +553,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -562,7 +562,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -579,7 +579,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -592,7 +592,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -601,7 +601,7 @@ GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, o
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/ushr.c b/src/arch/dalvik/opcodes/ushr.c
index 4b2fe80..ed377de 100644
--- a/src/arch/dalvik/opcodes/ushr.c
+++ b/src/arch/dalvik/opcodes/ushr.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *po
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/opcodes/xor.c b/src/arch/dalvik/opcodes/xor.c
index 48dcf99..bf41560 100644
--- a/src/arch/dalvik/opcodes/xor.c
+++ b/src/arch/dalvik/opcodes/xor.c
@@ -33,7 +33,7 @@
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -46,7 +46,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     SourceEndian endian;                    /* Boutisme lié au binaire     */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos
 
     endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
 
-    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
     {
         g_object_unref(G_OBJECT(result));
         return NULL;
diff --git a/src/arch/dalvik/operand.c b/src/arch/dalvik/operand.c
index a2d04b0..ee033e7 100644
--- a/src/arch/dalvik/operand.c
+++ b/src/arch/dalvik/operand.c
@@ -72,7 +72,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *, const GDexFormat *
 *                format = format du fichier contenant le code.                *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                low    = position éventuelle des 4 bits visés. [OUT]         *
 *                endian = boutisme lié au binaire accompagnant.               *
 *                model  = type d'opérandes attendues.                         *
@@ -86,7 +86,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *, const GDexFormat *
 *                                                                             *
 ******************************************************************************/
 
-static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model, va_list ap)
+static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model, va_list ap)
 {
     bool result;                            /* Bilan à retourner           */
     DalvikOperandID *types;                 /* Liste des chargements       */
@@ -281,64 +281,66 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
 
     for (iter = types; *iter != G_TYPE_INVALID && result; iter++)
     {
+        op = NULL;  /* Nul de GCC */
+
         switch (*iter)
         {
             case DOI_REGISTER_4:
-                op = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+                op = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
                 break;
 
             case DOI_REGISTER_8:
-                op = g_dalvik_register_operand_new(data, pos, len, NULL, MDS_8_BITS, endian);
+                op = g_dalvik_register_operand_new(data, pos, end, NULL, MDS_8_BITS, endian);
                 break;
 
             case DOI_REGISTER_16:
-                op = g_dalvik_register_operand_new(data, pos, len, NULL, MDS_16_BITS, endian);
+                op = g_dalvik_register_operand_new(data, pos, end, NULL, MDS_16_BITS, endian);
                 break;
 
             case DOI_IMMEDIATE_4:
-                op = _g_imm_operand_new_from_data(MDS_4_BITS, data, pos, len, low, endian);
+                op = _g_imm_operand_new_from_data(MDS_4_BITS, data, pos, end, low, endian);
                 break;
 
             case DOI_IMMEDIATE_8:
-                op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, len, endian);
+                op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, end, endian);
                 break;
 
             case DOI_IMMEDIATE_16:
-                op = g_imm_operand_new_from_data(MDS_16_BITS, data, pos, len, endian);
+                op = g_imm_operand_new_from_data(MDS_16_BITS, data, pos, end, endian);
                 break;
 
             case DOI_IMMEDIATE_32:
-                op = g_imm_operand_new_from_data(MDS_32_BITS, data, pos, len, endian);
+                op = g_imm_operand_new_from_data(MDS_32_BITS, data, pos, end, endian);
                 break;
 
             case DOI_IMMEDIATE_64:
-                op = g_imm_operand_new_from_data(MDS_64_BITS, data, pos, len, endian);
+                op = g_imm_operand_new_from_data(MDS_64_BITS, data, pos, end, endian);
                 break;
 
             case DOI_IMMEDIATE_H16:
-                result = read_u16(&value16, data, pos, len, endian);
+                result = read_u16(&value16, data, pos, end, endian);
                 if (result)
                     op = g_imm_operand_new_from_value(MDS_32_BITS_SIGNED, ((uint32_t)value16) << 16);
                 break;
 
             case DOI_POOL_CONST:
-                op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+                op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
                 break;
 
             case DOI_POOL_CONST_WIDE:
-                op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_32_BITS, endian);
+                op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_32_BITS, endian);
                 break;
 
             case DOI_TARGET_8:
-                op = g_dalvik_target_operand_new(data, pos, len, MDS_8_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+                op = g_dalvik_target_operand_new(data, pos, end, MDS_8_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
                 break;
 
             case DOI_TARGET_16:
-                op = g_dalvik_target_operand_new(data, pos, len, MDS_16_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+                op = g_dalvik_target_operand_new(data, pos, end, MDS_16_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
                 break;
 
             case DOI_TARGET_32:
-                op = g_dalvik_target_operand_new(data, pos, len, MDS_32_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+                op = g_dalvik_target_operand_new(data, pos, end, MDS_32_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
                 break;
 
             default:
@@ -363,7 +365,7 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
 *                format = format du fichier contenant le code.                *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                low    = position éventuelle des 4 bits visés. [OUT]         *
 *                endian = boutisme lié au binaire accompagnant.               *
 *                model  = type d'opérandes attendues.                         *
@@ -376,7 +378,7 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
 *                                                                             *
 ******************************************************************************/
 
-static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model)
+static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model)
 {
     GArchOperand *opa;                      /* Opérande vA décodé          */
     uint8_t b;                              /* Nbre. de registres utilisés */
@@ -388,13 +390,13 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
 
 
 
-    opa = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+    opa = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
 
-    if (!read_u4(&b, data, pos, len, low, endian))
+    if (!read_u4(&b, data, pos, end, low, endian))
         goto err_va;
 
 
-    target1 = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+    target1 = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
     if (target1 == NULL) goto err_target1;
 
 
@@ -416,7 +418,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
 
     for (i = 0; i < MIN(b, 4); i++)
     {
-        op = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+        op = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
         if (op == NULL) goto err_registers;
 
         g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op);
@@ -461,7 +463,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
 *                format = format du fichier contenant le code.                *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                low    = position éventuelle des 4 bits visés. [OUT]         *
 *                endian = boutisme lié au binaire accompagnant.               *
 *                model  = type d'opérandes attendues.                         *
@@ -474,7 +476,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
 *                                                                             *
 ******************************************************************************/
 
-static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model)
+static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model)
 {
     uint8_t a;                              /* Nbre. de registres utilisés */
     uint16_t b;                             /* Indice dans la table const. */
@@ -484,13 +486,13 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
     uint16_t c;                             /* Indice de registre          */
     GArchOperand *op;                       /* Opérande unique décodé      */
 
-    if (!read_u8(&a, data, pos, len, endian))
+    if (!read_u8(&a, data, pos, end, endian))
         return false;
 
-    if (!read_u16(&b, data, pos, len, endian))
+    if (!read_u16(&b, data, pos, end, endian))
         return false;
 
-    target = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+    target = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
     if (target == NULL) return false;
 
     /* Mise en place des arguments */
@@ -500,7 +502,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
 
     for (i = 0; i < a; i++)
     {
-        if (i == 0 && !read_u16(&c, data, pos, len, endian))
+        if (i == 0 && !read_u16(&c, data, pos, end, endian))
                 goto drvo_registers;
 
         op = g_dalvik_register_operand_new_from_existing(g_dalvik_register_new(c + i));
@@ -542,7 +544,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
 *                format = format du fichier contenant le code.                *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                endian = boutisme lié au binaire accompagnant.               *
 *                model  = type d'opérandes attendues.                         *
 *                ...    = éventuelles données complémentaires.                *
@@ -555,7 +557,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
 *                                                                             *
 ******************************************************************************/
 
-bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, SourceEndian endian, DalvikOperandType model, ...)
+bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, SourceEndian endian, DalvikOperandType model, ...)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -602,18 +604,18 @@ bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, con
         case DALVIK_OPT_32X:
         case DALVIK_OPT_51L:
             va_start(ap, model);
-            result = dalvik_read_basic_operands(instr, format, data, pos, len, &low, endian, model, ap);
+            result = dalvik_read_basic_operands(instr, format, data, pos, end, &low, endian, model, ap);
             va_end(ap);
             break;
 
         case DALVIK_OPT_35C:
-            result = dalvik_read_fixed_operands(instr, format, data, pos, len, &low, endian, model);
+            result = dalvik_read_fixed_operands(instr, format, data, pos, end, &low, endian, model);
             break;
 
         case DALVIK_OPT_3RC:
         case DALVIK_OPT_3RMS:
         case DALVIK_OPT_3RFS:
-            result = dalvik_read_variatic_operands(instr, format, data, pos, len, &low, endian, model);
+            result = dalvik_read_variatic_operands(instr, format, data, pos, end, &low, endian, model);
             break;
 
         default:
@@ -627,7 +629,7 @@ bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, con
 
 
 
-    if (*pos < len)
+    if (*pos < end)
     {
         (*pos)++;
 
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index 1e69a18..2c1f653 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -118,7 +118,7 @@ static void g_dalvik_pool_operand_init(GDalvikPoolOperand *operand)
 *                type   = type de table visée avec la référence.              *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                size   = taille de l'opérande, et donc du registre.          *
 *                endian = ordre des bits dans la source.                      *
 *                                                                             *
@@ -130,7 +130,7 @@ static void g_dalvik_pool_operand_init(GDalvikPoolOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType type, const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, SourceEndian endian)
+GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType type, const bin_t *data, off_t *pos, off_t end, MemoryDataSize size, SourceEndian endian)
 {
     GDalvikPoolOperand *result;             /* Structure à retourner       */
     uint8_t index8;                         /* Indice sur 8 bits           */
@@ -140,10 +140,10 @@ GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType
     switch (size)
     {
         case MDS_8_BITS:
-            test = read_u8(&index8, data, pos, len, endian);
+            test = read_u8(&index8, data, pos, end, endian);
             break;
         case MDS_16_BITS:
-            test = read_u16(&index16, data, pos, len, endian);
+            test = read_u16(&index16, data, pos, end, endian);
             break;
         default:
             test = false;
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index 45e965c..00d5699 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -113,7 +113,7 @@ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *operand)
 *                                                                             *
 *  Paramètres  : data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                low    = position éventuelle des 4 bits visés. [OUT]         *
 *                size   = taille de l'opérande, et donc du registre.          *
 *                endian = ordre des bits dans la source.                      *
@@ -126,7 +126,7 @@ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t len, bool *low, MemoryDataSize size, SourceEndian endian)
+GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t end, bool *low, MemoryDataSize size, SourceEndian endian)
 {
     GDalvikRegisterOperand *result;         /* Structure à retourner       */
     uint8_t index8;                         /* Indice sur 8 bits           */
@@ -136,13 +136,13 @@ GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t
     switch (size)
     {
         case MDS_4_BITS:
-            test = read_u4(&index8, data, pos, len, low, endian);
+            test = read_u4(&index8, data, pos, end, low, endian);
             break;
         case MDS_8_BITS:
-            test = read_u8(&index8, data, pos, len, endian);
+            test = read_u8(&index8, data, pos, end, endian);
             break;
         case MDS_16_BITS:
-            test = read_u16(&index16, data, pos, len, endian);
+            test = read_u16(&index16, data, pos, end, endian);
             break;
         default:
             test = false;
diff --git a/src/arch/dalvik/operands/target.c b/src/arch/dalvik/operands/target.c
index 6fe4df4..f53bb7b 100644
--- a/src/arch/dalvik/operands/target.c
+++ b/src/arch/dalvik/operands/target.c
@@ -106,7 +106,7 @@ static void g_dalvik_target_operand_init(GDalvikTargetOperand *operand)
 *                                                                             *
 *  Paramètres  : data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                size   = taille de l'opérande.                               *
 *                endian = ordre des bits dans la source.                      *
 *                base   = adresse de référence pour le calcul.                *
@@ -119,7 +119,7 @@ static void g_dalvik_target_operand_init(GDalvikTargetOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, SourceEndian endian, vmpa_t base)
+GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t end, MemoryDataSize size, SourceEndian endian, vmpa_t base)
 {
     GDalvikTargetOperand *result;           /* Structure à retourner       */
     int8_t val8;                            /* Valeur sur 8 bits           */
@@ -130,15 +130,15 @@ GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t l
     switch (size)
     {
         case MDS_8_BITS_SIGNED:
-            read_s8(&val8, data, pos, len, endian);
+            read_s8(&val8, data, pos, end, endian);
             address = base + val8 * sizeof(uint16_t);
             break;
         case MDS_16_BITS_SIGNED:
-            read_s16(&val16, data, pos, len, endian);
+            read_s16(&val16, data, pos, end, endian);
             address = base + val16 * sizeof(uint16_t);
             break;
         case MDS_32_BITS_SIGNED:
-            read_s32(&val32, data, pos, len, endian);
+            read_s32(&val32, data, pos, end, endian);
             address = base + val32 * sizeof(uint16_t);
             break;
         default:
diff --git a/src/arch/dalvik/processor.c b/src/arch/dalvik/processor.c
index e105fcd..fdfb38d 100644
--- a/src/arch/dalvik/processor.c
+++ b/src/arch/dalvik/processor.c
@@ -55,6 +55,12 @@ static void g_dalvik_processor_class_init(GDalvikProcessorClass *);
 /* Initialise une instance de processeur de VM Dalvik. */
 static void g_dalvik_processor_init(GDalvikProcessor *);
 
+/* Supprime toutes les références externes. */
+static void g_dalvik_processor_dispose(GDalvikProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dalvik_processor_finalize(GDalvikProcessor *);
+
 /* Fournit un contexte pour l'exécution du processeur Dalvik. */
 static GDalvikContext *g_dalvik_processor_get_context(const GDalvikProcessor *);
 
@@ -87,6 +93,17 @@ G_DEFINE_TYPE(GDalvikProcessor, g_dalvik_processor, G_TYPE_ARCH_PROCESSOR);
 
 static void g_dalvik_processor_class_init(GDalvikProcessorClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchProcessorClass *proc;              /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_processor_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_dalvik_processor_finalize;
+
+    proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+    proc->decode = (decode_instruction_fc)g_dalvik_processor_decode_instruction;
 
 }
 
@@ -115,7 +132,44 @@ static void g_dalvik_processor_init(GDalvikProcessor *proc)
 
     parent->get_ctx = (get_processor_context_fc)g_dalvik_processor_get_context;
     parent->get_dec_ctx = (get_decomp_context_fc)g_dalvik_processor_get_decomp_context;
-    parent->decode = (decode_instruction_fc)g_dalvik_processor_decode_instruction;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_processor_dispose(GDalvikProcessor *proc)
+{
+    G_OBJECT_CLASS(g_dalvik_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bookmark = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_processor_finalize(GDalvikProcessor *proc)
+{
+    G_OBJECT_CLASS(g_dalvik_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }
 
@@ -186,7 +240,7 @@ static GDalvikDContext *g_dalvik_processor_get_decomp_context(const GDalvikProce
 *  Paramètres  : proc = architecture visée par la procédure.                  *
 *                data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                                                                             *
 *  Description : Décode une pseudo-instruction dans un flux de données.       *
@@ -197,7 +251,7 @@ static GDalvikDContext *g_dalvik_processor_get_decomp_context(const GDalvikProce
 *                                                                             *
 ******************************************************************************/
 
-static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcessor *proc, const bin_t *data, off_t *pos, off_t len, vmpa_t addr)
+static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcessor *proc, const bin_t *data, off_t *pos, off_t end, vmpa_t addr)
 {
     GArchInstruction *result;               /* Instruction à renvoyer      */
     off_t tmp;                              /* Position modifiable         */
@@ -208,18 +262,18 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
 
     tmp = *pos;
 
-    if (!read_u16(&ident, data, &tmp, len, SRE_LITTLE))
+    if (!read_u16(&ident, data, &tmp, end, SRE_LITTLE))
         return NULL;
 
     switch (ident)
     {
         case DPO_PACKED_SWITCH:
         case DPO_SPARSE_SWITCH:
-            result = g_dalvik_switch_instr_new(data, pos, len, addr, proc);
+            result = g_dalvik_switch_instr_new(data, pos, end, addr, proc);
             break;
 
         case DPO_FILL_ARRAY_DATA:
-            result = g_dalvik_fill_instr_new(data, pos, len, addr, proc);
+            result = g_dalvik_fill_instr_new(data, pos, end, addr, proc);
             break;
 
         default:
@@ -239,7 +293,7 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
 *                ctx    = contexte lié à l'exécution du processeur.           *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                addr   = adresse virtuelle de l'instruction.                 *
 *                format = format du fichier contenant le code.                *
 *                                                                             *
@@ -251,7 +305,7 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
 *                                                                             *
 ******************************************************************************/
 
-static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProcessor *proc, GDalvikContext *ctx, const bin_t *data, off_t *pos, off_t len, vmpa_t addr, GDexFormat *format)
+static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProcessor *proc, GDalvikContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GDexFormat *format)
 {
     GArchInstruction *result;               /* Instruction à renvoyer      */
     DalvikOpcodes id;                       /* Identifiant d'instruction   */
@@ -480,17 +534,17 @@ static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProc
     };
 
     /* Pseudo-instruction... */
-    result = g_dalvik_guess_pseudo_instruction(proc, data, pos, len, addr);
+    result = g_dalvik_guess_pseudo_instruction(proc, data, pos, end, addr);
 
     /* ... ou instruction classique */
     if (result == NULL)
     {
-        id = dalvik_guess_next_instruction(data, *pos, len);
+        id = dalvik_guess_next_instruction(data, *pos, end);
 
         if (id != DOP_COUNT)
         {
             (*pos)++;
-            result = decodings[id](data, pos, len, addr, proc, format);
+            result = decodings[id](data, pos, end, addr, proc, format);
         }
 
     }
diff --git a/src/arch/dalvik/pseudo/fill.c b/src/arch/dalvik/pseudo/fill.c
index 9fa4a59..702f4b9 100644
--- a/src/arch/dalvik/pseudo/fill.c
+++ b/src/arch/dalvik/pseudo/fill.c
@@ -110,7 +110,7 @@ static void g_dalvik_fill_instr_init(GDalvikFillInstr *instr)
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                end  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
@@ -122,21 +122,21 @@ static void g_dalvik_fill_instr_init(GDalvikFillInstr *instr)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_dalvik_fill_instr_new(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc)
+GArchInstruction *g_dalvik_fill_instr_new(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc)
 {
     GDalvikFillInstr *result;               /* Structure à retourner       */
     uint16_t ident;                         /* Valeur lue dans le code     */
 
     result = g_object_new(G_TYPE_DALVIK_FILL_INSTR, NULL);
 
-    if (!read_u16(&ident, data, pos, len, SRE_LITTLE))
+    if (!read_u16(&ident, data, pos, end, SRE_LITTLE))
         goto gdfin_bad;
 
     G_DALVIK_INSTRUCTION(result)->ptype = DPO_FILL_ARRAY_DATA;
 
-    if (!read_u16(&result->array_width, data, pos, len, SRE_LITTLE))
+    if (!read_u16(&result->array_width, data, pos, end, SRE_LITTLE))
         goto gdfin_bad;
-    if (!read_u32(&result->array_size, data, pos, len, SRE_LITTLE))
+    if (!read_u32(&result->array_size, data, pos, end, SRE_LITTLE))
         goto gdfin_bad;
 
     *pos += result->array_width * result->array_size;
diff --git a/src/arch/dalvik/pseudo/switch.c b/src/arch/dalvik/pseudo/switch.c
index 5548258..c97c82b 100644
--- a/src/arch/dalvik/pseudo/switch.c
+++ b/src/arch/dalvik/pseudo/switch.c
@@ -109,7 +109,7 @@ static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *instr)
 *                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*                len  = limite des données à analyser.                        *
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
@@ -121,14 +121,14 @@ static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *instr)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc)
+GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc)
 {
     GDalvikSwitchInstr *result;               /* Structure à retourner       */
     uint16_t ident;                         /* Valeur lue dans le code     */
 
     result = g_object_new(G_TYPE_DALVIK_SWITCH_INSTR, NULL);
 
-    if (!read_u16(&ident, data, pos, len, SRE_LITTLE))
+    if (!read_u16(&ident, data, pos, end, SRE_LITTLE))
         goto gdsin_bad;
 
     if (ident != DPO_PACKED_SWITCH && ident != DPO_SPARSE_SWITCH)
@@ -136,7 +136,7 @@ GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t
 
     G_DALVIK_INSTRUCTION(result)->ptype = ident;
 
-    if (!read_u16(&result->switch_size, data, pos, len, SRE_LITTLE))
+    if (!read_u16(&result->switch_size, data, pos, end, SRE_LITTLE))
         goto gdsin_bad;
 
     if (ident != DPO_PACKED_SWITCH)
diff --git a/src/arch/immediate.c b/src/arch/immediate.c
index d9e36f2..46abe62 100644
--- a/src/arch/immediate.c
+++ b/src/arch/immediate.c
@@ -148,7 +148,7 @@ static void g_imm_operand_init(GImmOperand *operand)
 *  Paramètres  : size   = taille de l'opérande souhaitée.                     *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
+*                end    = limite des données à analyser.                      *
 *                low    = position éventuelle des 4 bits visés. [OUT]         *
 *                endian = ordre des bits dans la source.                      *
 *                                                                             *
@@ -160,7 +160,7 @@ static void g_imm_operand_init(GImmOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian)
+GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian)
 {
     GImmOperand *result;                    /* Opérande à retourner        */
 
@@ -171,52 +171,52 @@ GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *dat
     switch (size)
     {
         case MDS_4_BITS_UNSIGNED:
-            if (!read_u4(&result->unsigned_imm.val8, data, pos, len, low, endian))
+            if (!read_u4(&result->unsigned_imm.val8, data, pos, end, low, endian))
                 goto gionfd_error;
             break;
 
         case MDS_8_BITS_UNSIGNED:
-            if (!read_u8(&result->unsigned_imm.val8, data, pos, len, endian))
+            if (!read_u8(&result->unsigned_imm.val8, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_16_BITS_UNSIGNED:
-            if (!read_u16(&result->unsigned_imm.val16, data, pos, len, endian))
+            if (!read_u16(&result->unsigned_imm.val16, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_32_BITS_UNSIGNED:
-            if (!read_u32(&result->unsigned_imm.val32, data, pos, len, endian))
+            if (!read_u32(&result->unsigned_imm.val32, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_64_BITS_UNSIGNED:
-            if (!read_u64(&result->unsigned_imm.val64, data, pos, len, endian))
+            if (!read_u64(&result->unsigned_imm.val64, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_4_BITS_SIGNED:
-            if (!read_s4(&result->signed_imm.val8, data, pos, len, low, endian))
+            if (!read_s4(&result->signed_imm.val8, data, pos, end, low, endian))
                 goto gionfd_error;
             break;
 
         case MDS_8_BITS_SIGNED:
-            if (!read_s8(&result->signed_imm.val8, data, pos, len, endian))
+            if (!read_s8(&result->signed_imm.val8, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_16_BITS_SIGNED:
-            if (!read_s16(&result->signed_imm.val16, data, pos, len, endian))
+            if (!read_s16(&result->signed_imm.val16, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_32_BITS_SIGNED:
-            if (!read_s32(&result->signed_imm.val32, data, pos, len, endian))
+            if (!read_s32(&result->signed_imm.val32, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
         case MDS_64_BITS_SIGNED:
-            if (!read_s64(&result->signed_imm.val64, data, pos, len, endian))
+            if (!read_s64(&result->signed_imm.val64, data, pos, end, endian))
                 goto gionfd_error;
             break;
 
diff --git a/src/arch/jvm/processor.c b/src/arch/jvm/processor.c
index 10efc5b..5872fd9 100644
--- a/src/arch/jvm/processor.c
+++ b/src/arch/jvm/processor.c
@@ -52,6 +52,12 @@ static void g_jvm_processor_class_init(GJvmProcessorClass *);
 /* Initialise une instance de processeur de JVM. */
 static void g_jvm_processor_init(GJvmProcessor *);
 
+/* Supprime toutes les références externes. */
+static void g_jvm_processor_dispose(GJvmProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_jvm_processor_finalize(GJvmProcessor *);
+
 /* Décode une instruction dans un flux de données. */
 static GArchInstruction *g_jvm_processor_decode_instruction(const GJvmProcessor *, const bin_t *, off_t *, off_t, vmpa_t);
 
@@ -75,6 +81,17 @@ G_DEFINE_TYPE(GJvmProcessor, g_jvm_processor, G_TYPE_ARCH_PROCESSOR);
 
 static void g_jvm_processor_class_init(GJvmProcessorClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchProcessorClass *proc;              /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_jvm_processor_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_jvm_processor_finalize;
+
+    proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+    proc->decode = (decode_instruction_fc)g_jvm_processor_decode_instruction;
 
 }
 
@@ -100,7 +117,43 @@ static void g_jvm_processor_init(GJvmProcessor *proc)
     parent->endianness = SRE_BIG;
     parent->memsize = MDS_32_BITS;
 
-    parent->decode = (decode_instruction_fc)g_jvm_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_jvm_processor_dispose(GJvmProcessor *proc)
+{
+    G_OBJECT_CLASS(g_jvm_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bookmark = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_jvm_processor_finalize(GJvmProcessor *proc)
+{
+    G_OBJECT_CLASS(g_jvm_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }
 
diff --git a/src/arch/mips/processor.c b/src/arch/mips/processor.c
index aa288b1..15de6cc 100644
--- a/src/arch/mips/processor.c
+++ b/src/arch/mips/processor.c
@@ -51,6 +51,12 @@ static void g_mips_processor_class_init(GMipsProcessorClass *);
 /* Initialise la classe des lignes de descriptions initiales. */
 static void g_mips_processor_init(GMipsProcessor *);
 
+/* Supprime toutes les références externes. */
+static void g_mips_processor_dispose(GMipsProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_mips_processor_finalize(GMipsProcessor *);
+
 /* Décode une instruction dans un flux de données. */
 static GArchInstruction *g_mips_processor_decode_instruction(const GMipsProcessor *, const bin_t *, off_t *, off_t, vmpa_t);
 
@@ -74,6 +80,17 @@ G_DEFINE_TYPE(GMipsProcessor, g_mips_processor, G_TYPE_ARCH_PROCESSOR);
 
 static void g_mips_processor_class_init(GMipsProcessorClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchProcessorClass *proc;              /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_mips_processor_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_mips_processor_finalize;
+
+    proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+    proc->decode = (decode_instruction_fc)g_mips_processor_decode_instruction;
 
 }
 
@@ -99,7 +116,43 @@ static void g_mips_processor_init(GMipsProcessor *proc)
     parent->endianness = SRE_BIG;
     parent->memsize = MDS_32_BITS;
 
-    parent->decode = (decode_instruction_fc)g_mips_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_mips_processor_dispose(GMipsProcessor *proc)
+{
+    G_OBJECT_CLASS(g_mips_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bookmark = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_mips_processor_finalize(GMipsProcessor *proc)
+{
+    G_OBJECT_CLASS(g_mips_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }
 
diff --git a/src/arch/processor-int.h b/src/arch/processor-int.h
index 82f402a..c8263f7 100644
--- a/src/arch/processor-int.h
+++ b/src/arch/processor-int.h
@@ -67,7 +67,6 @@ struct _GArchProcessor
 
     get_processor_context_fc get_ctx;       /* Obtention d'un contexte #1  */
     get_decomp_context_fc get_dec_ctx;      /* Obtention d'un contexte #2  */
-    decode_instruction_fc decode;           /* Traduction en instructions  */
 
 };
 
@@ -82,6 +81,8 @@ struct _GArchProcessorClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    decode_instruction_fc decode;           /* Traduction en instructions  */
+
 };
 
 
diff --git a/src/arch/processor.c b/src/arch/processor.c
index ff2318d..8ca58a7 100644
--- a/src/arch/processor.c
+++ b/src/arch/processor.c
@@ -230,8 +230,7 @@ MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *proc)
 *                ctx    = contexte lié à l'exécution du processeur.           *
 *                data   = flux de données à analyser.                         *
 *                pos    = position courante dans ce flux. [OUT]               *
-*                len    = taille totale des données à analyser.               *
-*                base   = position physique du bloc de code courant.          *
+*                end    = limite des données à analyser.                      *
 *                addr   = adresse virtuelle de l'instruction.                 *
 *                format = format du fichier contenant le code.                *
 *                                                                             *
@@ -243,7 +242,7 @@ MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *proc)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t len, off_t base, vmpa_t addr, GBinFormat *format)
+GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GBinFormat *format)
 {
     GArchInstruction *result;               /* Instruction à renvoyer      */
     off_t old_pos;                          /* Sauvegarde de la position   */
@@ -251,7 +250,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
 
     old_pos = *pos;
 
-    result = proc->decode(proc, ctx, data, pos, len, addr, format);
+    result = G_ARCH_PROCESSOR_GET_CLASS(proc)->decode(proc, ctx, data, pos, end, addr, format);
 
     if (result == NULL || result == SKIPPED_INSTR)
     {
@@ -260,7 +259,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
         skipped = (result == SKIPPED_INSTR);
 
         *pos = old_pos;
-        result = g_db_instruction_new_from_data(data, pos, len, base, proc);
+        result = g_db_instruction_new_from_data(data, pos, end, addr, proc);
 
 #ifdef DEBUG /* FIXME */
         if (skipped)
@@ -268,7 +267,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
 #endif
     }
 
-    g_arch_instruction_set_location(result, base + old_pos, *pos - old_pos, addr);
+    g_arch_instruction_set_location(result, old_pos, *pos - old_pos, addr);
 
     return result;
 
diff --git a/src/arch/processor.h b/src/arch/processor.h
index b6d5f00..32dfbdb 100644
--- a/src/arch/processor.h
+++ b/src/arch/processor.h
@@ -39,7 +39,10 @@
 #define G_TYPE_ARCH_PROCESSOR               g_arch_processor_get_type()
 #define G_ARCH_PROCESSOR(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arch_processor_get_type(), GArchProcessor))
 #define G_IS_ARCH_PROCESSOR(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arch_processor_get_type()))
-#define G_ARCH_PROCESSOR_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_arch_processor_get_type(), GArchProcessorIface))
+#define G_ARCH_PROCESSOR_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
+#define G_IS_ARCH_PROCESSOR_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARCH_PROCESSOR))
+#define G_ARCH_PROCESSOR_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
+
 
 
 /* Ligne de représentation générique (instance) */
@@ -68,7 +71,7 @@ MemoryDataSize g_arch_processor_get_memory_size(const GArchProcessor *);
 MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *);
 
 /* Décode une instruction dans un flux de données. */
-GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *, GProcContext *, const bin_t *, off_t *, off_t, off_t, vmpa_t, GBinFormat *);
+GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *, GProcContext *, const bin_t *, off_t *, off_t, vmpa_t, GBinFormat *);
 
 
 
diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index 24d5792..c6972af 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -28,6 +28,8 @@
 #include <malloc.h>
 
 
+#include "../common/io.h"
+
 
 
 
@@ -46,11 +48,11 @@
 *                                                                             *
 ******************************************************************************/
 
-vmpa2_t *make_vmpa(off_t phy, uint64_t virt)
+vmpa2t *make_vmpa(off_t phy, uint64_t virt)
 {
-    vmpa2_t *result;                        /* Structure à retourner       */
+    vmpa2t *result;                         /* Structure à retourner       */
 
-    result = (vmpa2_t *)calloc(1, sizeof(vmpa2_t));
+    result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
 
     result->physical = phy;
     result->virtual = virt;
@@ -77,11 +79,182 @@ vmpa2_t *make_vmpa(off_t phy, uint64_t virt)
 *                                                                             *
 ******************************************************************************/
 
-void init_vmpa(vmpa2_t *addr, off_t phy, uint64_t virt)
+void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
 {
     addr->physical = phy;
     addr->virtual = virt;
 
+
+
+    MDS_UNDEFINED;
+
+
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr  = élément à venir lire. [OUT]                          *
+*                fd    = flux ouvert en lecture pour l'importation.           *
+*                flags = éventuelles options d'envoi supplémentaires.         *
+*                                                                             *
+*  Description : Lit la définition d'une adresse depuis un flux réseau.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool recv_vmpa(vmpa2t *addr, int fd, int flags)
+{
+    uint64_t val64;                         /* Valeur sur 64 bits          */
+    bool status;                            /* Bilan d'une réception       */
+
+    status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+    if (!status) return false;
+
+    addr->physical = be64toh(val64);
+
+    status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+    if (!status) return false;
+
+    addr->virtual = be64toh(val64);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr  = élément à venir écrire.                              *
+*                fd    = flux ouvert en écriture pour l'exportation.          *
+*                flags = éventuelles options d'envoi supplémentaires.         *
+*                                                                             *
+*  Description : Ecrit la définition d'une adresse dans un flux réseau.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool send_vmpa(const vmpa2t *addr, int fd, int flags)
+{
+    bool status;                            /* Bilan d'une émission        */
+
+    status = safe_send(fd, (uint64_t []) { htobe64(addr->physical) }, sizeof(uint64_t), flags);
+    if (!status) return false;
+
+    status = safe_send(fd, (uint64_t []) { htobe64(addr->virtual) }, sizeof(uint64_t), flags);
+    if (!status) return false;
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
+*                msize  = taille de cette adresse, réelle ou désirée.         *
+*                                                                             *
+*  Description : Transforme une adresse physique en chaîne de caractères.     *
+*                                                                             *
+*  Retour      : Chaîne de caractères constituée.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *vmpa2_phy_to_string(vmpa2t *addr, MemoryDataSize msize)
+{
+    if (addr->phy_cache[0] == '\0' || addr->last_phy_size != msize)
+    {
+        switch (msize)
+        {
+            case MDS_8_BITS:
+                snprintf(addr->phy_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
+                break;
+
+            case MDS_16_BITS:
+                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
+                break;
+
+            case MDS_32_BITS:
+                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
+                break;
+
+            case MDS_64_BITS:
+                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
+                break;
+
+            default:
+                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "???");
+                break;
+
+        }
+
+        addr->last_phy_size = msize;
+
+    }
+
+    return addr->phy_cache;
+
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
+*                msize  = taille de cette adresse, réelle ou désirée.         *
+*                                                                             *
+*  Description : Transforme une adresse virtuelle en chaîne de caractères.    *
+*                                                                             *
+*  Retour      : Chaîne de caractères constituée.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize)
+{
+    if (addr->virt_cache[0] == '\0' || addr->last_virt_size != msize)
+    {
+        switch (msize)
+        {
+            case MDS_8_BITS:
+                snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
+                break;
+
+            case MDS_16_BITS:
+                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
+                break;
+
+            case MDS_32_BITS:
+                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
+                break;
+
+            case MDS_64_BITS:
+                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
+                break;
+
+            default:
+                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
+                break;
+
+        }
+
+        addr->last_virt_size = msize;
+
+    }
+
+    return addr->virt_cache;
+
+}
diff --git a/src/arch/vmpa.h b/src/arch/vmpa.h
index fa14fda..5df9b8a 100644
--- a/src/arch/vmpa.h
+++ b/src/arch/vmpa.h
@@ -25,11 +25,22 @@
 #define _ARCH_VMPA_H
 
 
+#include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <sys/types.h>
 
 
+#include "archbase.h"
+#include "../common/cpp.h"
+
+
+
+
+
+
+#define VMPA_MAX_SIZE (sizeof(STR(ULLONG_MAX)) + 1)
+
 
 
 
@@ -39,6 +50,11 @@ struct _vmpa2_t
     off_t physical;                         /* Position physique           */
     uint64_t virtual;                       /* Adresse virtuelle           */
 
+    MemoryDataSize last_phy_size;           /* Dernière taille demandée #1 */
+    MemoryDataSize last_virt_size;          /* Dernière taille demandée #2 */
+    char phy_cache[VMPA_MAX_SIZE];          /* Impression physique cachée  */
+    char virt_cache[VMPA_MAX_SIZE];         /* Impression virtuelle cachée */
+
 };
 
 
@@ -47,20 +63,36 @@ struct _vmpa2_t
 typedef struct _vmpa2_t vmpa2_t;
 
 
+typedef struct _vmpa2_t vmpa2t;
+
+
 /* Initialise une localisation dans l'espace mémoire/physique. */
-void init_vmpa(vmpa2_t *, off_t, uint64_t);
+void init_vmpa(vmpa2t *, off_t, uint64_t);
 
 
 
 
 /* Crée une localisation dans l'adressage mémoire. */
-vmpa2_t *make_vmpa(off_t, uint64_t);
+vmpa2t *make_vmpa(off_t, uint64_t);
+
+
+
+#define cmp_vmpa(a, b) 0
+
+
+
 
+/* Lit la définition d'une adresse depuis un flux réseau. */
+bool recv_vmpa(vmpa2t *, int, int);
 
+/* Ecrit la définition d'une adresse dans un flux réseau. */
+bool send_vmpa(const vmpa2t *, int, int);
 
-#define load_vmpa_from_fd(vmpa, fd) true
+/* Transforme une adresse physique en chaîne de caractères. */
+const char *vmpa2_phy_to_string(vmpa2t *, MemoryDataSize);
 
-#define store_vmpa_to_fd(vmpa, fd) true
+/* Transforme une adresse virtuelle en chaîne de caractères. */
+const char *vmpa2_virt_to_string(vmpa2t *, MemoryDataSize);
 
 
 
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
index 7590532..38c3d20 100644
--- a/src/arch/x86/processor.c
+++ b/src/arch/x86/processor.c
@@ -45,12 +45,18 @@ struct _GX86ProcessorClass
 };
 
 
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise la classe des processeurs x86. */
 static void g_x86_processor_class_init(GX86ProcessorClass *);
 
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise une instance de processeur x86. */
 static void g_x86_processor_init(GX86Processor *);
 
+/* Supprime toutes les références externes. */
+static void g_x86_processor_dispose(GX86Processor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_x86_processor_finalize(GX86Processor *);
+
 /* Décode une instruction dans un flux de données. */
 static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor *, const bin_t *, off_t *, off_t, vmpa_t);
 
@@ -64,7 +70,7 @@ G_DEFINE_TYPE(GX86Processor, g_x86_processor, G_TYPE_ARCH_PROCESSOR);
 *                                                                             *
 *  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*  Description : Initialise la classe des processeurs x86.                    *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -74,6 +80,17 @@ G_DEFINE_TYPE(GX86Processor, g_x86_processor, G_TYPE_ARCH_PROCESSOR);
 
 static void g_x86_processor_class_init(GX86ProcessorClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchProcessorClass *proc;              /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_x86_processor_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_x86_processor_finalize;
+
+    proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+    proc->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
 
 }
 
@@ -82,7 +99,7 @@ static void g_x86_processor_class_init(GX86ProcessorClass *klass)
 *                                                                             *
 *  Paramètres  : proc = instance à initialiser.                               *
 *                                                                             *
-*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*  Description : Initialise une instance de processeur x86.                   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -100,7 +117,43 @@ static void g_x86_processor_init(GX86Processor *proc)
     parent->memsize = MDS_32_BITS;
     parent->inssize = MDS_8_BITS;
 
-    parent->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_x86_processor_dispose(GX86Processor *proc)
+{
+    G_OBJECT_CLASS(g_x86_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bookmark = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_x86_processor_finalize(GX86Processor *proc)
+{
+    G_OBJECT_CLASS(g_x86_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }