Built some expressions for the decompilation tree.

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

56 files changed, 3761 insertions, 43 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index f1fce92..7ef9192 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -41,7 +41,7 @@ liboidaglibext_la_LIBADD =						\
 liboidagtkext_la_SOURCES =
 
 liboidagtkext_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBGRAPH_LIBS)		\
-	-L.libs -loidadisass 
+	-L.libs -loidadisass
 
 liboidagtkext_la_LIBADD =						\
 	graph/libgraph.la							\
@@ -93,7 +93,7 @@ AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
 
 openida_LDFLAGS = $(LIBGTK_LIBS) -L/usr/X11R6/lib -ldl -lm $(LIBXML_LIBS) `pkg-config --libs gthread-2.0` $(LIBPYTHON_LIBS) $(LIBVTE_LIBS) \
-	-L.libs -loidadisass -loidagtkext			\
+	-L.libs  -loidaglibext -loidadisass -loidagtkext			\
 	-Lcommon/.libs -lcommon						\
 	-Lpanels/.libs -lpanels						\
 	-Lplugins/.libs -lplugins
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 949bb31..0159b29 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -593,6 +593,22 @@ static void limit_all_routines(GRenderingLine *lines, GBinRoutine **routines, si
 
     for (i = 0; i < count; i++)
     {
+        /* Instruction de départ */
+
+        /* FIXME : faire mieux ! */
+
+        line = g_rendering_line_find_by_address(lines, NULL, starts[i]);
+        if (line != NULL) line = g_rendering_line_loop_for_code(line, NULL);
+
+        if (line != NULL)
+        {
+            instr = g_code_line_get_instruction(G_CODE_LINE(line));
+
+            g_binary_routine_set_instructions(routines[i], instr);
+
+        }
+
+
         if (lengths[i] > 0) continue;
 
         start = g_binary_routine_get_address(routines[i]);
diff --git a/src/analysis/decomp/decompiler.c b/src/analysis/decomp/decompiler.c
index 284d3e1..9e8ec38 100644
--- a/src/analysis/decomp/decompiler.c
+++ b/src/analysis/decomp/decompiler.c
@@ -34,12 +34,16 @@
 
 #include "../../decomp/output.h"
 #include "../../decomp/lang/java.h"    /* FIXME : remme ! */
+#include "../../format/format.h"
 
 
 
 /* Construit la description d'introduction de la décompilation. */
 static void build_decomp_prologue(GCodeBuffer *, const char *);
 
+/* S'assure de la transcription de routines en expressions. */
+static void prepare_all_routines_for_decomp(const GOpenidaBinary *, const char *);
+
 
 
 /******************************************************************************
@@ -108,6 +112,59 @@ static void build_decomp_prologue(GCodeBuffer *buffer, const char *filename)
 *  Paramètres  : binary   = représentation de binaire chargé.                 *
 *                filename = nom du fichier source à cibler.                   *
 *                                                                             *
+*  Description : S'assure de la transcription de routines en expressions.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const char *filename)
+{
+    GExeFormat *format;                     /* Format du binaire fourni    */
+
+    GBinRoutine **routines;
+    size_t count;
+
+    size_t i;
+
+    GDecInstruction *instr;
+
+    format = g_openida_binary_get_format(binary);
+    
+
+    routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &count);
+
+
+
+    for (i = 0; i < count; i++)
+    {
+        //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
+
+        if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
+        {
+
+            printf("...\n");
+
+            instr = g_binary_format_decompile_routine(G_BIN_FORMAT(format), routines[i]);
+
+        }
+
+
+    }
+
+
+
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary   = représentation de binaire chargé.                 *
+*                filename = nom du fichier source à cibler.                   *
+*                                                                             *
 *  Description : Procède à la décompilation des routines d'un fichier donné.  *
 *                                                                             *
 *  Retour      : Tampon de code mis en place.                                 *
@@ -119,6 +176,7 @@ static void build_decomp_prologue(GCodeBuffer *buffer, const char *filename)
 GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *filename)
 {
     GCodeBuffer *result;                    /* Tampon constitué à renvoyer */
+    GExeFormat *format;                     /* Format du binaire fourni    */
 
     result = g_code_buffer_new();
 
@@ -126,6 +184,14 @@ GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *f
     build_decomp_prologue(result, filename);
 
 
+    prepare_all_routines_for_decomp(binary, filename);
+
+
+
+
+    format = g_openida_binary_get_format(binary);
+    g_binary_format_decompile(G_BIN_FORMAT(format), result);
+
     return result;
 
 }
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 0c8d83a..ad82407 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -55,6 +55,9 @@ struct _GBinRoutine
     GBinVariable **locals;                  /* Variables locales du code   */
     size_t locals_count;                    /* Nombre de variables locales */
 
+    GArchInstruction *instr;                /* Instructions natives        */
+    GDecInstruction *dinstr;                /* Instructions décompilées    */
+
 };
 
 
