/* 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 . */ #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; }