Improved the rendering of decompiled Dex code.

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

9 files changed, 360 insertions, 8 deletions

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"