@@ -770,3 +773,87 @@ char *_g_binary_routine_to_string(const GBinRoutine *routine, Routine2StringOpti
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à consulter.                               *
+*                                                                             *
+*  Description : Fournit les instructions natives correspondantes.            *
+*                                                                             *
+*  Retour      : Ensemble d'instructions décompilées ou NULL.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *g_binary_routine_get_instructions(const GBinRoutine *routine)
+{
+    return routine->instr;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à mettre à jour.                           *
+*                instr   = série d'instructions à conserver.                  *
+*                                                                             *
+*  Description : Définit les instructions natives de la routine.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_routine_set_instructions(GBinRoutine *routine, GArchInstruction *instr)
+{
+    if (routine->instr != NULL)
+        g_object_unref(G_OBJECT(routine->instr));
+
+    routine->instr = instr;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à consulter.                               *
+*                                                                             *
+*  Description : Fournit les instructions décompilées correspondantes.        *
+*                                                                             *
+*  Retour      : Ensemble d'instructions décompilées ou NULL.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_binary_routine_get_decomp_instructions(const GBinRoutine *routine)
+{
+    return routine->dinstr;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à mettre à jour.                           *
+*                instr   = série d'instructions à conserver.                  *
+*                                                                             *
+*  Description : Définit les instructions décompilées de la routine.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_routine_set_decomp_instructions(GBinRoutine *routine, GDecInstruction *instr)
+{
+    if (routine->dinstr != NULL)
+        g_object_unref(G_OBJECT(routine->dinstr));
+
+    routine->dinstr = instr;
+
+}
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index e2ea1cc..47de5bd 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -31,7 +31,8 @@
 
 
 #include "variable.h"
-#include "../arch/archbase.h"
+#include "../arch/instruction.h"
+#include "../decomp/instruction.h"
 
 
 
@@ -143,6 +144,18 @@ char *_g_binary_routine_to_string(const GBinRoutine *, Routine2StringOptions);
 
 #define g_binary_routine_to_string(r) _g_binary_routine_to_string((r), RSO_ALL)
 
+/* Fournit les instructions natives correspondantes. */
+GArchInstruction *g_binary_routine_get_instructions(const GBinRoutine *);
+
+/* Définit les instructions natives de la routine. */
+void g_binary_routine_set_instructions(GBinRoutine *, GArchInstruction *);
+
+/* Fournit les instructions décompilées correspondantes. */
+GDecInstruction *g_binary_routine_get_decomp_instructions(const GBinRoutine *);
+
+/* Définit les instructions décompilées de la routine. */
+void g_binary_routine_set_decomp_instructions(GBinRoutine *, GDecInstruction *);
+
 
 
 #endif  /* _ANALYSIS_ROUTINE_H */
diff --git a/src/arch/Makefile.am b/src/arch/Makefile.am
index 8f1c1ff..1a02c07 100644
--- a/src/arch/Makefile.am
+++ b/src/arch/Makefile.am
@@ -10,7 +10,8 @@ libarch_la_SOURCES =					\
 	operand-int.h						\
 	operand.h operand.c					\
 	processor-int.h						\
-	processor.h processor.c
+	processor.h processor.c				\
+	translate.h
 
 libarch_la_LIBADD =						\
 	arm/libarcharm.la					\
diff --git a/src/arch/dalvik/Makefile.am b/src/arch/dalvik/Makefile.am
index a7e099f..8dc93ae 100644
--- a/src/arch/dalvik/Makefile.am
+++ b/src/arch/dalvik/Makefile.am
@@ -3,6 +3,12 @@ noinst_LTLIBRARIES = libarchdalvik.la
 
 libarchdalvik_la_SOURCES =				\
 	instruction.h instruction.c			\
+	dop_aget.c							\
+	dop_aput.c							\
+	dop_arithm.c						\
+	dop_array.c							\
+	dop_const.c							\
+	dop_invoke.c						\
 	op_add.c							\
 	op_aget.c							\
 	op_and.c							\
@@ -33,7 +39,8 @@ libarchdalvik_la_SOURCES =				\
 	opcodes.h							\
 	operand.h operand.c					\
 	processor.h processor.c				\
-	register.h register.c
+	register.h register.c				\
+	translate.h
 
 libarchdalvik_la_CFLAGS = $(AM_CFLAGS)
 
diff --git a/src/arch/dalvik/dop_aget.c b/src/arch/dalvik/dop_aget.c
new file mode 100644
index 0000000..77e6ef2
--- /dev/null
+++ b/src/arch/dalvik/dop_aget.c
@@ -0,0 +1,68 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_aget.c - décompilation des instructions manipulant des tableaux (chargement)
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "../../decomp/expr/array.h"
+#include "../../decomp/expr/assign.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'aget'.                    *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_aget(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *content;               /* Contenu de cellule visé     */
+    GDecInstruction *array;                 /* Tableau accédé              */
+    GDecInstruction *index;                 /* Indice de cellule considérée*/
+    GDecInstruction *access;                /* Représentation de l'accès   */
+
+    operand = g_arch_instruction_get_operand(instr, 0);
+    content = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    array = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 2);
+    index = g_pseudo_register_new();
+
+    access = g_array_access_new(G_DEC_EXPRESSION(array), G_DEC_EXPRESSION(index));
+    result = g_assign_expression_new(G_DEC_EXPRESSION(content), G_DEC_EXPRESSION(access));
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/dop_aput.c b/src/arch/dalvik/dop_aput.c
new file mode 100644
index 0000000..2e4527e
--- /dev/null
+++ b/src/arch/dalvik/dop_aput.c
@@ -0,0 +1,68 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_aput.c - décompilation des instructions manipulant des tableaux (enregistrement)
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "../../decomp/expr/array.h"
+#include "../../decomp/expr/assign.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'aput'.                    *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_aput(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *content;               /* Contenu de cellule visé     */
+    GDecInstruction *array;                 /* Tableau accédé              */
+    GDecInstruction *index;                 /* Indice de cellule considérée*/
+    GDecInstruction *access;                /* Représentation de l'accès   */
+
+    operand = g_arch_instruction_get_operand(instr, 0);
+    content = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    array = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 2);
+    index = g_pseudo_register_new();
+
+    access = g_array_access_new(G_DEC_EXPRESSION(array), G_DEC_EXPRESSION(index));
+    result = g_assign_expression_new(G_DEC_EXPRESSION(access), G_DEC_EXPRESSION(content));
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/dop_arithm.c b/src/arch/dalvik/dop_arithm.c
new file mode 100644
index 0000000..388f906
--- /dev/null
+++ b/src/arch/dalvik/dop_arithm.c
@@ -0,0 +1,175 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_arithm.c - décompilation des opérations arithmétiques
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "instruction.h"
+#include "../../decomp/expr/arithm.h"
+#include "../../decomp/expr/assign.h"
+#include "../../decomp/expr/immediate.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'opérations arithmétiques'.*
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_arithm_2addr(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+    ArithmOperationType type;               /* Type d'opération menée      */
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *dest;                  /* Enregistrement du résultat  */
+    GDecInstruction *op1;                   /* Premier opérande utilisé    */
+    GDecInstruction *op2;                   /* Second opérande utilisé     */
+    GDecInstruction *arithm;                /* Opération arithmétique      */
+
+    switch (g_dalvik_instruction_get_opcode(G_DALVIK_INSTRUCTION(instr)))
+    {
+        case DOP_ADD_INT_2ADDR:
+            type = AOT_ADD;
+            break;
+        case DOP_MUL_INT_2ADDR:
+        case DOP_MUL_DOUBLE_2ADDR:
+            type = AOT_MUL;
+            break;
+        case DOP_DIV_INT_2ADDR:
+            type = AOT_DIV;
+            break;
+        case DOP_REM_INT_2ADDR:
+            type = AOT_REM;
+            break;
+        case DOP_AND_INT_2ADDR:
+            type = AOT_AND;
+            break;
+        case DOP_OR_INT_2ADDR:
+            type = AOT_OR;
+            break;
+        case DOP_XOR_INT_2ADDR:
+            type = AOT_XOR;
+            break;
+        default:
+            type = AOT_COUNT;
+            break;
+    }
+
+    operand = g_arch_instruction_get_operand(instr, 0);
+    dest = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    op1 = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 2);
+    op2 = g_pseudo_register_new();
+
+    arithm = g_arithm_expression_new(G_DEC_EXPRESSION(op1), type, G_DEC_EXPRESSION(op2));
+    result = g_assign_expression_new(G_DEC_EXPRESSION(dest), G_DEC_EXPRESSION(arithm));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'opérations arithmétiques'.*
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_arithm_lit(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+    ArithmOperationType type;               /* Type d'opération menée      */
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *dest;                  /* Enregistrement du résultat  */
+    GDecInstruction *op1;                   /* Premier opérande utilisé    */
+    GDecInstruction *op2;                   /* Second opérande utilisé     */
+    GDecInstruction *arithm;                /* Opération arithmétique      */
+
+    switch (g_dalvik_instruction_get_opcode(G_DALVIK_INSTRUCTION(instr)))
+    {
+        case DOP_ADD_INT_LIT8:
+        case DOP_ADD_INT_LIT16:
+            type = AOT_ADD;
+            break;
+        case DOP_MUL_INT_LIT8:
+        case DOP_MUL_INT_LIT16:
+            type = AOT_MUL;
+            break;
+        case DOP_DIV_INT_LIT8:
+        case DOP_DIV_INT_LIT16:
+            type = AOT_DIV;
+            break;
+        case DOP_REM_INT_LIT8:
+        case DOP_REM_INT_LIT16:
+            type = AOT_REM;
+            break;
+        case DOP_AND_INT_LIT8:
+        case DOP_AND_INT_LIT16:
+            type = AOT_AND;
+            break;
+        case DOP_OR_INT_LIT8:
+        case DOP_OR_INT_LIT16:
+            type = AOT_OR;
+            break;
+        case DOP_XOR_INT_LIT8:
+        case DOP_XOR_INT_LIT16:
+            type = AOT_XOR;
+            break;
+        default:
+            type = AOT_COUNT;
+            break;
+    }
+
+    operand = g_arch_instruction_get_operand(instr, 0);
+    dest = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    op1 = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 2);
+    op2 = g_imm_expression_new(G_IMM_OPERAND(operand));
+
+    arithm = g_arithm_expression_new(G_DEC_EXPRESSION(op1), type, G_DEC_EXPRESSION(op2));
+    result = g_assign_expression_new(G_DEC_EXPRESSION(dest), G_DEC_EXPRESSION(arithm));
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/dop_array.c b/src/arch/dalvik/dop_array.c
new file mode 100644
index 0000000..035b3eb
--- /dev/null
+++ b/src/arch/dalvik/dop_array.c
@@ -0,0 +1,74 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_array.c - décompilation de l'opération récupérant la longueur d'un tableau
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "../../decomp/expr/assign.h"
+#include "../../decomp/expr/dalvik/array.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'array-length'.                   *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_array_length(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+
+
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *reg;                   /* Pseudo-registre redéfini    */
+    GDecInstruction *len;                   /* Enregistrement de taille    */
+
+
+    result = NULL;
+
+
+    printf("PAssaage !\n");
+
+
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    reg = g_pseudo_register_new();
+    len = g_dalvik_alength_new(G_DEC_EXPRESSION(reg));
+
+    operand = g_arch_instruction_get_operand(instr, 0);
+    reg = g_pseudo_register_new();
+
+
+    result = g_assign_expression_new(G_DEC_EXPRESSION(reg), G_DEC_EXPRESSION(len));
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/dop_const.c b/src/arch/dalvik/dop_const.c
new file mode 100644
index 0000000..eab7acd
--- /dev/null
+++ b/src/arch/dalvik/dop_const.c
@@ -0,0 +1,72 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_const.c - décompilation des chargements de constantes
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "../../decomp/expr/assign.h"
+#include "../../decomp/expr/immediate.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'const'.                   *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_const(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+
+
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *reg;                   /* Pseudo-registre redéfini    */
+    GDecInstruction *imm;                   /* Valeur immédiate décompilée */
+
+
+    result = NULL;
+
+
+    printf("PAssaage !\n");
+
+
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    reg = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    imm = g_imm_expression_new(G_IMM_OPERAND(operand));
+
+    result = g_assign_expression_new(G_DEC_EXPRESSION(reg), G_DEC_EXPRESSION(imm));
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/dop_invoke.c b/src/arch/dalvik/dop_invoke.c
new file mode 100644
index 0000000..e4fa1fb
--- /dev/null
+++ b/src/arch/dalvik/dop_invoke.c
@@ -0,0 +1,158 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dop_invoke.c - décompilation des appels de méthode
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "translate.h"
+
+
+#include "instruction.h"
+#include "operand.h"
+#include "../../decomp/expr/assign.h"
+#include "../../decomp/expr/call.h"
+#include "../../format/dex/pool.h"
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de type 'invoke-virtual'.          *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_decomp_instr_invoke_virtual(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+
+
+    size_t count;                           /* Quantité d'opérandes        */
+    GArchOperand *op;                       /* Opérande de l'instruction   */
+    uint32_t index;                         /* Indice de l'élément visé    */
+    GDexFormat *format;                     /* Accès aux constantes        */
+    GBinRoutine *routine;                   /* Routine visée par l'appel   */
+
+    const char *string;                     /* Chaîne à afficher           */
+    GOpenidaType *type;                     /* Type quelconque             */
+    char *tmp;                              /* Chaîne à afficher & libérer */
+
+
+
+    GArchOperand *operand;                  /* Opérande de l'instruction   */
+    GDecInstruction *reg;                   /* Pseudo-registre redéfini    */
+    GDecInstruction *imm;                   /* Valeur immédiate décompilée */
+
+    GArchInstruction *iter;                 /* Boucle de parcours          */
+    vmpa_t max;                             /* Limite à ne pas dépasser    */
+
+
+    result = NULL;
+
+
+    printf("PAssaage !\n");
+
+
+
+
+
+
+    /* Récupération de la méthode */
+
+    count = g_arch_instruction_count_operands(instr);
+    op = g_arch_instruction_get_operand(instr, count - 1);
+
+    index = g_dalvik_pool_operand_get_index(G_DALVIK_POOL_OPERAND(op));
+
+    printf("POOL ?? %d -> %d\n", G_IS_DALVIK_POOL_OPERAND(op), index);
+
+    format = G_DEX_FORMAT(g_object_get_data(G_OBJECT(ctx), "format"));
+    routine = get_routine_from_dex_pool(format, index);
+    if (routine == NULL) return NULL;
+
+
+#if 0
+            if (operand->cache.method == NULL)
+                g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+                                                      "<bad_method_index>", 18, RTT_VAR_NAME);
+
+            else
+            {
+                tmp = g_binary_routine_to_string(operand->cache.method);
+
+                g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+                                                      tmp, strlen(tmp), RTT_VAR_NAME);
+
+                free(tmp);
+
+
+#endif
+
+    result = g_routine_call_new(routine, true);
+
+        //GDecInstruction *g_routine_call_new(GBinRoutine *routine, bool is_object)
+    /*
+    operand = g_arch_instruction_get_operand(instr, 1);
+    reg = g_pseudo_register_new();
+
+    operand = g_arch_instruction_get_operand(instr, 1);
+    imm = g_imm_expression_new(G_IMM_OPERAND(operand));
+
+    result = g_assign_expression_new(G_DEC_EXPRESSION(reg), G_DEC_EXPRESSION(imm));
+    */
+
+
+
+
+
+    /* Récupération d'un résultat ? */
+
+    iter = instr;
+    max = g_dec_context_get_max_address(ctx);
+
+    iter = g_arch_instruction_get_next_iter(instr, iter, max);
+
+    if (iter != NULL)
+        switch (g_dalvik_instruction_get_opcode(G_DALVIK_INSTRUCTION(iter)))
+        {
+            case DOP_MOVE_RESULT:
+
+                operand = g_arch_instruction_get_operand(instr, 0);
+                reg = g_pseudo_register_new();
+
+                result = g_assign_expression_new(G_DEC_EXPRESSION(reg), G_DEC_EXPRESSION(result));
+
+                break;
+
+            default:
+                break;
+
+        }
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index 13c8e83..e8059d6 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -24,7 +24,8 @@
 #include "instruction.h"
 
 
-#include "../instruction-int.h" 
+#include "translate.h"
+#include "../instruction-int.h"
 
 
 
@@ -63,6 +64,8 @@ typedef struct _dalvik_instruction
 
     const char *keyword;                    /* Mot clef de la commande     */
 
+    decomp_instr_fc decomp;                 /* Procédure de décompilation  */
+
 } dalvik_instruction;
 
 
@@ -81,7 +84,7 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_RETURN]                = { 0x0f, "return" },
     [DOP_RETURN_WIDE]           = { 0x10, "return-wide" },
     [DOP_RETURN_OBJECT]         = { 0x11, "return-object" },
-    [DOP_CONST_4]               = { 0x12, "const/4" },
+    [DOP_CONST_4]               = { 0x12, "const/4",            dalvik_decomp_instr_const },
     [DOP_CONST_16]              = { 0x13, "const/16" },
     [DOP_CONST]                 = { 0x14, "const" },
     [DOP_CONST_HIGH16]          = { 0x15, "const/high16" },
@@ -94,7 +97,7 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_CHECK_CAST]            = { 0x1f, "check-cast" },
 
 
-    [DOP_ARRAY_LENGTH]          = { 0x21, "array-length" },
+    [DOP_ARRAY_LENGTH]          = { 0x21, "array-length",       dalvik_decomp_instr_array_length },
     [DOP_NEW_INSTANCE]          = { 0x22, "new-instance" },
     [DOP_NEW_ARRAY]             = { 0x23, "new-array" },
 
@@ -126,14 +129,14 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_AGET_WIDE]             = { 0x45, "aget-wide" },
     [DOP_AGET_OBJECT]           = { 0x46, "aget-object" },
     [DOP_AGET_BOOLEAN]          = { 0x47, "aget-boolean" },
-    [DOP_AGET_BYTE]             = { 0x48, "aget-byte" },
+    [DOP_AGET_BYTE]             = { 0x48, "aget-byte",          dalvik_decomp_instr_aget },
     [DOP_AGET_CHAR]             = { 0x49, "aget-char" },
     [DOP_AGET_SHORT]            = { 0x4a, "aget-short" },
     [DOP_APUT]                  = { 0x4b, "aput" },
     [DOP_APUT_WIDE]             = { 0x4c, "aput-wide" },
     [DOP_APUT_OBJECT]           = { 0x4d, "aput-object" },
     [DOP_APUT_BOOLEAN]          = { 0x4e, "aput-boolean" },
-    [DOP_APUT_BYTE]             = { 0x4f, "aput-byte" },
+    [DOP_APUT_BYTE]             = { 0x4f, "aput-byte",          dalvik_decomp_instr_aput },
     [DOP_APUT_CHAR]             = { 0x50, "aput-char" },
     [DOP_APUT_SHORT]            = { 0x51, "aput-short" },
     [DOP_IGET]                  = { 0x52, "iget" },
