Provided a clean way to run delayed tasks.

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

3 files changed, 160 insertions, 211 deletions

diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index c21b554..8cec72a 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -41,6 +41,7 @@
 #include "line_prologue.h"
 #include "prototype.h"
 #include "../common/extstr.h"
+#include "../glibext/delayed.h"
 #include "../format/format.h"
 #include "../panel/log.h"
 #include "../plugins/pglist.h"
@@ -101,7 +102,7 @@ bin_t *map_binary_file(const char *, off_t *);
 GRenderingLine *build_binary_prologue(const char *, const uint8_t *, off_t);
 
 /* Acquitte la fin d'un désasemblage différé et complet. */
-void ack_completed_disassembly(GDelayedManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *);
+void ack_completed_disassembly(GDisassManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *);
 
 
 
@@ -312,24 +313,22 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat
 
 void g_openida_binary_analyse(GOpenidaBinary *binary)
 {
-    GDelayedManager *manager;               /* Gestionnaire de différés    */
+    GDisassManager *manager;                /* Gestionnaire de différés    */
     GBinPart **parts;                       /* Parties d'élément binaire   */
     size_t parts_count;                     /* Nombre de ces parties       */
+    GDelayedDisassembly *disass;            /* Désassemblage à mener       */
 
-    manager = get_delayed_manager();
+    manager = get_disassembly_manager();
 
     parts = g_exe_format_get_parts(binary->format, &parts_count);
     qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare);
 
+    disass = g_delayed_disassembly_new(binary, parts, parts_count);
 
     g_signal_connect(manager, "disassembly-completed",
                      G_CALLBACK(ack_completed_disassembly), binary);
 
-    g_delayed_manager_schedule_disassembly(manager, binary, parts, parts_count);
-
-
-
-
+    g_delayed_queue_schedule_work(G_WORK_QUEUE(manager), G_DELAYED_WORK(disass));
 
 }
 
@@ -605,7 +604,7 @@ GRenderingLine *build_binary_prologue(const char *filename, const uint8_t *data,
 *                                                                             *
 ******************************************************************************/
 
-void ack_completed_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user)
+void ack_completed_disassembly(GDisassManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user)
 {
     GRenderingLine *line;                   /* "Première" ligne de rendu   */
     GPluginModule **pglist;                 /* Liste de greffons           */
diff --git a/src/analysis/delayed.c b/src/analysis/delayed.c
index 6ec03e8..0d02d39 100644
--- a/src/analysis/delayed.c
+++ b/src/analysis/delayed.c
@@ -24,13 +24,11 @@
 #include "delayed.h"
 
 
-#include <malloc.h>
-
-
 #include "line_code.h"
 #include "line_comment.h"
 #include "../common/dllist.h"
 #include "../format/format.h"
+#include "../glibext/delayed-int.h"
 #include "../gtkext/gtkextstatusbar.h"
 #include "../gtkext/iodamarshal.h"
 
@@ -43,75 +41,75 @@
 
 
 
-/* Ensembles binaires à désassembler */
-typedef struct _disassembly_task
+/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
+
+
+/* Ensembles binaires à désassembler (instance) */
+struct _GDelayedDisassembly
 {
-    GOpenidaBinary *owner;                  /* Destinataire final          */
+    GDelayedWork parent;                    /* A laisser en premier        */
 
-    DL_LIST_ITEM(link);                     /* Lien vers les maillons      */
+    GOpenidaBinary *binary;                 /* Destinataire final          */
 
     GBinPart **parts;                       /* Parties binaires à traiter  */
     size_t count;                           /* Nombre de ces parties       */
 
-} disassembly_task;
-
+};
 
-#define disassembly_task_list_add_tail(new, head) dl_list_add_tail(new, head, disassembly_task, link)
-#define disassembly_task_list_del(item, head) dl_list_del(item, head, disassembly_task, link)
+/* Ensembles binaires à désassembler (classe) */
+struct _GDelayedDisassemblyClass
+{
+    GDelayedWorkClass parent;               /* A laisser en premier        */
 
+};
 
-/* Crée un tâche de désassemblage différé. */
-static disassembly_task *create_disassembly_task(GOpenidaBinary *, GBinPart **, size_t);
 
-/* Efface une tâche de désassemblage de la mémoire. */
-static void delete_disassembly_task(disassembly_task *);
+/* Initialise la classe des tâches de désassemblage différé. */
+static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *);
 
