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

36 files changed, 654 insertions, 654 deletions

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;