@@ -164,7 +167,7 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_SPUT_BYTE]             = { 0x6b, "sput-byte" },
     [DOP_SPUT_CHAR]             = { 0x6c, "sput-char" },
     [DOP_SPUT_SHORT]            = { 0x6d, "sput-short" },
-    [DOP_INVOKE_VIRTUAL]        = { 0x6e, "invoke-virtual" },
+    [DOP_INVOKE_VIRTUAL]        = { 0x6e, "invoke-virtual",     dalvik_decomp_instr_invoke_virtual },
     [DOP_INVOKE_SUPER]          = { 0x6f, "invoke-static" },
     [DOP_INVOKE_DIRECT]         = { 0x70, "invoke-direct" },
     [DOP_INVOKE_STATIC]         = { 0x71, "invoke-static" },
@@ -195,34 +198,34 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_XOR_INT]               = { 0x97, "xor-int" },
 
 
-    [DOP_ADD_INT_2ADDR]         = { 0xb0, "add-int/2addr" },
+    [DOP_ADD_INT_2ADDR]         = { 0xb0, "add-int/2addr",      dalvik_decomp_instr_arithm_2addr },
 
 
-    [DOP_MUL_INT_2ADDR]         = { 0xb2, "mul-int/2addr" },
-    [DOP_DIV_INT_2ADDR]         = { 0xb3, "div-int/2addr" },
-    [DOP_REM_INT_2ADDR]         = { 0xb4, "rem-int/2addr" },
-    [DOP_AND_INT_2ADDR]         = { 0xb5, "and-int/2addr" },
-    [DOP_OR_INT_2ADDR]          = { 0xb6, "or-int/2addr" },
-    [DOP_XOR_INT_2ADDR]         = { 0xb7, "xor-int/2addr" },
+    [DOP_MUL_INT_2ADDR]         = { 0xb2, "mul-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_DIV_INT_2ADDR]         = { 0xb3, "div-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_REM_INT_2ADDR]         = { 0xb4, "rem-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_AND_INT_2ADDR]         = { 0xb5, "and-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_OR_INT_2ADDR]          = { 0xb6, "or-int/2addr",       dalvik_decomp_instr_arithm_2addr },
+    [DOP_XOR_INT_2ADDR]         = { 0xb7, "xor-int/2addr",      dalvik_decomp_instr_arithm_2addr },
 
-    [DOP_MUL_DOUBLE_2ADDR]      = { 0xcd, "mul-double/2addr" },
+    [DOP_MUL_DOUBLE_2ADDR]      = { 0xcd, "mul-double/2addr",   dalvik_decomp_instr_arithm_2addr },
 
-    [DOP_ADD_INT_LIT16]         = { 0xd0, "add-int/lit16" },
+    [DOP_ADD_INT_LIT16]         = { 0xd0, "add-int/lit16",      dalvik_decomp_instr_arithm_lit },
     [DOP_RSUB_INT]              = { 0xd1, "rsub-int" },
-    [DOP_MUL_INT_LIT16]         = { 0xd2, "mul-int/lit16" },
-    [DOP_DIV_INT_LIT16]         = { 0xd3, "div-int/lit16" },
-    [DOP_REM_INT_LIT16]         = { 0xd4, "rem-int/lit16" },
-    [DOP_AND_INT_LIT16]         = { 0xd5, "and-int/lit16" },
-    [DOP_OR_INT_LIT16]          = { 0xd6, "or-int/lit16" },
-    [DOP_XOR_INT_LIT16]         = { 0xd7, "xor-int/lit16" },
-    [DOP_ADD_INT_LIT8]          = { 0xd8, "add-int/lit8" },
+    [DOP_MUL_INT_LIT16]         = { 0xd2, "mul-int/lit16",      dalvik_decomp_instr_arithm_lit },
+    [DOP_DIV_INT_LIT16]         = { 0xd3, "div-int/lit16",      dalvik_decomp_instr_arithm_lit },
+    [DOP_REM_INT_LIT16]         = { 0xd4, "rem-int/lit16",      dalvik_decomp_instr_arithm_lit },
+    [DOP_AND_INT_LIT16]         = { 0xd5, "and-int/lit16",      dalvik_decomp_instr_arithm_lit },
+    [DOP_OR_INT_LIT16]          = { 0xd6, "or-int/lit16",       dalvik_decomp_instr_arithm_lit },
+    [DOP_XOR_INT_LIT16]         = { 0xd7, "xor-int/lit16",      dalvik_decomp_instr_arithm_lit },
+    [DOP_ADD_INT_LIT8]          = { 0xd8, "add-int/lit8",       dalvik_decomp_instr_arithm_lit },
     [DOP_RSUB_INT_LIT8]         = { 0xd9, "rsub-int/lit8" },
-    [DOP_MUL_INT_LIT8]          = { 0xda, "mul-int/lit8" },
-    [DOP_DIV_INT_LIT8]          = { 0xdb, "div-int/lit8" },
-    [DOP_REM_INT_LIT8]          = { 0xdc, "rem-int/lit8" },
-    [DOP_AND_INT_LIT8]          = { 0xdd, "and-int/lit8" },
-    [DOP_OR_INT_LIT8]           = { 0xde, "or-int/lit8" },
-    [DOP_XOR_INT_LIT8]          = { 0xdf, "xor-int/lit8" }
+    [DOP_MUL_INT_LIT8]          = { 0xda, "mul-int/lit8",       dalvik_decomp_instr_arithm_lit },
+    [DOP_DIV_INT_LIT8]          = { 0xdb, "div-int/lit8",       dalvik_decomp_instr_arithm_lit },
+    [DOP_REM_INT_LIT8]          = { 0xdc, "rem-int/lit8",       dalvik_decomp_instr_arithm_lit },
+    [DOP_AND_INT_LIT8]          = { 0xdd, "and-int/lit8",       dalvik_decomp_instr_arithm_lit },
+    [DOP_OR_INT_LIT8]           = { 0xde, "or-int/lit8",        dalvik_decomp_instr_arithm_lit },
+    [DOP_XOR_INT_LIT8]          = { 0xdf, "xor-int/lit8",       dalvik_decomp_instr_arithm_lit }
 
 
 };
@@ -237,6 +240,9 @@ static InstructionLinkType dalvik_get_instruction_link(const GDalvikInstruction
 /* Indique si l'instruction correspond à un retour de fonction. */
 static bool dalvik_instruction_is_return(const GDalvikInstruction *);
 
+/* Décompile une instruction de la machine virtuelle Dalvik. */
+GDecInstruction *dalvik_instruction_decompile(const GDalvikInstruction *, GDecContext *);
+
 
 
 /* Indique le type défini pour une instruction d'architecture Dalvik. */
@@ -283,6 +289,7 @@ static void g_dalvik_instruction_init(GDalvikInstruction *instr)
     parent->get_text = (get_instruction_text_fc)dalvik_get_instruction_text;
     parent->get_link = (get_instruction_link_fc)dalvik_get_instruction_link;
     parent->is_return = (is_instruction_return_fc)dalvik_instruction_is_return;
+    parent->decomp = (decomp_instr_fc)dalvik_instruction_decompile;
 
 }
 
@@ -312,6 +319,25 @@ GArchInstruction *g_dalvik_instruction_new(DalvikOpcodes type)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction Dalvik à consulter.                      *
+*                                                                             *
+*  Description : Indique l'opcode associé à une instruction Dalvik.           *
+*                                                                             *
+*  Retour      : Identifiant de l'instruction en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+DalvikOpcodes g_dalvik_instruction_get_opcode(const GDalvikInstruction *instr)
+{
+    return instr->type;
+
+}
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       AIDE A LA MISE EN PLACE D'INSTRUCTIONS                       */
@@ -409,3 +435,31 @@ static bool dalvik_instruction_is_return(const GDalvikInstruction *instr)
     return (instr->type == DOP_RETURN_VOID);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de la machine virtuelle Dalvik.    *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *dalvik_instruction_decompile(const GDalvikInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+
+    if (_instructions[instr->type].decomp != NULL)
+        result = _instructions[instr->type].decomp(G_ARCH_INSTRUCTION(instr), ctx);
+
+    else
+        result = NULL;
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/instruction.h b/src/arch/dalvik/instruction.h
index cc7f845..8eaed17 100644
--- a/src/arch/dalvik/instruction.h
+++ b/src/arch/dalvik/instruction.h
@@ -214,6 +214,9 @@ GType g_dalvik_instruction_get_type(void);
 /* Crée une instruction pour l'architecture Dalvik. */
 GArchInstruction *g_dalvik_instruction_new(DalvikOpcodes);
 
+/* Indique l'opcode associé à une instruction Dalvik. */
+DalvikOpcodes g_dalvik_instruction_get_opcode(const GDalvikInstruction *);
+
 
 
 /* --------------------- AIDE A LA MISE EN PLACE D'INSTRUCTIONS --------------------- */
diff --git a/src/arch/dalvik/translate.h b/src/arch/dalvik/translate.h
new file mode 100644
index 0000000..779c133
--- /dev/null
+++ b/src/arch/dalvik/translate.h
@@ -0,0 +1,56 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * translate.h - prototypes pour les environnements de traduction d'instructions Dalvik
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_DECOMP_RTL_DALVIK_TRANSLATE_H
+#define _ANALYSIS_DECOMP_RTL_DALVIK_TRANSLATE_H
+
+
+#include "../translate.h"
+
+
+
+/* Décompile une instruction de type 'aget'. */
+GDecInstruction *dalvik_decomp_instr_aget(const GArchInstruction *, GDecContext *);
+
+/* Décompile une instruction de type 'aput'. */
+GDecInstruction *dalvik_decomp_instr_aput(const GArchInstruction *, GDecContext *);
+
+/* Décompile une instruction de type 'array-length'. */
+GDecInstruction *dalvik_decomp_instr_array_length(const GArchInstruction *, GDecContext *);
+
+/* Décompile une instruction de type 'const'. */
+GDecInstruction *dalvik_decomp_instr_const(const GArchInstruction *, GDecContext *);
+
+/* Décompile une instruction de type 'invoke-virtual'. */
+GDecInstruction *dalvik_decomp_instr_invoke_virtual(const GArchInstruction *, GDecContext *);
+
+
+/* Décompile une instruction de type 'opérations arithmétiques'. */
+GDecInstruction *dalvik_decomp_instr_arithm_2addr(const GArchInstruction *, GDecContext *);
+
+/* Décompile une instruction de type 'opérations arithmétiques'. */
+GDecInstruction *dalvik_decomp_instr_arithm_lit(const GArchInstruction *, GDecContext *);
+
+
+
+#endif  /* _ANALYSIS_DECOMP_RTL_DALVIK_TRANSLATE_H */
diff --git a/src/arch/immediate.c b/src/arch/immediate.c
index 3018b6b..ec689b8 100644
--- a/src/arch/immediate.c
+++ b/src/arch/immediate.c
@@ -95,6 +95,9 @@ static void g_imm_operand_add_text(const GImmOperand *, GRenderingOptions *, Mai
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 static void g_imm_operand_to_buffer(const GImmOperand *, GBufferLine *, GRenderingOptions *);
 
+/* Traduit un opérande en version humainement lisible. */
+static void g_imm_operand_print(const GImmOperand *, GBufferLine *, AsmSyntax);
+
 
 
 /* Indique le type défini pour un opérande de valeur numérique. */
@@ -134,13 +137,18 @@ static void g_imm_operand_class_init(GImmOperandClass *klass)
 
 static void g_imm_operand_init(GImmOperand *operand)
 {
-    GContentExporter *parent;               /* Instance parente            */
+    GContentExporter *parent;               /* Instance parente #1         */
+    GArchOperand *arch;                     /* Instance parente #2         */
 
     parent = G_CONTENT_EXPORTER(operand);
 
     parent->add_text = (add_text_fc)g_imm_operand_add_text;
     parent->export_buffer = (export_buffer_fc)g_imm_operand_to_buffer;
 
+    arch = G_ARCH_OPERAND(operand);
+
+    arch->print = (operand_print_fc)g_imm_operand_print;
+
     operand->zpad = false;
 
 }
@@ -653,7 +661,52 @@ static size_t g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax synt
             }
             break;
 
-        default:
+        case ASX_COUNT:
+            switch (operand->size)
+            {
+                case MDS_UNDEFINED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "0x???");
+                    break;
+
+                case MDS_4_BITS_UNSIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hhu", operand->unsigned_imm.val8);
+
+                case MDS_8_BITS_UNSIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hhu", operand->unsigned_imm.val8);
+                    break;
+
+                case MDS_16_BITS_UNSIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hu", operand->unsigned_imm.val16);
+                    break;
+
+                case MDS_32_BITS_UNSIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%u", operand->unsigned_imm.val32);
+                    break;
+
+                case MDS_64_BITS_UNSIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%llu", operand->unsigned_imm.val64);
+                    break;
+
+                case MDS_4_BITS_SIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hhd", operand->signed_imm.val8);
+                    break;
+
+                case MDS_8_BITS_SIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hhd", operand->signed_imm.val8);
+                    break;
+
+                case MDS_16_BITS_SIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%hd", operand->signed_imm.val16);
+                    break;
+
+                case MDS_32_BITS_SIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%d", operand->signed_imm.val32);
+                    break;
+
+                case MDS_64_BITS_SIGNED:
+                    result = snprintf(value, VMPA_MAX_SIZE, "%lld", operand->signed_imm.val64);
+                    break;
+            }
             break;
 
     }
