Improved the rendering of decompiled Dex code.

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

25 files changed, 625 insertions, 22 deletions

diff --git a/ChangeLog b/ChangeLog
index 82c6916..729f051 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,49 @@
+10-12-02  Cyrille Bagard <nocbos@gmail.com>
+
+	* src/analysis/decomp/decompiler.c:
+	Change debug code.
+
+	* src/analysis/routine.c:
+	* src/analysis/routine.h:
+	Print decompiled code of routines.
+
+	* src/analysis/type.h:
+	Fix included headers.
+
+	* src/arch/immediate.c:
+	* src/decomp/expr/arithm.c:
+	* src/decomp/expr/array.c:
+	* src/decomp/expr/assign.c:
+	* src/decomp/expr/call.c:
+	* src/decomp/expr/pseudo.c:
+	Fix output area (BLC_ASSEMBLY -> BLC_ASSEMBLY_HEAD).
+
+	* src/decomp/lang/java.c:
+	* src/decomp/output.c:
+	* src/decomp/output.h:
+	* src/decomp/output-int.h:
+	Extend the output features.
+
+	* src/format/dex/class.c:
+	* src/format/dex/class.h:
+	* src/format/dex/dex.c:
+	* src/format/dex/method.c:
+	* src/format/dex/method.h:
+	Improve the rendering of decompiled Dex code.
+
+	* src/format/format.c:
+	Change debug code.
+
+	* src/format/format.h:
+	Fix included headers.
+
+	* src/glibext/gbufferline.c:
+	* src/glibext/gbufferline.h:
+	Add the RTT_KEY_WORD rendering attribute.
+
+	* src/gtkext/gtkbufferview.c:
+	Avoid a crash by adding the needed scrolling function.
+
 10-11-28  Cyrille Bagard <nocbos@gmail.com>
 
 	* configure.ac:
diff --git a/src/analysis/decomp/decompiler.c b/src/analysis/decomp/decompiler.c
index faa2f00..c446c0e 100644
--- a/src/analysis/decomp/decompiler.c
+++ b/src/analysis/decomp/decompiler.c
@@ -140,9 +140,9 @@ static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const
 
     for (i = 0; i < count; i++)
     {
-        //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
+        printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
 
-        if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
+        //if (strcmp("fib2", g_binary_routine_get_name(routines[i])) == 0)
         {
 
             printf("...\n");
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index ad82407..fd3d206 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -857,3 +857,64 @@ void g_binary_routine_set_decomp_instructions(GBinRoutine *routine, GDecInstruct
     routine->dinstr = instr;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine à mettre à jour.                           *
+*                lang    = langage à utiliser pour la sortie humaine.         *
+*                buffer  = tampon mis à disposition pour la sortie.           *
+*                body    = indique le type d'impression attendu.              *
+*                                                                             *
+*  Description : Procède à l'impression de la décompilation d'une routine.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_binary_routine_print_code(const GBinRoutine *routine, GLangOutput *lang, GCodeBuffer *buffer, bool body)
+{
+    GBufferLine *line;                      /* Adresse d'une ligne nouvelle*/
+    const char *name;                       /* Nom humain de la routine    */
+    size_t len;                             /* Taille de ce nom            */
+
+    /* Type de retour */
+
+    line = g_lang_output_start_routine_prototype(lang, buffer, routine->ret_type);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW);
+
+    /* Nom de la routine */
+
+    name = g_binary_routine_get_name(routine);
+    if (name != NULL) len = strlen(name);
+    else
+    {
+        name = "???";
+        len = 3;
+    }
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, name, len, RTT_RAW);
+
+
+
+
+    /* Corps de la routine ? */
+
+    if (!body)
+        g_lang_output_end_routine_prototype(lang, buffer, line);
+
+    else
+    {
+        g_lang_output_start_routine_body(lang, buffer, line);
+
+        if (routine->dinstr != NULL)
+            g_dec_instruction_print(routine->dinstr, buffer, NULL, lang);
+
+        g_lang_output_end_routine_body(lang, buffer);
+
+    }
+
+}
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 47de5bd..c58925c 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -156,6 +156,9 @@ 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 *);
 
