Simplified the way processors are registered.

2 files changed, 28 insertions, 63 deletions

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 *);