Reorganized the way the program is built again and added partial support for the JVM.

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

1 files changed, 133 insertions, 23 deletions

diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index a03ced4..d3cc882 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -24,56 +24,94 @@
 #include "instruction.h"
 
 
-#include <malloc.h>
+#include <string.h>
 
 
 #include "instruction-int.h"
+#include "../common/extstr.h"
 
 
 
+/* Initialise la classe générique des instructions. */
+static void g_arch_instruction_class_init(GArchInstructionClass *);
+
+/* Initialise une instance d'opérande d'architecture. */
+static void g_arch_instruction_init(GArchInstruction *);
+
+
+
+/* Indique le type défini pour une instruction d'architecture. */
+G_DEFINE_TYPE(GArchInstruction, g_arch_instruction, G_TYPE_OBJECT);
+
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : data = flux de données à analyser.                           *
-*                pos  = position courante dans ce flux. [OUT]                 *
-*                len  = taille totale des données à analyser.                 *
+*  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Crée une instruction de type 'db' à partir de données.       *
+*  Description : Initialise la classe générique des instructions.             *
 *                                                                             *
-*  Retour      : Instruction mise en place.                                   *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-asm_instr *create_db_instruction(const uint8_t *data, off_t *pos, off_t len)
+static void g_arch_instruction_class_init(GArchInstructionClass *klass)
 {
-    asm_instr *result;                      /* Représentation à renvoyer   */
 
-    result = (asm_instr *)calloc(1, sizeof(asm_instr));
+}
 
-    result->opcode = DB_OPCODE;
 
-    result->type = AIT_DB;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance d'instruction d'architecture.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    /* TODO: check result */
-    result->operands = (asm_operand **)calloc(1, sizeof(asm_operand *));
-    result->operands[0] = (asm_operand *)calloc(1, sizeof(asm_operand));
-    fill_db_operand(result->operands[0], data[(*pos)++]);
+static void g_arch_instruction_init(GArchInstruction *instr)
+{
 
-    result->operands_count = 1;
+}
 
-    return result;
 
-}
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction quelconque à modifier.                 *
+*                offset  = position physique dans le code binaire.            *
+*                length  = taille de l'instruction.                           *
+*                address = adresse virtuelle ou position physique.            *
+*                                                                             *
+*  Description : Définit la localisation d'une instruction.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void g_arch_instruction_set_location(GArchInstruction *instr, off_t offset, off_t length, vmpa_t address)
+{
+    instr->offset = offset;
+    instr->length = length;
+
+    instr->address = address;
+
+}
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr  = instruction quelconque à traiter.                   *
-*                offset = position physique dans le code binaire / NULL. [OUT]*
-*                length = taille de l'instruction ou NULL. [OUT]              *
+*  Paramètres  : instr   = instruction quelconque à consulter.                *
+*                offset  = position physique dans le code binaire/NULL. [OUT] *
+*                length  = taille de l'instruction ou NULL. [OUT]             *
+*                address = adresse virtuelle ou position physique/NULL. [OUT] *
 *                                                                             *
-*  Description : Indique la position et/ou la taille d'une instruction.       *
+*  Description : Fournit la localisation d'une instruction.                   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -81,9 +119,81 @@ asm_instr *create_db_instruction(const uint8_t *data, off_t *pos, off_t len)
 *                                                                             *
 ******************************************************************************/
 
-void get_asm_instr_offset_and_length(const asm_instr *instr, off_t *offset, off_t *length)
+void g_arch_instruction_get_location(GArchInstruction *instr, off_t *offset, off_t *length, vmpa_t *address)
 {
     if (offset != NULL) *offset = instr->offset;
     if (length != NULL) *length = instr->length;
 
+    if (address != NULL) *address = instr->address;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr     = instance à mettre à jour.                        *
+*                opererand = instruction à venir associer.                    *
+*                                                                             *
+*  Description : Attache une seule opérande à une instruction.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_arch_instruction_attach_one_operand(GArchInstruction *instr, GArchOperand *operand)
+{
+    instr->operands = (GArchOperand **)calloc(1, sizeof(GArchOperand *));
+    instr->operands_count = 1;
+
+    instr->operands[0] = operand;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr  = instruction à traiter.                              *
+*                format = format du binaire manipulé.                         *
+*                syntax = type de représentation demandée.                    *
+*                                                                             *
+*  Description : Traduit une instruction en version humainement lisible.      *
+*                                                                             *
+*  Retour      : Chaîne de caractères à libérer de la mémoire.                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_arch_instruction_get_text(const GArchInstruction *instr, const exe_format *format, AsmSyntax syntax)
+{
+    char *result;                           /* Chaîne à retourner          */
+    size_t i;                               /* Boucle de parcours          */
+    char *opstr;                            /* Chaîne d'opérande           */
+
+    if (instr->operands_count == 0)
+        result = strdup(instr->get_text(instr, format, syntax));
+
+    else
+    {
+        result = g_arch_operand_get_text(G_ARCH_INSTRUCTION(instr)->operands[0], format, syntax);
+
+        for (i = 1; i < instr->operands_count; i++)
+        {
+            result = stradd(result, ", ");
+
+            opstr = g_arch_operand_get_text(G_ARCH_INSTRUCTION(instr)->operands[i], format, syntax);
+            result = stradd(result, opstr);
+            free(opstr);
+
+        }
+
+        result = strprep(result, "\t");
+        result = strprep(result, instr->get_text(instr, format, syntax));
+
+    }
+
+    return result;
+
 }