From 957f50b657456c4c7da2778197c144548eded8cd Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Thu, 2 Dec 2010 00:59:53 +0000 Subject: Improved the rendering of decompiled Dex code. git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@196 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a --- ChangeLog | 46 ++++++++++ src/analysis/decomp/decompiler.c | 4 +- src/analysis/routine.c | 61 +++++++++++++ src/analysis/routine.h | 3 + src/analysis/type.h | 2 +- src/arch/immediate.c | 2 +- src/decomp/expr/arithm.c | 2 +- src/decomp/expr/array.c | 4 +- src/decomp/expr/assign.c | 2 +- src/decomp/expr/call.c | 6 +- src/decomp/expr/pseudo.c | 2 +- src/decomp/lang/java.c | 181 +++++++++++++++++++++++++++++++++++++++ src/decomp/output-int.h | 17 ++++ src/decomp/output.c | 134 +++++++++++++++++++++++++++++ src/decomp/output.h | 20 +++++ src/format/dex/class.c | 80 ++++++++++++++++- src/format/dex/class.h | 3 + src/format/dex/dex.c | 7 +- src/format/dex/method.c | 18 ++++ src/format/dex/method.h | 5 +- src/format/format.c | 8 +- src/format/format.h | 1 - src/glibext/gbufferline.c | 10 +++ src/glibext/gbufferline.h | 2 + src/gtkext/gtkbufferview.c | 27 ++++++ 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 + + * 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 * 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 #include +#include #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. * * * -- cgit v0.11.2-87-g4458