diff options
Diffstat (limited to 'src/decomp/expr')
28 files changed, 0 insertions, 4401 deletions
diff --git a/src/decomp/expr/Makefile.am b/src/decomp/expr/Makefile.am deleted file mode 100644 index 665c3f7..0000000 --- a/src/decomp/expr/Makefile.am +++ /dev/null @@ -1,28 +0,0 @@ - -noinst_LTLIBRARIES = libdecompexpr.la - -libdecompexpr_la_SOURCES = \ - access.h access.c \ - arithm.h arithm.c \ - array.h array.c \ - assign.h assign.c \ - block.h block.c \ - call.h call.c \ - comp.h comp.c \ - cond.h cond.c \ - immediate.h immediate.c \ - pseudo.h pseudo.c \ - return.h return.c \ - text.h text.c - -libdecompexpr_la_LDFLAGS = - -libdecompexpr_la_LIBADD = \ - dalvik/libdecompexprdalvik.la - - -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) - -AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) - -SUBDIRS = dalvik diff --git a/src/decomp/expr/access.c b/src/decomp/expr/access.c deleted file mode 100644 index b16ee36..0000000 --- a/src/decomp/expr/access.c +++ /dev/null @@ -1,249 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * access.c - représentation des accès à des éléments d'entités - * - * Copyright (C) 2012-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "access.h" - - -#include "../expression-int.h" - - - -/* Définition d'un accès quelconque (instance) */ -struct _GAccessExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *owner; /* Destination de l'accessat° */ - GDecExpression *target; /* Source de l'accessation */ - -}; - - -/* Définition d'un accès quelconque (classe) */ -struct _GAccessExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des accessations quelconques. */ -static void g_access_expression_class_init(GAccessExpressionClass *); - -/* Initialise une instance d'accessation quelconque. */ -static void g_access_expression_init(GAccessExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_access_expression_visit(GAccessExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_access_expression_replace(GAccessExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_access_expression_print(const GAccessExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un accès quelconque. */ -G_DEFINE_TYPE(GAccessExpression, g_access_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des accessations quelconques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_access_expression_class_init(GAccessExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'accessation quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_access_expression_init(GAccessExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_access_expression_visit; - instr->replace = (dec_instr_replace_fc)g_access_expression_replace; - instr->print = (dec_instr_print_fc)g_access_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : owner = entité qui accueille la cible accédée. * -* target = élément du propriétaire auquel on accède. * -* * -* Description : Représente l'accès à un élément d'une entité. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_access_expression_new(GDecExpression *owner, GDecExpression *target) -{ - GAccessExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_ACCESS_EXPRESSION, NULL); - - result->owner = owner; - result->target = target; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_access_expression_visit(GAccessExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->owner), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - if (result) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->target), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_access_expression_replace(GAccessExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->owner == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->owner)); - g_object_ref(G_OBJECT(new)); - expr->owner = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->owner), old, new); - - if (expr->target == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->target)); - g_object_ref(G_OBJECT(new)); - expr->target = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->target), old, new); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_access_expression_print(const GAccessExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->owner), - buffer, line, output); - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, ".", 3, RTT_PUNCT, NULL); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->target), - buffer, result, output); - - return result; - -} diff --git a/src/decomp/expr/access.h b/src/decomp/expr/access.h deleted file mode 100644 index 220de07..0000000 --- a/src/decomp/expr/access.h +++ /dev/null @@ -1,60 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * access.h - prototypes pour la représentation des accès à des éléments d'entités - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_ACCESS_H -#define _DECOMP_EXPR_ACCESS_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" - - - -#define G_TYPE_ACCESS_EXPRESSION g_access_expression_get_type() -#define G_ACCESS_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_access_expression_get_type(), GAccessExpression)) -#define G_IS_ACCESS_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_access_expression_get_type())) -#define G_ACCESS_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ACCESS_EXPRESSION, GAccessExpressionClass)) -#define G_IS_ACCESS_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ACCESS_EXPRESSION)) -#define G_ACCESS_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ACCESS_EXPRESSION, GAccessExpressionClass)) - - - -/* Définition d'un accès quelconque (instance) */ -typedef struct _GAccessExpression GAccessExpression; - -/* Définition d'un accès quelconque (classe) */ -typedef struct _GAccessExpressionClass GAccessExpressionClass; - - -/* Indique le type défini pour un accès quelconque. */ -GType g_access_expression_get_type(void); - -/* Représente l'accès à un élément d'une entité. */ -GDecInstruction *g_access_expression_new(GDecExpression *, GDecExpression *); - - - -#endif /* _DECOMP_EXPR_ACCESS_H */ diff --git a/src/decomp/expr/arithm.c b/src/decomp/expr/arithm.c deleted file mode 100644 index 8944596..0000000 --- a/src/decomp/expr/arithm.c +++ /dev/null @@ -1,286 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * arithm.c - représentation des opérations arithmétiques - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "arithm.h" - - -#include "../expression-int.h" - - - -/* Définition d'une opération arithmétique définie (instance) */ -struct _GArithmExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *op1; /* Premier opérande manipulé */ - GDecExpression *op2; /* Second opérande manipulé */ - - ArithmOperationType type; /* Opération à représenter */ - -}; - - -/* Définition d'une opération arithmétique définie (classe) */ -struct _GArithmExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des opérations arithmétiques définies. */ -static void g_arithm_expression_class_init(GArithmExpressionClass *); - -/* Initialise une instance d'opération arithmétique définie. */ -static void g_arithm_expression_init(GArithmExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_arithm_expression_visit(GArithmExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_arithm_expression_replace(GArithmExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_arithm_expression_print(const GArithmExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour une opération arithmétique définie. */ -G_DEFINE_TYPE(GArithmExpression, g_arithm_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérations arithmétiques définies. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_arithm_expression_class_init(GArithmExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'opération arithmétique définie. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_arithm_expression_init(GArithmExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_arithm_expression_visit; - instr->replace = (dec_instr_replace_fc)g_arithm_expression_replace; - instr->print = (dec_instr_print_fc)g_arithm_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : op1 = premier opérande à manipuler. * -* type = type d'opération à mener ici. * -* op2 = seconde opérande à manipuler. * -* * -* Description : Représente une opération arithmétique entre deux opérandes. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_arithm_expression_new(GDecExpression *op1, ArithmOperationType type, GDecExpression *op2) -{ - GArithmExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_ARITHM_EXPRESSION, NULL); - - result->op1 = op1; - result->op2 = op2; - - result->type = type; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_arithm_expression_visit(GArithmExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->op1), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - if (result) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->op2), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_arithm_expression_replace(GArithmExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->op1 == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->op1)); - g_object_ref(G_OBJECT(new)); - expr->op1 = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->op1), old, new); - - if (expr->op2 == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->op2)); - g_object_ref(G_OBJECT(new)); - expr->op2 = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->op2), old, new); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_arithm_expression_print(const GArithmExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - const char *sign; /* Symbole de l'opération */ - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->op1), - buffer, line, output); - - switch (expr->type) - { - case AOT_ADD: - sign = " + "; - break; - case AOT_SUB: - sign = " - "; - break; - case AOT_MUL: - sign = " * "; - break; - case AOT_DIV: - sign = " / "; - break; - case AOT_REM: - sign = " % "; - break; - case AOT_AND: - sign = " & "; - break; - case AOT_OR: - sign = " | "; - break; - case AOT_XOR: - sign = " ^ "; - break; - default: /* AOT_COUNT */ - sign = " ? "; - break; - } - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, sign, 3, RTT_SIGNS, NULL); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->op2), - buffer, result, output); - - return result; - -} diff --git a/src/decomp/expr/arithm.h b/src/decomp/expr/arithm.h deleted file mode 100644 index 47aac7f..0000000 --- a/src/decomp/expr/arithm.h +++ /dev/null @@ -1,76 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * arithm.h - prototypes pour la représentation des opérations arithmétiques - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _ANALYSIS_DECOMP_COMMON_ARITHM_H -#define _ANALYSIS_DECOMP_COMMON_ARITHM_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" - - - -#define G_TYPE_ARITHM_EXPRESSION g_arithm_expression_get_type() -#define G_ARITHM_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arithm_expression_get_type(), GArithmExpression)) -#define G_IS_ARITHM_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arithm_expression_get_type())) -#define G_ARITHM_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARITHM_EXPRESSION, GArithmExpressionClass)) -#define G_IS_ARITHM_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARITHM_EXPRESSION)) -#define G_ARITHM_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARITHM_EXPRESSION, GArithmExpressionClass)) - - -/* Définition d'une opération arithmétique définie (instance) */ -typedef struct _GArithmExpression GArithmExpression; - -/* Définition d'une opération arithmétique définie (classe) */ -typedef struct _GArithmExpressionClass GArithmExpressionClass; - - -/* Types d'opérations menables */ -typedef enum _ArithmOperationType -{ - AOT_ADD, /* Addition */ - AOT_SUB, /* Soustraction */ - AOT_MUL, /* Multiplication */ - AOT_DIV, /* Division */ - AOT_REM, /* Modulo */ - AOT_AND, /* Et logique */ - AOT_OR, /* Ou logique */ - AOT_XOR, /* Ou exclusif */ - - AOT_COUNT - -} ArithmOperationType; - - -/* Indique le type défini pour une opération arithmétique définie. */ -GType g_arithm_expression_get_type(void); - -/* Représente une opération arithmétique entre deux opérandes. */ -GDecInstruction *g_arithm_expression_new(GDecExpression *, ArithmOperationType, GDecExpression *); - - - -#endif /* _ANALYSIS_DECOMP_COMMON_ARITHM_H */ diff --git a/src/decomp/expr/array.c b/src/decomp/expr/array.c deleted file mode 100644 index a78405e..0000000 --- a/src/decomp/expr/array.c +++ /dev/null @@ -1,251 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * array.c - manipulations de tableaux génériques - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "array.h" - - -#include "../expression-int.h" - - - -/* Définition d'un accès à une cellule de tableau (instance) */ -struct _GArrayAccess -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *array; /* Elément auquel accéder */ - GDecExpression *index; /* Position de la cellule */ - -}; - - -/* Définition d'un accès à une cellule de tableau (classe) */ -struct _GArrayAccessClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des accès aux cellules de tableau. */ -static void g_array_access_class_init(GArrayAccessClass *); - -/* Initialise une instance d'accès à une cellule de tableau. */ -static void g_array_access_init(GArrayAccess *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_array_access_visit(GArrayAccess *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_array_access_replace(GArrayAccess *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_array_access_print(const GArrayAccess *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un accès à une cellule de tableau. */ -G_DEFINE_TYPE(GArrayAccess, g_array_access, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des accès aux cellules de tableau. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_array_access_class_init(GArrayAccessClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'accès à une cellule de tableau. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_array_access_init(GArrayAccess *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_array_access_visit; - instr->replace = (dec_instr_replace_fc)g_array_access_replace; - instr->print = (dec_instr_print_fc)g_array_access_print; - -} - - -/****************************************************************************** -* * -* Paramètres : array = tableau auquel on doit accéder. * -* index = indice de la cellule concernée. * -* * -* Description : Construit un accès à une cellule de tableau comme expression.* -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_array_access_new(GDecExpression *array, GDecExpression *index) -{ - GArrayAccess *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_ARRAY_ACCESS, NULL); - - result->array = array; - result->index = index; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_array_access_visit(GArrayAccess *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->array), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - if (result) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->index), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_array_access_replace(GArrayAccess *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->array == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->array)); - g_object_ref(G_OBJECT(new)); - expr->array = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->array), old, new); - - if (expr->index == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->index)); - g_object_ref(G_OBJECT(new)); - expr->index = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->index), old, new); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_array_access_print(const GArrayAccess *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->array), - buffer, line, output); - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "[", 1, RTT_RAW, NULL); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->index), - buffer, result, output); - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "]", 1, RTT_RAW, NULL); - - return result; - -} diff --git a/src/decomp/expr/array.h b/src/decomp/expr/array.h deleted file mode 100644 index 2cce58a..0000000 --- a/src/decomp/expr/array.h +++ /dev/null @@ -1,61 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * array.h - prototypes pour les manipulations de tableaux génériques - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_ARRAY_H -#define _DECOMP_EXPR_ARRAY_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" - - - -#define G_TYPE_ARRAY_ACCESS g_array_access_get_type() -#define G_ARRAY_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_array_access_get_type(), GArrayAccess)) -#define G_IS_ARRAY_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_array_access_get_type())) -#define G_ARRAY_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARRAY_ACCESS, GArrayAccessClass)) -#define G_IS_ARRAY_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARRAY_ACCESS)) -#define G_ARRAY_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARRAY_ACCESS, GArrayAccessClass)) - - - -/* Définition d'un accès à une cellule de tableau (instance) */ -typedef struct _GArrayAccess GArrayAccess; - -/* Définition d'un accès à une cellule de tableau (classe) */ -typedef struct _GArrayAccessClass GArrayAccessClass; - - - -/* Indique le type défini pour un accès à une cellule de tableau. */ -GType g_array_access_get_type(void); - -/* Construit un accès à une cellule de tableau comme expression. */ -GDecInstruction *g_array_access_new(GDecExpression *, GDecExpression *); - - - -#endif /* _DECOMP_EXPR_ARRAY_H */ diff --git a/src/decomp/expr/assign.c b/src/decomp/expr/assign.c deleted file mode 100644 index 6a614ae..0000000 --- a/src/decomp/expr/assign.c +++ /dev/null @@ -1,287 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * assign.c - représentation des assignations - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "assign.h" - - -#include "../expression-int.h" - - - -/* Définition d'une assignation quelconque (instance) */ -struct _GAssignExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *dest; /* Destination de l'assignat° */ - GDecExpression *src; /* Source de l'assignation */ - -}; - - -/* Définition d'une assignation quelconque (classe) */ -struct _GAssignExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des assignations quelconques. */ -static void g_assign_expression_class_init(GAssignExpressionClass *); - -/* Initialise une instance d'assignation quelconque. */ -static void g_assign_expression_init(GAssignExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_assign_expression_visit(GAssignExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_assign_expression_replace(GAssignExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_assign_expression_print(const GAssignExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour une assignation quelconque. */ -G_DEFINE_TYPE(GAssignExpression, g_assign_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des assignations quelconques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_assign_expression_class_init(GAssignExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'assignation quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_assign_expression_init(GAssignExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_assign_expression_visit; - instr->replace = (dec_instr_replace_fc)g_assign_expression_replace; - instr->print = (dec_instr_print_fc)g_assign_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : dest = expression servant de destination. * -* src = source de l'expression à transférer. * -* * -* Description : Assigne le contenu d'une expression dans une autre. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_assign_expression_new(GDecExpression *dest, GDecExpression *src) -{ - GAssignExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_ASSIGN_EXPRESSION, NULL); - - result->dest = dest; - result->src = src; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_assign_expression_visit(GAssignExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->dest), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - if (result) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->src), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_assign_expression_replace(GAssignExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->dest == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->dest)); - g_object_ref(G_OBJECT(new)); - expr->dest = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->dest), old, new); - - if (expr->src == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->src)); - g_object_ref(G_OBJECT(new)); - expr->src = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->src), old, new); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_assign_expression_print(const GAssignExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->dest), - buffer, line, output); - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, " = ", 3, RTT_SIGNS, NULL); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->src), - buffer, result, output); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : assign = expression à consulter. * -* * -* Description : Indique la destination d'une assignation. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecExpression *g_assign_expression_get_dest(const GAssignExpression *assign) -{ - return assign->dest; - -} - - -/****************************************************************************** -* * -* Paramètres : assign = expression à consulter. * -* * -* Description : Indique la source d'une assignation. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecExpression *g_assign_expression_get_src(const GAssignExpression *assign) -{ - return assign->src; - -} diff --git a/src/decomp/expr/assign.h b/src/decomp/expr/assign.h deleted file mode 100644 index ed1ad91..0000000 --- a/src/decomp/expr/assign.h +++ /dev/null @@ -1,66 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * assign.h - prototypes pour la représentation des assignations - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_ASSIGN_H -#define _DECOMP_EXPR_ASSIGN_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" - - - -#define G_TYPE_ASSIGN_EXPRESSION g_assign_expression_get_type() -#define G_ASSIGN_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_assign_expression_get_type(), GAssignExpression)) -#define G_IS_ASSIGN_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_assign_expression_get_type())) -#define G_ASSIGN_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ASSIGN_EXPRESSION, GAssignExpressionClass)) -#define G_IS_ASSIGN_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ASSIGN_EXPRESSION)) -#define G_ASSIGN_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ASSIGN_EXPRESSION, GAssignExpressionClass)) - - - -/* Définition d'une assignation quelconque (instance) */ -typedef struct _GAssignExpression GAssignExpression; - -/* Définition d'une assignation quelconque (classe) */ -typedef struct _GAssignExpressionClass GAssignExpressionClass; - - -/* Indique le type défini pour une assignation quelconque. */ -GType g_assign_expression_get_type(void); - -/* Assigne le contenu d'une expression dans une autre. */ -GDecInstruction *g_assign_expression_new(GDecExpression *, GDecExpression *); - -/* Indique la destination d'une assignation. */ -GDecExpression *g_assign_expression_get_dest(const GAssignExpression *); - -/* Indique la source d'une assignation. */ -GDecExpression *g_assign_expression_get_src(const GAssignExpression *); - - - -#endif /* _DECOMP_EXPR_ASSIGN_H */ diff --git a/src/decomp/expr/block.c b/src/decomp/expr/block.c deleted file mode 100644 index e7d11a7..0000000 --- a/src/decomp/expr/block.c +++ /dev/null @@ -1,395 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * block.c - regroupement d'un lot d'instructions - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "block.h" - - -#include <malloc.h> -#include <string.h> - - -#include "../expression-int.h" - - - -/* Définition d'un ensemble d'instructions décompilées (instance) */ -struct _GExprBlock -{ - GDecExpression parent; /* A laisser en premier */ - - BlockBordeBehavior behavior; /* Type de Rendu des bordures */ - - GDecInstruction **list; /* Instructions contenues */ - size_t count; /* Taille de cette liste */ - -}; - - -/* Définition d'un ensemble d'instructions décompilées (classe) */ -struct _GExprBlockClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des ensembles d'instructions. */ -static void g_expr_block_class_init(GExprBlockClass *); - -/* Initialise une instance d'ensemble d'instructions. */ -static void g_expr_block_init(GExprBlock *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_expr_block_visit(GExprBlock *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_expr_block_replace(GExprBlock *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_expr_block_print(const GExprBlock *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un ensemble d'instructions décompilées. */ -G_DEFINE_TYPE(GExprBlock, g_expr_block, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des ensembles d'instructions. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_expr_block_class_init(GExprBlockClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : block = instance à initialiser. * -* * -* Description : Initialise une instance d'ensemble d'instructions. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_expr_block_init(GExprBlock *block) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(block); - - instr->visit = (dec_instr_visit_fc)g_expr_block_visit; - instr->replace = (dec_instr_replace_fc)g_expr_block_replace; - instr->print = (dec_instr_print_fc)g_expr_block_print; - - block->behavior = BBB_AUTO; - -} - - -/****************************************************************************** -* * -* Paramètres : item = premier élément du nouvel ensemble. * -* * -* Description : Constuit un conteneur pour diverses instructions décompilées.* -* * -* Retour : Conteneur d'instructions mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_expr_block_new(GDecInstruction *item) -{ - GExprBlock *result; /* Groupe d'instructions à renvoyer */ - - result = g_object_new(G_TYPE_EXPR_BLOCK, NULL); - - g_expr_block_add_item(result, item); - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : block = première instruction à venir visiter. * -* * -* Description : Fournit le comportement du bloc pour le rendu de ses bords. * -* * -* Retour : Comportement pour le rendu des bordures. * -* * -* Remarques : - * -* * -******************************************************************************/ - -BlockBordeBehavior g_expr_block_get_border_behavior(const GExprBlock *block) -{ - return block->behavior; - -} - - -/****************************************************************************** -* * -* Paramètres : block = première instruction à venir visiter. * -* behavior = comportement pour le rendu des bordures. * -* * -* Description : Définit le comportement du bloc pour le rendu de ses bords. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_expr_block_set_border_behavior(GExprBlock *block, BlockBordeBehavior behavior) -{ - block->behavior = behavior; - -} - - -/****************************************************************************** -* * -* Paramètres : block = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_expr_block_visit(GExprBlock *block, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - result = true; - - for (i = 0; i < block->count && result; i++) - result = _g_dec_instruction_visit(block->list[i], G_DEC_INSTRUCTION(block), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : block = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_expr_block_replace(GExprBlock *block, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - result = false; - - for (i = 0; i < block->count; i++) - { - if (block->list[i] == old) - { - g_object_unref(G_OBJECT(block->list[i])); - g_object_ref(G_OBJECT(new)); - block->list[i] = new; - - result = true; - - } - else - result |= g_dec_instruction_replace(block->list[i], old, new); - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : block = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_expr_block_print(const GExprBlock *block, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - size_t expr_count; /* Taille officielle */ - size_t i; /* Boucle de parcours */ - - switch (block->behavior) - { - case BBB_AUTO: - expr_count = block->count; - break; - case BBB_FORCE_OFF: - expr_count = 1; - break; - case BBB_FORCE_ON: - expr_count = 2; - break; - } - - result = g_lang_output_start_code_block(output, buffer, line, expr_count); - - for (i = 0; i < block->count; i++) - { - if (i > 0) - result = g_code_buffer_append_new_line_fixme(buffer); /* FIXME : n° de ligne */ - - result = g_dec_instruction_print(block->list[i], buffer, result, output); - - } - - result = g_lang_output_end_code_block(output, buffer, result, expr_count); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : block = ensemble à faire évoluer. * -* item = nouvel élément à placer dans l'ensemble. * -* * -* Description : Ajoute une instruction décompilée au conteneur existant. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_expr_block_add_item(GExprBlock *block, GDecInstruction *item) -{ - block->list = (GDecInstruction **)realloc(block->list, - ++block->count * sizeof(GDecInstruction *)); - block->list[block->count - 1] = item; - -} - - -/****************************************************************************** -* * -* Paramètres : block = ensemble à consulter. * -* index = indice de l'instruction décompilée recherchée. * -* * -* Description : Fournit une instruction décompilée donnée du conteneur. * -* * -* Retour : Instruction décompilée, ou NULL si l'indice n'est pas valide.* -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_expr_block_get_item(const GExprBlock *block, size_t index) -{ - GDecInstruction *result; /* Elément à retourner */ - - result = NULL; - - if (index < block->count) - result = block->list[index]; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : block = ensemble à faire évoluer. * -* item = nouvel élément à retirer de l'ensemble. * -* * -* Description : Supprime une instruction décompilée du conteneur existant. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_expr_block_delete_item(GExprBlock *block, GDecInstruction *item) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < block->count; i++) - if (block->list[i] == item) - break; - - if (i < block->count) - { - if ((i + 1) < block->count) - memmove(&block->list[i], &block->list[i + 1], - (block->count - i - 1) * sizeof(GDecInstruction *)); - - block->list = (GDecInstruction **)realloc(block->list, - --block->count * sizeof(GDecInstruction *)); - - g_object_unref(G_OBJECT(item)); - - } - -} diff --git a/src/decomp/expr/block.h b/src/decomp/expr/block.h deleted file mode 100644 index 88abc91..0000000 --- a/src/decomp/expr/block.h +++ /dev/null @@ -1,84 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * block.h - prototypes pour le regroupement d'un lot d'instructions - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_BLOCK_H -#define _DECOMP_EXPR_BLOCK_H - - -#include <glib-object.h> - - -#include "../instruction.h" - - - -#define G_TYPE_EXPR_BLOCK g_expr_block_get_type() -#define G_EXPR_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_expr_block_get_type(), GExprBlock)) -#define G_IS_EXPR_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_expr_block_get_type())) -#define G_EXPR_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_EXPR_BLOCK, GExprBlockClass)) -#define G_IS_EXPR_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_EXPR_BLOCK)) -#define G_EXPR_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_EXPR_BLOCK, GExprBlockClass)) - - - -/* Définition d'un ensemble d'instructions décompilées (instance) */ -typedef struct _GExprBlock GExprBlock; - -/* Définition d'un ensemble d'instructions décompilées (classe) */ -typedef struct _GExprBlockClass GExprBlockClass; - - -/* Rendu des bordures */ -typedef enum _BlockBordeBehavior -{ - BBB_AUTO, - BBB_FORCE_OFF, - BBB_FORCE_ON - -} BlockBordeBehavior; - - -/* Indique le type défini pour un ensemble d'instructions décompilées. */ -GType g_expr_block_get_type(void); - -/* Constuit un conteneur pour diverses instructions décompilées. */ -GDecInstruction *g_expr_block_new(GDecInstruction *); - -/* Fournit le comportement du bloc pour le rendu de ses bords. */ -BlockBordeBehavior g_expr_block_get_border_behavior(const GExprBlock *); - -/* Définit le comportement du bloc pour le rendu de ses bords. */ -void g_expr_block_set_border_behavior(GExprBlock *, BlockBordeBehavior); - -/* Ajoute une instruction décompilée au conteneur existant. */ -void g_expr_block_add_item(GExprBlock *, GDecInstruction *); - -/* Fournit une instruction décompilée donnée du conteneur. */ -GDecInstruction *g_expr_block_get_item(const GExprBlock *, size_t); - -/* Supprime une instruction décompilée du conteneur existant. */ -void g_expr_block_delete_item(GExprBlock *, GDecInstruction *); - - - -#endif /* _DECOMP_EXPR_BLOCK_H */ diff --git a/src/decomp/expr/call.c b/src/decomp/expr/call.c deleted file mode 100644 index 6387730..0000000 --- a/src/decomp/expr/call.c +++ /dev/null @@ -1,290 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * call.c - encadrement des appels de routine - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "call.h" - - -#include <malloc.h> -#include <string.h> - - -#include "../expression-int.h" - - - -/* Définition d'un appel à une routine quelconque (instance) */ -struct _GRoutineCall -{ - GDecExpression parent; /* A laisser en premier */ - - GBinRoutine *routine; /* Routine sollicitée */ - - GDecInstruction **args; /* Arguments à associer */ - size_t count; /* Nombre d'arguments présents */ - -}; - - -/* Définition d'un appel à une routine quelconque (classe) */ -struct _GRoutineCallClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des appels à une routine quelconque. */ -static void g_routine_call_class_init(GRoutineCallClass *); - -/* Initialise une instance d'appel à une routine quelconque. */ -static void g_routine_call_init(GRoutineCall *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_routine_call_visit(GRoutineCall *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_routine_call_replace(GRoutineCall *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_routine_call_print(const GRoutineCall *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un appel à une routine quelconque. */ -G_DEFINE_TYPE(GRoutineCall, g_routine_call, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des appels à une routine quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_routine_call_class_init(GRoutineCallClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'appel à une routine quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_routine_call_init(GRoutineCall *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_routine_call_visit; - instr->replace = (dec_instr_replace_fc)g_routine_call_replace; - instr->print = (dec_instr_print_fc)g_routine_call_print; - -} - - -/****************************************************************************** -* * -* Paramètres : routine = routine dont il est fait appel. * -* * -* Description : Exprime un appel à une routine quelconque. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_routine_call_new(GBinRoutine *routine) -{ - GRoutineCall *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_ROUTINE_CALL, NULL); - - result->routine = routine; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : call = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_routine_call_visit(GRoutineCall *call, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - result = true; - - for (i = 0; i < call->count && result; i++) - result = _g_dec_instruction_visit(call->args[i], G_DEC_INSTRUCTION(call), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : call = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_routine_call_replace(GRoutineCall *call, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - result = false; - - for (i = 0; i < call->count; i++) - { - if (call->args[i] == old) - { - g_object_unref(G_OBJECT(call->args[i])); - g_object_ref(G_OBJECT(new)); - call->args[i] = new; - - result = true; - - } - else - result |= g_dec_instruction_replace(call->args[i], old, new); - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : call = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_routine_call_print(const GRoutineCall *call, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - const char *name; /* Désignation de la routine */ - size_t i; /* Boucle de parcours */ - - name = g_binary_routine_get_name(call->routine); - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, name, strlen(name), RTT_RAW, NULL); - - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "(", 1, RTT_PUNCT, NULL); - - if (call->count > 0) - { - result = g_dec_instruction_print(call->args[0], buffer, line, output); - - for (i = 1; i < call->count; i++) - { - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, ",", 1, RTT_PUNCT, NULL); - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); - - g_dec_instruction_print(call->args[i], buffer, result, output); - - } - - } - else result = line; - - g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, ")", 1, RTT_PUNCT, NULL); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : call = expression d'appel à mettre à jour. * -* arg = nouvel argument à associer à l'appel. * -* * -* Description : Enregistre un nouvel argument pour l'appel de routine. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_routine_call_add_arg(GRoutineCall *call, GDecInstruction *arg) -{ - call->args = (GDecInstruction **)realloc(call->args, - ++call->count * sizeof(GDecInstruction *)); - - call->args[call->count - 1] = arg; - - /* TODO : synchroniser avec la routine (cf. constructeurs construits à la volée) */ - -} diff --git a/src/decomp/expr/call.h b/src/decomp/expr/call.h deleted file mode 100644 index 7ce8354..0000000 --- a/src/decomp/expr/call.h +++ /dev/null @@ -1,64 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * call.h - prototypes pour l'encadrement des appels de routine - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_CALL_H -#define _DECOMP_EXPR_CALL_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" -#include "../../analysis/routine.h" - - - -#define G_TYPE_ROUTINE_CALL g_routine_call_get_type() -#define G_ROUTINE_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_routine_call_get_type(), GRoutineCall)) -#define G_IS_ROUTINE_CALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_routine_call_get_type())) -#define G_ROUTINE_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ROUTINE_CALL, GRoutineCallClass)) -#define G_IS_ROUTINE_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ROUTINE_CALL)) -#define G_ROUTINE_CALL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ROUTINE_CALL, GRoutineCallClass)) - - - -/* Définition d'un appel à une routine quelconque (instance) */ -typedef struct _GRoutineCall GRoutineCall; - -/* Définition d'un appel à une routine quelconque (classe) */ -typedef struct _GRoutineCallClass GRoutineCallClass; - - -/* Indique le type défini pour un appel à une routine quelconque. */ -GType g_routine_call_get_type(void); - -/* Exprime un appel à une routine quelconque. */ -GDecInstruction *g_routine_call_new(GBinRoutine *); - -/* Enregistre un nouvel argument pour l'appel de routine. */ -void g_routine_call_add_arg(GRoutineCall *, GDecInstruction *); - - - -#endif /* _DECOMP_EXPR_CALL_H */ diff --git a/src/decomp/expr/comp.c b/src/decomp/expr/comp.c deleted file mode 100644 index 6d22898..0000000 --- a/src/decomp/expr/comp.c +++ /dev/null @@ -1,311 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * comp.c - représentation des comparaisons - * - * Copyright (C) 2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "comp.h" - - -#include "../expression-int.h" - - - -/* Définition d'une comparaison binaire quelconque (instance) */ -struct _GCompExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *a; /* Premier élément à comparer */ - CompSignType sign; /* Méthode de comparaison */ - GDecExpression *b; /* Second élément à comparer */ - -}; - - -/* Définition d'une comparaison binaire quelconque (classe) */ -struct _GCompExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des comparaisons binaires quelconques. */ -static void g_comp_expression_class_init(GCompExpressionClass *); - -/* Initialise une instance de comparaison binaire quelconque. */ -static void g_comp_expression_init(GCompExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_comp_expression_visit(GCompExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_comp_expression_replace(GCompExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_comp_expression_print(const GCompExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - -/* Réalise une négation sur une expression décompilée. */ -static bool g_comp_expression_negate(GCompExpression *); - - - -/* Indique le type défini pour une comparaison binaire quelconque. */ -G_DEFINE_TYPE(GCompExpression, g_comp_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des comparaisons binaires quelconques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_comp_expression_class_init(GCompExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance de comparaison binaire quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_comp_expression_init(GCompExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - GDecExpression *base; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_comp_expression_visit; - instr->replace = (dec_instr_replace_fc)g_comp_expression_replace; - instr->print = (dec_instr_print_fc)g_comp_expression_print; - - base = G_DEC_EXPRESSION(expr); - - base->negate = (dec_expr_negate_fc)g_comp_expression_negate; - -} - - -/****************************************************************************** -* * -* Paramètres : a = second élément à comparer. * -* sign = choix de la méthode de comparaison. * -* b = second élément à comparer. * -* * -* Description : Exprime une comparaison binaire quelconque. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecExpression *g_comp_expression_new(GDecExpression *a, CompSignType sign, GDecExpression *b) -{ - GCompExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_COMP_EXPRESSION, NULL); - - result->a = a; - result->sign = sign; - result->b = b; - - return G_DEC_EXPRESSION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_comp_expression_visit(GCompExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->a), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - if (result) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->b), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_comp_expression_replace(GCompExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->a == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->a)); - g_object_ref(G_OBJECT(new)); - expr->a = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->a), old, new); - - if (expr->b == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->b)); - g_object_ref(G_OBJECT(new)); - expr->b = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->b), old, new); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_comp_expression_print(const GCompExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - - result = line; - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->a), - buffer, result, output); - - g_lang_output_write_comp_sign(output, result, expr->sign); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->b), - buffer, result, output); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à traiter. * -* * -* Description : Réalise une négation sur une expression décompilée. * -* * -* Retour : true si la négation a été gérée, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_comp_expression_negate(GCompExpression *expr) -{ - bool result; /* Bilan à retourner */ - - result = true; - - switch (expr->sign) - { - case CST_EQ: - expr->sign = CST_NE; - break; - case CST_NE: - expr->sign = CST_EQ; - break; - case CST_LT: - expr->sign = CST_GE; - break; - case CST_GE: - expr->sign = CST_LT; - break; - case CST_GT: - expr->sign = CST_LE; - break; - case CST_LE: - expr->sign = CST_GT; - break; - default: - result = false; - break; - - } - - return result; - -} diff --git a/src/decomp/expr/comp.h b/src/decomp/expr/comp.h deleted file mode 100644 index d3f534c..0000000 --- a/src/decomp/expr/comp.h +++ /dev/null @@ -1,60 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * comp.h - prototypes pour la représentation des comparaisons - * - * Copyright (C) 2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_COMP_H -#define _DECOMP_EXPR_COMP_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../output.h" - - - -#define G_TYPE_COMP_EXPRESSION g_comp_expression_get_type() -#define G_COMP_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_comp_expression_get_type(), GCompExpression)) -#define G_IS_COMP_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_comp_expression_get_type())) -#define G_COMP_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_COMP_EXPRESSION, GCompExpressionClass)) -#define G_IS_COMP_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_COMP_EXPRESSION)) -#define G_COMP_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_COMP_EXPRESSION, GCompExpressionClass)) - - - -/* Définition d'une comparaison binaire quelconque (instance) */ -typedef struct _GCompExpression GCompExpression; - -/* Définition d'une comparaison binaire quelconque (classe) */ -typedef struct _GCompExpressionClass GCompExpressionClass; - - -/* Indique le type défini pour une comparaison binaire quelconque. */ -GType g_comp_expression_get_type(void); - -/* Exprime une comparaison binaire quelconque. */ -GDecExpression *g_comp_expression_new(GDecExpression *, CompSignType, GDecExpression *); - - - -#endif /* _DECOMP_EXPR_COMP_H */ diff --git a/src/decomp/expr/cond.c b/src/decomp/expr/cond.c deleted file mode 100644 index c0b3f83..0000000 --- a/src/decomp/expr/cond.c +++ /dev/null @@ -1,461 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * cond.c - représentation des conditions - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "cond.h" - - -#include <malloc.h> - - -#include "../expression-int.h" - - - -/* Définition d'une condition binaire quelconque (instance) */ -struct _GCondExpression -{ - GDecExpression parent; /* A laisser en premier */ - - CondOperatorType operator; /* Opérateur de la liste */ - - union - { - GDecExpression *exp; /* Expression analysée de base */ - struct - { - GCondExpression **conds; /* Liste d'expressions */ - size_t count; /* Taille de cette liste */ - }; - }; - -}; - - -/* Définition d'une condition binaire quelconque (classe) */ -struct _GCondExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des conditions binaires quelconques. */ -static void g_cond_expression_class_init(GCondExpressionClass *); - -/* Initialise une instance de condition binaire quelconque. */ -static void g_cond_expression_init(GCondExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_cond_expression_visit(GCondExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_cond_expression_replace(GCondExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_cond_expression_print(const GCondExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - -/* Réalise une négation sur une expression décompilée. */ -static bool g_cond_expression_negate(GCondExpression *); - - - -/* Indique le type défini pour une condition binaire quelconque. */ -G_DEFINE_TYPE(GCondExpression, g_cond_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des conditions binaires quelconques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_cond_expression_class_init(GCondExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à initialiser. * -* * -* Description : Initialise une instance de condition binaire quelconque. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_cond_expression_init(GCondExpression *cond) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - GDecExpression *expr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(cond); - - instr->visit = (dec_instr_visit_fc)g_cond_expression_visit; - instr->replace = (dec_instr_replace_fc)g_cond_expression_replace; - instr->print = (dec_instr_print_fc)g_cond_expression_print; - - expr = G_DEC_EXPRESSION(cond); - - expr->negate = (dec_expr_negate_fc)g_cond_expression_negate; - - cond->operator = COT_NONE; - -} - - -/****************************************************************************** -* * -* Paramètres : exp = expression sur laquelle repose la condition. * -* * -* Description : Exprime une condition binaire quelconque. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecExpression *g_cond_expression_new(GDecExpression *exp) -{ - GCondExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_COND_EXPRESSION, NULL); - - result->exp = exp; - - return G_DEC_EXPRESSION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_cond_expression_visit(GCondExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - if (expr->operator == COT_NONE) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->exp), G_DEC_INSTRUCTION(expr), - callback, flags, data); - - else - { - result = true; - - for (i = 0; i < expr->count && result; i++) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->conds[i]), - G_DEC_INSTRUCTION(expr), - callback, flags, data); - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_cond_expression_replace(GCondExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - if (expr->operator == COT_NONE) - { - if (expr->exp == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->exp)); - g_object_ref(G_OBJECT(new)); - expr->exp = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->exp), old, new); - - } - else - { - result = false; - - for (i = 0; i < expr->count; i++) - { - if (expr->conds[i] == G_COND_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->conds[i])); - g_object_ref(G_OBJECT(new)); - expr->conds[i] = G_COND_EXPRESSION(new); - - result = true; - - } - else - result |= g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->conds[i]), old, new); - - } - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_cond_expression_print(const GCondExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - size_t i; /* Boucle de parcours */ - - result = g_lang_output_encapsulate_condition(output, buffer, line, true); - - if (expr->operator == COT_NONE) - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->exp), - buffer, result, output); - - else - for (i = 0; i < expr->count; i++) - { - if (i > 0) - g_lang_output_write_cond_operator(output, result, expr->operator); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->conds[i]), - buffer, result, output); - - } - - result = g_lang_output_encapsulate_condition(output, buffer, result, false); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à traiter. * -* * -* Description : Réalise une négation sur une expression décompilée. * -* * -* Retour : true si la négation a été gérée, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_cond_expression_negate(GCondExpression *cond) -{ - size_t i; /* Boucle de parcours */ - - if (cond->operator == COT_NONE) - g_dec_expression_negate(cond->exp); - - else - { - cond->operator = (cond->operator == COT_AND ? COT_OR : COT_AND); - - for (i = 0; i < cond->count; i++) - g_dec_expression_negate(G_DEC_EXPRESSION(cond->conds[i])); - - } - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à consulter. * -* * -* Description : Fournit l'opération logique entre les comparaisons. * -* * -* Retour : Opération liant les différentes parties, ou COT_NONE. * -* * -* Remarques : - * -* * -******************************************************************************/ - -CondOperatorType g_cond_expression_get_operator(const GCondExpression *cond) -{ - return cond->operator; - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à consulter. * -* * -* Description : Fournit l'expression d'une condition. * -* * -* Retour : Expression sur laquelle repose la condition. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecExpression *g_cond_expression_get_expression(const GCondExpression *cond) -{ - return cond->exp; - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à modifier. * -* exp = expression sur laquelle repose la condition. * -* * -* Description : Définit l'expression d'une condition. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_cond_expression_set_expression(GCondExpression *cond, GDecExpression *exp) -{ - if (cond->exp != NULL) - g_object_unref(G_OBJECT(cond->exp)); - - cond->exp = exp; - -} - - -/****************************************************************************** -* * -* Paramètres : cond = instance à compléter. * -* extra = condition à rajouter. * -* op = lien avec le reste de la condition. * -* * -* Description : Etend l'expression d'une condition. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_cond_expression_add_condition(GCondExpression *cond, GCondExpression *extra, CondOperatorType op) -{ - GCondExpression *existing; /* Expr. première revalorisée */ - - if (cond->operator == COT_NONE) - { - existing = G_COND_EXPRESSION(g_cond_expression_new(cond->exp)); - goto gceac_replace_existing; - } - else - { - if (cond->operator == op) - { - cond->conds = (GCondExpression **)calloc(++cond->count, sizeof(GCondExpression)); - cond->conds[cond->count - 1] = extra; - } - else - { - existing = G_COND_EXPRESSION(g_cond_expression_new(NULL)); - - existing->operator = cond->operator; - existing->conds = cond->conds; - existing->count = cond->count; - - goto gceac_replace_existing; - - } - - } - - gceac_done: - - return; - - gceac_replace_existing: - - cond->operator = op; - - cond->conds = (GCondExpression **)calloc(2, sizeof(GCondExpression)); - cond->conds[0] = existing; - cond->conds[1] = extra; - - cond->count = 2; - - goto gceac_done; - -} diff --git a/src/decomp/expr/cond.h b/src/decomp/expr/cond.h deleted file mode 100644 index 7980a75..0000000 --- a/src/decomp/expr/cond.h +++ /dev/null @@ -1,72 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * cond.h - prototypes pour la représentation des conditions - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_COND_H -#define _DECOMP_EXPR_COND_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../output.h" - - - -#define G_TYPE_COND_EXPRESSION g_cond_expression_get_type() -#define G_COND_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_cond_expression_get_type(), GCondExpression)) -#define G_IS_COND_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_cond_expression_get_type())) -#define G_COND_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_COND_EXPRESSION, GCondExpressionClass)) -#define G_IS_COND_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_COND_EXPRESSION)) -#define G_COND_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_COND_EXPRESSION, GCondExpressionClass)) - - - -/* Définition d'une condition binaire quelconque (instance) */ -typedef struct _GCondExpression GCondExpression; - -/* Définition d'une condition binaire quelconque (classe) */ -typedef struct _GCondExpressionClass GCondExpressionClass; - - -/* Indique le type défini pour une condition binaire quelconque. */ -GType g_cond_expression_get_type(void); - -/* Exprime une condition binaire quelconque. */ -GDecExpression *g_cond_expression_new(GDecExpression *); - -/* Fournit l'opération logique entre les comparaisons. */ -CondOperatorType g_cond_expression_get_operator(const GCondExpression *); - -/* Fournit l'expression d'une condition. */ -GDecExpression *g_cond_expression_get_expression(const GCondExpression *); - -/* Définit l'expression d'une condition. */ -void g_cond_expression_set_expression(GCondExpression *, GDecExpression *); - -/* Etend l'expression d'une condition. */ -void g_cond_expression_add_condition(GCondExpression *, GCondExpression *, CondOperatorType); - - - -#endif /* _DECOMP_EXPR_COND_H */ diff --git a/src/decomp/expr/dalvik/Makefile.am b/src/decomp/expr/dalvik/Makefile.am deleted file mode 100644 index 1fe430e..0000000 --- a/src/decomp/expr/dalvik/Makefile.am +++ /dev/null @@ -1,12 +0,0 @@ - -noinst_LTLIBRARIES = libdecompexprdalvik.la - -libdecompexprdalvik_la_SOURCES = \ - array.h array.c - -libdecompexprdalvik_la_LDFLAGS = - - -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) - -AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/src/decomp/expr/dalvik/array.c b/src/decomp/expr/dalvik/array.c deleted file mode 100644 index 98647f4..0000000 --- a/src/decomp/expr/dalvik/array.c +++ /dev/null @@ -1,155 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * array.c - manipulations de tableaux propres à Dalvik - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "array.h" - - -#include "../../expression-int.h" - - - -/* Définition d'une expression de mesure de tableau (instance) */ -struct _GDalvikALength -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *array; /* Elément auquel accéder */ - -}; - - -/* Définition d'une expression de mesure de tableau (classe) */ -struct _GDalvikALengthClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des expressions de mesure de tableau. */ -static void g_dalvik_alength_class_init(GDalvikALengthClass *); - -/* Initialise une instance d'expression de mesure de tableau. */ -static void g_dalvik_alength_init(GDalvikALength *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static void g_dalvik_alength_print(const GDalvikALength *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour une expression de mesure de tableau. */ -G_DEFINE_TYPE(GDalvikALength, g_dalvik_alength, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des expressions de mesure de tableau. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dalvik_alength_class_init(GDalvikALengthClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'expression de mesure de tableau. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dalvik_alength_init(GDalvikALength *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->print = (dec_instr_print_fc)g_dalvik_alength_print; - -} - - -/****************************************************************************** -* * -* Paramètres : array = tableau dont on doit mesurer la taille. * -* * -* Description : Construit une expression à partir d'une mesure de tableau. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_dalvik_alength_new(GDecExpression *array) -{ - GDalvikALength *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_DALVIK_ALENGTH, NULL); - - result->array = array; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dalvik_alength_print(const GDalvikALength *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - g_dec_instruction_print(G_DEC_INSTRUCTION(expr->array), - buffer, line, output); - - g_buffer_line_append_text(line, BLC_ASSEMBLY, ".", 1, RTT_RAW, NULL); - - g_buffer_line_append_text(line, BLC_ASSEMBLY, "length", 6, RTT_RAW, NULL); - -} diff --git a/src/decomp/expr/dalvik/array.h b/src/decomp/expr/dalvik/array.h deleted file mode 100644 index ee50a43..0000000 --- a/src/decomp/expr/dalvik/array.h +++ /dev/null @@ -1,61 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * array.h - prototypes pour les manipulations de tableaux propres à Dalvik - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_DALVIK_ARRAY_H -#define _DECOMP_EXPR_DALVIK_ARRAY_H - - -#include <glib-object.h> - - -#include "../../expression.h" -#include "../../instruction.h" - - - -#define G_TYPE_DALVIK_ALENGTH g_dalvik_alength_get_type() -#define G_DALVIK_ALENGTH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dalvik_alength_get_type(), GDalvikALength)) -#define G_IS_DALVIK_ALENGTH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dalvik_alength_get_type())) -#define G_DALVIK_ALENGTH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DALVIK_ALENGTH, GDalvikALengthClass)) -#define G_IS_DALVIK_ALENGTH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DALVIK_ALENGTH)) -#define G_DALVIK_ALENGTH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DALVIK_ALENGTH, GDalvikALengthClass)) - - - -/* Définition d'une expression de mesure de tableau (instance) */ -typedef struct _GDalvikALength GDalvikALength; - -/* Définition d'une expression de mesure de tableau (classe) */ -typedef struct _GDalvikALengthClass GDalvikALengthClass; - - - -/* Indique le type défini pour une expression de mesure de tableau. */ -GType g_dalvik_alength_get_type(void); - -/* Construit une expression à partir d'une mesure de tableau. */ -GDecInstruction *g_dalvik_alength_new(GDecExpression *); - - - -#endif /* _DECOMP_EXPR_DALVIK_ARRAY_H */ diff --git a/src/decomp/expr/immediate.c b/src/decomp/expr/immediate.c deleted file mode 100644 index 3bf2dea..0000000 --- a/src/decomp/expr/immediate.c +++ /dev/null @@ -1,153 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * immediate.c - raccord avec les opérandes de valeur immédiate - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "immediate.h" - - -#include "../expression-int.h" - - - -/* Définition d'une expression de valeur immédiate (instance) */ -struct _GImmExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GImmOperand *operand; /* Conteneur d'origine */ - -}; - - -/* Définition d'une expression de valeur immédiate (classe) */ -struct _GImmExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des expressions de valeur immédiate. */ -static void g_imm_expression_class_init(GImmExpressionClass *); - -/* Initialise une instance d'expression de valeur immédiate. */ -static void g_imm_expression_init(GImmExpression *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_imm_expression_print(const GImmExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour une expression de valeur immédiate. */ -G_DEFINE_TYPE(GImmExpression, g_imm_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des expressions de valeur immédiate. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_imm_expression_class_init(GImmExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'expression de valeur immédiate. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_imm_expression_init(GImmExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->print = (dec_instr_print_fc)g_imm_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : operand = conteneur d'origie de la valeur immédiate. * -* * -* Description : Construit une expression à partir d'une valeur immédiate. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_imm_expression_new(GImmOperand *operand) -{ - GImmExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_IMM_EXPRESSION, NULL); - - result->operand = operand; - g_object_ref(G_OBJECT(operand)); /* FIXME : ref pas déjà acquise ? */ - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_imm_expression_print(const GImmExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - g_arch_operand_print(G_ARCH_OPERAND(expr->operand), line, ASX_COUNT); - - return line; - -} diff --git a/src/decomp/expr/immediate.h b/src/decomp/expr/immediate.h deleted file mode 100644 index 8185754..0000000 --- a/src/decomp/expr/immediate.h +++ /dev/null @@ -1,61 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * immediate.h - prototypes pour le raccord avec les opérandes de valeur immédiate - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_IMMEDIATE_H -#define _DECOMP_EXPR_IMMEDIATE_H - - -#include <glib-object.h> - - -#include "../instruction.h" -#include "../../arch/immediate.h" - - - -#define G_TYPE_IMM_EXPRESSION g_imm_expression_get_type() -#define G_IMM_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_imm_expression_get_type(), GImmExpression)) -#define G_IS_IMM_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_imm_expression_get_type())) -#define G_IMM_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_IMM_EXPRESSION, GImmExpressionClass)) -#define G_IS_IMM_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_IMM_EXPRESSION)) -#define G_IMM_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_IMM_EXPRESSION, GImmExpressionClass)) - - - -/* Définition d'une expression de valeur immédiate (instance) */ -typedef struct _GImmExpression GImmExpression; - -/* Définition d'une expression de valeur immédiate (classe) */ -typedef struct _GImmExpressionClass GImmExpressionClass; - - - -/* Indique le type défini pour une expression de valeur immédiate. */ -GType g_imm_expression_get_type(void); - -/*Construit une expression à partir d'une valeur immédiate. */ -GDecInstruction *g_imm_expression_new(GImmOperand *); - - - -#endif /* _DECOMP_EXPR_IMMEDIATE_H */ diff --git a/src/decomp/expr/pseudo.c b/src/decomp/expr/pseudo.c deleted file mode 100644 index 626cd8f..0000000 --- a/src/decomp/expr/pseudo.c +++ /dev/null @@ -1,253 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * pseudo.c - définition des pseudo-registres - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "pseudo.h" - - -#include <malloc.h> -#include <stdio.h> -#include <string.h> - - -#include "../expression-int.h" - - - -/* Définition d'un pseudo-registre (instance) */ -struct _GPseudoRegister -{ - GDecExpression parent; /* A laisser en premier */ - - PseudoRegUsage usage; /* Type d'utilisation attendue */ - - char *name; /* Désignation générale */ - size_t index; /* Position dans l'ensemble */ - GBinVariable *var; /* Variable plus précise */ - -}; - - -/* Définition d'un pseudo-registre (classe) */ -struct _GPseudoRegisterClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des pseudo-registres. */ -static void g_pseudo_register_class_init(GPseudoRegisterClass *); - -/* Initialise une instance de pseudo-registre. */ -static void g_pseudo_register_init(GPseudoRegister *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_pseudo_register_print(const GPseudoRegister *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un pseudo-registre. */ -G_DEFINE_TYPE(GPseudoRegister, g_pseudo_register, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des pseudo-registres. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_pseudo_register_class_init(GPseudoRegisterClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : reg = instance à initialiser. * -* * -* Description : Initialise une instance de pseudo-registre. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_pseudo_register_init(GPseudoRegister *reg) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(reg); - - instr->print = (dec_instr_print_fc)g_pseudo_register_print; - -} - - -/****************************************************************************** -* * -* Paramètres : usage = précision quant à l'usage du pseudo-registre à créer.* -* * -* Description : Assigne le contenu d'une expression dans une autre. * -* * -* Retour : Pseudo-registre mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_pseudo_register_new(PseudoRegUsage usage) -{ - GPseudoRegister *result; /* Pseudo-registre à renvoyer */ - - result = g_object_new(G_TYPE_PSEUDO_REGISTER, NULL); - - result->usage = usage; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : reg = pseudo-registre à venir consulter. * -* * -* Description : Indique l'usage attendu du pseudo-registre consulté. * -* * -* Retour : Utilité du pseudo-registre en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -PseudoRegUsage g_pseudo_register_get_usage(const GPseudoRegister *reg) -{ - return reg->usage; - -} - - -/****************************************************************************** -* * -* Paramètres : reg = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_pseudo_register_print(const GPseudoRegister *reg, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - char label[32]; - char *name; - - if (reg->var != NULL) - { - name = g_binary_variable_to_string(reg->var, true); - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, name, strlen(name), RTT_RAW, NULL); - free(name); - } - else - { - snprintf(label, 32, "%s%zu", reg->name, reg->index); - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, label, strlen(label), RTT_RAW, NULL); - } - - return line; - -} - - -/****************************************************************************** -* * -* Paramètres : reg = expression représentant un pseudo-registre à traiter. * -* name = désignation générale à associer au pseudo-registre. * -* * -* Description : Définit un nom général pour un pseudo-registre donné. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_pseudo_register_set_basename(GPseudoRegister *reg, const char *name) -{ - reg->name = strdup(name); - -} - - -/****************************************************************************** -* * -* Paramètres : reg = expression représentant un pseudo-registre à traiter.* -* index = indice à associer au pseudo-registre. * -* * -* Description : Définit un indice unique pour un pseudo-registre donné. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_pseudo_register_set_index(GPseudoRegister *reg, size_t index) -{ - reg->index = index; - -} - - -/****************************************************************************** -* * -* Paramètres : reg = expression représentant un pseudo-registre à traiter. * -* var = indications supplémentaire quant à la variable. * -* * -* Description : Précise le nom et le type de la variable. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_pseudo_register_set_variable(GPseudoRegister *reg, GBinVariable *var) -{ - reg->var = var; - -} diff --git a/src/decomp/expr/pseudo.h b/src/decomp/expr/pseudo.h deleted file mode 100644 index 5436404..0000000 --- a/src/decomp/expr/pseudo.h +++ /dev/null @@ -1,83 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * pseudo.h - prototypes pour la définition des pseudo-registres - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_PSEUDO_H -#define _DECOMP_EXPR_PSEUDO_H - - -#include <glib-object.h> - - -#include "../instruction.h" -#include "../../analysis/variable.h" - - - -#define G_TYPE_PSEUDO_REGISTER g_pseudo_register_get_type() -#define G_PSEUDO_REGISTER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_pseudo_register_get_type(), GPseudoRegister)) -#define G_IS_PSEUDO_REGISTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_pseudo_register_get_type())) -#define G_PSEUDO_REGISTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PSEUDO_REGISTER, GPseudoRegisterClass)) -#define G_IS_PSEUDO_REGISTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PSEUDO_REGISTER)) -#define G_PSEUDO_REGISTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PSEUDO_REGISTER, GPseudoRegisterClass)) - - - -/* Types de pseudo-registre */ -typedef enum _PseudoRegUsage -{ - PRU_THIS, /* "this" pour les objets */ - PRU_ARG, /* Argument de fonction */ - PRU_LOCAL, /* Variable locale */ - PRU_FIXED /* Variable type champ */ - -} PseudoRegUsage; - - -/* Définition d'un pseudo-registre (instance) */ -typedef struct _GPseudoRegister GPseudoRegister; - -/* Définition d'un pseudo-registre (classe) */ -typedef struct _GPseudoRegisterClass GPseudoRegisterClass; - - -/* Indique le type défini pour un pseudo-registre. */ -GType g_pseudo_register_get_type(void); - -/* Assigne le contenu d'une expression dans une autre. */ -GDecInstruction *g_pseudo_register_new(PseudoRegUsage); - -/* Indique l'usage attendu du pseudo-registre consulté. */ -PseudoRegUsage g_pseudo_register_get_usage(const GPseudoRegister *); - -/* Définit un nom général pour un pseudo-registre donné. */ -void g_pseudo_register_set_basename(GPseudoRegister *, const char *); - -/* Définit un indice unique pour un pseudo-registre donné. */ -void g_pseudo_register_set_index(GPseudoRegister *, size_t); - -/* Précise le nom et le type de la variable. */ -void g_pseudo_register_set_variable(GPseudoRegister *, GBinVariable *); - - - -#endif /* _DECOMP_EXPR_PSEUDO_H */ diff --git a/src/decomp/expr/return.c b/src/decomp/expr/return.c deleted file mode 100644 index 16a5a54..0000000 --- a/src/decomp/expr/return.c +++ /dev/null @@ -1,243 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * return.c - représentation des ordres de retour - * - * Copyright (C) 2010-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "return.h" - - -#include "../expression-int.h" - - - -/* Définition d'un ordre de retour (instance) */ -struct _GReturnExpression -{ - GDecExpression parent; /* A laisser en premier */ - - GDecExpression *payload; /* Eventuel paquet associé */ - -}; - - -/* Définition d'un ordre de retour (classe) */ -struct _GReturnExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des ordres de retour. */ -static void g_return_expression_class_init(GReturnExpressionClass *); - -/* Initialise une instance d'ordre de retour. */ -static void g_return_expression_init(GReturnExpression *); - -/* Visite un ensemble hiérarchique d'instructions décompilées. */ -static bool g_return_expression_visit(GReturnExpression *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); - -/* Remplace une instruction décompilée par une autre. */ -static bool g_return_expression_replace(GReturnExpression *, GDecInstruction *, GDecInstruction *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_return_expression_print(const GReturnExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour un ordre de retour. */ -G_DEFINE_TYPE(GReturnExpression, g_return_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des ordres de retour. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_return_expression_class_init(GReturnExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'ordre de retour. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_return_expression_init(GReturnExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->visit = (dec_instr_visit_fc)g_return_expression_visit; - instr->replace = (dec_instr_replace_fc)g_return_expression_replace; - instr->print = (dec_instr_print_fc)g_return_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : payload = éventuelle expression à associer au retour. * -* * -* Description : Constitue un ordre de retour vers l'appelant. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_return_expression_new(GDecExpression *payload) -{ - GReturnExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_RETURN_EXPRESSION, NULL); - - result->payload = payload; - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir visiter. * -* callback = procédure à appeler à chaque instruction visitée. * -* flags = moments des appels à réaliser en retour. * -* data = données quelconques associées au visiteur. * -* * -* Description : Visite un ensemble hiérarchique d'instructions décompilées. * -* * -* Retour : true si le parcours a été jusqu'à son terme, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_return_expression_visit(GReturnExpression *expr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) -{ - bool result; /* Bilan à retourner */ - - if (expr->payload) - result = _g_dec_instruction_visit(G_DEC_INSTRUCTION(expr->payload), G_DEC_INSTRUCTION(expr), - callback, flags, data); - else - result = false; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = première instruction à venir ausculter. * -* old = instruction décompilée à venir remplacer. * -* new = instruction décompilée à utiliser dorénavant. * -* * -* Description : Remplace une instruction décompilée par une autre. * -* * -* Retour : true si un remplacement a été effectué, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_return_expression_replace(GReturnExpression *expr, GDecInstruction *old, GDecInstruction *new) -{ - bool result; /* Bilan à retourner */ - - if (expr->payload) - { - if (expr->payload == G_DEC_EXPRESSION(old)) - { - g_object_unref(G_OBJECT(expr->payload)); - g_object_ref(G_OBJECT(new)); - expr->payload = G_DEC_EXPRESSION(new); - - result = true; - - } - else - result = g_dec_instruction_replace(G_DEC_INSTRUCTION(expr->payload), old, new); - - } - else - result = false; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_return_expression_print(const GReturnExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - GBufferLine *result; /* Ligne à retourner */ - - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "return", 6, RTT_KEY_WORD, NULL); - - if (expr->payload != NULL) - { - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); - - result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->payload), - buffer, line, output); - - } - else result = line; - - return result; - -} diff --git a/src/decomp/expr/return.h b/src/decomp/expr/return.h deleted file mode 100644 index ed28b96..0000000 --- a/src/decomp/expr/return.h +++ /dev/null @@ -1,60 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * return.h - prototypes pour la représentation des ordres de retour - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_RETURN_H -#define _DECOMP_EXPR_RETURN_H - - -#include <glib-object.h> - - -#include "../expression.h" -#include "../instruction.h" - - - -#define G_TYPE_RETURN_EXPRESSION g_return_expression_get_type() -#define G_RETURN_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_return_expression_get_type(), GReturnExpression)) -#define G_IS_RETURN_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_return_expression_get_type())) -#define G_RETURN_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RETURN_EXPRESSION, GReturnExpressionClass)) -#define G_IS_RETURN_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RETURN_EXPRESSION)) -#define G_RETURN_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RETURN_EXPRESSION, GReturnExpressionClass)) - - - -/* Définition d'un ordre de retour (instance) */ -typedef struct _GReturnExpression GReturnExpression; - -/* Définition d'un ordre de retour (classe) */ -typedef struct _GReturnExpressionClass GReturnExpressionClass; - - -/* Indique le type défini pour un ordre de retour. */ -GType g_return_expression_get_type(void); - -/* Constitue un ordre de retour vers l'appelant. */ -GDecInstruction *g_return_expression_new(GDecExpression *); - - - -#endif /* _DECOMP_EXPR_RETURN_H */ diff --git a/src/decomp/expr/text.c b/src/decomp/expr/text.c deleted file mode 100644 index bdf0495..0000000 --- a/src/decomp/expr/text.c +++ /dev/null @@ -1,159 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * text.c - raccord avec les opérandes de chaînes de caractères - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "text.h" - - -#include <string.h> - - -#include "../expression-int.h" - - - -/* Définition d'une expression de valeur immédiate (instance) */ -struct _GStrExpression -{ - GDecExpression parent; /* A laisser en premier */ - - char *value; /* Chaîne représentée */ - size_t len; /* Taille du texte */ - -}; - - -/* Définition d'une expression de valeur immédiate (classe) */ -struct _GStrExpressionClass -{ - GDecExpressionClass parent; /* A laisser en premier */ - -}; - - - -/* Initialise la classe des expressions de valeur immédiate. */ -static void g_str_expression_class_init(GStrExpressionClass *); - -/* Initialise une instance d'expression de valeur immédiate. */ -static void g_str_expression_init(GStrExpression *); - -/* Imprime pour l'écran un version humaine d'une expression. */ -static GBufferLine *g_str_expression_print(const GStrExpression *, GCodeBuffer *, GBufferLine *, GLangOutput *); - - - -/* Indique le type défini pour une expression de valeur immédiate. */ -G_DEFINE_TYPE(GStrExpression, g_str_expression, G_TYPE_DEC_EXPRESSION); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des expressions de valeur immédiate. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_str_expression_class_init(GStrExpressionClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : expr = instance à initialiser. * -* * -* Description : Initialise une instance d'expression de valeur immédiate. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_str_expression_init(GStrExpression *expr) -{ - GDecInstruction *instr; /* Autre version de l'objet */ - - instr = G_DEC_INSTRUCTION(expr); - - instr->print = (dec_instr_print_fc)g_str_expression_print; - -} - - -/****************************************************************************** -* * -* Paramètres : value = chaîne de caractères à représenter. * -* * -* Description : Construit une expression à partir d'une valeur immédiate. * -* * -* Retour : Expression mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GDecInstruction *g_str_expression_new(const char *value) -{ - GStrExpression *result; /* Expression à retourner */ - - result = g_object_new(G_TYPE_STR_EXPRESSION, NULL); - - result->value = strdup(value); - result->len = strlen(value); - - return G_DEC_INSTRUCTION(result); - -} - - -/****************************************************************************** -* * -* Paramètres : expr = expression à transcrire en version humaine. * -* buffer = tampon où doit se réaliser l'insertion. * -* line = ligne d'impression prête à emploi ou NULL. * -* output = langage de programmation de sortie. * -* * -* Description : Imprime pour l'écran un version humaine d'une expression. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBufferLine *g_str_expression_print(const GStrExpression *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) -{ - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "\"", 1, RTT_STRING, NULL); - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, expr->value, expr->len, RTT_STRING, NULL); - g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "\"", 1, RTT_STRING, NULL); - - return line; - -} diff --git a/src/decomp/expr/text.h b/src/decomp/expr/text.h deleted file mode 100644 index e54b4db..0000000 --- a/src/decomp/expr/text.h +++ /dev/null @@ -1,60 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * text.h - prototypes pour le raccord avec les opérandes de chaînes de caractères - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * Chrysalide is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * Chrysalide is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DECOMP_EXPR_TEXT_H -#define _DECOMP_EXPR_TEXT_H - - -#include <glib-object.h> - - -#include "../instruction.h" - - - -#define G_TYPE_STR_EXPRESSION g_str_expression_get_type() -#define G_STR_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_str_expression_get_type(), GStrExpression)) -#define G_IS_STR_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_str_expression_get_type())) -#define G_STR_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_STR_EXPRESSION, GStrExpressionClass)) -#define G_IS_STR_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_STR_EXPRESSION)) -#define G_STR_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_STR_EXPRESSION, GStrExpressionClass)) - - - -/* Définition d'une expression de valeur immédiate (instance) */ -typedef struct _GStrExpression GStrExpression; - -/* Définition d'une expression de valeur immédiate (classe) */ -typedef struct _GStrExpressionClass GStrExpressionClass; - - - -/* Indique le type défini pour une expression de valeur immédiate. */ -GType g_str_expression_get_type(void); - -/*Construit une expression à partir d'une valeur immédiate. */ -GDecInstruction *g_str_expression_new(const char *); - - - -#endif /* _DECOMP_EXPR_TEXT_H */ |