+/* Procède à l'impression de la décompilation d'une routine. */
+void g_binary_routine_print_code(const GBinRoutine *, GLangOutput *, GCodeBuffer *, bool);
+
 
 
 #endif  /* _ANALYSIS_ROUTINE_H */
diff --git a/src/analysis/type.h b/src/analysis/type.h
index 77f3ace..45d0b82 100644
--- a/src/analysis/type.h
+++ b/src/analysis/type.h
@@ -27,10 +27,10 @@
 
 #include <glib.h>
 #include <glib-object.h>
+#include <stdbool.h>
 
 
 #include "../arch/archbase.h"
-#include "../arch/processor.h"
 
 
 
diff --git a/src/arch/immediate.c b/src/arch/immediate.c
index ec689b8..c3a2f6b 100644
--- a/src/arch/immediate.c
+++ b/src/arch/immediate.c
@@ -793,7 +793,7 @@ static void g_imm_operand_print(const GImmOperand *operand, GBufferLine *line, A
 
     len = g_imm_operand_to_string(operand, syntax, value);
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, value, len, RTT_IMMEDIATE);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, value, len, RTT_IMMEDIATE);
 
 }
 
diff --git a/src/decomp/expr/arithm.c b/src/decomp/expr/arithm.c
index 605830d..0ca73ac 100644
--- a/src/decomp/expr/arithm.c
+++ b/src/decomp/expr/arithm.c
@@ -189,7 +189,7 @@ static void g_arithm_expression_print(const GArithmExpression *expr, GCodeBuffer
             break;
     }
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, sign, 3, RTT_SIGNS);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, sign, 3, RTT_SIGNS);
 
     g_dec_instruction_print(G_DEC_INSTRUCTION(expr->op2),
                             buffer, line, output);
diff --git a/src/decomp/expr/array.c b/src/decomp/expr/array.c
index 497e47a..c14374b 100644
--- a/src/decomp/expr/array.c
+++ b/src/decomp/expr/array.c
@@ -151,11 +151,11 @@ static void g_array_access_print(const GArrayAccess *expr, GCodeBuffer *buffer,
     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_HEAD, "[", 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);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "]", 1, RTT_RAW);
 
 }
diff --git a/src/decomp/expr/assign.c b/src/decomp/expr/assign.c
index 561fb0f..29eb0f8 100644
--- a/src/decomp/expr/assign.c
+++ b/src/decomp/expr/assign.c
@@ -151,7 +151,7 @@ static void g_assign_expression_print(const GAssignExpression *expr, GCodeBuffer
     g_dec_instruction_print(G_DEC_INSTRUCTION(expr->dest),
                             buffer, line, output);
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, " = ", 3, RTT_SIGNS);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, " = ", 3, RTT_SIGNS);
 
     g_dec_instruction_print(G_DEC_INSTRUCTION(expr->src),
                             buffer, line, output);
diff --git a/src/decomp/expr/call.c b/src/decomp/expr/call.c
index 8f73c4f..05e596a 100644
--- a/src/decomp/expr/call.c
+++ b/src/decomp/expr/call.c
@@ -154,10 +154,10 @@ static void g_routine_call_print(const GRoutineCall *expr, GCodeBuffer *buffer,
     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_HEAD, name, strlen(name), RTT_RAW);
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, "(", 1, RTT_PUNCT);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "(", 1, RTT_PUNCT);
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, ")", 1, RTT_PUNCT);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, ")", 1, RTT_PUNCT);
 
 }
