Stored all errors detected when loading and disassembling a binary file.

1 files changed, 170 insertions, 1 deletions

diff --git a/src/arch/processor.c b/src/arch/processor.c
index 38c39e6..21b6c49 100644
--- a/src/arch/processor.c
+++ b/src/arch/processor.c
@@ -27,6 +27,7 @@
 #include <assert.h>
 #include <malloc.h>
 #include <stdlib.h>
+#include <string.h>
 
 
 
@@ -129,10 +130,17 @@ static void g_arch_processor_class_init(GArchProcessorClass *klass)
 
 static void g_arch_processor_init(GArchProcessor *proc)
 {
+    g_mutex_init(&proc->mutex);
 #ifndef DEBUG
     g_atomic_int_set(&proc->locked, 0);
 #endif
-    g_mutex_init(&proc->mutex);
+
+    proc->errors = NULL;
+    proc->error_count = 0;
+    g_mutex_init(&proc->error_mutex);
+#ifndef DEBUG
+    g_atomic_int_set(&proc->error_locked, 0);
+#endif
 
     proc->coverages = NULL;
     proc->cov_allocated = 0;
@@ -157,6 +165,8 @@ static void g_arch_processor_dispose(GArchProcessor *proc)
 {
     g_mutex_clear(&proc->mutex);
 
+    g_mutex_clear(&proc->error_mutex);
+
     G_OBJECT_CLASS(g_arch_processor_parent_class)->dispose(G_OBJECT(proc));
 
 }
@@ -176,6 +186,18 @@ static void g_arch_processor_dispose(GArchProcessor *proc)
 
 static void g_arch_processor_finalize(GArchProcessor *proc)
 {
+    size_t i;                               /* Boucle de parcours          */
+
+    if (proc->errors != NULL)
+    {
+        for (i = 0; i < proc->error_count; i++)
+            if (proc->errors[i].desc != NULL)
+                free(proc->errors[i].desc);
+
+        free(proc->errors);
+
+    }
+
     G_OBJECT_CLASS(g_arch_processor_parent_class)->finalize(G_OBJECT(proc));
 
 }
@@ -498,6 +520,153 @@ GArchInstruction *g_arch_processor_get_instruction(const GArchProcessor *proc, s
 
 
 /* ---------------------------------------------------------------------------------- */
+/*                    CONSERVATION DES SOUCIS DURANT LE CHARGEMENT                    */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc  = architecture à manipuler.                            *
+*                state = nouvel état de l'accès aux erreurs relevées.         *
+*                                                                             *
+*  Description : Protège ou lève la protection de l'accès aux erreurs.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_arch_processor_lock_unlock_errors(GArchProcessor *proc, bool state)
+{
+    if (state)
+    {
+        g_mutex_lock(&proc->error_mutex);
+        g_atomic_int_set(&proc->error_locked, 1);
+    }
+    else
+    {
+        g_atomic_int_set(&proc->error_locked, 0);
+        g_mutex_unlock(&proc->error_mutex);
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc  = architecture concernée par la procédure.             *
+*                index = indice du problème visé.                             *
+*                type  = type d'erreur retrouvée.                             *
+*                addr  = localisation associée.                               *
+*                desc  = éventuelle description humaine de description.       *
+*                                                                             *
+*  Description : Etend la liste des soucis détectés avec de nouvelles infos.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_arch_processor_add_error(GArchProcessor *proc, ArchProcessingError type, const vmpa2t *addr, const char *desc)
+{
+    proc_error *error;                      /* Raccourci de confort        */
+
+    g_arch_processor_lock_errors(proc);
+
+    proc->errors = realloc(proc->errors, ++proc->error_count * sizeof(proc_error));
+
+    error = &proc->errors[proc->error_count - 1];
+
+    error->type = type;
+
+    copy_vmpa(&error->addr, addr);
+
+    if (desc != NULL)
+        error->desc = strdup(desc);
+    else
+        error->desc = NULL;
+
+    g_arch_processor_unlock_errors(proc);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = architecture à consulter durant la procédure.         *
+*                                                                             *
+*  Description : Indique le nombre d'erreurs relevées au niveau assembleur.   *
+*                                                                             *
+*  Retour      : Nombre d'erreurs en stock.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_arch_processor_count_errors(GArchProcessor *proc)
+{
+    size_t result;                          /* Quantité à retourner        */
+
+    assert(g_atomic_int_get(&proc->error_locked) == 1);
+
+    result = proc->error_count;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc  = architecture concernée par la procédure.             *
+*                index = indice du problème visé.                             *
+*                type  = type d'erreur retrouvée. [OUT]                       *
+*                addr  = localisation associée. [OUT]                         *
+*                desc  = éventuelle description humaine de description. [OUT] *
+*                                                                             *
+*  Description : Fournit les éléments concernant un soucis détecté.           *
+*                                                                             *
+*  Retour      : Validité des informations renseignées.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_arch_processor_get_error(GArchProcessor *proc, size_t index, ArchProcessingError *type, vmpa2t *addr, char **desc)
+{
+    bool result;                            /* Bilan à retourner           */
+    proc_error *error;                      /* Raccourci de confort        */
+
+    assert(g_atomic_int_get(&proc->error_locked) == 1);
+
+    result = (index < proc->error_count);
+
+    assert(result);
+
+    if (result)
+    {
+        error = &proc->errors[index];
+
+        *type = error->type;
+
+        copy_vmpa(addr, &error->addr);
+
+        if (error->desc != NULL)
+            *desc = strdup(error->desc);
+        else
+            *desc = NULL;
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
 /*                    MANIPULATIONS DES INSTRUCTIONS DESASSEMBLEES                    */
 /* ---------------------------------------------------------------------------------- */