@@ -706,10 +759,12 @@ static void g_imm_operand_add_text(const GImmOperand *operand, GRenderingOptions
 
 static void g_imm_operand_to_buffer(const GImmOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
 {
+    AsmSyntax syntax;                       /* Choix de l'exportation      */
     char value[VMPA_MAX_SIZE];              /* Chaîne à imprimer           */
     size_t len;                             /* Taille de l'élément inséré  */
 
-    len = g_imm_operand_to_string(operand, g_rendering_options_get_syntax(options), value);
+    syntax = (options == NULL ? ASX_COUNT : g_rendering_options_get_syntax(options));
+    len = g_imm_operand_to_string(operand, syntax, value);
 
     g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
                                           value, len, RTT_IMMEDIATE);
@@ -720,6 +775,32 @@ static void g_imm_operand_to_buffer(const GImmOperand *operand, GBufferLine *buf
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_imm_operand_print(const GImmOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    char value[VMPA_MAX_SIZE];              /* Chaîne à imprimer           */
+    size_t len;                             /* Taille de l'élément inséré  */
+
+    len = g_imm_operand_to_string(operand, syntax, value);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, value, len, RTT_IMMEDIATE);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
 *                addr    = valeur résultante. [OUT]                           *
 *                                                                             *
 *  Description : Convertit une valeur immédiate en adresse de type vmpa_t.    *
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index 45a8b2d..2a92bad 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -1,6 +1,6 @@
 
 /* OpenIDA - Outil d'analyse de fichiers binaires
- * instruction.h - prototypes pour la définition générique interne des instructions
+ * instruction-int.h - prototypes pour la définition générique interne des instructions
  *
  * Copyright (C) 2008 Cyrille Bagard
  *
@@ -27,6 +27,7 @@
 
 #include "archbase.h"
 #include "instruction.h"
+#include "translate.h"
 #include "../analysis/exporter-int.h"
 #include "../common/dllist.h"
 
@@ -60,6 +61,7 @@ struct _GArchInstruction
     get_instruction_text_fc get_text;       /* Texte humain équivalent     */
     get_instruction_link_fc get_link;       /* Référence à une instruction */
     is_instruction_return_fc is_return;     /* Retour de fonction ou pas ? */
+    decomp_instr_fc decomp;                 /* Procédure de décompilation  */
 
 };
 
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index b642219..dd43e14 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -306,9 +306,9 @@ size_t g_arch_instruction_count_operands(const GArchInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-const GArchOperand *g_arch_instruction_get_operand(GArchInstruction *instr, size_t index)
+GArchOperand *g_arch_instruction_get_operand(const GArchInstruction *instr, size_t index)
 {
-    const GArchOperand *result;             /* Opérande à retourner        */
+    GArchOperand *result;                   /* Opérande à retourner        */
 
     if (index >= instr->operands_count) result = NULL;
     else result = instr->operands[index];
@@ -463,6 +463,33 @@ bool g_arch_instruction_is_return(const GArchInstruction *instr)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'origine à convertir.                   *
+*                ctx   = contexte de la phase de décompilation.               *
+*                                                                             *
+*  Description : Décompile une instruction de façon générique.                *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_arch_instruction_decompile(const GArchInstruction *instr, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instruction à retourner     */
+
+    if (instr->decomp != NULL)
+        result = instr->decomp(instr, ctx);
+
+    else
+        result = NULL;
+
+    return result;
+
+}
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                      TRAITEMENT DES INSTRUCTIONS PAR ENSEMBLE                      */
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index a9e2bd2..4dcba44 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -32,6 +32,8 @@
 
 #include "archbase.h"
 #include "operand.h"
+#include "../decomp/context.h"
+#include "../decomp/instruction.h"
 #include "../format/executable.h"
 
 
@@ -77,7 +79,7 @@ void g_arch_instruction_attach_extra_operand(GArchInstruction *, GArchOperand *)
 size_t g_arch_instruction_count_operands(const GArchInstruction *);
 
 /* Fournit un opérande donné d'une instruction. */
-const GArchOperand *g_arch_instruction_get_operand(GArchInstruction *, size_t);
+GArchOperand *g_arch_instruction_get_operand(const GArchInstruction *, size_t);
 
 /* Remplace un opérande d'une instruction par un autre. */
 void g_arch_instruction_replace_operand(GArchInstruction *, GArchOperand *, const GArchOperand *);
@@ -94,6 +96,9 @@ InstructionLinkType g_arch_instruction_get_link(const GArchInstruction *, vmpa_t
 /* Indique si l'instruction correspond à un retour de fonction. */
 bool g_arch_instruction_is_return(const GArchInstruction *instr);
 
+/* Décompile une instruction de façon générique. */
+GDecInstruction *g_arch_instruction_decompile(const GArchInstruction *, GDecContext *);
+
 
 
 /* -------------------- TRAITEMENT DES INSTRUCTIONS PAR ENSEMBLE -------------------- */
diff --git a/src/arch/operand-int.h b/src/arch/operand-int.h
index 258a60e..f21b995 100644
--- a/src/arch/operand-int.h
+++ b/src/arch/operand-int.h
@@ -33,6 +33,8 @@
 /* Traduit un opérande en version humainement lisible. */
 typedef char * (* get_operand_text_fc) (const GArchOperand *, const GExeFormat *, AsmSyntax);
 
+/* Traduit un opérande en version humainement lisible. */
+typedef void (* operand_print_fc) (const GArchOperand *, GBufferLine *, AsmSyntax);
 
 /* Définition générique d'un opérande d'architecture (instance) */
 struct _GArchOperand
@@ -40,6 +42,7 @@ struct _GArchOperand
     GContentExporter parent;                /* A laisser en premier        */
 
     get_operand_text_fc get_text;           /* Texte humain équivalent     */
+    operand_print_fc print;                 /* Texte humain équivalent     */
 
 };
 
diff --git a/src/arch/operand.c b/src/arch/operand.c
index d4f6b56..16fc073 100644
--- a/src/arch/operand.c
+++ b/src/arch/operand.c
@@ -96,3 +96,24 @@ char *g_arch_operand_get_text(const GArchOperand *operand, const GExeFormat *for
     return operand->get_text(operand, format, syntax);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_arch_operand_print(const GArchOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    return operand->print(operand, line, syntax);
+
+}
diff --git a/src/arch/operand.h b/src/arch/operand.h
index 6d0dc48..3745a80 100644
--- a/src/arch/operand.h
+++ b/src/arch/operand.h
@@ -28,7 +28,8 @@
 #include <glib-object.h>
 
 
-#include "../format/executable.h"
+#include "../format/executable.h"   /* FIXME : remme ! */
+#include "../glibext/gbufferline.h"
 
 
 
@@ -51,6 +52,9 @@ GType g_arch_operand_get_type(void);
 /* Traduit un opérande en version humainement lisible. */
 char *g_arch_operand_get_text(const GArchOperand *, const GExeFormat *, AsmSyntax);
 
+/* Traduit un opérande en version humainement lisible. */
+void g_arch_operand_print(const GArchOperand *, GBufferLine *, AsmSyntax);
+
 
 
 #endif  /* _ARCH_OPERAND_H */
diff --git a/src/arch/translate.h b/src/arch/translate.h
new file mode 100644
index 0000000..6811bc3
--- /dev/null
+++ b/src/arch/translate.h
@@ -0,0 +1,39 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * translate.h - prototypes pour les environnements de traduction d'instructions
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_TRANSLATE_H
+#define _ARCH_TRANSLATE_H
+
+
+#include "instruction.h"
+#include "../decomp/context.h"
+#include "../decomp/instruction.h"
+
+
+
+/* Décompile une instruction quelconque. */
+typedef GDecInstruction * (* decomp_instr_fc) (const GArchInstruction *, GDecContext *);
+
+
+
+#endif  /* _ANALYSIS_DECOMP_RTL_TRANSLATE_H */
diff --git a/src/decomp/Makefile.am b/src/decomp/Makefile.am
index d77ad29..20694d0 100755
--- a/src/decomp/Makefile.am
+++ b/src/decomp/Makefile.am
@@ -2,10 +2,16 @@
 noinst_LTLIBRARIES  = libdecomp.la
 
 libdecomp_la_SOURCES =					\
+	context.h context.c					\
+	expression-int.h					\
+	expression.h expression.c			\
+	instruction-int.h					\
+	instruction.h instruction.c			\
 	output-int.h						\
 	output.h output.c
 
 libdecomp_la_LIBADD =					\
+	expr/libdecompexpr.la				\
 	lang/libdecomplang.la
 
 libdecomp_la_LDFLAGS = 
@@ -17,4 +23,4 @@ AM_CPPFLAGS =
 
 AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
-SUBDIRS = lang
+SUBDIRS = expr lang
diff --git a/src/decomp/context.c b/src/decomp/context.c
new file mode 100644
index 0000000..7fe6937
--- /dev/null
+++ b/src/decomp/context.c
@@ -0,0 +1,153 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.c - mise en place d'un contexte de décompilation
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "context.h"
+
+
+
+/* Définition d'une context décompilée (instance) */
+struct _GDecContext
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    vmpa_t max;                             /* Première adresse à écarter  */
+
+};
+
+
+/* Définition d'une context décompilée (classe) */
+struct _GDecContextClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des contextes de décompilation. */
+static void g_dec_context_class_init(GDecContextClass *);
+
+/* Initialise une instance de contexte de décompilation. */
+static void g_dec_context_init(GDecContext *);
+
+
+
+/* Indique le type défini pour un contexte de décompilation. */
+G_DEFINE_TYPE(GDecContext, g_dec_context, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décompilation.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_context_class_init(GDecContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ctx = instance à initialiser.                                *
+*                                                                             *
+*  Description : Initialise une instance de contexte de décompilation.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_context_init(GDecContext *ctx)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place un nouveau contexte de décompilation.           *
+*                                                                             *
+*  Retour      : Contexte de décompilation prêt à emploi.                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecContext *g_dec_context_new(void)
+{
+    GDecContext *result;                    /* Instance à retourner        */
+
+    result = g_object_new(G_TYPE_DEC_CONTEXT, NULL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ctx = instance à consulter.                                  *
+*                                                                             *
+*  Description : Indique l'adresse où la décompilation n'est plus souhaitée.  *
+*                                                                             *
+*  Retour      : Adresse mémoire ou physique.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+vmpa_t g_dec_context_get_max_address(const GDecContext *ctx)
+{
+    return ctx->max;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ctx = instance à consulter.                                  *
+*                max = adresse mémoire ou physique.                           *
+*                                                                             *
+*  Description : Définit l'adresse où la décompilation n'est plus souhaitée.  *
+*                                                                             *
+*  Retour      : -                          .                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_dec_context_set_max_address(GDecContext *ctx, vmpa_t max)
+{
+    ctx->max = max;
+
+}
diff --git a/src/decomp/context.h b/src/decomp/context.h
new file mode 100644
index 0000000..76105e6
--- /dev/null
+++ b/src/decomp/context.h
@@ -0,0 +1,66 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.h - prototypes pour la mise en place d'un contexte de décompilation
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_CONTEXT_H
+#define _DECOMP_CONTEXT_H
+
+
+#include <glib-object.h>
+
+
+#include "expr/pseudo.h"
+#include "../arch/archbase.h"
+
+
+
+#define G_TYPE_DEC_CONTEXT               g_dec_context_get_type()
+#define G_DEC_CONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dec_context_get_type(), GDecContext))
+#define G_IS_DEC_CONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dec_context_get_type()))
+#define G_DEC_CONTEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEC_CONTEXT, GDecContextClass))
+#define G_IS_DEC_CONTEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEC_CONTEXT))
+#define G_DEC_CONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEC_CONTEXT, GDecContextClass))
+
+
+
+/* Définition d'un contexte de décompilation (instance) */
+typedef struct _GDecContext GDecContext;
+
+/* Définition d'un contexte de décompilation (classe) */
+typedef struct _GDecContextClass GDecContextClass;
+
+
+/* Indique le type défini pour un contexte de décompilation. */
+GType g_dec_context_get_type(void);
+
+/* Met en place un nouveau contexte de décompilation. */
+GDecContext *g_dec_context_new(void);
+
+/* Indique l'adresse où la décompilation n'est plus souhaitée. */
+vmpa_t g_dec_context_get_max_address(const GDecContext *);
+
+/* Définit l'adresse où la décompilation n'est plus souhaitée. */
+void g_dec_context_set_max_address(GDecContext *, vmpa_t);
+
+
+
+#endif  /* _DECOMP_CONTEXT_H */
diff --git a/src/decomp/expr/Makefile.am b/src/decomp/expr/Makefile.am
new file mode 100644
index 0000000..3c15758
--- /dev/null
+++ b/src/decomp/expr/Makefile.am
@@ -0,0 +1,24 @@
+
+noinst_LTLIBRARIES = libdecompexpr.la
+
+libdecompexpr_la_SOURCES =				\
+	arithm.h arithm.c					\
+	array.h array.c						\
+	assign.h assign.c					\
+	block.h block.c						\
+	call.h call.c						\
+	immediate.h immediate.c				\
+	pseudo.h pseudo.c
+
+libdecompexpr_la_LDFLAGS = 
+
+libdecompexpr_la_LIBADD =				\
+	dalvik/libdecompexprdalvik.la
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS = dalvik
diff --git a/src/decomp/expr/arithm.c b/src/decomp/expr/arithm.c
new file mode 100644
index 0000000..605830d
--- /dev/null
+++ b/src/decomp/expr/arithm.c
@@ -0,0 +1,197 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * arithm.c - représentation des opérations arithmétiques
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "arithm.h"
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'une opération arithmétique définie (instance) */
+struct _GArithmExpression
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GDecExpression *op1;                    /* Premier opérande manipulé   */
+    GDecExpression *op2;                    /* Second opérande manipulé    */
+
+    ArithmOperationType type;               /* Opération à représenter     */
+
+};
+
+
+/* Définition d'une opération arithmétique définie (classe) */
+struct _GArithmExpressionClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des opérations arithmétiques définies. */
+static void g_arithm_expression_class_init(GArithmExpressionClass *);
+
+/* Initialise une instance d'opération arithmétique définie. */
+static void g_arithm_expression_init(GArithmExpression *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_arithm_expression_print(const GArithmExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour une opération arithmétique définie. */
+G_DEFINE_TYPE(GArithmExpression, g_arithm_expression, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des opérations arithmétiques définies.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arithm_expression_class_init(GArithmExpressionClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'opération arithmétique définie.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arithm_expression_init(GArithmExpression *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_arithm_expression_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : op1  = premier opérande à manipuler.                         *
+*                type = type d'opération à mener ici.                         *
+*                op2  = seconde opérande à manipuler.                         *
+*                                                                             *
+*  Description : Représente une opération arithmétique entre deux opérandes.  *
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_arithm_expression_new(GDecExpression *op1, ArithmOperationType type, GDecExpression *op2)
+{
+    GArithmExpression *result;              /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_ARITHM_EXPRESSION, NULL);
+
+    result->op1 = op1;
+    result->op2 = op2;
+
+    result->type = type;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arithm_expression_print(const GArithmExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    const char *sign;                       /* Symbole de l'opération      */
+
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->op1),
+                            buffer, line, output);
+
+    switch (expr->type)
+    {
+        case AOT_ADD:
+            sign = " + ";
+            break;
+        case AOT_SUB:
+            sign = " - ";
+            break;
+        case AOT_MUL:
+            sign = " * ";
+            break;
+        case AOT_DIV:
+            sign = " / ";
+            break;
+        case AOT_REM:
+            sign = " % ";
+            break;
+        case AOT_AND:
+            sign = " & ";
+            break;
+        case AOT_OR:
+            sign = " | ";
+            break;
+        case AOT_XOR:
+            sign = " ^ ";
+            break;
+        default:    /* AOT_COUNT */
+            sign = " ? ";
+            break;
+    }
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, sign, 3, RTT_SIGNS);
+
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->op2),
+                            buffer, line, output);
+
+}
diff --git a/src/decomp/expr/arithm.h b/src/decomp/expr/arithm.h
new file mode 100644
index 0000000..1de9865
--- /dev/null
+++ b/src/decomp/expr/arithm.h
@@ -0,0 +1,76 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * arithm.h - prototypes pour la représentation des opérations arithmétiques
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_DECOMP_COMMON_ARITHM_H
+#define _ANALYSIS_DECOMP_COMMON_ARITHM_H
+
+
+#include <glib-object.h>
+
+
+#include "../expression.h"
+#include "../instruction.h"
+
+
+
+#define G_TYPE_ARITHM_EXPRESSION               g_arithm_expression_get_type()
+#define G_ARITHM_EXPRESSION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arithm_expression_get_type(), GArithmExpression))
+#define G_IS_ARITHM_EXPRESSION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arithm_expression_get_type()))
+#define G_ARITHM_EXPRESSION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARITHM_EXPRESSION, GArithmExpressionClass))
+#define G_IS_ARITHM_EXPRESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARITHM_EXPRESSION))
+#define G_ARITHM_EXPRESSION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARITHM_EXPRESSION, GArithmExpressionClass))
+
+
+/* Définition d'une opération arithmétique définie (instance) */
+typedef struct _GArithmExpression GArithmExpression;
+
+/* Définition d'une opération arithmétique définie (classe) */
+typedef struct _GArithmExpressionClass GArithmExpressionClass;
+
+
+/* Types d'opérations menables */
+typedef enum _ArithmOperationType
+{
+    AOT_ADD,                                /* Addition                    */
+    AOT_SUB,                                /* Soustraction                */
+    AOT_MUL,                                /* Multiplication              */
+    AOT_DIV,                                /* Division                    */
+    AOT_REM,                                /* Modulo                      */
+    AOT_AND,                                /* Et logique                  */
+    AOT_OR,                                 /* Ou logique                  */
+    AOT_XOR,                                /* Ou exclusif                 */
+
+    AOT_COUNT
+
+} ArithmOperationType;
+
+
+/* Indique le type défini pour une opération arithmétique définie. */
+GType g_arithm_expression_get_type(void);
+
+/* Représente une opération arithmétique entre deux opérandes. */
+GDecInstruction *g_arithm_expression_new(GDecExpression *, ArithmOperationType, GDecExpression *);
+
+
+
+#endif  /* _ANALYSIS_DECOMP_COMMON_ARITHM_H */
diff --git a/src/decomp/expr/array.c b/src/decomp/expr/array.c
new file mode 100644
index 0000000..497e47a
--- /dev/null
+++ b/src/decomp/expr/array.c
@@ -0,0 +1,161 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * array.c - manipulations de tableaux génériques
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "array.h"
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'un accès à une cellule de tableau (instance) */
+struct _GArrayAccess
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GDecExpression *array;                  /* Elément auquel accéder      */
+    GDecExpression *index;                  /* Position de la cellule      */
+
+};
+
+
+/* Définition d'un accès à une cellule de tableau (classe) */
+struct _GArrayAccessClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des accès aux cellules de tableau. */
+static void g_array_access_class_init(GArrayAccessClass *);
+
+/* Initialise une instance d'accès à une cellule de tableau. */
+static void g_array_access_init(GArrayAccess *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_array_access_print(const GArrayAccess *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour un accès à une cellule de tableau. */
+G_DEFINE_TYPE(GArrayAccess, g_array_access, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des accès aux cellules de tableau.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_array_access_class_init(GArrayAccessClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'accès à une cellule de tableau.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_array_access_init(GArrayAccess *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_array_access_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : array = tableau auquel on doit accéder.                      *
+*                index = indice de la cellule concernée.                      *
+*                                                                             *
+*  Description : Construit un accès à une cellule de tableau comme expression.*
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_array_access_new(GDecExpression *array, GDecExpression *index)
+{
+    GArrayAccess *result;                 /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_ARRAY_ACCESS, NULL);
+
+    result->array = array;
+    result->index = index;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_array_access_print(const GArrayAccess *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->array),
+                            buffer, line, output);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "[", 1, RTT_RAW);
+
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->index),
+                            buffer, line, output);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "]", 1, RTT_RAW);
+
+}
diff --git a/src/decomp/expr/array.h b/src/decomp/expr/array.h
new file mode 100644
index 0000000..0007a8e
--- /dev/null
+++ b/src/decomp/expr/array.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * array.h - prototypes pour les manipulations de tableaux génériques
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_ARRAY_H
+#define _DECOMP_EXPR_ARRAY_H
+
+
+#include <glib-object.h>
+
+
+#include "../expression.h"
+#include "../instruction.h"
+
+
+
+#define G_TYPE_ARRAY_ACCESS               g_array_access_get_type()
+#define G_ARRAY_ACCESS(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_array_access_get_type(), GArrayAccess))
+#define G_IS_ARRAY_ACCESS(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_array_access_get_type()))
+#define G_ARRAY_ACCESS_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARRAY_ACCESS, GArrayAccessClass))
+#define G_IS_ARRAY_ACCESS_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARRAY_ACCESS))
+#define G_ARRAY_ACCESS_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARRAY_ACCESS, GArrayAccessClass))
+
+
+
+/* Définition d'un accès à une cellule de tableau (instance) */
+typedef struct _GArrayAccess GArrayAccess;
+
+/* Définition d'un accès à une cellule de tableau (classe) */
+typedef struct _GArrayAccessClass GArrayAccessClass;
+
+
+
+/* Indique le type défini pour un accès à une cellule de tableau. */
+GType g_array_access_get_type(void);
+
+/* Construit un accès à une cellule de tableau comme expression. */
+GDecInstruction *g_array_access_new(GDecExpression *, GDecExpression *);
+
+
+
+#endif  /* _DECOMP_EXPR_ARRAY_H */
diff --git a/src/decomp/expr/assign.c b/src/decomp/expr/assign.c
new file mode 100644
index 0000000..561fb0f
--- /dev/null
+++ b/src/decomp/expr/assign.c
@@ -0,0 +1,159 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * assign.c - représentation des assignations
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "assign.h"
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'une assignation quelconque (instance) */
+struct _GAssignExpression
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GDecExpression *dest;                   /* Destination de l'assignat°  */
+    GDecExpression *src;                    /* Source de l'assignation     */
+
+};
+
+
+/* Définition d'une assignation quelconque (classe) */
+struct _GAssignExpressionClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des assignations quelconques. */
+static void g_assign_expression_class_init(GAssignExpressionClass *);
+
+/* Initialise une instance d'assignation quelconque. */
+static void g_assign_expression_init(GAssignExpression *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_assign_expression_print(const GAssignExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour une assignation quelconque. */
+G_DEFINE_TYPE(GAssignExpression, g_assign_expression, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des assignations quelconques.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_assign_expression_class_init(GAssignExpressionClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'assignation quelconque.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_assign_expression_init(GAssignExpression *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_assign_expression_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = expression servant de destination.                    *
+*                src  = source de l'expression à transférer.                  *
+*                                                                             *
+*  Description : Assigne le contenu d'une expression dans une autre.          *
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_assign_expression_new(GDecExpression *dest, GDecExpression *src)
+{
+    GAssignExpression *result;              /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_ASSIGN_EXPRESSION, NULL);
+
+    result->dest = dest;
+    result->src = src;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_assign_expression_print(const GAssignExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->dest),
+                            buffer, line, output);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, " = ", 3, RTT_SIGNS);
+
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->src),
+                            buffer, line, output);
+
+}
diff --git a/src/decomp/expr/assign.h b/src/decomp/expr/assign.h
new file mode 100644
index 0000000..87d167e
--- /dev/null
+++ b/src/decomp/expr/assign.h
@@ -0,0 +1,60 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * assign.h - prototypes pour la représentation des assignations
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_ASSIGN_H
+#define _DECOMP_EXPR_ASSIGN_H
+
+
+#include <glib-object.h>
+
+
+#include "../expression.h"
+#include "../instruction.h"
+
+
+
+#define G_TYPE_ASSIGN_EXPRESSION               g_assign_expression_get_type()
+#define G_ASSIGN_EXPRESSION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_assign_expression_get_type(), GAssignExpression))
+#define G_IS_ASSIGN_EXPRESSION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_assign_expression_get_type()))
+#define G_ASSIGN_EXPRESSION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ASSIGN_EXPRESSION, GAssignExpressionClass))
+#define G_IS_ASSIGN_EXPRESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ASSIGN_EXPRESSION))
+#define G_ASSIGN_EXPRESSION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ASSIGN_EXPRESSION, GAssignExpressionClass))
+
+
+
+/* Définition d'une assignation quelconque (instance) */
+typedef struct _GAssignExpression GAssignExpression;
+
+/* Définition d'une assignation quelconque (classe) */
+typedef struct _GAssignExpressionClass GAssignExpressionClass;
+
+
+/* Indique le type défini pour une assignation quelconque. */
+GType g_assign_expression_get_type(void);
+
+/* Assigne le contenu d'une expression dans une autre. */
+GDecInstruction *g_assign_expression_new(GDecExpression *, GDecExpression *);
+
+
+
+#endif  /* _DECOMP_EXPR_ASSIGN_H */
diff --git a/src/decomp/expr/block.c b/src/decomp/expr/block.c
new file mode 100644
index 0000000..c14e169
--- /dev/null
+++ b/src/decomp/expr/block.c
@@ -0,0 +1,185 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * block.c - regroupement d'un lot d'instructions
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "block.h"
+
+
+#include <malloc.h>
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'un ensemble d'instructions décompilées (instance) */
+struct _GExprBlock
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GDecInstruction **list;                 /* Instructions contenues      */
+    size_t count;                           /* Taille de cette liste       */
+
+};
+
+
+/* Définition d'un ensemble d'instructions décompilées (classe) */
+struct _GExprBlockClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des ensembles d'instructions. */
+static void g_expr_block_class_init(GExprBlockClass *);
+
+/* Initialise une instance d'ensemble d'instructions. */
+static void g_expr_block_init(GExprBlock *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_expr_block_print(const GExprBlock *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour un ensemble d'instructions décompilées. */
+G_DEFINE_TYPE(GExprBlock, g_expr_block, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des ensembles d'instructions.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_expr_block_class_init(GExprBlockClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance d'ensemble d'instructions.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_expr_block_init(GExprBlock *block)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(block);
+
+    instr->print = (dec_instr_print_fc)g_expr_block_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = premier élément du nouvel ensemble.                   *
+*                                                                             *
+*  Description : Constuit un conteneur pour diverses instructions décompilées.*
+*                                                                             *
+*  Retour      : Conteneur d'instructions mis en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_expr_block_new(GDecInstruction *item)
+{
+    GExprBlock *result;                /* Groupe d'instructions à renvoyer */
+
+    result = g_object_new(G_TYPE_EXPR_BLOCK, NULL);
+
+    g_expr_block_add_item(result, item);
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block  = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_expr_block_print(const GExprBlock *block, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < block->count; i++)
+    {
+        if (i > 0)
+            line = g_code_buffer_append_new_line(buffer);   /* FIXME : n° de ligne */
+
+        g_dec_instruction_print(block->list[i], buffer, line, output);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = ensemble à faire évoluer.                            *
+*                item  = nouvel élément à placer dans l'ensemble.             *
+*                                                                             *
+*  Description : Ajoute une instruction décompilée au conteneur existant.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_expr_block_add_item(GExprBlock *block, GDecInstruction *item)
+{
+    block->list = (GDecInstruction **)realloc(block->list, 
+                                              ++block->count * sizeof(GDecInstruction *));
+    block->list[block->count - 1] = item;
+
+}
diff --git a/src/decomp/expr/block.h b/src/decomp/expr/block.h
new file mode 100644
index 0000000..4ae4ff1
--- /dev/null
+++ b/src/decomp/expr/block.h
@@ -0,0 +1,62 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * block.h - prototypes pour le regroupement d'un lot d'instructions
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_BLOCK_H
+#define _DECOMP_EXPR_BLOCK_H
+
+
+#include <glib-object.h>
+
+
+#include "../instruction.h"
+
+
+
+#define G_TYPE_EXPR_BLOCK               g_expr_block_get_type()
+#define G_EXPR_BLOCK(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_expr_block_get_type(), GExprBlock))
+#define G_IS_EXPR_BLOCK(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_expr_block_get_type()))
+#define G_EXPR_BLOCK_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_EXPR_BLOCK, GExprBlockClass))
+#define G_IS_EXPR_BLOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_EXPR_BLOCK))
+#define G_EXPR_BLOCK_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_EXPR_BLOCK, GExprBlockClass))
+
+
+
+/* Définition d'un ensemble d'instructions décompilées (instance) */
+typedef struct _GExprBlock GExprBlock;
+
+/* Définition d'un ensemble d'instructions décompilées (classe) */
+typedef struct _GExprBlockClass GExprBlockClass;
+
+
+/* Indique le type défini pour un ensemble d'instructions décompilées. */
+GType g_expr_block_get_type(void);
+
+/* Constuit un conteneur pour diverses instructions décompilées. */
+GDecInstruction *g_expr_block_new(GDecInstruction *);
+
+/* Ajoute une instruction décompilée au conteneur existant. */
+void g_expr_block_add_item(GExprBlock *, GDecInstruction *);
+
+
+
+#endif  /* _DECOMP_EXPR_BLOCK_H */
diff --git a/src/decomp/expr/call.c b/src/decomp/expr/call.c
new file mode 100644
index 0000000..8f73c4f
--- /dev/null
+++ b/src/decomp/expr/call.c
@@ -0,0 +1,163 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * call.c - encadrement des appels de routine
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "call.h"
+
+
+#include <string.h>
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'un appel à une routine quelconque (instance) */
+struct _GRoutineCall
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GBinRoutine *routine;                   /* Routine sollicitée          */
+    bool is_object;                         /* Nature de l'argument n°1    */
+
+};
+
+
+/* Définition d'un appel à une routine quelconque (classe) */
+struct _GRoutineCallClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des appels à une routine quelconque. */
+static void g_routine_call_class_init(GRoutineCallClass *);
+
+/* Initialise une instance d'appel à une routine quelconque. */
+static void g_routine_call_init(GRoutineCall *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_routine_call_print(const GRoutineCall *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour un appel à une routine quelconque. */
+G_DEFINE_TYPE(GRoutineCall, g_routine_call, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des appels à une routine quelconque.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_routine_call_class_init(GRoutineCallClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'appel à une routine quelconque.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_routine_call_init(GRoutineCall *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_routine_call_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine   = routine dont il est fait appel.                  *
+*                is_object = indique la nature du premier argument.           *
+*                                                                             *
+*  Description : Exprime un appel à une routine quelconque.                   *
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_routine_call_new(GBinRoutine *routine, bool is_object)
+{
+    GRoutineCall *result;              /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_ROUTINE_CALL, NULL);
+
+    result->routine = routine;
+    result->is_object = is_object;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_routine_call_print(const GRoutineCall *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    const char *name;                       /* Désignation de la routine   */
+
+    name = g_binary_routine_get_name(expr->routine);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, name, strlen(name), RTT_RAW);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "(", 1, RTT_PUNCT);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, ")", 1, RTT_PUNCT);
+
+}
diff --git a/src/decomp/expr/call.h b/src/decomp/expr/call.h
new file mode 100644
index 0000000..7515261
--- /dev/null
+++ b/src/decomp/expr/call.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * call.h - prototypes pour l'encadrement des appels de routine
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_CALL_H
+#define _DECOMP_EXPR_CALL_H
+
+
+#include <glib-object.h>
+
+
+#include "../expression.h"
+#include "../instruction.h"
+#include "../../analysis/routine.h"
+
+
+
+#define G_TYPE_ROUTINE_CALL               g_routine_call_get_type()
+#define G_ROUTINE_CALL(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_routine_call_get_type(), GRoutineCall))
+#define G_IS_ROUTINE_CALL(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_routine_call_get_type()))
+#define G_ROUTINE_CALL_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ROUTINE_CALL, GRoutineCallClass))
+#define G_IS_ROUTINE_CALL_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ROUTINE_CALL))
+#define G_ROUTINE_CALL_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ROUTINE_CALL, GRoutineCallClass))
+
+
+
+/* Définition d'un appel à une routine quelconque (instance) */
+typedef struct _GRoutineCall GRoutineCall;
+
+/* Définition d'un appel à une routine quelconque (classe) */
+typedef struct _GRoutineCallClass GRoutineCallClass;
+
+
+/* Indique le type défini pour un appel à une routine quelconque. */
+GType g_routine_call_get_type(void);
+
+/* Exprime un appel à une routine quelconque. */
+GDecInstruction *g_routine_call_new(GBinRoutine *, bool);
+
+
+
+#endif  /* _DECOMP_EXPR_CALL_H */
diff --git a/src/decomp/expr/dalvik/Makefile.am b/src/decomp/expr/dalvik/Makefile.am
new file mode 100644
index 0000000..a14b9dd
--- /dev/null
+++ b/src/decomp/expr/dalvik/Makefile.am
@@ -0,0 +1,14 @@
+
+noinst_LTLIBRARIES = libdecompexprdalvik.la
+
+libdecompexprdalvik_la_SOURCES =		\
+	array.h array.c
+
+libdecompexprdalvik_la_LDFLAGS = 
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
diff --git a/src/decomp/expr/dalvik/array.c b/src/decomp/expr/dalvik/array.c
new file mode 100644
index 0000000..55b9d07
--- /dev/null
+++ b/src/decomp/expr/dalvik/array.c
@@ -0,0 +1,155 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * array.c - manipulations de tableaux propres à Dalvik
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "array.h"
+
+
+#include "../../expression-int.h"
+
+
+
+/* Définition d'une expression de mesure de tableau (instance) */
+struct _GDalvikALength
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GDecExpression *array;                  /* Elément auquel accéder      */
+
+};
+
+
+/* Définition d'une expression de mesure de tableau (classe) */
+struct _GDalvikALengthClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des expressions de mesure de tableau. */
+static void g_dalvik_alength_class_init(GDalvikALengthClass *);
+
+/* Initialise une instance d'expression de mesure de tableau. */
+static void g_dalvik_alength_init(GDalvikALength *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_dalvik_alength_print(const GDalvikALength *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour une expression de mesure de tableau. */
+G_DEFINE_TYPE(GDalvikALength, g_dalvik_alength, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des expressions de mesure de tableau.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_alength_class_init(GDalvikALengthClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'expression de mesure de tableau.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_alength_init(GDalvikALength *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_dalvik_alength_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : array = tableau dont on doit mesurer la taille.              *
+*                                                                             *
+*  Description : Construit une expression à partir d'une mesure de tableau.   *
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_dalvik_alength_new(GDecExpression *array)
+{
+    GDalvikALength *result;                 /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_DALVIK_ALENGTH, NULL);
+
+    result->array = array;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_alength_print(const GDalvikALength *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    g_dec_instruction_print(G_DEC_INSTRUCTION(expr->array),
+                            buffer, line, output);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, ".", 1, RTT_RAW);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "length", 6, RTT_RAW);
+
+}
diff --git a/src/decomp/expr/dalvik/array.h b/src/decomp/expr/dalvik/array.h
new file mode 100644
index 0000000..15670ab
--- /dev/null
+++ b/src/decomp/expr/dalvik/array.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * array.h - prototypes pour les manipulations de tableaux propres à Dalvik
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_DALVIK_ARRAY_H
+#define _DECOMP_EXPR_DALVIK_ARRAY_H
+
+
+#include <glib-object.h>
+
+
+#include "../../expression.h"
+#include "../../instruction.h"
+
+
+
+#define G_TYPE_DALVIK_ALENGTH               g_dalvik_alength_get_type()
+#define G_DALVIK_ALENGTH(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dalvik_alength_get_type(), GDalvikALength))
+#define G_IS_DALVIK_ALENGTH(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dalvik_alength_get_type()))
+#define G_DALVIK_ALENGTH_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DALVIK_ALENGTH, GDalvikALengthClass))
+#define G_IS_DALVIK_ALENGTH_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DALVIK_ALENGTH))
+#define G_DALVIK_ALENGTH_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DALVIK_ALENGTH, GDalvikALengthClass))
+
+
+
+/* Définition d'une expression de mesure de tableau (instance) */
+typedef struct _GDalvikALength GDalvikALength;
+
+/* Définition d'une expression de mesure de tableau (classe) */
+typedef struct _GDalvikALengthClass GDalvikALengthClass;
+
+
+
+/* Indique le type défini pour une expression de mesure de tableau. */
+GType g_dalvik_alength_get_type(void);
+
+/* Construit une expression à partir d'une mesure de tableau. */
+GDecInstruction *g_dalvik_alength_new(GDecExpression *);
+
+
+
+#endif  /* _DECOMP_EXPR_DALVIK_ARRAY_H */
diff --git a/src/decomp/expr/immediate.c b/src/decomp/expr/immediate.c
new file mode 100644
index 0000000..a97c8bd
--- /dev/null
+++ b/src/decomp/expr/immediate.c
@@ -0,0 +1,150 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * immediate.c - raccord avec les opérandes de valeur immédiate
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "immediate.h"
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'une expression de valeur immédiate (instance) */
+struct _GImmExpression
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+    GImmOperand *operand;                   /* Conteneur d'origine         */
+
+};
+
+
+/* Définition d'une expression de valeur immédiate (classe) */
+struct _GImmExpressionClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des expressions de valeur immédiate. */
+static void g_imm_expression_class_init(GImmExpressionClass *);
+
+/* Initialise une instance d'expression de valeur immédiate. */
+static void g_imm_expression_init(GImmExpression *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_imm_expression_print(const GImmExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour une expression de valeur immédiate. */
+G_DEFINE_TYPE(GImmExpression, g_imm_expression, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des expressions de valeur immédiate.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_imm_expression_class_init(GImmExpressionClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'expression de valeur immédiate.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_imm_expression_init(GImmExpression *expr)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(expr);
+
+    instr->print = (dec_instr_print_fc)g_imm_expression_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = conteneur d'origie de la valeur immédiate.         *
+*                                                                             *
+*  Description : Construit une expression à partir d'une valeur immédiate.    *
+*                                                                             *
+*  Retour      : Expression mise en place.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_imm_expression_new(GImmOperand *operand)
+{
+    GImmExpression *result;                 /* Expression à retourner      */
+
+    result = g_object_new(G_TYPE_IMM_EXPRESSION, NULL);
+
+    result->operand = operand;
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr   = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_imm_expression_print(const GImmExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    g_arch_operand_print(G_ARCH_OPERAND(expr->operand), line, ASX_COUNT);
+
+}
diff --git a/src/decomp/expr/immediate.h b/src/decomp/expr/immediate.h
new file mode 100644
index 0000000..c86a15c
--- /dev/null
+++ b/src/decomp/expr/immediate.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * immediate.h - prototypes pour le raccord avec les opérandes de valeur immédiate
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_IMMEDIATE_H
+#define _DECOMP_EXPR_IMMEDIATE_H
+
+
+#include <glib-object.h>
+
+
+#include "../instruction.h"
+#include "../../arch/immediate.h"
+
+
+
+#define G_TYPE_IMM_EXPRESSION               g_imm_expression_get_type()
+#define G_IMM_EXPRESSION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_imm_expression_get_type(), GImmExpression))
+#define G_IS_IMM_EXPRESSION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_imm_expression_get_type()))
+#define G_IMM_EXPRESSION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_IMM_EXPRESSION, GImmExpressionClass))
+#define G_IS_IMM_EXPRESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_IMM_EXPRESSION))
+#define G_IMM_EXPRESSION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_IMM_EXPRESSION, GImmExpressionClass))
+
+
+
+/* Définition d'une expression de valeur immédiate (instance) */
+typedef struct _GImmExpression GImmExpression;
+
+/* Définition d'une expression de valeur immédiate (classe) */
+typedef struct _GImmExpressionClass GImmExpressionClass;
+
+
+
+/* Indique le type défini pour une expression de valeur immédiate. */
+GType g_imm_expression_get_type(void);
+
+/*Construit une expression à partir d'une valeur immédiate. */
+GDecInstruction *g_imm_expression_new(GImmOperand *);
+
+
+
+#endif  /* _DECOMP_EXPR_IMMEDIATE_H */
diff --git a/src/decomp/expr/pseudo.c b/src/decomp/expr/pseudo.c
new file mode 100644
index 0000000..393f32c
--- /dev/null
+++ b/src/decomp/expr/pseudo.c
@@ -0,0 +1,148 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * pseudo.c - définition des pseudo-registres
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "pseudo.h"
+
+
+#include "../expression-int.h"
+
+
+
+/* Définition d'un pseudo-registre (instance) */
+struct _GPseudoRegister
+{
+    GDecExpression parent;                  /* A laisser en premier        */
+
+};
+
+
+/* Définition d'un pseudo-registre (classe) */
+struct _GPseudoRegisterClass
+{
+    GDecExpressionClass parent;             /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des pseudo-registres. */
+static void g_pseudo_register_class_init(GPseudoRegisterClass *);
+
+/* Initialise une instance de pseudo-registre. */
+static void g_pseudo_register_init(GPseudoRegister *);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+static void g_pseudo_register_print(const GPseudoRegister *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+/* Indique le type défini pour un pseudo-registre. */
+G_DEFINE_TYPE(GPseudoRegister, g_pseudo_register, G_TYPE_DEC_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des pseudo-registres.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_pseudo_register_class_init(GPseudoRegisterClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg = instance à initialiser.                                *
+*                                                                             *
+*  Description : Initialise une instance de pseudo-registre.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_pseudo_register_init(GPseudoRegister *reg)
+{
+    GDecInstruction *instr;                 /* Autre version de l'objet    */
+
+    instr = G_DEC_INSTRUCTION(reg);
+
+    instr->print = (dec_instr_print_fc)g_pseudo_register_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Assigne le contenu d'une expression dans une autre.          *
+*                                                                             *
+*  Retour      : Pseudo-registre mis en place.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_pseudo_register_new(void)
+{
+    GPseudoRegister *result;                /* Pseudo-registre à renvoyer  */
+
+    result = g_object_new(G_TYPE_PSEUDO_REGISTER, NULL);
+
+    return G_DEC_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg    = expression à transcrire en version humaine.         *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une expression.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_pseudo_register_print(const GPseudoRegister *reg, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "varX", 4, RTT_RAW);
+
+
+}
diff --git a/src/decomp/expr/pseudo.h b/src/decomp/expr/pseudo.h
new file mode 100644
index 0000000..9734625
--- /dev/null
+++ b/src/decomp/expr/pseudo.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * pseudo.h - prototypes pour la définition des pseudo-registres
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPR_PSEUDO_H
+#define _DECOMP_EXPR_PSEUDO_H
+
+
+#include <glib-object.h>
+
+
+#include "../instruction.h"
+
+
+
+#define G_TYPE_PSEUDO_REGISTER               g_pseudo_register_get_type()
+#define G_PSEUDO_REGISTER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_pseudo_register_get_type(), GPseudoRegister))
+#define G_IS_PSEUDO_REGISTER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_pseudo_register_get_type()))
+#define G_PSEUDO_REGISTER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PSEUDO_REGISTER, GPseudoRegisterClass))
+#define G_IS_PSEUDO_REGISTER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PSEUDO_REGISTER))
+#define G_PSEUDO_REGISTER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PSEUDO_REGISTER, GPseudoRegisterClass))
+
+
+
+/* Définition d'un pseudo-registre (instance) */
+typedef struct _GPseudoRegister GPseudoRegister;
+
+/* Définition d'un pseudo-registre (classe) */
+typedef struct _GPseudoRegisterClass GPseudoRegisterClass;
+
+
+/* Indique le type défini pour un pseudo-registre. */
+GType g_pseudo_register_get_type(void);
+
+/* Assigne le contenu d'une expression dans une autre. */
+GDecInstruction *g_pseudo_register_new(void);
+
+
+
+#endif  /* _DECOMP_EXPR_PSEUDO_H */
diff --git a/src/decomp/expression-int.h b/src/decomp/expression-int.h
new file mode 100644
index 0000000..dacd9b8
--- /dev/null
+++ b/src/decomp/expression-int.h
@@ -0,0 +1,50 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * expression-int.h - prototypes pour la définition interne des expressions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPRESSION_INT_H
+#define _DECOMP_EXPRESSION_INT_H
+
+
+#include "expression.h"
+#include "instruction-int.h"
+
+
+
+/* Définition d'une expression décompilée (instance) */
+struct _GDecExpression
+{
+    GDecInstruction parent;                 /* A laisser en premier        */
+
+};
+
+
+/* Définition d'une expression décompilée (classe) */
+struct _GDecExpressionClass
+{
+    GDecInstructionClass parent;            /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _DECOMP_EXPRESSION_INT_H */
diff --git a/src/decomp/expression.c b/src/decomp/expression.c
new file mode 100644
index 0000000..82a2b4a
--- /dev/null
+++ b/src/decomp/expression.c
@@ -0,0 +1,76 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * expression.c - gestion des expressions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "expression.h"
+
+
+#include "expression-int.h"
+
+
+
+/* Initialise la classe des expressions décompilées. */
+static void g_dec_expression_class_init(GDecExpressionClass *);
+
+/* Initialise une instance d'expression décompilée. */
+static void g_dec_expression_init(GDecExpression *);
+
+
+
+/* Indique le type défini pour une expression décompilée. */
+G_DEFINE_TYPE(GDecExpression, g_dec_expression, G_TYPE_DEC_INSTRUCTION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des expressions décompilées.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_expression_class_init(GDecExpressionClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance d'expression décompilée.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_expression_init(GDecExpression *expr)
+{
+
+}
diff --git a/src/decomp/expression.h b/src/decomp/expression.h
new file mode 100644
index 0000000..4a56c24
--- /dev/null
+++ b/src/decomp/expression.h
@@ -0,0 +1,53 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * expression.h - prototypes pour la gestion des expressions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_EXPRESSION_H
+#define _DECOMP_EXPRESSION_H
+
+
+#include <glib-object.h>
+
+
+
+#define G_TYPE_DEC_EXPRESSION               g_dec_expression_get_type()
+#define G_DEC_EXPRESSION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dec_expression_get_type(), GDecExpression))
+#define G_IS_DEC_EXPRESSION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dec_expression_get_type()))
+#define G_DEC_EXPRESSION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEC_EXPRESSION, GDecExpressionClass))
+#define G_IS_DEC_EXPRESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEC_EXPRESSION))
+#define G_DEC_EXPRESSION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEC_EXPRESSION, GDecExpressionClass))
+
+
+
+/* Définition d'une expression décompilée (instance) */
+typedef struct _GDecExpression GDecExpression;
+
+/* Définition d'une expression décompilée (classe) */
+typedef struct _GDecExpressionClass GDecExpressionClass;
+
+
+/* Indique le type défini pour une expression décompilée. */
+GType g_dec_expression_get_type(void);
+
+
+
+#endif  /* _DECOMP_EXPRESSION_H */
diff --git a/src/decomp/instruction-int.h b/src/decomp/instruction-int.h
new file mode 100644
index 0000000..49a68fc
--- /dev/null
+++ b/src/decomp/instruction-int.h
@@ -0,0 +1,58 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction-int.h - prototypes pour la définition interne des instructions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_INSTRUCTION_INT_H
+#define _DECOMP_INSTRUCTION_INT_H
+
+
+#include "instruction.h"
+#include "../arch/archbase.h"
+
+
+
+/* Imprime pour l'écran un version humaine d'une instruction. */
+typedef void (* dec_instr_print_fc) (GDecInstruction *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+/* Définition d'une instruction décompilée (instance) */
+struct _GDecInstruction
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    vmpa_t address;                         /* Position associée           */
+
+    dec_instr_print_fc print;               /* Impression pour à l'écran   */
+
+};
+
+
+/* Définition d'une instruction décompilée (classe) */
+struct _GDecInstructionClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _DECOMP_INSTRUCTION_INT_H */
diff --git a/src/decomp/instruction.c b/src/decomp/instruction.c
new file mode 100644
index 0000000..96411f5
--- /dev/null
+++ b/src/decomp/instruction.c
@@ -0,0 +1,101 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.c - gestion des instructions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "instruction.h"
+
+
+#include "instruction-int.h"
+
+
+
+/* Initialise la classe des instructions décompilées. */
+static void g_dec_instruction_class_init(GDecInstructionClass *);
+
+/* Initialise une instance d'instruction décompilée. */
+static void g_dec_instruction_init(GDecInstruction *);
+
+
+
+/* Indique le type défini pour une instruction décompilée. */
+G_DEFINE_TYPE(GDecInstruction, g_dec_instruction, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des instructions décompilées.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_instruction_class_init(GDecInstructionClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance d'instruction décompilée.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dec_instruction_init(GDecInstruction *instr)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr  = instruction à transcrire en version humaine.        *
+*                buffer = tampon où doit se réaliser l'insertion.             *
+*                line   = ligne d'impression prête à emploi ou NULL.          *
+*                output = langage de programmation de sortie.                 *
+*                                                                             *
+*  Description : Imprime pour l'écran un version humaine d'une instruction.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_dec_instruction_print(const GDecInstruction *instr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output)
+{
+    if (line == NULL)
+        line = g_code_buffer_append_new_line(buffer);   /* FIXME : n° de ligne */
+
+    instr->print(instr, buffer, line, output);
+
+}
diff --git a/src/decomp/instruction.h b/src/decomp/instruction.h
new file mode 100644
index 0000000..9c8a935
--- /dev/null
+++ b/src/decomp/instruction.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.h - prototypes pour la gestion des instructions décompilées
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _DECOMP_INSTRUCTION_H
+#define _DECOMP_INSTRUCTION_H
+
+
+#include <glib-object.h>
+
+
+#include "output.h"
+
+
+
+#define G_TYPE_DEC_INSTRUCTION               g_dec_instruction_get_type()
+#define G_DEC_INSTRUCTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dec_instruction_get_type(), GDecInstruction))
+#define G_IS_DEC_INSTRUCTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dec_instruction_get_type()))
+#define G_DEC_INSTRUCTION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEC_INSTRUCTION, GDecInstructionClass))
+#define G_IS_DEC_INSTRUCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEC_INSTRUCTION))
+#define G_DEC_INSTRUCTION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEC_INSTRUCTION, GDecInstructionClass))
+
+
+
+/* Définition d'une instruction décompilée (instance) */
+typedef struct _GDecInstruction GDecInstruction;
+
+/* Définition d'une instruction décompilée (classe) */
+typedef struct _GDecInstructionClass GDecInstructionClass;
+
+
+/* Indique le type défini pour une instruction décompilée. */
+GType g_dec_instruction_get_type(void);
+
+/* Imprime pour l'écran un version humaine d'une expression. */
+void g_dec_instruction_print(const GDecInstruction *, GCodeBuffer *, GBufferLine *, GLangOutput *);
+
+
+
+#endif  /* _DECOMP_INSTRUCTION_H */
diff --git a/src/decomp/output.h b/src/decomp/output.h
index 402a73a..63be0f5 100644
--- a/src/decomp/output.h
+++ b/src/decomp/output.h
@@ -53,6 +53,9 @@ GBufferLine *g_lang_output_write_comments(GLangOutput *, GCodeBuffer *, const ch
 
 
 
+typedef unsigned int lang_t;
+
+
 
 
 #endif  /* _DECOMP_OUTPUT_H */
diff --git a/src/format/format.c b/src/format/format.c
index c53e7aa..73f23bd 100644
--- a/src/format/format.c
+++ b/src/format/format.c
@@ -33,6 +33,7 @@
 #include "elf/elf.h"
 #include "java/java.h"
 #include "pe/pe.h"
+#include "../decomp/expr/block.h"
 #include "../panels/log.h"
 
 
@@ -269,6 +270,124 @@ GBinRoutine **g_binary_format_get_routines(const GBinFormat *format, size_t *cou
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : format  = informations chargées à consulter.                 *
+*                routine = routine à traiter.                                 *
+*                                                                             *
+*  Description : Procède à la décompilation basique d'une routine donnée.     *
+*                                                                             *
+*  Retour      : Instructions créées et enregistrées, ou NULL si erreur.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *g_binary_format_decompile_routine(const GBinFormat *format, GBinRoutine *routine)
+{
+    GDecInstruction *result;                /* Instructions décompilées    */
+    GArchInstruction *instr;                /* Instructions natives        */
+    vmpa_t max;                             /* Première adresse à écarter  */
+    GDecContext *ctx;                       /* Contexte de décompilation   */
+    GArchInstruction *iter;                 /* Boucle de parcours          */
+    GDecInstruction *dinstr;                /* Nouvelle décompilation      */
+
+    result = NULL;
+
+    instr = g_binary_routine_get_instructions(routine);
+    max = g_binary_routine_get_address(routine)
+        + g_binary_routine_get_size(routine);
+
+    printf("max :: 0x%08llx\n", max);
+
+    max = 0x00000a98ll; /* FIXME !!!! */
+
+    ctx = g_dec_context_new();
+    g_object_set_data(G_OBJECT(ctx), "format", format);
+    g_dec_context_set_max_address(ctx, max);
+
+    for (iter = instr;
+         iter != NULL;
+         iter = g_arch_instruction_get_next_iter(instr, iter, max))
+    {
+
+
+        printf("DECOMP isntr :: %p\n", iter);
+
+
+        dinstr = g_arch_instruction_decompile(iter, ctx);
+        if (dinstr == NULL) continue;
+
+        printf(" -> done :: %p\n", dinstr);
+
+        if (result == NULL) result = g_expr_block_new(dinstr);
+        else g_expr_block_add_item(G_EXPR_BLOCK(result), dinstr);
+
+    }
+
+
+
+
+
+    g_binary_routine_set_decomp_instructions(routine, result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                buffer = tampon mis à disposition pour la sortie.            *
+*                                                                             *
+*  Description : Procède à la décompilation complète du format.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_format_decompile(const GBinFormat *format, GCodeBuffer *buffer)
+{
+
+
+    GBinRoutine **routines;
+    size_t count;
+
+    size_t i;
+
+    GDecInstruction *instr;
+    
+
+    routines = g_binary_format_get_routines(format, &count);
+
+
+
+    for (i = 0; i < count; i++)
+    {
+        //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
+
+        if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
+        {
+
+            printf("...\n");
+
+            instr = g_binary_routine_get_decomp_instructions(routines[i]);
+
+            g_dec_instruction_print(instr, buffer, NULL, g_java_output_new());
+
+
+
+        }
+
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format  = informations chargées à consulter.                 *
 *                label   = étiquette du symbole si trouvé. [OUT]              *
 *                type    = type du symbole trouvé. [OUT]                      *
 *                address = adresse à cibler, puis décallage final. [OUT]      *
diff --git a/src/format/format.h b/src/format/format.h
index 0223525..073fae3 100644
--- a/src/format/format.h
+++ b/src/format/format.h
@@ -32,7 +32,7 @@
 
 #include "symbol.h"
 #include "../analysis/routine.h"
-
+#include "../decomp/instruction.h"
 
 
 /* ------------------------ TRAITEMENT INDIVIDUEL DE FORMATS ------------------------ */
@@ -70,6 +70,12 @@ void g_binary_format_add_routine(GBinFormat *, GBinRoutine *);
 /* Fournit le prototype de toutes les routines détectées. */
 GBinRoutine **g_binary_format_get_routines(const GBinFormat *, size_t *);
 
+/* Procède à la décompilation basique d'une routine donnée. */
+GDecInstruction *g_binary_format_decompile_routine(const GBinFormat *, GBinRoutine *);
+
+/* Procède à la décompilation complète du format. */
+void g_binary_format_decompile(const GBinFormat *, GCodeBuffer *);
+
 /* Recherche le symbole correspondant à une adresse. */
 bool g_binary_format_resolve_symbol(const GBinFormat *, const char **, SymbolType *, vmpa_t *);
 
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 701cb4b..2527124 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -296,6 +296,16 @@ static void g_buffer_line_class_init(GBufferLineClass *class)
     attrib = pango_attr_foreground_new(16895, 16895, 53759);
     pango_attr_list_insert(class->attribs[RTT_REGISTER], attrib);
 
+    /* RTT_PUNCT */
+
+    class->attribs[RTT_PUNCT] = pango_attr_list_new();
+
+    attrib = pango_attr_foreground_new(0, 0, 0);
+    pango_attr_list_insert(class->attribs[RTT_PUNCT], attrib);
+
+    attrib = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
+    pango_attr_list_insert(class->attribs[RTT_PUNCT], attrib);
+
     /* RTT_HOOK */
 
     class->attribs[RTT_HOOK] = pango_attr_list_new();
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
index 504f0a3..7ee3361 100644
--- a/src/glibext/gbufferline.h
+++ b/src/glibext/gbufferline.h
@@ -75,6 +75,7 @@ typedef enum _RenderingTagType
 
     RTT_REGISTER,                           /* Registre                    */
 
+    RTT_PUNCT,                              /* Signes de ponctuation       */
     RTT_HOOK,                               /* Crochets '[' et ']'         */
     RTT_SIGNS,                              /* Signes '+', '-' et '*'      */
     RTT_LTGT,                               /* Caractères '<' et '>'       */