diff --git a/src/decomp/expr/pseudo.c b/src/decomp/expr/pseudo.c
index abfcd4d..06ba184 100644
--- a/src/decomp/expr/pseudo.c
+++ b/src/decomp/expr/pseudo.c
@@ -151,7 +151,7 @@ static void g_pseudo_register_print(const GPseudoRegister *reg, GCodeBuffer *buf
 
     snprintf(label, 32, "var%d", reg->index);
 
-    g_buffer_line_insert_text(line, BLC_ASSEMBLY, label, strlen(label), RTT_RAW);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, label, strlen(label), RTT_RAW);
 
 }
 
diff --git a/src/decomp/lang/java.c b/src/decomp/lang/java.c
index d83646d..b934a62 100644
--- a/src/decomp/lang/java.c
+++ b/src/decomp/lang/java.c
@@ -53,6 +53,24 @@ static void g_java_output_init(GJavaOutput *);
 /* Ajoute un commentaire à un tampon donné. */
 static GBufferLine *g_java_output_write_comments(GJavaOutput *, GCodeBuffer *, const char *, size_t);
 
+/* Débute la définition d'une classe. */
+static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GOpenidaType *);
+
+/* Termine la définition d'une classe. */
+static void g_java_output_end_class(GJavaOutput *, GCodeBuffer *);
+
+/* Débute la définition d'une routine. */
+static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GOpenidaType *);
+
+/* Termine la définition d'une routine. */
+static void g_java_output_end_routine_prototype(GJavaOutput *, GCodeBuffer *, GBufferLine *);
+
+/* Commence la définition du corps d'une routine. */
+static void g_java_output_start_routine_body(GJavaOutput *, GCodeBuffer *, GBufferLine *);
+
+/* Termine la définition du corps d'une routine. */
+static void g_java_output_end_routine_body(GJavaOutput *, GCodeBuffer *);
+
 
 
 /* Indique le type défini pour une sortie en langage Java. */
@@ -97,6 +115,14 @@ static void g_java_output_init(GJavaOutput *output)
 
     lang->write_comments = (write_comments_fc)g_java_output_write_comments;
 
+    lang->start_class = (rlgbuftp_fc)g_java_output_start_class;
+    lang->end_class = (lgbuf_fc)g_java_output_end_class;
+
+    lang->start_routine_proto = (rlgbuftp_fc)g_java_output_start_routine_prototype;
+    lang->end_routine_proto = (lgbufln_fc)g_java_output_end_routine_prototype;
+    lang->start_routine_body = (lgbufln_fc)g_java_output_start_routine_body;
+    lang->end_routine_body = (lgbuf_fc)g_java_output_end_routine_body;
+
 }
 
 
@@ -153,3 +179,158 @@ static GBufferLine *g_java_output_write_comments(GJavaOutput *output, GCodeBuffe
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                type   = désignation de la classe à définir.                 *
+*                                                                             *
+*  Description : Débute la définition d'une classe.                           *
+*                                                                             *
+*  Retour      : Ligne nouvellement créée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *type)
+{
+    GBufferLine *result;                    /* Adresse nouvelle à remonter */
+
+    result = g_code_buffer_append_new_line(buffer);
+
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "class", 5, RTT_KEY_WORD);
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW);
+
+    /* TODO */
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "XXX", 3, RTT_RAW);
+
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW);
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "{", 1, RTT_HOOK);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                                                                             *
+*  Description : Termine la définition d'une classe.                          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_output_end_class(GJavaOutput *output, GCodeBuffer *buffer)
+{
+    GBufferLine *result;                    /* Adresse nouvelle à remonter */
+
+    result = g_code_buffer_append_new_line(buffer);
+
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "}", 1, RTT_HOOK);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                ret    = type de retour de la routine traitée.               *
+*                                                                             *
+*  Description : Débute la définition d'une routine.                          *
+*                                                                             *
+*  Retour      : Ligne nouvellement créée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret)
+{
+    GBufferLine *result;                    /* Adresse nouvelle à remonter */
+
+    result = g_code_buffer_append_new_line(buffer);
+
+    /* TODO */
+    g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "XXX", 3, RTT_RAW);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                line   = ligne contenant le prototype de la routine traitée. *
+*                                                                             *
+*  Description : Termine la définition d'une routine.                         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_output_end_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line)
+{
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, ";", 1, RTT_PUNCT);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                line   = ligne contenant le prototype de la routine traitée. *
+*                                                                             *
+*  Description : Commence la définition du corps d'une routine.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_output_start_routine_body(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line)
+{
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW);
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "{", 2, RTT_HOOK);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                                                                             *
+*  Description : Termine la définition du corps d'une routine.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_output_end_routine_body(GJavaOutput *output, GCodeBuffer *buffer)
+{
+    GBufferLine *line;                      /* Nouvelle ligne à constituer */
+
+    line = g_code_buffer_append_new_line(buffer);
+
+    g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "}", 1, RTT_HOOK);
+
+}
diff --git a/src/decomp/output-int.h b/src/decomp/output-int.h
index eb22fd6..0d22aa5 100644
--- a/src/decomp/output-int.h
+++ b/src/decomp/output-int.h
@@ -32,6 +32,15 @@
 /* Ajoute un commentaire à un tampon donné. */
 typedef GBufferLine * (* write_comments_fc) (GLangOutput *, GCodeBuffer *, const char *, size_t);
 
