Simplified the way processors are registered.

6 files changed, 134 insertions, 79 deletions

diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 2bcc88d..cfb4ea0 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -1701,8 +1701,8 @@ static bool g_loaded_binary_analyze(GLoadedBinary *binary, bool cache, wgroup_id
 {
     bool result;                            /* Bilan à retourner           */
     GBinFormat *format;                     /* Format lié au binaire       */
-    const char *desc;                       /* Description humaine associée*/
     const char *arch;                       /* Architecture d'exécution    */
+    const char *desc;                       /* Description humaine associée*/
     bool has_virt;                          /* Présence de virtuel ?       */
     GProcContext *context;                  /* Contexte de suivi dédié     */
     GWidthTracker *tracker;                 /* Gestionnaire de largeur     */
@@ -1724,26 +1724,27 @@ static bool g_loaded_binary_analyze(GLoadedBinary *binary, bool cache, wgroup_id
     /* Architecture visée */
 
     arch = g_exe_format_get_target_machine(binary->format);
-    desc = get_arch_processor_description(arch);
 
-    if (desc == NULL)
+    if (arch == NULL)
     {
         log_simple_message(LMT_INFO, _("Unknown architecture"));
         result = false;
         goto glba_exit;
     }
-    else
-        log_variadic_message(LMT_INFO, _("Detected architecture: %s"), desc);
 
-    binary->proc = get_arch_processor_for_name(arch);
+    binary->proc = get_arch_processor_for_key(arch);
 
     if (binary->proc == NULL)
     {
-        log_simple_message(LMT_ERROR, _("Unable to load the required processor"));
+        log_variadic_message(LMT_ERROR, _("Unable to load the required processor (%s)"), arch);
         result = false;
         goto glba_exit;
     }
 
+    desc = g_arch_processor_get_desc(binary->proc);
+
+    log_variadic_message(LMT_INFO, _("Detected architecture: %s"), desc);
+
     g_signal_connect(binary->proc, "changed", G_CALLBACK(on_binary_processor_changed), binary);
 
     has_virt = g_arch_processor_has_virtual_space(binary->proc);
diff --git a/src/arch/processor-int.h b/src/arch/processor-int.h
index 475fadc..d29539b 100644
--- a/src/arch/processor-int.h
+++ b/src/arch/processor-int.h
@@ -66,11 +66,6 @@ struct _GArchProcessor
 {
     GObject parent;                         /* A laisser en premier        */
 
-    SourceEndian endianness;                /* Boutisme de l'architecture  */
-    MemoryDataSize memsize;                 /* Taille de l'espace mémoire  */
-    MemoryDataSize inssize;                 /* Taille min. d'encodage      */
-    bool virt_space;                        /* Présence d'espace virtuel ? */
-
     GArchInstruction **instructions;        /* Instructions désassemblées  */
     size_t instr_count;                     /* Taille de la liste aplatie  */
     unsigned int stamp;                     /* Marque de suivi des modifs  */
@@ -97,6 +92,14 @@ struct _GArchProcessorClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    const char *key;                        /* Désignation interne         */
+    const char *desc;                       /* Description humaine liée    */
+
+    SourceEndian endianness;                /* Boutisme de l'architecture  */
+    MemoryDataSize memsize;                 /* Taille de l'espace mémoire  */
+    MemoryDataSize inssize;                 /* Taille min. d'encodage      */
+    bool virt_space;                        /* Présence d'espace virtuel ? */
+
     get_processor_context_fc get_ctx;       /* Obtention d'un contexte #1  */
 
     disass_instr_fc disassemble;            /* Traduction en instructions  */
diff --git a/src/arch/processor.c b/src/arch/processor.c
index dccd12e..644a1ca 100644
--- a/src/arch/processor.c
+++ b/src/arch/processor.c
@@ -275,6 +275,58 @@ static GProcContext *_g_arch_processor_get_context(const GArchProcessor *proc)
 *                                                                             *
 *  Paramètres  : proc = processeur d'architecture à consulter.                *
 *                                                                             *
+*  Description : Fournit la désignation interne du processeur d'architecture. *
+*                                                                             *
+*  Retour      : Simple chaîne de caractères.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_arch_processor_get_key(const GArchProcessor *proc)
+{
+    const char *result;                     /* Désignation à renvoyer      */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->key;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = processeur d'architecture à consulter.                *
+*                                                                             *
+*  Description : Fournit le nom humain de l'architecture visée.               *
+*                                                                             *
+*  Retour      : Désignation humaine associée au processeur.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_arch_processor_get_desc(const GArchProcessor *proc)
+{
+    const char *result;                     /* Désignation à renvoyer      */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->desc;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : proc = processeur d'architecture à consulter.                *
+*                                                                             *
 *  Description : Fournit le boustime du processeur d'une architecture.        *
 *                                                                             *
 *  Retour      : Boutisme associé au processeur.                              *
@@ -285,7 +337,14 @@ static GProcContext *_g_arch_processor_get_context(const GArchProcessor *proc)
 
 SourceEndian g_arch_processor_get_endianness(const GArchProcessor *proc)
 {
-    return proc->endianness;
+    SourceEndian result;                    /* Boutisme à retourner        */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->endianness;
+
+    return result;
 
 }
 
@@ -304,7 +363,14 @@ SourceEndian g_arch_processor_get_endianness(const GArchProcessor *proc)
 
 MemoryDataSize g_arch_processor_get_memory_size(const GArchProcessor *proc)
 {
-    return proc->memsize;
+    MemoryDataSize result;                  /* Taille  à retourner         */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->memsize;
+
+    return result;
 
 }
 
@@ -323,7 +389,14 @@ MemoryDataSize g_arch_processor_get_memory_size(const GArchProcessor *proc)
 
 MemoryDataSize g_arch_processor_get_instruction_min_size(const GArchProcessor *proc)
 {
-    return proc->inssize;
+    MemoryDataSize result;                  /* Taille  à retourner         */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->inssize;
+
+    return result;
 
 }
 
@@ -342,7 +415,14 @@ MemoryDataSize g_arch_processor_get_instruction_min_size(const GArchProcessor *p
 
 bool g_arch_processor_has_virtual_space(const GArchProcessor *proc)
 {
-    return proc->virt_space;
+    bool result;                            /* Indication à retourner      */
+    GArchProcessorClass *class;             /* Classe de l'instance        */
+
+    class = G_ARCH_PROCESSOR_GET_CLASS(proc);
+
+    result = class->virt_space;
+
+    return result;
 
 }
 
diff --git a/src/arch/processor.h b/src/arch/processor.h
index 26eddb1..0b33a50 100644
--- a/src/arch/processor.h
+++ b/src/arch/processor.h
@@ -55,6 +55,12 @@ typedef struct _GArchProcessorClass GArchProcessorClass;
 /* Indique le type défini pour un processeur d'architecture. */
 GType g_arch_processor_get_type(void);
 
+/* Fournit la désignation interne du processeur d'architecture. */
+const char *g_arch_processor_get_key(const GArchProcessor *);
+
+/* Fournit le nom humain de l'architecture visée. */
+const char *g_arch_processor_get_desc(const GArchProcessor *);
+
 /* Fournit le boustime du processeur d'une architecture. */
 SourceEndian g_arch_processor_get_endianness(const GArchProcessor *);
 
diff --git a/src/core/processors.c b/src/core/processors.c
index 631e819..42d4e4b 100644
--- a/src/core/processors.c
+++ b/src/core/processors.c
@@ -40,9 +40,8 @@
 /* Caractéristiques d'un processeur */
 typedef struct _proc_t
 {
-    char *name;                             /* Clef pour un accès rapide   */
-    char *desc;                             /* Désignation humaine         */
-    GType instance;                         /* Type à manipuler en interne */
+    char *key;                              /* Clef pour un accès rapide   */
+    GType type;                             /* Type à manipuler en interne */
 
 } proc_t;
 
@@ -85,9 +84,7 @@ void register_arch_gtypes(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : name     = désignation rapide et interne d'un processeur.    *
-*                desc     = désignation humaine de l'architecture.            *
-*                instance = type GLib représentant le type à instancier.      *
+*  Paramètres  : type = type GLib représentant le type à instancier.          *
 *                                                                             *
 *  Description : Enregistre un processeur pour une architecture donnée.       *
 *                                                                             *
@@ -97,32 +94,39 @@ void register_arch_gtypes(void)
 *                                                                             *
 ******************************************************************************/
 
-bool register_processor_type(const char *name, const char *desc, GType instance)
+bool register_processor_type(GType type)
 {
     bool result;                            /* Bilan à retourner           */
+    GArchProcessor *proc;                   /* Instance pour consultation  */
+    const char *key;                        /* Désignation associée        */
     proc_t *new;                            /* Nouvel élément à définir    */
 
+    proc = g_object_new(type, NULL);
+
+    key = g_arch_processor_get_key(proc);
+
     G_LOCK(_pdef_access);
 
-    new = find_processor_by_key(name);
+    new = find_processor_by_key(key);
 
     result = (new == NULL);
 
     if (result)
     {
-        _processors_definitions = (proc_t *)realloc(_processors_definitions,
-                                                    ++_processors_definitions_count * sizeof(proc_t));
+        _processors_definitions = realloc(_processors_definitions,
+                                          ++_processors_definitions_count * sizeof(proc_t));
 
         new = &_processors_definitions[_processors_definitions_count - 1];
 
-        new->name = strdup(name);
-        new->desc = strdup(desc);
-        new->instance = instance;
+        new->key = strdup(key);
+        new->type = type;
 
     }
 
     G_UNLOCK(_pdef_access);
 
+    g_object_unref(G_OBJECT(proc));
+
     return result;
 
 }
@@ -147,10 +151,7 @@ void unload_processors_definitions(void)
     G_LOCK(_pdef_access);
 
     for (i = 0; i < _processors_definitions_count; i++)
-    {
-        free(_processors_definitions[i].name);
-        free(_processors_definitions[i].desc);
-    }
+        free(_processors_definitions[i].key);
 
     if (_processors_definitions != NULL)
         free(_processors_definitions);
@@ -165,7 +166,7 @@ void unload_processors_definitions(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : name = nom technique du processeur recherché.                *
+*  Paramètres  : key = nom technique du processeur recherché.                 *
 *                                                                             *
 *  Description : Retrouve l'enregistrement correspondant à une architecture.  *
 *                                                                             *
@@ -175,7 +176,7 @@ void unload_processors_definitions(void)
 *                                                                             *
 ******************************************************************************/
 
-static proc_t *find_processor_by_key(const char *name)
+static proc_t *find_processor_by_key(const char *key)
 {
     proc_t *result;                         /* Trouvaille à retourner      */
     size_t i;                               /* Boucle de parcours          */
@@ -186,9 +187,9 @@ static proc_t *find_processor_by_key(const char *name)
 
     result = NULL;
 
-    if (name != NULL)
+    if (key != NULL)
         for (i = 0; i < _processors_definitions_count; i++)
-            if (strcmp(_processors_definitions[i].name, name) == 0)
+            if (strcmp(_processors_definitions[i].key, key) == 0)
                 result = &_processors_definitions[i];
 
     return result;
@@ -198,40 +199,7 @@ static proc_t *find_processor_by_key(const char *name)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : name = nom technique du processeur recherché.                *
-*                                                                             *
-*  Description : Fournit le nom humain de l'architecture visée.               *
-*                                                                             *
-*  Retour      : Désignation humaine trouvée ou NULL.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-const char *get_arch_processor_description(const char *name)
-{
-    const char *result;                     /* Description à retourner     */
-    proc_t *def;                            /* Définition d'architecture   */
-
-    G_LOCK(_pdef_access);
-
-    def = find_processor_by_key(name);
-
-    if (def == NULL)
-        result = NULL;
-    else
-        result = def->desc;
-
-    G_UNLOCK(_pdef_access);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : name = nom technique du processeur recherché.                *
+*  Paramètres  : key = nom technique du processeur recherché.                 *
 *                                                                             *
 *  Description : Fournit le processeur d'architecture correspondant à un nom. *
 *                                                                             *
@@ -241,19 +209,19 @@ const char *get_arch_processor_description(const char *name)
 *                                                                             *
 ******************************************************************************/
 
-GArchProcessor *get_arch_processor_for_name(const char *name)
+GArchProcessor *get_arch_processor_for_key(const char *key)
 {
     GArchProcessor *result;                 /* Instance à retourner        */
     proc_t *def;                            /* Définition d'architecture   */
 
     G_LOCK(_pdef_access);
 
-    def = find_processor_by_key(name);
+    def = find_processor_by_key(key);
 
     if (def == NULL)
         result = NULL;
     else
-        result = g_object_new(def->instance, NULL);
+        result = g_object_new(def->type, NULL);
 
     G_UNLOCK(_pdef_access);
 
diff --git a/src/core/processors.h b/src/core/processors.h
index 975c716..034f219 100644
--- a/src/core/processors.h
+++ b/src/core/processors.h
@@ -36,16 +36,13 @@
 void register_arch_gtypes(void);
 
 /* Enregistre un processeur pour une architecture donnée. */
-bool register_processor_type(const char *, const char *, GType);
+bool register_processor_type(GType);
 
 /* Décharge toutes les définitions de processeurs. */
 void unload_processors_definitions(void);
 
-/* Fournit le nom humain de l'architecture visée. */
-const char *get_arch_processor_description(const char *);
-
 /* Fournit le processeur d'architecture correspondant à un nom. */
-GArchProcessor *get_arch_processor_for_name(const char *);
+GArchProcessor *get_arch_processor_for_key(const char *);