+/* Initialise une tâche de désassemblage différé. */
+static void g_delayed_disassembly_init(GDelayedDisassembly *);
 
 
 
+/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */
 
 
 /* Gestionnaire des analyses différées (instance) */
-struct _GDelayedManager
+struct _GDisassManager
 {
-    GObject parent;                         /* A laisser en premier        */
+    GWorkQueue parent;                      /* A laisser en premier        */
 
     GtkExtStatusBar *statusbar;             /* Barre de statut principale  */
 
-    disassembly_task *disassemblies;        /* Binaires à désassembler     */
-    GMutex *disass_mutex;                   /* Verrou pour l'accès         */
-    GCond *disass_cond;                     /* Réveil pour un traitement   */
-
-    GThread *disassemble;                   /* Procédures de désassemblage */
-
 };
 
 /* Gestionnaire des analyses différées (classe) */
-struct _GDelayedManagerClass
+struct _GDisassManagerClass
 {
-    GObjectClass parent;                    /* A laisser en premier        */
+    GWorkQueueClass parent;                 /* A laisser en premier        */
 
     /* Signaux */
 
-    void (* disassembly_completed) (GDelayedManager *, GOpenidaBinary *, GRenderingLine *);
+    void (* disassembly_completed) (GDisassManager *, GOpenidaBinary *, GRenderingLine *);
 
 };
 
 
 /* Initialise la classe des gestionnaires d'analyses différées. */
-static void g_delayed_manager_class_init(GDelayedManagerClass *);
+static void g_disassembly_manager_class_init(GDisassManagerClass *);
 
 /* Initialise un gestionnaire d'analyses différées. */
-static void g_delayed_manager_init(GDelayedManager *);
+static void g_disassembly_manager_init(GDisassManager *);
 
 /* Crée un gestionnaire d'analyses différées. */
-static GDelayedManager *g_delayed_manager_new(GObject *);
+static GDisassManager *g_disassembly_manager_new(GObject *);
 
 /* Assure le désassemblage en différé. */
-static void *process_disassemblies(GDelayedManager *);
+static void process_disassemblies(GDisassManager *, GDelayedDisassembly *);
 
 /* Procède au désassemblage basique d'un contenu binaire. */
-static GRenderingLine *disassemble_binary_parts(disassembly_task *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
+static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
 
 /* Etablit les liens entres les différentes lignes de code. */
 static void establish_links_between_lines(GRenderingLine *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
@@ -124,48 +122,38 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, con
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                          DESASSEMBLAGE DE BINAIRE DIFFERE                          */
+/* ---------------------------------------------------------------------------------- */
 
 
-
+/* Indique le type défini pour les tâches de désassemblage différé. */
+G_DEFINE_TYPE(GDelayedDisassembly, g_delayed_disassembly, G_TYPE_DELAYED_WORK);
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : owner = binaire chargé en attente des résultats.             *
-*                parts = parties binaires à désassembler.                     *
-*                count = nombre de parties à traiter.                         *
+*  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Crée un tâche de désassemblage différé.                      *
+*  Description : Initialise la classe des tâches de désassemblage différé.    *
 *                                                                             *
-*  Retour      : Tâche créée.                                                 *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart **parts, size_t count)
+static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *klass)
 {
-    disassembly_task *result;               /* Tâche à retourner           */
-
-    result = (disassembly_task *)calloc(1, sizeof(disassembly_task));
-
-    result->owner = owner;
-
-    DL_LIST_ITEM_INIT(&result->link);
-
-    result->parts = parts;
-    result->count = count;
-
-    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : task = tâche à libérer de la mémoire.                        *
+*  Paramètres  : disass = instance à initialiser.                             *
 *                                                                             *
-*  Description : Efface une tâche de désassemblage de la mémoire.             *
+*  Description : Initialise une tâche de désassemblage différé.               *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -173,34 +161,50 @@ static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart
 *                                                                             *
 ******************************************************************************/
 
-static void delete_disassembly_task(disassembly_task *task)
+static void g_delayed_disassembly_init(GDelayedDisassembly *disass)
 {
-    /* TODO
-    result->parts = parts;
-    result->count = count;
-    */
-
-    free(task);
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = binaire chargé en attente des résultats.            *
+*                parts  = parties binaires à désassembler.                    *
+*                count  = nombre de parties à traiter.                        *
+*                                                                             *
+*  Description : Crée une tâche de désassemblage différé.                     *
+*                                                                             *
+*  Retour      : Tâche créée.                                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *binary, GBinPart **parts, size_t count)
+{
+    GDelayedDisassembly *result;            /* Tâche à retourner           */
 
+    result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL);
 
+    result->binary = binary;
 
+    result->parts = parts;
+    result->count = count;
 
+    return result;
 
+}
 
 
 