+/* Xxx. */
+typedef GBufferLine * (* rlgbuftp_fc) (GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+
+/* Xxx. */
+typedef void (* lgbuf_fc) (GLangOutput *, GCodeBuffer *);
+
+/* Xxx. */
+typedef void (* lgbufln_fc) (GLangOutput *, GCodeBuffer *, GBufferLine *);
+
 
 
 /* Sortie selon un langage de programmation (instance) */
@@ -41,6 +50,14 @@ struct _GLangOutput
 
     write_comments_fc write_comments;       /* Commentaires sur une ligne  */
 
+    rlgbuftp_fc start_class;                /* Début de définition         */
+    lgbuf_fc end_class;                     /* Fin de définition de classe */
+
+    rlgbuftp_fc start_routine_proto;        /* Début de prototype          */
+    lgbufln_fc end_routine_proto;           /* Fin de prototype            */
+    lgbufln_fc start_routine_body;          /* Début de définition         */
+    lgbuf_fc end_routine_body;              /* Fin de définition de corps  */
+
 };
 
 
diff --git a/src/decomp/output.c b/src/decomp/output.c
index 17aaa0e..066096e 100644
--- a/src/decomp/output.c
+++ b/src/decomp/output.c
@@ -98,9 +98,143 @@ GBufferLine *g_lang_output_write_comments(GLangOutput *output, GCodeBuffer *buff
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                type   = désignation de la classe à définir.                 *
+*                                                                             *
+*  Description : Débute la définition d'une classe.                           *
+*                                                                             *
+*  Retour      : Ligne nouvellement créée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBufferLine *g_lang_output_start_class(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *type)
+{
+    GBufferLine *result;                    /* Adresse nouvelle à remonter */
+
+    if (output->start_class != NULL)
+        result = output->start_class(output, buffer, type);
+
+    else result = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                                                                             *
+*  Description : Termine la définition d'une classe.                          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_lang_output_end_class(GLangOutput *output, GCodeBuffer *buffer)
+{
+    if (output->end_class != NULL)
+        output->end_class(output, buffer);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                ret    = type de retour de la routine traitée.               *
+*                                                                             *
+*  Description : Débute la définition d'une routine.                          *
+*                                                                             *
+*  Retour      : Ligne nouvellement créée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret)
+{
+    GBufferLine *result;                    /* Adresse nouvelle à remonter */
 
+    if (output->start_routine_proto != NULL)
+        result = output->start_routine_proto(output, buffer, ret);
 
+    else result = NULL;
 
+    return result;
 
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                line   = ligne contenant le prototype de la routine traitée. *
+*                                                                             *
+*  Description : Termine la définition d'une routine.                         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_lang_output_end_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, GBufferLine *line)
+{
+    if (output->end_routine_proto != NULL)
+        output->end_routine_proto(output, buffer, line);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                line   = ligne contenant le prototype de la routine traitée. *
+*                                                                             *
+*  Description : Commence la définition du corps d'une routine.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_lang_output_start_routine_body(GLangOutput *output, GCodeBuffer *buffer, GBufferLine *line)
+{
+    if (output->start_routine_body != NULL)
+        output->start_routine_body(output, buffer, line);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : output = encadrant de l'impression en langage de prog.       *
+*                buffer = tampon de sortie à disposition.                     *
+*                                                                             *
+*  Description : Termine la définition du corps d'une routine.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_lang_output_end_routine_body(GLangOutput *output, GCodeBuffer *buffer)
+{
+    if (output->end_routine_body != NULL)
+        output->end_routine_body(output, buffer);
+
+}
diff --git a/src/decomp/output.h b/src/decomp/output.h
index 63be0f5..a4f72b2 100644
--- a/src/decomp/output.h
+++ b/src/decomp/output.h
@@ -25,6 +25,7 @@
 #define _DECOMP_OUTPUT_H
 
 
+#include "../analysis/type.h"
 #include "../glibext/gcodebuffer.h"
 
 
@@ -50,11 +51,30 @@ GType g_lang_output_get_type(void);
 /* Ajoute un commentaire à un tampon donné. */
 GBufferLine *g_lang_output_write_comments(GLangOutput *, GCodeBuffer *, const char *, size_t);
 
+/* Débute la définition d'une classe. */
+GBufferLine *g_lang_output_start_class(GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+
+/* Termine la définition d'une classe. */
+void g_lang_output_end_class(GLangOutput *, GCodeBuffer *);
+
+/* Définit le prototype d'une routine. */
+GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *, GCodeBuffer *, const GOpenidaType *);
+
+/* Marque la fin du prototype d'une routine. */
+void g_lang_output_end_routine_prototype(GLangOutput *, GCodeBuffer *, GBufferLine *);
+
+/* Commence la définition du corps d'une routine. */
+void g_lang_output_start_routine_body(GLangOutput *, GCodeBuffer *, GBufferLine *);
+
+/* Termine la définition du corps d'une routine. */
+void g_lang_output_end_routine_body(GLangOutput *, GCodeBuffer *);
+
 
 
 
 typedef unsigned int lang_t;
 
+#include "lang/java.h"
 
 
 
diff --git a/src/format/dex/class.c b/src/format/dex/class.c
index 8182987..710b023 100644
--- a/src/format/dex/class.c
+++ b/src/format/dex/class.c
@@ -307,14 +307,90 @@ const char *g_dex_class_get_source_file(const GDexClass *class, const GDexFormat
 {
     const char *result;                     /* Trouvaille à renvoyer       */
 
-    result = get_string_from_dex_pool(format,
-                                      class->definition.source_file_idx);
+    result = get_string_from_dex_pool(format, class->definition.source_file_idx);
 
     return result;
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class  = informations chargées à consulter.                  *
+*                lang   = langage à utiliser pour la sortie humaine.          *
+*                buffer = tampon mis à disposition pour la sortie.            *
+*                format = informations chargées à consulter.                  *
+*                                                                             *
+*  Description : Procède à la décompilation complète d'une classe donnée.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_dex_class_decompile(const GDexClass *class, GLangOutput *lang, GCodeBuffer *buffer, const GDexFormat *format)
+{
+
+
+    GOpenidaType *type;
+
+
+    size_t i;                               /* Boucle de parcours          */
+
+
+    /*
+GBufferLine *line, GLangOutput *output)
+
+    for (i = 0; i < block->count; i++)
+    {
+        if (i > 0)
+            line = g_code_buffer_append_new_line(buffer);
+
+*/
+
+
+
+    type = get_type_from_dex_pool(format, class->definition.class_idx);
+
+    //g_buffer_line_insert_text(line, BLC_ASSEMBLY, "{", 3, RTT_SIGNS);
+
+    printf("Output :: %s\n", _g_openida_type_to_string(type, true));
+
+
+
+    g_lang_output_start_class(lang, buffer, type);
+
+
+
+    for (i = 0; i < class->vmethods_count; i++)
+    {
+        g_dex_method_decompile(class->virtual_methods[i], lang, buffer);
+        g_code_buffer_append_new_line(buffer);
+    }
+
+    for (i = 0; i < class->dmethods_count; i++)
+    {
+        g_dex_method_decompile(class->direct_methods[i], lang, buffer);
+        g_code_buffer_append_new_line(buffer);
+    }
+
+
+
+
+
+
+
+
+    g_lang_output_end_class(lang, buffer);
+
+
+
+
+
+
+}
+
 
 
 
diff --git a/src/format/dex/class.h b/src/format/dex/class.h
index b9dfed1..f4d5cb0 100644
--- a/src/format/dex/class.h
+++ b/src/format/dex/class.h
@@ -29,6 +29,7 @@
 
 
 #include "dex.h"
+#include "../../decomp/output.h"
 
 
 
@@ -58,6 +59,8 @@ GBinPart **g_dex_class_get_parts(const GDexClass *, GBinPart **, size_t *);
 /* Retrouve si possible le nom du fichier source d'une classe. */
 const char *g_dex_class_get_source_file(const GDexClass *, const GDexFormat *);
 
+/* Procède à la décompilation complète d'une classe donnée. */
+void g_dex_class_decompile(const GDexClass *, GLangOutput *, GCodeBuffer *, const GDexFormat *);
 
 
 
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
index 25482af..174bd2b 100755
--- a/src/format/dex/dex.c
+++ b/src/format/dex/dex.c
@@ -260,15 +260,20 @@ static void g_dex_format_find_all_sources(GDexFormat *format)
 
 static void g_dex_format_decompile(const GDexFormat *format, GCodeBuffer *buffer, const char *filename)
 {
+    GLangOutput *lang;                      /* Langage de sortie           */
     size_t i;                               /* Boucle de parcours          */
     const char *source;                     /* Fichier source trouvé       */
 
+    lang = g_java_output_new();
+
     for (i = 0; i < format->classes_count; i++)
     {
         source = g_dex_class_get_source_file(format->classes[i], format);
         if (source == NULL || strcmp(source, filename) != 0) continue;
 
-        printf("SRC :: '%s'\n", source);
+        g_dex_class_decompile(format->classes[i], lang, buffer, format);
+
+
 
 #if 0
         GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
diff --git a/src/format/dex/method.c b/src/format/dex/method.c
index 9bac013..b9023d8 100644
--- a/src/format/dex/method.c
+++ b/src/format/dex/method.c
@@ -221,4 +221,22 @@ GBinPart *g_dex_method_as_part(const GDexMethod *method)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : method = informations chargées à consulter.                  *
+*                lang   = langage à utiliser pour la sortie humaine.          *
+*                buffer = tampon mis à disposition pour la sortie.            *
+*                                                                             *
+*  Description : Procède à la décompilation complète d'une routine donnée.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void g_dex_method_decompile(const GDexMethod *method, GLangOutput *lang, GCodeBuffer *buffer)
+{
+    g_binary_routine_print_code(method->routine, lang, buffer, true);
+
+}
diff --git a/src/format/dex/method.h b/src/format/dex/method.h
index 0f5a465..79dbd7e 100644
--- a/src/format/dex/method.h
+++ b/src/format/dex/method.h
@@ -62,9 +62,8 @@ GBinRoutine *g_dex_method_get_routine(const GDexMethod *);
 /* Fournit la zone binaire correspondant à la méthode. */
 GBinPart *g_dex_method_as_part(const GDexMethod *);
 
-
-
-
+/* Procède à la décompilation complète d'une routine donnée. */
+void g_dex_method_decompile(const GDexMethod *, GLangOutput *, GCodeBuffer *);
 
 
 
diff --git a/src/format/format.c b/src/format/format.c
index c104649..053a7aa 100644
--- a/src/format/format.c
+++ b/src/format/format.c
@@ -297,7 +297,7 @@ GDecInstruction *g_binary_format_decompile_routine(const GBinFormat *format, GBi
 
     printf("max :: 0x%08llx\n", max);
 
-    max = 0x00000a98ll; /* FIXME !!!! */
+    //max = 0x00000a98ll; /* FIXME !!!! */
 
     ctx = g_dec_context_new();
     g_object_set_data(G_OBJECT(ctx), "format", format);
@@ -394,14 +394,16 @@ void g_binary_format_decompile(const GBinFormat *format, GCodeBuffer *buffer, co
     {
         //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
 
-        if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
+        //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());
+            if (instr == NULL) continue;
+
+            //g_dec_instruction_print(instr, buffer, NULL, g_java_output_new());
 
 
 
diff --git a/src/format/format.h b/src/format/format.h
index 90aabbc..dd05dd2 100644
--- a/src/format/format.h
+++ b/src/format/format.h
@@ -33,7 +33,6 @@
 #include "symbol.h"
 #include "../analysis/routine.h"
 #include "../decomp/instruction.h"
-#include "../decomp/output.h"
 
 
 
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 2527124..08684d5 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -360,6 +360,16 @@ static void g_buffer_line_class_init(GBufferLineClass *class)
 
     class->attribs[RTT_VAR_NAME] = pango_attr_list_new();
 
+    attrib = pango_attr_foreground_new(0, 0, 0);
+    pango_attr_list_insert(class->attribs[RTT_VAR_NAME], attrib);
+
+    /* RTT_KEY_WORD */
+
+    class->attribs[RTT_KEY_WORD] = pango_attr_list_new();
+
+    attrib = pango_attr_foreground_new(0, 0, 0);
+    pango_attr_list_insert(class->attribs[RTT_KEY_WORD], attrib);
+
 }
 
 
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
index 7ee3361..d4384e3 100644
--- a/src/glibext/gbufferline.h
+++ b/src/glibext/gbufferline.h
@@ -86,6 +86,8 @@ typedef enum _RenderingTagType
 
     RTT_VAR_NAME,                           /* Nom de variable             */
 
+    RTT_KEY_WORD,                           /* Mot clef de langage         */
+
     RTT_COUNT
 
 } RenderingTagType;
diff --git a/src/gtkext/gtkbufferview.c b/src/gtkext/gtkbufferview.c
index 81fb998..485ed79 100644
--- a/src/gtkext/gtkbufferview.c
+++ b/src/gtkext/gtkbufferview.c
@@ -43,6 +43,9 @@ static void gtk_buffer_view_size_allocate(GtkWidget *, GtkAllocation *);
 /* Met à jour l'affichage de la visualisation de code buffer. */
 static gboolean gtk_buffer_view_expose(GtkWidget *, GdkEventExpose *);
 
+/* Réagit à un défilement quelconque. */
+static void gtk_buffer_view_scroll(GtkBufferView *);
+
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -93,6 +96,11 @@ static void gtk_buffer_view_class_init(GtkBufferViewClass *class)
 
 static void gtk_buffer_view_init(GtkBufferView *view)
 {
+    GtkViewPanel *viewpanel;                /* Instance parente            */
+
+    viewpanel = GTK_VIEW_PANEL(view);
+
+    viewpanel->scroll = (scroll_fc)gtk_buffer_view_scroll;
 
 }
 
@@ -271,6 +279,25 @@ static gboolean gtk_buffer_view_expose(GtkWidget *widget, GdkEventExpose *event)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : view  = composant GTK à mettre à jour.                       *
+*                                                                             *
+*  Description : Réagit à un défilement quelconque.                           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_buffer_view_scroll(GtkBufferView *view)
+{
+    gtk_widget_queue_draw(GTK_WIDGET(view));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : view   = composant GTK à mettre à jour.                      *
 *                buffer = tampon de lignes à encadrer.                        *
 *                                                                             *