-
-
-
+/* ---------------------------------------------------------------------------------- */
+/*                           GESTION DES ANALYSES DIFFEREES                           */
+/* ---------------------------------------------------------------------------------- */
 
 
 /* Indique le type défini pour le gestionnaire des analyses différées. */
-G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GDisassManager, g_disassembly_manager, G_TYPE_WORK_QUEUE);
 
 
 /******************************************************************************
@@ -215,12 +219,12 @@ G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT);
 *                                                                             *
 ******************************************************************************/
 
-static void g_delayed_manager_class_init(GDelayedManagerClass *klass)
+static void g_disassembly_manager_class_init(GDisassManagerClass *klass)
 {
     g_signal_new("disassembly-completed",
-                 G_TYPE_DELAYED_MANAGER,
+                 G_TYPE_DISASS_MANAGER,
                  G_SIGNAL_RUN_LAST,
-                 G_STRUCT_OFFSET(GDelayedManagerClass, disassembly_completed),
+                 G_STRUCT_OFFSET(GDisassManagerClass, disassembly_completed),
                  NULL, NULL,
                  g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
                  G_TYPE_NONE, 2, G_TYPE_OPENIDA_BINARY, G_TYPE_RENDERING_LINE);
@@ -240,8 +244,13 @@ static void g_delayed_manager_class_init(GDelayedManagerClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_delayed_manager_init(GDelayedManager *manager)
+static void g_disassembly_manager_init(GDisassManager *manager)
 {
+    GWorkQueue *parent;                     /* Instance parente            */
+
+    parent = G_WORK_QUEUE(manager);
+
+    parent->process = (process_work_fc)process_disassemblies;
 
 }
 
@@ -258,116 +267,76 @@ static void g_delayed_manager_init(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-static GDelayedManager *g_delayed_manager_new(GObject *ref)
+static GDisassManager *g_disassembly_manager_new(GObject *ref)
 {
-    GDelayedManager *result;                /* Adresse à retourner         */
-    GError *error;                          /* Bilan de création de thread */
+    GDisassManager *result;                 /* Adresse à retourner         */
 
-    result = g_object_new(G_TYPE_DELAYED_MANAGER, NULL);
+    result = g_object_new(G_TYPE_DISASS_MANAGER, NULL);
 
     result->statusbar = g_object_get_data(ref, "statusbar");
 
-    result->disass_mutex = g_mutex_new();
-    if (result->disass_mutex == NULL)
-        goto dmn_error;
-
-    result->disass_cond = g_cond_new();
-    if (result->disass_cond == NULL)
-        goto dmn_error;
-
-    result->disassemble = g_thread_create((GThreadFunc)process_disassemblies, result, FALSE, &error);
-    if (!result->disassemble)
-        goto dmn_error;
-
     return result;
 
- dmn_error:
-
-    /* TODO */
-
-    return NULL;
-
 }
 
 
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : manager = gestionnaire des actions à mener.                  *
+*                disass  = analyse à mener.                                   *
 *                                                                             *
 *  Description : Assure le désassemblage en différé.                          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void *process_disassemblies(GDelayedManager *manager)
+static void process_disassemblies(GDisassManager *manager, GDelayedDisassembly *disass)
 {
-    disassembly_task *task;                 /* Désassemblage à effectuer   */
     GBinRoutine **routines;                 /* Liste des routines trouvées */
     size_t routines_count;                  /* Nombre de ces routines      */
     guint id;                               /* Identifiant de statut       */
     GRenderingLine *lines;                  /* Nouvelles lignes de rendu   */
 
-    while (1)
-    {
-        g_mutex_lock(manager->disass_mutex);
-
-        if (dl_list_empty(manager->disassemblies))
-            g_cond_wait(manager->disass_cond, manager->disass_mutex);
-
-        task = manager->disassemblies;
-        disassembly_task_list_del(task, &manager->disassemblies);
-
-        g_mutex_unlock(manager->disass_mutex);
+    routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(disass->binary)), &routines_count);
+    qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
 
-        routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(task->owner)), &routines_count);
-        qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
+    /* Première étape */
 
-        /* Première étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true);
+    lines = disassemble_binary_parts(disass, routines, routines_count, manager->statusbar, id);
 
-        lines = disassemble_binary_parts(task, routines, routines_count,
-                                         manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Seconde étape */
 
-        /* Seconde étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true);
+    establish_links_between_lines(lines, routines, routines_count, manager->statusbar, id);
 
-        establish_links_between_lines(lines, routines, routines_count,
-                                      manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Troisième  étape */
 
-        /* Troisième  étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true);
+    limit_all_routines(lines, routines, routines_count, manager->statusbar, id);
 
-        limit_all_routines(lines, routines, routines_count,
-                           manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Fin */
 
-        /* Fin */
-
-        g_signal_emit_by_name(manager, "disassembly-completed", task->owner, lines);
-
-        delete_disassembly_task(task);
-
-    }
-
-    return NULL;
+    g_signal_emit_by_name(manager, "disassembly-completed", disass->binary, lines);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : task      = tâche à l'origine du traitement.                 *
+*  Paramètres  : disass    = tâche à l'origine du traitement.                 *
 *                routines  = prototypes existants à insérer.                  *
 *                count     = quantité de ces prototypes.                      *
 *                statusbar = barre de statut avec progression à mettre à jour.*
@@ -381,7 +350,7 @@ static void *process_disassemblies(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
+static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *disass, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
 {
     GRenderingLine *result;                 /* Ligne de rendu à retourner  */
     GArchProcessor *proc;                   /* Architecture du binaire     */
@@ -403,25 +372,25 @@ static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRout
 
     result = NULL;
 
-    proc = get_arch_processor_from_format(g_openida_binary_get_format(task->owner));
-    options = g_openida_binary_get_options(task->owner);
-    bin_data = g_openida_binary_get_data(task->owner, NULL);
+    proc = get_arch_processor_from_format(g_openida_binary_get_format(disass->binary));
+    options = g_openida_binary_get_options(disass->binary);
+    bin_data = g_openida_binary_get_data(disass->binary, NULL);
 
     /* Préparation du suivi de la progression */
 
     sum = 0;
 
-    for (i = 0; i < task->count; i++)
+    for (i = 0; i < disass->count; i++)
     {
-        g_binary_part_get_values(task->parts[i], NULL, &len, NULL);
+        g_binary_part_get_values(disass->parts[i], NULL, &len, NULL);
         sum += len;
     }
 
     done = 0;
 
-    for (i = 0; i < task->count; i++)
+    for (i = 0; i < disass->count; i++)
     {
-        g_binary_part_get_values(task->parts[i], &pos, &len, &base);
+        g_binary_part_get_values(disass->parts[i], &pos, &len, &base);
 
         /* Décodage des instructions */
 
@@ -695,48 +664,6 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *line, size_t
 }
 
 
-
-
-
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : manager = gestionnaire des actions à mener.                  *
-*                binary  = élément binaire concerné par la procédure.         *
-*                parts   = blocs binaires à désassembler.                     *
-*                count   = quantité de ces blocs binaires.                    *
-*                                                                             *
-*  Description : Place un nouveau désassemblage en attente.                   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GBinPart **parts, size_t count)
-{
-    disassembly_task *task;                 /* Nouveau désassemblage       */
-
-    task = create_disassembly_task(binary, parts, count);
-
-    g_mutex_lock(manager->disass_mutex);
-
-    disassembly_task_list_add_tail(task, &manager->disassemblies);
-
-    g_cond_signal(manager->disass_cond);
-
-    g_mutex_unlock(manager->disass_mutex);
-
-}
-
-
-
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : manager = nouveau gestionnaire à mémoriser ou NULL.          *
@@ -749,9 +676,9 @@ void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBi
 *                                                                             *
 ******************************************************************************/
 
-GDelayedManager *_get_delayed_manager(GDelayedManager *manager)
+GDisassManager *_get_disassembly_manager(GDisassManager *manager)
 {
-    static GDelayedManager *result = NULL;  /* Singleton à retourner       */
+    static GDisassManager *result = NULL;   /* Singleton à retourner       */
 
     if (manager != NULL)
         result = manager;
@@ -773,14 +700,14 @@ GDelayedManager *_get_delayed_manager(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-bool init_delayed_manager(GObject *ref)
+bool init_disassembly_manager(GObject *ref)
 {
-    GDelayedManager *manager;               /* Singleton à mettre en place */
+    GDisassManager *manager;                /* Singleton à mettre en place */
 
-    manager = g_delayed_manager_new(ref);
+    manager = g_disassembly_manager_new(ref);
 
     if (manager != NULL)
-        _get_delayed_manager(manager);
+        _get_disassembly_manager(manager);
 
     return (manager != NULL);
 
diff --git a/src/analysis/delayed.h b/src/analysis/delayed.h
index 437f968..c543f0b 100644
--- a/src/analysis/delayed.h
+++ b/src/analysis/delayed.h
@@ -36,38 +36,61 @@
 
 
 
-#define G_TYPE_DELAYED_MANAGER               g_delayed_manager_get_type()
-#define G_DELAYED_MANAGER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_manager_get_type(), GDelayedManager))
-#define G_IS_DELAYED_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_manager_get_type()))
-#define G_DELAYED_MANAGER_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_delayed_manager_get_type(), GDelayedManagerIface))
-#define G_DELAYED_MANAGER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_MANAGER, GDelayedManagerClass))
+/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
 
 
-/* Gestionnaire des analyses différées (instance) */
-typedef struct _GDelayedManager GDelayedManager;
+#define G_TYPE_DELAYED_DISASSEMBLY               g_delayed_disassembly_get_type()
+#define G_DELAYED_DISASSEMBLY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_disassembly_get_type(), GDelayedDisassembly))
+#define G_IS_DELAYED_DISASSEMBLY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_disassembly_get_type()))
+#define G_DELAYED_DISASSEMBLY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
+#define G_IS_DELAYED_DISASSEMBLY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_DISASSEMBLY))
+#define G_DELAYED_DISASSEMBLY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
 
-/* Gestionnaire des analyses différées (classe) */
-typedef struct _GDelayedManagerClass GDelayedManagerClass;
 
+/* Ensembles binaires à désassembler (instance) */
+typedef struct _GDelayedDisassembly GDelayedDisassembly;
+
+/* Ensembles binaires à désassembler (classe) */
+typedef struct _GDelayedDisassemblyClass GDelayedDisassemblyClass;
 
-/* Indique le type défini pour le gestionnaire des analyses différées. */
-GType g_delayed_manager_get_type(void);
 
-/* Place un nouveau désassemblage en attente. */
-void g_delayed_manager_schedule_disassembly(GDelayedManager *, GOpenidaBinary *, GBinPart **, size_t);
 
+/* Indique le type défini pour les tâches de désassemblage différé. */
+GType g_delayed_disassembly_get_type(void);
 
+/* Crée une tâche de désassemblage différé. */
+GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *, GBinPart **, size_t);
 
 
 
-#define get_delayed_manager() _get_delayed_manager(NULL)
+/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */
 
 
+#define G_TYPE_DISASS_MANAGER               g_disassembly_manager_get_type()
+#define G_DISASS_MANAGER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_disassembly_manager_get_type(), GDisassManager))
+#define G_IS_DISASS_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_disassembly_manager_get_type()))
+#define G_DISASS_MANAGER_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_disassembly_manager_get_type(), GDisassManagerIface))
+#define G_DISASS_MANAGER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DISASS_MANAGER, GDisassManagerClass))
+
+
+/* Gestionnaire des analyses différées (instance) */
+typedef struct _GDisassManager GDisassManager;
+
+/* Gestionnaire des analyses différées (classe) */
+typedef struct _GDisassManagerClass GDisassManagerClass;
+
+
+#define get_disassembly_manager() _get_disassembly_manager(NULL)
+
+
+/* Indique le type défini pour le gestionnaire des analyses différées. */
+GType g_disassembly_manager_get_type(void);
+
 /* Fournit le gestionnaire d'analyse en différé courant. */
-GDelayedManager *_get_delayed_manager(GDelayedManager *);
+GDisassManager *_get_disassembly_manager(GDisassManager *);
 
 /* Procède au chargement du gestionnaire d'analyse différées. */
-bool init_delayed_manager(GObject *);
+bool init_disassembly_manager(GObject *);