Extended the prototype for matching formats in order to get it suitable for plugins.

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

26 files changed, 1447 insertions, 120 deletions

diff --git a/src/analysis/binaries/file.c b/src/analysis/binaries/file.c
index 32cd41f..c31828c 100644
--- a/src/analysis/binaries/file.c
+++ b/src/analysis/binaries/file.c
@@ -116,8 +116,8 @@ static void g_file_binary_init(GFileBinary *binary)
 
     loaded = G_LOADED_BINARY(binary);
 
-    loaded->save = (save_binary_fc)g_file_binary_save;
-    loaded->get_name = (get_binary_name_fc)g_file_binary_get_name;
+    //loaded->save = (save_binary_fc)g_file_binary_save;
+    //loaded->get_name = (get_binary_name_fc)g_file_binary_get_name;
 
 }
 
@@ -173,7 +173,7 @@ GLoadedBinary *g_file_binary_new_from_file(const char *filename)
     content = g_file_content_new(filename);
     if (content == NULL) goto lbf_error;
 
-    target = find_matching_format(content, NULL);
+    target = "";//find_matching_format(content, NULL);
     desc = get_binary_format_name(target);
 
     if (desc == NULL)
@@ -194,7 +194,7 @@ GLoadedBinary *g_file_binary_new_from_file(const char *filename)
         goto lbf_error;
     }
 
-    target = find_matching_format(content, loaded->format);
+    target = "";//find_matching_format(content, loaded->format);
     desc = get_binary_format_name(target);
 
     if (desc != NULL)
diff --git a/src/analysis/binary-int.h b/src/analysis/binary-int.h
index 4bfb14e..60b9662 100644
--- a/src/analysis/binary-int.h
+++ b/src/analysis/binary-int.h
@@ -33,11 +33,8 @@
 
 
 
-/* Ecrit une sauvegarde du binaire dans un fichier XML. */
-typedef bool (* save_binary_fc) (const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
-
 /* Fournit le fichier correspondant à l'élément binaire. */
-typedef const char * (* get_binary_name_fc) (const GLoadedBinary *, bool);
+typedef const char * (* get_binary_name_fc) (const GLoadedBinary *, bool); //// REMME
 
 
 /* Description de fichier binaire (instance) */
@@ -57,11 +54,12 @@ struct _GLoadedBinary
     DBStorage storages[DBF_COUNT];          /* Lieux d'enregistrement      */
     GList *collections;                     /* Ensemble de modifications   */
 
-    save_binary_fc save;                    /* Sauvegarde au format XML    */
-    get_binary_name_fc get_name;            /* Obtention d'une description */
+    get_binary_name_fc get_name;            /* Obtention d'une description */ //// REMME
+
+    GBinContent *content;                   /* Contenu binaire chargé      */ //// REMME
 
     GExeFormat *format;                     /* Format du binaire           */
-    GDbgFormat *debug;                      /* Informations de débogage    */
+    GDbgFormat *debug;                      /* Informations de débogage    */ //// REMME
     GArchProcessor *proc;                   /* Architecture du binaire     */
 
     GArchInstruction *instrs;               /* Instructions d'assemblage   */
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 615e72e..c94f4f6 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -24,12 +24,14 @@
 #include "binary.h"
 
 
+#include <assert.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
+
 #include <i18n.h>
 
 
@@ -41,8 +43,11 @@
 #include "../common/extstr.h"
 #include "../common/cpp.h"
 #include "../core/collections.h"
+#include "../core/formats.h"
 #include "../core/params.h"
+#include "../core/processors.h"
 #include "../glibext/chrysamarshal.h"
+#include "../gui/panels/log.h"
 
 
 
@@ -185,8 +190,11 @@ static void g_loaded_binary_init(GLoadedBinary *binary)
 
 static void g_loaded_binary_dispose(GLoadedBinary *binary)
 {
+    g_object_unref(G_OBJECT(binary->content));
+
     if (binary->format != NULL)
         g_object_unref(G_OBJECT(binary->format));
+
     if (binary->proc != NULL)
         g_object_unref(G_OBJECT(binary->proc));
 
@@ -222,10 +230,103 @@ static void g_loaded_binary_finalize(GLoadedBinary *binary)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : context = contexte pour les recherches XPath.                *
+*  Paramètres  : content = contenu binaire chargé en mémoire.                 *
+*                                                                             *
+*  Description : Interprète un contenu binaire chargé.                        *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GLoadedBinary *g_loaded_binary_new(GBinContent *content)
+{
+    GLoadedBinary *result;                  /* Adresse à retourner         */
+    FormatMatchStatus status;               /* Statut d'une reconnaissance */
+    char *target;                           /* Sous-traitance requise      */
+    const char *desc;                       /* Description humaine associée*/
+    const char *arch;                       /* Architecture d'exécution    */
+
+    result = g_object_new(G_TYPE_LOADED_BINARY, NULL);
+
+    log_variadic_message(LMT_PROCESS, _("Opening binary data from '%s'..."),
+                         g_binary_content_describe(content, true));
+
+    g_object_ref(G_OBJECT(content));
+    result->content = content;
+
+    /* Format d'exécutable */
+
+    status = find_matching_format(content, NULL, &target);
+    assert(status == FMS_MATCHED);
+
+    desc = get_binary_format_name(target);
+
+    if (desc == NULL)
+    {
+        free(target);
+        log_simple_message(LMT_INFO, _("Unknown binary format"));
+        goto lbf_error;
+    }
+    else
+        log_variadic_message(LMT_INFO, _("Detected format: %s"), desc);
+
+    result->format = G_EXE_FORMAT(load_new_named_format(target, content, NULL));
+
+    free(target);
+
+    if (result->format == NULL)
+    {
+        log_simple_message(LMT_ERROR, _("Error while loading the binary"));
+        goto lbf_error;
+    }
+
+    /* Informations de débogage associées */
+
+    if (!g_loaded_binary_attach_debug_info(result, content))
+        goto lbf_error;
+
+    /* Architecture visée */
+
+    arch = g_exe_format_get_target_machine(result->format);
+    desc = get_arch_processor_name(arch);
+
+    if (desc == NULL)
+    {
+        log_simple_message(LMT_INFO, _("Unknown architecture"));
+        goto lbf_error;
+    }
+    else
+        log_variadic_message(LMT_INFO, _("Detected architecture: %s"), desc);
+
+    result->proc = get_arch_processor_for_type(arch);
+
+    if (result->proc == NULL)
+    {
+        log_simple_message(LMT_ERROR, _("Unable to load the required processor"));
+        goto lbf_error;
+    }
+
+    return G_LOADED_BINARY(result);
+
+ lbf_error:
+
+    g_object_unref(G_OBJECT(result));
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire chargé en mémoire.                 *
+*                context = contexte pour les recherches XPath.                *
 *                path    = chemin d'accès au noeud XML à lire.                *
+*                project = projet dans lequel venir rechercher les contenus.  *
 *                                                                             *
-*  Description : Charge en mémoire le contenu d'un fichier à partir d'XML.    *
+*  Description : Interprète un contenu binaire chargé avec un appui XML.      *
 *                                                                             *
 *  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
 *                                                                             *
@@ -233,39 +334,94 @@ static void g_loaded_binary_finalize(GLoadedBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
+GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path, GStudyProject *project)
 {
     GLoadedBinary *result;                  /* Adresse à retourner         */
-    char *type;                             /* Type de binaire à charger   */
+    char *content_path;                     /* Partie "Contenus"           */
+    char *access;                           /* Chemin d'accès à un élément */
+    char *hash;                             /* Empreinte à retrouver       */
+    GBinContent *content;                   /* Contenu à référencer        */
+
+    xmlXPathObjectPtr xobject;              /* Cible d'une recherche       */
+    unsigned int i;                         /* Boucle de parcours          */
+
+    /* Contenus binaires associés */
+
+    content_path = strdup(path);
+    content_path = stradd(content_path, "/Contents");
+
+    access = strdup(content_path);
+    access = stradd(access, "/Main");
 
+    hash = get_node_text_value(context, access);
 
+    free(access);
 
-    result = NULL;
+    if (hash == NULL)
+    {
+        free(content_path);
+        return NULL;
+    }
 
-    type = get_node_prop_value(context, path, "type");
+    content = g_study_project_find_binary_content_by_hash(project, hash);
+    free(hash);
 
-    if (strcmp(type, "file") == 0)
-        result = g_file_binary_new_from_xml(context, path);
+    if (content == NULL)
+    {
+        free(content_path);
+        return NULL;
+    }
 
-    free(type);
+    result = g_loaded_binary_new(content);
 
     if (result == NULL)
+    {
+        free(content_path);
         return NULL;
+    }
 
-    /* --------- %< --------- TODO : à bouger pour + de générique --------- %< --------- */
+    xobject = get_node_xpath_object(context, "/ChrysalideProject/Contents/Content");
 
+    for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
+    {
+        asprintf(&access, "%s/DebugInfo[position()=%u]", content_path, i + 1);
 
-    // -> init()
-    //result->collections = create_collections_list();
+        hash = get_node_text_value(context, access);
 
+        free(access);
 
-    if (!g_loaded_binary_load_storage(result, context, path))
-        goto glbnfx_error;
+        if (hash == NULL)
+        {
+            free(content_path);
+            goto glbnfx_error;
+        }
+
+        content = g_study_project_find_binary_content_by_hash(project, hash);
+        free(hash);
+
+        if (content == NULL)
+        {
+            free(content_path);
+            goto glbnfx_error;
+        }
 
+        if (!g_loaded_binary_attach_debug_info(result, content))
+        {
+            free(content_path);
+            goto glbnfx_error;
+        }
+
+    }
+
+    if(xobject != NULL)
+        xmlXPathFreeObject(xobject);
 
-    /* --------- %< --------- TODO : à bouger pur + de générique --------- %< --------- */
+    free(content_path);
 
+    /* Elément divers associés au binaire */
 
+    if (!g_loaded_binary_load_storage(result, context, path))
+        goto glbnfx_error;
 
     return result;
 
@@ -296,15 +452,88 @@ GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const ch
 bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
 {
     bool result;                            /* Bilan à faire remonter      */
+    char *content_path;                     /* Partie "Contenus"           */
+    char *access;                           /* Chemin d'accès à un élément */
+    GBinContent *content;                   /* Contenu à référencer        */
+    const gchar *hash;                      /* Empreinte à mémoriser       */
+    size_t debugs_count;                    /* Quantité de formats liés    */
+    size_t i;                               /* Boucle de parcours          */
+    GDbgFormat *debug;                      /* Informations de débogage    */
+
+    /* Contenus binaires associés */
 
-    result = binary->save(binary, xdoc, context, path);
+    content_path = strdup(path);
+    content_path = stradd(content_path, "/Contents");
+
+    access = strdup(content_path);
+    access = stradd(access, "/Main");
+
+    content = g_binary_format_get_content(G_BIN_FORMAT(binary->format));
+    hash = g_binary_content_get_cheksum(content);
+    g_object_unref(G_OBJECT(content));
+
+    result = add_content_to_node(xdoc, context, access, hash);
+
+    free(access);
+
+    debugs_count = g_exe_format_count_debug_info(binary->format);
+
+    for (i = 0; i < debugs_count; i++)
+    {
+        asprintf(&access, "%s/DebugInfo[position()=%zu]", content_path, i);
+
+        debug = g_exe_format_get_debug_info(binary->format, i);
+
+        content = g_binary_format_get_content(G_BIN_FORMAT(debug));
+        hash = g_binary_content_get_cheksum(content);
+        g_object_unref(G_OBJECT(content));
+
+        g_object_unref(G_OBJECT(debug));
+
+        result &= add_content_to_node(xdoc, context, access, hash);
+
+        free(access);
+
+    }
+
+    free(content_path);
+
+    /* Elément divers associés au binaire */
 
     result = g_loaded_binary_save_storage(binary, xdoc, context, path);
 
+    /* Sauvegarde côté serveur */
 
-    ////
     g_db_client_save(binary->local);
 
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = élément binaire à consulter.                        *
+*                full   = précise s'il s'agit d'une version longue ou non.    *
+*                                                                             *
+*  Description : Fournit le nom associé à l'élément binaire.                  *
+*                                                                             *
+*  Retour      : Nom de fichier avec chemin absolu.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_loaded_binary_get_name(const GLoadedBinary *binary, bool full)
+{
+    const char *result;                     /* Description à retourner     */
+    GBinContent *content;                   /* Contenu binaire mannipulé   */
+
+    content = g_binary_format_get_content(G_BIN_FORMAT(binary->format));
+
+    result = g_binary_content_describe(content, full);
+
+    g_object_unref(G_OBJECT(content));
 
     return result;
 
@@ -961,19 +1190,53 @@ void g_loaded_binary_analyse(GLoadedBinary *binary)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : binary = élément binaire à consulter.                        *
-*                full   = précise s'il s'agit d'une version longue ou non.    *
 *                                                                             *
-*  Description : Fournit le nom associé à l'élément binaire.                  *
+*  Description : Fournit le format de fichier reconnu dans le contenu binaire.*
 *                                                                             *
-*  Retour      : Nom de fichier avec chemin absolu.                           *
+*  Retour      : Instance du format reconnu.                                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *g_loaded_binary_get_name(const GLoadedBinary *binary, bool full)
+bool g_loaded_binary_attach_debug_info(GLoadedBinary *binary, GBinContent *content)
 {
-    return binary->get_name(binary, full);
+    bool result;                            /* Bilan à retourner pour info */
+    FormatMatchStatus status;               /* Statut d'une reconnaissance */
+    char *target;                           /* Sous-traitance requise      */
+    const char *desc;                       /* Description humaine associée*/
+    GDbgFormat *debug;                      /* Format de débogage trouvé   */
+
+    result = false;
+
+    status = find_matching_format(content, binary->format, &target);
+
+    if (status == FMS_MATCHED)
+    {
+        desc = get_binary_format_name(target);
+
+        if (desc != NULL)
+        {
+            log_variadic_message(LMT_INFO, _("Detected debug format: %s"), desc);
+
+            debug = G_DBG_FORMAT(load_new_named_format(target, content, binary->format));
+
+            if (debug == NULL)
+                log_simple_message(LMT_ERROR, _("Error while loading the debug information for binary"));
+
+            else
+            {
+                result = true;
+                g_exe_format_add_debug_info(binary->format, debug);
+            }
+
+        }
+
+        free(target);
+
+    }
+
+    return result;
 
 }
 
diff --git a/src/analysis/binary.h b/src/analysis/binary.h
index 6b7d338..4ef3a0d 100644
--- a/src/analysis/binary.h
+++ b/src/analysis/binary.h
@@ -28,6 +28,7 @@
 #include <glib-object.h>
 #include <stdbool.h>
 
+#include "content.h"
 #include "db/collection.h"
 #include "db/client.h"
 #include "db/protocol.h"
@@ -39,6 +40,23 @@
 
 
 
+/* Redéfinition depuis project.c : projet d'étude regroupant les binaires analysés (instance) */
+typedef struct _GStudyProject GStudyProject;
+
+
+
+#define G_TYPE_LOADED_BINARY               g_loaded_binary_get_type()
+#define G_LOADED_BINARY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_loaded_binary_get_type(), GLoadedBinary))
+#define G_IS_LOADED_BINARY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_loaded_binary_get_type()))
+#define G_LOADED_BINARY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_LOADED_BINARY, GLoadedBinaryClass))
+#define G_IS_LOADED_BINARY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_LOADED_BINARY))
+#define G_LOADED_BINARY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LOADED_BINARY, GLoadedBinaryClass))
+
+
+
+
+
+
 #define G_TYPE_LOADED_BINARY               g_loaded_binary_get_type()
 #define G_LOADED_BINARY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_loaded_binary_get_type(), GLoadedBinary))
 #define G_IS_LOADED_BINARY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_loaded_binary_get_type()))
@@ -79,12 +97,18 @@ typedef enum _BinaryView
 /* Indique le type défini pour une description de fichier binaire. */
 GType g_loaded_binary_get_type(void);
 
-/* Charge en mémoire le contenu d'un fichier à partir d'XML. */
-GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *);
+/* Interprète un contenu binaire chargé. */
+GLoadedBinary *g_loaded_binary_new(GBinContent *);
+
+/* Interprète un contenu binaire chargé avec un appui XML. */
+GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *, GStudyProject *);
 
 /* Ecrit une sauvegarde du binaire dans un fichier XML. */
 bool g_loaded_binary_save(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
 
+/* Fournit le nom associé à l'élément binaire. */
+const char *g_loaded_binary_get_name(const GLoadedBinary *, bool);
+
 
 
 /* ------------------------- INFORMATIONS D'ENREGISTREMENTS ------------------------- */
@@ -155,8 +179,8 @@ bool _g_loaded_binary_remove_from_collection(GLoadedBinary *, DBFeatures, GDbIte
 /* Lance l'analyse d'un élément binaire chargé. */
 void g_loaded_binary_analyse(GLoadedBinary *);
 
-/* Fournit le nom associé à l'élément binaire. */
-const char *g_loaded_binary_get_name(const GLoadedBinary *, bool);
+/* Fournit le format de fichier reconnu dans le contenu binaire. */
+bool g_loaded_binary_attach_debug_info(GLoadedBinary *, GBinContent *);
 
 /* Fournit le format de fichier reconnu dans le contenu binaire. */
 GExeFormat *g_loaded_binary_get_format(const GLoadedBinary *);
diff --git a/src/analysis/content-int.h b/src/analysis/content-int.h
index 7734916..c5b1659 100644
--- a/src/analysis/content-int.h
+++ b/src/analysis/content-int.h
@@ -29,6 +29,12 @@
 
 
 
+/* Fournit le nom associé au contenu binaire. */
+typedef const char * (* describe_content_fc) (const GBinContent *, bool);
+
+/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
+typedef bool (* save_content_fc) (const GBinContent *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
 /* Fournit une empreinte unique (SHA256) pour les données. */
 typedef const gchar * (* get_checksum_fc) (GBinContent *);
 
@@ -62,6 +68,10 @@ struct _GBinContentIface
 {
     GTypeInterface base_iface;              /* A laisser en premier        */
 
+    describe_content_fc describe;           /* Fournit une description     */
+
+    save_content_fc save;                   /* Sauvegarde du contenu       */
+
     get_checksum_fc get_checksum;           /* Calcul de l'empreinte       */
 
     compute_size_fc compute_size;           /* Calcul de la taille totale  */
diff --git a/src/analysis/content.c b/src/analysis/content.c
index 5a4c899..d314d0c 100644
--- a/src/analysis/content.c
+++ b/src/analysis/content.c
@@ -24,7 +24,11 @@
 #include "content.h"
 
 
+#include <string.h>
+
+
 #include "content-int.h"
+#include "contents/file.h"
 
 
 
@@ -57,6 +61,88 @@ static void g_binary_content_default_init(GBinContentInterface *iface)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : context = contexte pour les recherches XPath.                *
+*                path    = chemin d'accès au noeud XML à lire.                *
+*                                                                             *
+*  Description : Charge en mémoire un contenu binaire à partir d'XML.         *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinContent *g_binary_content_new_from_xml(xmlXPathContextPtr context, const char *path)
+{
+    GBinContent *result;                    /* Contenu en place à renvoyer */
+    char *type;                             /* Type de binaire à charger   */
+
+    result = NULL;
+
+    type = get_node_prop_value(context, path, "type");
+
+    if (strcmp(type, "file") == 0)
+        result = g_file_content_new_from_xml(context, path);
+
+    free(type);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire à consulter.                       *
+*                full    = précise s'il s'agit d'une version longue ou non.   *
+*                                                                             *
+*  Description : Fournit le nom associé au contenu binaire.                   *
+*                                                                             *
+*  Retour      : Nom de fichier avec chemin absolu au besoin.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_binary_content_describe(const GBinContent *content, bool full)
+{
+    GBinContentIface *iface;                /* Interface utilisée          */
+
+    iface = G_BIN_CONTENT_GET_IFACE(content);
+
+    return iface->describe(content, full);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire à traiter.                         *
+*                xdoc    = structure XML en cours d'édition.                  *
+*                context = contexte à utiliser pour les recherches.           *
+*                path    = chemin d'accès réservé au binaire.                 *
+*                                                                             *
+*  Description : Ecrit une sauvegarde de contenu binaire dans un fichier XML. *
+*                                                                             *
+*  Retour      : true si l'opération a bien tourné, false sinon.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_binary_content_save(const GBinContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+{
+    GBinContentIface *iface;                /* Interface utilisée          */
+
+    iface = G_BIN_CONTENT_GET_IFACE(content);
+
+    return iface->save(content, xdoc, context, path);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : content = contenu binaire à venir lire.                      *
 *                                                                             *
 *  Description : Fournit une empreinte unique (SHA256) pour les données.      *
diff --git a/src/analysis/content.h b/src/analysis/content.h
index d422dc6..0d991b9 100644
--- a/src/analysis/content.h
+++ b/src/analysis/content.h
@@ -31,6 +31,7 @@
 
 #include "../arch/vmpa.h"
 #include "../common/endianness.h"
+#include "../common/xml.h"
 
 
 
@@ -52,6 +53,15 @@ typedef struct _GBinContentIface GBinContentIface;
 /* Détermine le type d'une interface pour la lecture de binaire. */
 GType g_binary_content_get_type(void) G_GNUC_CONST;
 
+/* Charge en mémoire un contenu binaire à partir d'XML. */
+GBinContent *g_binary_content_new_from_xml(xmlXPathContextPtr, const char *);
+
+/* Fournit le nom associé au contenu binaire. */
+const char *g_binary_content_describe(const GBinContent *, bool);
+
+/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
+bool g_binary_content_save(const GBinContent *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
 /* Fournit une empreinte unique (SHA256) pour les données. */
 const gchar *g_binary_content_get_cheksum(GBinContent *);
 
diff --git a/src/analysis/contents/file.c b/src/analysis/contents/file.c
index eb0d488..9f1c10c 100644
--- a/src/analysis/contents/file.c
+++ b/src/analysis/contents/file.c
@@ -27,12 +27,14 @@
 #include <assert.h>
 #include <fcntl.h>
 #include <malloc.h>
+#include <string.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 
 
 #include "../content-int.h"
+#include "../../common/extstr.h"
 
 
 
@@ -41,6 +43,8 @@ struct _GFileContent
 {
     GObject parent;                         /* A laisser en premier        */
 
+    char *filename;                         /* Fichier chargé en mémoire   */
+
     bin_t *data;                            /* Contenu binaire représenté  */
     mrange_t range;                         /* Couverture du binaire       */
 
@@ -72,6 +76,12 @@ static void g_file_content_dispose(GFileContent *);
 /* Procède à la libération totale de la mémoire. */
 static void g_file_content_finalize(GFileContent *);
 
+/* Fournit le nom associé au contenu binaire. */
+static const char *g_file_content_describe(const GFileContent *, bool);
+
+/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
+static bool g_file_content_save(const GFileContent *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
 /* Fournit une empreinte unique (SHA256) pour les données. */
 static const gchar *g_file_content_get_checksum(GFileContent *);
 
@@ -166,6 +176,10 @@ static void g_file_content_init(GFileContent *content)
 
 static void g_file_content_interface_init(GBinContentInterface *iface)
 {
+    iface->describe = (describe_content_fc)g_file_content_describe;
+
+    iface->save = (save_content_fc)g_file_content_save;
+
     iface->get_checksum = (get_checksum_fc)g_file_content_get_checksum;
 
     iface->compute_size = (compute_size_fc)g_file_content_compute_size;
@@ -217,6 +231,8 @@ static void g_file_content_dispose(GFileContent *content)
 
 static void g_file_content_finalize(GFileContent *content)
 {
+    free(content->filename);
+
     if (content->data != NULL)
         free(content->data);
 
@@ -275,6 +291,8 @@ GBinContent *g_file_content_new(const char *filename)
 
     result = g_object_new(G_TYPE_FILE_CONTENT, NULL);
 
+    result->filename = strdup(filename);
+
     result->data = (bin_t *)malloc(info.st_size);
     memcpy(result->data, content, info.st_size);
 
@@ -295,6 +313,116 @@ GBinContent *g_file_content_new(const char *filename)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : context = contexte pour les recherches XPath.                *
+*                path    = chemin d'accès au noeud XML à lire.                *
+*                                                                             *
+*  Description : Charge en mémoire le contenu d'un fichier à partir d'XML.    *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinContent *g_file_content_new_from_xml(xmlXPathContextPtr context, const char *path)
+{
+    GBinContent *result;                    /* Adresse à retourner         */
+    char *access;                           /* Chemin pour une sous-config.*/
+    char *filename;                         /* Chemin du binaire à charger */
+
+    result = NULL;
+
+    /* Chemin du fichier à retrouver */
+
+    access = strdup(path);
+    access = stradd(access, "/Filename");
+
+    filename = get_node_text_value(context, access);
+
+    free(access);
+
+    /* Chargement */
+
+    if (filename != NULL)
+    {
+        result = g_file_content_new(filename);
+        free(filename);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire à consulter.                       *
+*                full    = précise s'il s'agit d'une version longue ou non.   *
+*                                                                             *
+*  Description : Fournit le nom associé au contenu binaire.                   *
+*                                                                             *
+*  Retour      : Nom de fichier avec chemin absolu au besoin.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_file_content_describe(const GFileContent *content, bool full)
+{
+    const char *result;                     /* Description à retourner     */
+
+    if (full)
+        result = content->filename;
+    else
+        result = strrchr(content->filename, G_DIR_SEPARATOR) + 1;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire à traiter.                         *
+*                xdoc    = structure XML en cours d'édition.                  *
+*                context = contexte à utiliser pour les recherches.           *
+*                path    = chemin d'accès réservé au binaire.                 *
+*                                                                             *
+*  Description : Ecrit une sauvegarde de contenu binaire dans un fichier XML. *
+*                                                                             *
+*  Retour      : true si l'opération a bien tourné, false sinon.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_file_content_save(const GFileContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+{
+    bool result;                            /* Bilan à faire remonter      */
+    char *access;                           /* Chemin d'accès à un élément */
+
+    result = true;
+
+    /* Type */
+
+    result &= add_string_attribute_to_node(xdoc, context, path, "type", "file");
+
+    /* Nom du fichier associé */
+
+    access = strdup(path);
+    access = stradd(access, "/Filename");
+
+    result &= add_content_to_node(xdoc, context, access, content->filename);
+
+    free(access);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : content = contenu binaire à venir lire.                      *
 *                                                                             *
 *  Description : Fournit une empreinte unique (SHA256) pour les données.      *
diff --git a/src/analysis/contents/file.h b/src/analysis/contents/file.h
index 2e3cfef..0985f6b 100644
--- a/src/analysis/contents/file.h
+++ b/src/analysis/contents/file.h
@@ -53,6 +53,9 @@ GType g_file_content_get_type(void);
 /* Charge en mémoire le contenu d'un fichier donné. */
 GBinContent *g_file_content_new(const char *);
 
+/* Charge en mémoire le contenu d'un fichier à partir d'XML. */
+GBinContent *g_file_content_new_from_xml(xmlXPathContextPtr, const char *);
+
 
 
 #endif  /* _ANALYSIS_CONTENTS_FILE_H */
diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c
index cd16429..990ab0f 100644
--- a/src/analysis/disass/disassembler.c
+++ b/src/analysis/disass/disassembler.c
@@ -705,7 +705,7 @@ void disassemble_binary(GLoadedBinary *binary, GArchInstruction **instrs, GCodeB
     checksum = g_binary_content_get_cheksum(content);
     g_object_unref(G_OBJECT(content));
 
-    build_disass_prologue(*buffer, g_loaded_binary_get_name(binary, true), checksum);
+    build_disass_prologue(*buffer, g_binary_content_describe(content, true), checksum);
 
     disass = g_delayed_disassembly_new(binary, instrs, *buffer);
     g_signal_connect(disass, "work-completed", G_CALLBACK(ack), binary);
diff --git a/src/analysis/project.c b/src/analysis/project.c
index 5bb028f..db00f09 100644
--- a/src/analysis/project.c
+++ b/src/analysis/project.c
@@ -29,14 +29,20 @@
 #include <string.h>
 
 
+#include <i18n.h>
+
+
 #include "binaries/file.h"
 #include "../common/xml.h"
+#include "../core/formats.h"
 #include "../core/params.h"
 #include "../glibext/signal.h"
 #include "../gtkext/easygtk.h"
+#include "../glibext/delayed-int.h"
 #include "../gtkext/gtkblockview.h"
 #include "../gtkext/gtkgraphview.h"
 #include "../gtkext/gtksourceview.h"
+#include "../gui/panels/log.h"
 #include "../gui/panels/panel.h"
 
 
@@ -44,6 +50,14 @@
 /* ------------------------- DEFINITION D'UN PROJET INTERNE ------------------------- */
 
 
+/* Conservation d'un contenu chargé */
+typedef struct _loaded_content
+{
+    GBinContent *content;                   /* Contenu binaire en place    */
+    ProjectContentState state;              /* Renseigne le type de contenu*/
+
+} loaded_content;
+
 /* Conservation d'un binaire chargé */
 typedef struct _loaded_binary
 {
@@ -65,9 +79,13 @@ struct _GStudyProject
 
     char *filename;                         /* Lieu d'enregistrement       */
 
+    loaded_content *contents;               /* Contenus binaires chargés   */
+    size_t contents_count;                  /* Nombre de ces contenus      */
+    GMutex cnt_mutex;                       /* Modification de la liste    */
+
     loaded_binary **binaries;               /* Fichiers binaires associés  */
     size_t binaries_count;                  /* Nombre de ces fichiers      */
-    GMutex mutex;                           /* Modification de la liste    */
+    GMutex bin_mutex;                       /* Modification de la liste    */
 
 };
 
@@ -91,6 +109,49 @@ static void g_study_project_hide(const GStudyProject *);
 
 
 
+
+
+/* ----------------------- AMORCE POUR CHARGEMENT DE CONTENUS ----------------------- */
+
+
+/* Ensembles binaires à désassembler (instance) */
+struct _GDelayedStudy
+{
+    GDelayedWork parent;                    /* A laisser en premier        */
+
+    GStudyProject *project;                 /* Projet de rattachement      */
+    GBinContent *content;                   /* Contenu binaire à traiter   */
+    ProjectContentState state;              /* Renseigne le type de contenu*/
+
+    bool only_preload;                      /* Enregistrement seulement ?  */
+
+};
+
+/* Ensembles binaires à désassembler (classe) */
+struct _GDelayedStudyClass
+{
+    GDelayedWorkClass parent;               /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des intégrations de binaires à étudier. */
+static void g_delayed_study_class_init(GDelayedStudyClass *);
+
+/* Initialise une intégration de binaire à étudier. */
+static void g_delayed_study_init(GDelayedStudy *);
+
+/* Supprime toutes les références externes. */
+static void g_delayed_study_dispose(GDelayedStudy *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_delayed_study_finalize(GDelayedStudy *);
+
+/* Prépare une intégration de binaire au projet courant. */
+static void g_delayed_study_process(GDelayedStudy *, GtkExtStatusBar *);
+
+
+
 /* ---------------------------------------------------------------------------------- */
 /*                           DEFINITION D'UN PROJET INTERNE                           */
 /* ---------------------------------------------------------------------------------- */
@@ -132,7 +193,9 @@ static void g_study_project_class_init(GStudyProjectClass *klass)
 
 static void g_study_project_init(GStudyProject *project)
 {
-    g_mutex_init(&project->mutex);
+    g_mutex_init(&project->cnt_mutex);
+
+    g_mutex_init(&project->bin_mutex);
 
 }
 
@@ -180,11 +243,17 @@ GStudyProject *g_study_project_open(GObject *ref, const char *filename)
     GStudyProject *result;                  /* Adresse à retourner         */
     xmlDocPtr xdoc;                         /* Structure XML chargée       */
     xmlXPathContextPtr context;             /* Contexte pour les XPath     */
+    unsigned int root_contents;             /* Quantité de contenus majeurs*/
+    GAsyncQueue *sema;                      /* Sémaphore taisant son nom   */
     xmlXPathObjectPtr xobject;              /* Cible d'une recherche       */
     unsigned int i;                         /* Boucle de parcours          */
     size_t access_len;                      /* Taille d'un chemin interne  */
     char *access;                           /* Chemin pour une sous-config.*/
-    GLoadedBinary *binary;                 /* Représentation à intégrer   */
+    GBinContent *content;                   /* Contenu binaire retrouvé    */
+    long state;                             /* Etat de ce contenu binaire  */
+    bool status;                            /* Bilan d'une lecture         */
+    GDelayedStudy *dstudy;                  /* Etude complémentaire à mener*/
+    GLoadedBinary *binary;                  /* Représentation à intégrer   */
 
     if (!open_xml_file(filename, &xdoc, &context)) return NULL;
 
@@ -192,19 +261,78 @@ GStudyProject *g_study_project_open(GObject *ref, const char *filename)
 
     result->filename = strdup(filename);
 
-    /* Chargement des éléments binaires attachés */
+    /* Préparations aux traitements parallèles */
+
+    root_contents = 0;
+
+    sema = g_async_queue_new();
+
+    void ack_content_processing(GDelayedStudy *dstudy, GAsyncQueue *aqueue)
+    {
+        g_async_queue_push(aqueue, GINT_TO_POINTER(1));
+    }
+
+    /* Chargement des contenus binaires attachés */
+
+    xobject = get_node_xpath_object(context, "/ChrysalideProject/Contents/Content");
+
+    for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
+    {
+        access_len = strlen("/ChrysalideProject/Contents/Content[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;
+
+        access = calloc(access_len, sizeof(char));
+        snprintf(access, access_len, "/ChrysalideProject/Contents/Content[position()=%u]", i + 1);
+
+        content = g_binary_content_new_from_xml(context, access);
+        status = get_node_prop_long_value(context, access, "state", &state);
+
+        free(access);
+
+        if (!status)
+        {
+            log_variadic_message(LMT_PROCESS, _("bad state for content '%s' ; skipping..."),
+                                 g_binary_content_describe(content, true));
+            continue;
+        }
+
+        /* Le contenu peut être un conteneur ? */
+        if (state == PCS_ROOT)
+        {
+            dstudy = g_delayed_study_new(result, content, state);
+            g_signal_connect(dstudy, "work-completed", G_CALLBACK(ack_content_processing), sema);
+
+            g_delayed_study_preload_only(dstudy);
+
+            root_contents++;
+
+            study_new_content(dstudy);
+
+        }
+
+    }
+
+    if(xobject != NULL)
+        xmlXPathFreeObject(xobject);
+
+    /* Attente pour la réception de contenus supplémentaires éventuels */
+
+    for (i = 0; i < root_contents; i++)
+        g_async_queue_pop(sema);
+
+    g_async_queue_unref(sema);
 
-    xobject = get_node_xpath_object(context, "/OpenIDAProject/Binaries/Binary");
+    /* Chargement des binaires analysés */
+
+    xobject = get_node_xpath_object(context, "/ChrysalideProject/Binaries/Binary");
 
     for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
     {
-        access_len = strlen("/OpenIDAProject/Binaries/Binary[position()=")
-            + strlen("4294967295" /* UINT_MAX */) + strlen("]") + 1;
+        access_len = strlen("/ChrysalideProject/Binaries/Binary[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;
 
         access = calloc(access_len, sizeof(char));
-        snprintf(access, access_len, "/OpenIDAProject/Binaries/Binary[position()=%u]", i + 1);
+        snprintf(access, access_len, "/ChrysalideProject/Binaries/Binary[position()=%u]", i + 1);
 
-        binary = g_loaded_binary_new_from_xml(context, access);
+        binary = g_loaded_binary_new_from_xml(context, access, result);
 
         free(access);
 
@@ -254,17 +382,36 @@ bool g_study_project_save(GStudyProject *project, const char *filename)
 
     result = create_new_xml_file(&xdoc, &context);
 
-    result &= (ensure_node_exist(xdoc, context, "/OpenIDAProject") != NULL);
+    result &= (ensure_node_exist(xdoc, context, "/ChrysalideProject") != NULL);
+
+    /* Enregistrement des contenus binaires attachés */
 
-    /* Enregistrement des éléments binaires attachés */
+    for (i = 0; i < project->contents_count && result; i++)
+    {
+        if (!project->contents[i].state == PCS_INTERNAL) continue;
+
+        access_len = strlen("/ChrysalideProject/Contents/Content[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;
+
+        access = calloc(access_len, sizeof(char));
+        snprintf(access, access_len, "/ChrysalideProject/Contents/Content[position()=%zu]", i + 1);
+
+        result = g_binary_content_save(project->contents[i].content, xdoc, context, access);
+
+        if (result)
+            result = add_long_attribute_to_node(xdoc, context, access, "state", project->contents[i].state);
+
+        free(access);
+
+    }
+
+    /* Enregistrement des binaires analysés */
 
     for (i = 0; i < project->binaries_count && result; i++)
     {
-        access_len = strlen("/OpenIDAProject/Binaries/Binary[position()=")
-            + strlen("4294967295" /* UINT_MAX */) + strlen("]") + 1;
+        access_len = strlen("/ChrysalideProject/Binaries/Binary[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;
 
         access = calloc(access_len, sizeof(char));
-        snprintf(access, access_len, "/OpenIDAProject/Binaries/Binary[position()=%zu]", i + 1);
+        snprintf(access, access_len, "/ChrysalideProject/Binaries/Binary[position()=%zu]", i + 1);
 
         result = g_loaded_binary_save(project->binaries[i]->binary, xdoc, context, access);
 
@@ -311,6 +458,88 @@ const char *g_study_project_get_filename(const GStudyProject *project)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : project = projet dont le contenu est à compléter.            *
+*                content = contenu binaire à mémoriser pour le projet.        *
+*                state   = état du contenu à conserver.                       *
+*                                                                             *
+*  Description : Assure l'intégration d'un contenu binaire dans un projet.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_study_project_add_binary_content(GStudyProject *project, GBinContent *content, ProjectContentState state)
+{
+    loaded_content *new;                    /* Nouveau contenu à définir   */
+
+    g_mutex_lock(&project->cnt_mutex);
+
+    project->contents = (loaded_content *)realloc(project->contents,
+                                                  ++project->contents_count * sizeof(loaded_content));
+
+    new = &project->contents[project->contents_count - 1];
+
+    g_object_ref(G_OBJECT(content));
+
+    new->content = content;
+    new->state = state;
+
+    g_mutex_unlock(&project->cnt_mutex);
+
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : project = projet dont le contenu est à compléter.            *
+*                hash    = empreinte du contenu à retrouver.                  *
+*                                                                             *
+*  Description : Recherche un contenu binaire du projet selon son empreinte.  *
+*                                                                             *
+*  Retour      : Contenu avec propriété transférée ou NULL en cas d'échec.    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBinContent *g_study_project_find_binary_content_by_hash(GStudyProject *project, const char *hash)
+{
+    GBinContent *result;                    /* Trouvaille à retourner      */
+    size_t i;                               /* Boucle de parcours          */
+    GBinContent *iter;                      /* Contenu binaire analysé     */
+    const gchar *other;                     /* Autre empreinte à comparer  */
+
+    result = NULL;
+
+    g_mutex_lock(&project->cnt_mutex);
+
+    for (i = 0; i < project->contents_count && result == NULL; i++)
+    {
+        iter = project->contents[i].content;
+        other = g_binary_content_get_cheksum(iter);
+
+        if (strcmp(hash, other) == 0)
+        {
+            g_object_ref(G_OBJECT(iter));
+            result = iter;
+        }
+
+    }
+
+    g_mutex_unlock(&project->cnt_mutex);
+
+    return result;
+
+}
+
+
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : binary  = élément binaire tout juste désassemblé.            *
 *                project = projet dont le contenu est à compléter.            *
 *                                                                             *
@@ -431,7 +660,7 @@ size_t g_study_project_attach_binary(GStudyProject *project, GLoadedBinary *bina
 
     /* Enregistrement dans le projet */
 
-    g_mutex_lock(&project->mutex);
+    g_mutex_lock(&project->bin_mutex);
 
     project->binaries = (loaded_binary **)realloc(project->binaries,
                                                   ++project->binaries_count * sizeof(loaded_binary *));
@@ -440,7 +669,7 @@ size_t g_study_project_attach_binary(GStudyProject *project, GLoadedBinary *bina
 
     project->binaries[result] = loaded;
 
-    g_mutex_unlock(&project->mutex);
+    g_mutex_unlock(&project->bin_mutex);
 
     update_project_area(project);
 
@@ -714,3 +943,272 @@ void push_project_into_recent_list(const GStudyProject *project)
     g_generic_config_set_value(get_main_configuration(), MPK_LAST_PROJECT, project->filename);
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         AMORCE POUR CHARGEMENT DE CONTENUS                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour les tâches de préparations d'étude. */
+G_DEFINE_TYPE(GDelayedStudy, g_delayed_study, G_TYPE_DELAYED_WORK);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des intégrations de binaires à étudier. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_study_class_init(GDelayedStudyClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_delayed_study_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_delayed_study_finalize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dstudy = instance à initialiser.                             *
+*                                                                             *
+*  Description : Initialise une intégration de binaire à étudier.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_study_init(GDelayedStudy *dstudy)
+{
+    G_DELAYED_WORK(dstudy)->run = (run_task_fc)g_delayed_study_process;
+
+    dstudy->only_preload = false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_study_dispose(GDelayedStudy *dstudy)
+{
+    g_object_unref(G_OBJECT(dstudy->project));
+    g_object_unref(G_OBJECT(dstudy->content));
+
+    G_OBJECT_CLASS(g_delayed_study_parent_class)->dispose(G_OBJECT(dstudy));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_study_finalize(GDelayedStudy *dstudy)
+{
+    G_OBJECT_CLASS(g_delayed_study_parent_class)->finalize(G_OBJECT(dstudy));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : project = projet dont le contenu est à compléter.            *
+*                content = contenu binaire chargé à analyser.                 *
+*                state   = état du contenu à conserver.                       *
+*                                                                             *
+*  Description : Crée une tâche d'intégration de contenu binaire.             *
+*                                                                             *
+*  Retour      : Tâche créée.                                                 *
+*                                                                             *
+*  Remarques   : L'appelant perd la propriété du contenu.                     *
+*                                                                             *
+******************************************************************************/
+
+GDelayedStudy *g_delayed_study_new(GStudyProject *project, GBinContent *content, ProjectContentState state)
+{
+    GDelayedStudy *result;            /* Tâche à retourner           */
+
+    result = g_object_new(G_TYPE_DELAYED_STUDY, NULL);
+
+    g_object_ref(G_OBJECT(project));
+    result->project = project;
+
+    g_object_ref(G_OBJECT(content));
+    result->content = content;
+
+    result->state = state;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dstudy    = intégration à mener.                             *
+*                statusbar = barre de statut à tenir informée.                *
+*                                                                             *
+*  Description : Prépare une intégration de binaire au projet courant.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_study_process(GDelayedStudy *dstudy, GtkExtStatusBar *statusbar)
+{
+    FormatMatchStatus status;               /* Statut d'une reconnaissance */
+    char *target;                           /* Sous-traitance requise      */
+    GLoadedBinary *binary;                  /* Représentation chargée      */
+
+    status = find_matching_format(dstudy->content, NULL, &target);
+
+    switch (status)
+    {
+        case FMS_MATCHED:
+
+            if (dstudy->only_preload)
+                g_study_project_add_binary_content(dstudy->project, dstudy->content, dstudy->state);
+
+            else
+            {
+                binary = g_loaded_binary_new(dstudy->content);
+
+                if (binary != NULL)
+                {
+                    g_study_project_add_binary_content(dstudy->project, dstudy->content, dstudy->state);
+
+                    g_signal_connect_to_main(binary, "disassembly-done",
+                                             G_CALLBACK(g_study_project_add_loaded_binary),
+                                             dstudy->project, g_cclosure_marshal_VOID__VOID);
+
+                    g_loaded_binary_analyse(binary);
+
+                }
+
+            }
+
+            break;
+
+        case FMS_FORWARDED:
+            /**
+             * L'émetteur de ce type de réponse a pour charge de
+             * reprogrammer lui même l'analyse de nouveaux contenus.
+             */
+            log_variadic_message(LMT_PROCESS, _("binary '%s' contains other binaries..."),
+                                 g_binary_content_describe(dstudy->content, true));
+
+            if (dstudy->state == PCS_ROOT)
+                g_study_project_add_binary_content(dstudy->project, dstudy->content, PCS_ROOT);
+
+            break;
+
+        default:
+            /**
+             * Les jeux sont faits pour le contenu binaire courant.
+             */
+            log_variadic_message(LMT_PROCESS, _("Unknown binary format for '%s'..."),
+                                 g_binary_content_describe(dstudy->content, true));
+            break;
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dstudy = tâche d'analyse de contenu pour projet à mener.     *
+*                                                                             *
+*  Description : Limite l'étude et l'intégration d'un contenu binaire.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_delayed_study_preload_only(GDelayedStudy *dstudy)
+{
+    dstudy->only_preload = true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire chargé à analyser.                 *
+*                state   = état du contenu à conserver.                       *
+*                                                                             *
+*  Description : Programme l'étude et l'intégration d'un contenu binaire.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void qck_study_new_content(GBinContent *content, ProjectContentState state)
+{
+    GDelayedStudy *dstudy;                  /* Etude à conduire            */
+
+    dstudy = g_delayed_study_new(get_current_project(), content, state);
+
+    study_new_content(dstudy);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire chargé à analyser.                 *
+*                state   = état du contenu à conserver.                       *
+*                                                                             *
+*  Description : Programme l'étude et l'intégration d'un contenu binaire.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void study_new_content(GDelayedStudy *dstudy)
+{
+    GWorkQueue *queue;                      /* Gestionnaire de différés    */
+
+    queue = get_work_queue();
+    g_work_queue_schedule_work(queue, G_DELAYED_WORK(dstudy));
+
+}
diff --git a/src/analysis/project.h b/src/analysis/project.h
index 05e7f12..5f5b38c 100644
--- a/src/analysis/project.h
+++ b/src/analysis/project.h
@@ -66,6 +66,23 @@ bool g_study_project_save(GStudyProject *, const char *);
 /* Indique le chemin du fichier destiné à la sauvegarde. */
 const char *g_study_project_get_filename(const GStudyProject *);
 
+/* Etat d'un contenu binaire du projet */
+typedef enum _ProjectContentState
+{
+    PCS_ROOT,                               /* Contenu principal           */
+    PCS_INTERNAL,                           /* Contenu dérivé              */
+    PCS_ATTACHED,                           /* Contenu complémentaire      */
+
+    PCS_COUNT
+
+} ProjectContentState;
+
+/* Assure l'intégration d'un contenu binaire dans un projet. */
+void g_study_project_add_binary_content(GStudyProject *, GBinContent *, ProjectContentState);
+
+/* Recherche un contenu binaire du projet selon son empreinte. */
+GBinContent *g_study_project_find_binary_content_by_hash(GStudyProject *, const char *);
+
 /* Assure l'intégration d'un élément binaire dans un projet. */
 void g_study_project_add_loaded_binary(GLoadedBinary *, GStudyProject *);
 
@@ -103,4 +120,39 @@ void push_project_into_recent_list(const GStudyProject *);
 
 
 
+/* ----------------------- AMORCE POUR CHARGEMENT DE CONTENUS ----------------------- */
+
+
+#define G_TYPE_DELAYED_STUDY               g_delayed_study_get_type()
+#define G_DELAYED_STUDY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_study_get_type(), GDelayedStudy))
+#define G_IS_DELAYED_STUDY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_study_get_type()))
+#define G_DELAYED_STUDY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_STUDY, GDelayedStudyClass))
+#define G_IS_DELAYED_STUDY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_STUDY))
+#define G_DELAYED_STUDY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_STUDY, GDelayedStudyClass))
+
+
+/* Ensembles binaires à désassembler (instance) */
+typedef struct _GDelayedStudy GDelayedStudy;
+
+/* Ensembles binaires à désassembler (classe) */
+typedef struct _GDelayedStudyClass GDelayedStudyClass;
+
+
+/* Indique le type défini pour les tâches de préparations d'étude. */
+GType g_delayed_study_get_type(void);
+
+/* Crée une tâche d'intégration de contenu binaire. */
+GDelayedStudy *g_delayed_study_new(GStudyProject *, GBinContent *, ProjectContentState);
+
+/* Limite l'étude et l'intégration d'un contenu binaire. */
+void g_delayed_study_preload_only(GDelayedStudy *);
+
+/* Programme l'étude et l'intégration d'un contenu binaire. */
+void qck_study_new_content(GBinContent *, ProjectContentState);
+
+/* Programme l'étude et l'intégration d'un contenu binaire. */
+void study_new_content(GDelayedStudy *);
+
+
+
 #endif  /* _PROJECT_H */
diff --git a/src/common/xml.c b/src/common/xml.c
index 1e2871b..a9c65b5 100644
--- a/src/common/xml.c
+++ b/src/common/xml.c
@@ -27,6 +27,7 @@
 
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 
@@ -322,6 +323,43 @@ char *qck_get_node_prop_value(xmlNodePtr node, const char *name)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : node = noeud dont une propriété est à lire.                  *
+*                name = nom de la propriété à lire.                           *
+*                out  = valeur entière lue depuis le contenu textuel. [OUT]   *
+*                                                                             *
+*  Description : Obtient la valeur entière d'une propriété d'un élément.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool qck_get_node_prop_long_value(xmlNodePtr node, const char *name, long *out)
+{
+    bool result;                            /* Bilan à retourner           */
+    char *value;                            /* Valeur brute lue            */
+
+    value = qck_get_node_prop_value(node, name);
+
+    if (value)
+    {
+        result = true;
+
+        *out = strtol(value, NULL, 10);
+        free(value);
+
+    }
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : xpathCtx = contexte à utiliser pour les recherches.          *
 *                path     = chemin d'accès au noeud à traiter.                *
 *                name     = nom de la propriété à lire.                       *
@@ -356,6 +394,41 @@ char *get_node_prop_value(xmlXPathContextPtr xpathCtx, const char *path, const c
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : xpathCtx = contexte à utiliser pour les recherches.          *
+*                path     = chemin d'accès au noeud à traiter.                *
+*                name     = nom de la propriété à lire.                       *
+*                out      = valeur entière obtenue via contenu textuel. [OUT] *
+*                                                                             *
+*  Description : Obtient la valeur entière d'une propriété d'un élément.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool get_node_prop_long_value(xmlXPathContextPtr xpathCtx, const char *path, const char *name, long *out)
+{
+    bool result;                            /* Bilan à retourner           */
+    xmlXPathObjectPtr xpathObj;             /* Point de départ XML         */
+
+    result = NULL;
+
+    xpathObj = get_node_xpath_object(xpathCtx, path);
+    if (xpathObj == NULL) return NULL;
+
+    if (xpathObj->nodesetval->nodeNr > 0)
+        result = qck_get_node_prop_long_value(xpathObj->nodesetval->nodeTab[0], name, out);
+
+    xmlXPathFreeObject(xpathObj);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : node = noeud de texte avec un lien avec le document XML.     *
 *                                                                             *
 *  Description : Construit un chemin d'accès complet selon le fichier XML.    *
@@ -965,16 +1038,13 @@ bool _add_string_attribute_to_node(xmlNodePtr node, const char *name, const char
 bool add_string_attribute_to_node(xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *name, const char *value)
 {
     xmlNodePtr node;                        /* Noeud à modifier            */
-    xmlAttrPtr attrib;                      /* Attribut créé et en place   */
 
     if (value == NULL) return true;
 
     node = ensure_node_exist(xdoc, context, path);
     if (node == NULL) return false;
 
-    attrib = xmlSetProp(node, BAD_CAST name, BAD_CAST value);
-
-    return (attrib != NULL);
+    return _add_string_attribute_to_node(node, name, value);
 
 }
 
@@ -993,7 +1063,7 @@ bool add_string_attribute_to_node(xmlDocPtr xdoc, xmlXPathContextPtr context, co
 *                                                                             *
 ******************************************************************************/
 
-bool add_long_attribute_to_node(xmlNodePtr node, const char *name, long value)
+bool _add_long_attribute_to_node(xmlNodePtr node, const char *name, long value)
 {
     char tmp[11/*strlen("2147483647")*/];   /* Stockage temporaire         */
 
@@ -1002,3 +1072,31 @@ bool add_long_attribute_to_node(xmlNodePtr node, const char *name, long value)
     return _add_string_attribute_to_node(node, name, tmp);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : xdoc    = structure XML chargée.                             *
+*                context = contexte à utiliser pour les recherches.           *
+*                path    = chemin d'accès au noeud visé.                      *
+*                name    = nom de la propriété à créer.                       *
+*                value   = valeur numérique à placer.                         *
+*                                                                             *
+*  Description : Ajoute une propriété à un noeud existant donné.              *
+*                                                                             *
+*  Retour      : true en cas de succès, false sinon.                          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool add_long_attribute_to_node(xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *name, long value)
+{
+    xmlNodePtr node;                        /* Noeud à modifier            */
+
+    node = ensure_node_exist(xdoc, context, path);
+    if (node == NULL) return false;
+
+    return _add_long_attribute_to_node(node, name, value);
+
+}
diff --git a/src/common/xml.h b/src/common/xml.h
index 8cb8c0e..60891f7 100644
--- a/src/common/xml.h
+++ b/src/common/xml.h
@@ -68,9 +68,15 @@ char *get_node_text_value(xmlXPathContextPtr, const char *);
 /* Obtient la valeur d'une propriété d'un élément. */
 char *qck_get_node_prop_value(xmlNodePtr, const char *);
 
+/* Obtient la valeur entière d'une propriété d'un élément. */
+bool qck_get_node_prop_long_value(xmlNodePtr, const char *, long *);
+
 /* Obtient la valeur d'une propriété d'un élément. */
 char *get_node_prop_value(xmlXPathContextPtr, const char *, const char *);
 
+/* Obtient la valeur entière d'une propriété d'un élément. */
+bool get_node_prop_long_value(xmlXPathContextPtr, const char *, const char *, long *);
+
 /* Construit un chemin d'accès complet selon le fichier XML. */
 char *qck_build_filename_with_doc_url(xmlNodePtr);
 
@@ -133,7 +139,10 @@ bool _add_string_attribute_to_node(xmlNodePtr, const char *, const char *);
 bool add_string_attribute_to_node(xmlDocPtr, xmlXPathContextPtr, const char *, const char *, const char *);
 
 /* Ajoute une propriété à un noeud existant donné. */
-bool add_long_attribute_to_node(xmlNodePtr, const char *, long);
+bool _add_long_attribute_to_node(xmlNodePtr, const char *, long);
+
+/* Ajoute une propriété à un noeud existant donné. */
+bool add_long_attribute_to_node(xmlDocPtr, xmlXPathContextPtr, const char *, const char *, long);
 
 
 
diff --git a/src/core/formats.c b/src/core/formats.c
index 891fc12..1326fc4 100644
--- a/src/core/formats.c
+++ b/src/core/formats.c
@@ -41,6 +41,7 @@
 typedef struct _format_matcher_t
 {
     format_match_fc func;                   /* Recherche de correspondance */
+    void *data;                             /* Eventuelle donnée à y lier  */
 
 } format_matcher_t;
 
@@ -76,6 +77,7 @@ static format_loader_t *find_format_by_key(const char *);
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : func = procédure de détection à utiliser.                    *
+*                data = éventuelle donnée à associer aux opérations.          *
 *                                                                             *
 *  Description : Enregistre un détection de format(s) binaire(s).             *
 *                                                                             *
@@ -85,18 +87,24 @@ static format_loader_t *find_format_by_key(const char *);
 *                                                                             *
 ******************************************************************************/
 
-bool register_format_matcher(format_match_fc func)
+bool register_format_matcher(format_match_fc func, void *data)
 {
     bool result;                            /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours          */
+    const format_matcher_t *cur;            /* Elément parcouru et analysé */
     format_matcher_t *new;                  /* Nouvel élément à définir    */
 
     g_rw_lock_writer_lock(&_formats_lock);
 
     for (i = 0; i < _formats_matchers_count; i++)
-        if (_formats_matchers[i].func == func)
+    {
+        cur = &_formats_matchers[i];
+
+        if (cur->func == func && cur->data == data)
             break;
 
+    }
+
     result = (i == _formats_matchers_count);
 
     if (result)
@@ -107,6 +115,7 @@ bool register_format_matcher(format_match_fc func)
         new = &_formats_matchers[_formats_matchers_count - 1];
 
         new->func = func;
+        new->data = data;
 
     }
 
@@ -186,9 +195,9 @@ bool load_hard_coded_formats_definitions(void)
 
     /* Détections */
 
-    result &= register_format_matcher(dwarf_is_matching);
+    result &= register_format_matcher(dwarf_is_matching, NULL);
 
-    result &= register_format_matcher(elf_is_matching);
+    result &= register_format_matcher(elf_is_matching, NULL);
 
     /* Chargements */
 
@@ -315,27 +324,32 @@ const char *get_binary_format_name(const char *key)
 *                                                                             *
 *  Paramètres  : content = contenu binaire à parcourir.                       *
 *                parent  = éventuel format exécutable déjà chargé.            *
+*                key     = identifiant de format trouvé ou NULL. [OUT]        *
 *                                                                             *
 *  Description : Identifie un format binaire par son contenu.                 *
 *                                                                             *
-*  Retour      : Identifiant du format binaire trouvé ou NULL si échec.       *
+*  Retour      : Conclusion de haut niveau sur la reconnaissance effectuée.   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *find_matching_format(GBinContent *content, GExeFormat *parent)
+FormatMatchStatus find_matching_format(GBinContent *content, GExeFormat *parent, char **key)
 {
-    const char *result;                     /* Identifiant à retourner     */
+    FormatMatchStatus result;               /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours          */
+    const format_matcher_t *cur;            /* Elément parcouru et analysé */
 
-    result = NULL;
+    result = FMS_UNKNOWN;
 
     g_rw_lock_reader_lock(&_formats_lock);
 
-    for (i = 0; i < _formats_matchers_count && result == NULL; i++)
+    for (i = 0; i < _formats_matchers_count && result == FMS_UNKNOWN; i++)
     {
-        result = _formats_matchers[i].func(content, parent);
+        cur = &_formats_matchers[i];
+
+        result = cur->func(content, parent, cur->data, key);
+
     }
 
     g_rw_lock_reader_unlock(&_formats_lock);
diff --git a/src/core/formats.h b/src/core/formats.h
index 8857217..76b57d0 100644
--- a/src/core/formats.h
+++ b/src/core/formats.h
@@ -34,15 +34,27 @@
 
 
 
+/* Conclusion d'une opération de reconnaissance */
+typedef enum _FormatMatchStatus
+{
+    FMS_MATCHED,                            /* Correspondance établie      */
+    FMS_FORWARDED,                          /* Sous-formats détectés       */
+    FMS_UNKNOWN,                            /* Aucun format reconnu        */
+
+    FMS_COUNT
+
+} FormatMatchStatus;
+
+
 /* Indication à propos du support d'un format */
-typedef const char * (* format_match_fc) (GBinContent *, GExeFormat *);
+typedef FormatMatchStatus (* format_match_fc) (GBinContent *, GExeFormat *, void *, char **);
 
 /* Méthode de chargement d'un format */
 typedef GBinFormat * (* format_load_fc) (GBinContent *, GExeFormat *);
 
 
 /* Enregistre un détection de format(s) binaire(s). */
-bool register_format_matcher(format_match_fc);
+bool register_format_matcher(format_match_fc, void *);
 
 /* Enregistre un format de contenu binaire donné. */
 bool register_format_loader(const char *, const char *, format_load_fc);
@@ -57,11 +69,11 @@ void unload_formats_definitions(void);
 const char *get_binary_format_name(const char *);
 
 /* Identifie un format binaire par son contenu. */
-const char *find_matching_format(GBinContent *, GExeFormat *);
+FormatMatchStatus find_matching_format(GBinContent *, GExeFormat *, char **);
 
 /* Charge le format binaire correspondant à un type. */
 GBinFormat *load_new_named_format(const char *, GBinContent *, GExeFormat *);
 
 
 
-#endif  /* _ANALYSIS_DB_COLLECTION_H */
+#endif  /* _CORE_FORMATS_H */
diff --git a/src/format/dwarf/dwarf.c b/src/format/dwarf/dwarf.c
index db8335b..519aa49 100644
--- a/src/format/dwarf/dwarf.c
+++ b/src/format/dwarf/dwarf.c
@@ -47,18 +47,20 @@ static void g_dwarf_format_finalize(GDwarfFormat *);
 *                                                                             *
 *  Paramètres  : content = contenu binaire à parcourir.                       *
 *                parent  = éventuel format exécutable déjà chargé.            *
+*                unused  = adresse non utilisée ici.                          *
+*                key     = identifiant de format trouvé ou NULL. [OUT]        *
 *                                                                             *
 *  Description : Indique si le format peut être pris en charge ici.           *
 *                                                                             *
-*  Retour      : Désignation du format reconnu ou NULL si aucun.              *
+*  Retour      : Conclusion de haut niveau sur la reconnaissance effectuée.   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *dwarf_is_matching(GBinContent *content, GExeFormat *parent)
+FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, void *unused, char **key)
 {
-    const char *result;                     /* Format détecté à renvoyer   */
+    FormatMatchStatus result;               /* Bilan à renvoyer            */
     size_t i;                               /* Boucle de parcours          */
     mrange_t range;                         /* Couverture d'une section    */
     dw_section_header header;               /* En-tête DWARF de section    */
@@ -114,10 +116,10 @@ const char *dwarf_is_matching(GBinContent *content, GExeFormat *parent)
         0   /* .debug_types */
     };
 
-    result = NULL;
+    result = FMS_UNKNOWN;
 
     if (parent == NULL)
-        return NULL;
+        return FMS_UNKNOWN;
 
     /* Lecture des indices présents */
 
@@ -159,23 +161,32 @@ const char *dwarf_is_matching(GBinContent *content, GExeFormat *parent)
     found = check_dwarf_version(dwarf_v4_versions, current_versions, ARRAY_SIZE(section_names));
 
     if (found)
-        result = "dwarf_v4";
+    {
+        result = FMS_MATCHED;
+        *key = strdup("dwarf_v4");
+    }
 
-    if (result == NULL)
+    if (result == FMS_UNKNOWN)
     {
         found = check_dwarf_version(dwarf_v3_versions, current_versions, ARRAY_SIZE(section_names));
 
         if (found)
-            result = "dwarf_v3";
+        {
+            result = FMS_MATCHED;
+            *key = strdup("dwarf_v3");
+        }
 
     }
 
-    if (result == NULL)
+    if (result == FMS_UNKNOWN)
     {
         found = check_dwarf_version(dwarf_v2_versions, current_versions, ARRAY_SIZE(section_names));
 
         if (found)
-            result = "dwarf_v2";
+        {
+            result = FMS_MATCHED;
+            *key = strdup("dwarf_v2");
+        }
 
     }
 
diff --git a/src/format/dwarf/dwarf.h b/src/format/dwarf/dwarf.h
index a5e988b..da5b70a 100644
--- a/src/format/dwarf/dwarf.h
+++ b/src/format/dwarf/dwarf.h
@@ -25,7 +25,7 @@
 #define _FORMAT_DWARF_DWARF_H
 
 
-#include "../executable.h"
+#include "../../core/formats.h"
 
 
 
@@ -45,7 +45,7 @@ typedef struct _GDwarfFormatClass GDwarfFormatClass;
 
 
 /* Indique si le format peut être pris en charge ici. */
-const char *dwarf_is_matching(GBinContent *, GExeFormat *);
+FormatMatchStatus dwarf_is_matching(GBinContent *, GExeFormat *, void *, char **);
 
 /* Indique le type défini pour un format de débogage DWARF. */
 GType g_dwarf_format_get_type(void);
diff --git a/src/format/elf/elf.c b/src/format/elf/elf.c
index 5c81b2f..50df077 100644
--- a/src/format/elf/elf.c
+++ b/src/format/elf/elf.c
@@ -84,18 +84,20 @@ bool g_elf_format_get_section_range_by_name(const GElfFormat *, const char *, mr
 *                                                                             *
 *  Paramètres  : content = contenu binaire à parcourir.                       *
 *                parent  = éventuel format exécutable déjà chargé.            *
+*                unused  = adresse non utilisée ici.                          *
+*                key     = identifiant de format trouvé ou NULL. [OUT]        *
 *                                                                             *
 *  Description : Indique si le format peut être pris en charge ici.           *
 *                                                                             *
-*  Retour      : Désignation du format reconnu ou NULL si aucun.              *
+*  Retour      : Conclusion de haut niveau sur la reconnaissance effectuée.   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *elf_is_matching(GBinContent *content, GExeFormat *parent)
+FormatMatchStatus elf_is_matching(GBinContent *content, GExeFormat *parent, void *unused, char **key)
 {
-    const char *result;                     /* Format détecté à renvoyer   */
+    FormatMatchStatus result;               /* Bilan à renvoyer            */
     vmpa2t addr;                            /* Tête de lecture initiale    */
     bool status;                            /* Bilan des accès mémoire     */
     char magic[4];                          /* Idenfiant standard          */
@@ -106,7 +108,13 @@ const char *elf_is_matching(GBinContent *content, GExeFormat *parent)
 
     status &= (memcmp(magic, "\x7f\x45\x4c\x46" /* .ELF */, 4) == 0);
 
-    result = status ? "elf" : NULL;
+    if (status)
+    {
+        result = FMS_MATCHED;
+        *key = strdup("elf");
+    }
+    else
+        result = FMS_UNKNOWN;
 
     return result;
 
diff --git a/src/format/elf/elf.h b/src/format/elf/elf.h
index 8e9a2cc..a557927 100644
--- a/src/format/elf/elf.h
+++ b/src/format/elf/elf.h
@@ -31,8 +31,7 @@
 
 
 #include "elf_def.h"
-#include "../executable.h"
-#include "../format.h"
+#include "../../core/formats.h"
 
 
 
@@ -51,7 +50,7 @@ typedef struct _GElfFormatClass GElfFormatClass;
 
 
 /* Indique si le format peut être pris en charge ici. */
-const char *elf_is_matching(GBinContent *, GExeFormat *);
+FormatMatchStatus elf_is_matching(GBinContent *, GExeFormat *, void *, char **);
 
 /* Indique le type défini pour un format d'exécutable ELF. */
 GType g_elf_format_get_type(void);
diff --git a/src/format/executable-int.h b/src/format/executable-int.h
index 704466e..f5a25b5 100644
--- a/src/format/executable-int.h
+++ b/src/format/executable-int.h
@@ -62,6 +62,9 @@ struct _GExeFormat
 {
     GBinFormat parent;                      /* A laisser en premier        */
 
+    GDbgFormat **debugs;                    /* Informations de débogage    */
+    size_t debugs_count;                    /* Nombre de ces informations  */
+
     get_target_machine_fc get_machine;      /* Architecture ciblée         */
     refine_portions_fc refine_portions;     /* Décrit les portions binaires*/
 
diff --git a/src/format/executable.c b/src/format/executable.c
index aae182a..5ff773c 100644
--- a/src/format/executable.c
+++ b/src/format/executable.c
@@ -84,6 +84,84 @@ static void g_executable_format_init(GExeFormat *format)
 
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à compléter.                  *
+*                info   = informations de débogage à lier.                    *
+*                                                                             *
+*  Description : Rajoute des informations de débogage à un exécutable.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_exe_format_add_debug_info(GExeFormat *format, GDbgFormat *info)
+{
+    /* Ajout dans la liste */
+
+    format->debugs = (GDbgFormat **)realloc(format->debugs,
+                                            ++format->debugs_count * sizeof(GDbgFormat *));
+
+    format->debugs[format->debugs_count - 1] = info;
+
+    /* Intégration des symboles */
+
+    /* TODO */
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                                                                             *
+*  Description : Compte le nombre de formats de débogage liés à l'exécutable. *
+*                                                                             *
+*  Retour      : Nombre de formats de débogage attachés.                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_exe_format_count_debug_info(const GExeFormat *format)
+{
+    return format->debugs_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                index  = indice des informations à transmettre.              *
+*                                                                             *
+*  Description : Fournit un format de débogage attaché à l'exécutable.        *
+*                                                                             *
+*  Retour      : Informations de débogage attachées.                          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *format, size_t index)
+{
+    GDbgFormat *result;                     /* Format à retourner          */
+
+    if (index >= format->debugs_count)
+        result = NULL;
+
+    else
+    {
+        result = format->debugs[index];
+        g_object_ref(G_OBJECT(result));
+    }
+
+    return result;
+
+}
+
 
 
 
diff --git a/src/format/executable.h b/src/format/executable.h
index 45c736b..48a8139 100644
--- a/src/format/executable.h
+++ b/src/format/executable.h
@@ -28,6 +28,7 @@
 #include <glib-object.h>
 
 
+#include "debuggable.h"
 #include "../glibext/gbinportion.h"
 
 
@@ -52,6 +53,14 @@ typedef struct _GExeFormatClass GExeFormatClass;
 GType g_executable_format_get_type(void);
 
 
+/* Rajoute des informations de débogage à un exécutable. */
+void g_exe_format_add_debug_info(GExeFormat *, GDbgFormat *);
+
+/* Compte le nombre de formats de débogage liés à l'exécutable. */
+size_t g_exe_format_count_debug_info(const GExeFormat *);
+
+/* Fournit un format de débogage attaché à l'exécutable. */
+GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *, size_t);
 
 
 /* Indique le type d'architecture visée par le format. */
diff --git a/src/gui/menus/project.c b/src/gui/menus/project.c
index a68b137..6b7e6b4 100644
--- a/src/gui/menus/project.c
+++ b/src/gui/menus/project.c
@@ -32,7 +32,7 @@
 
 
 #include "../editem-int.h"
-#include "../../analysis/binaries/file.h"
+#include "../../analysis/contents/file.h"
 #include "../../dialogs/shellcode.h"
 #include "../../gtkext/easygtk.h"
 
@@ -270,7 +270,7 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar)
     GtkWidget *dialog;                      /* Boîte à afficher            */
     char *dir;                              /* Répertoire courant          */
     gchar *filename;                        /* Nom du fichier à intégrer   */
-    GLoadedBinary *binary;                  /* Représentation chargée      */
+    GBinContent *content;                   /* Contenu binaire à charger   */
 
     dialog = gtk_file_chooser_dialog_new(_("Open a binary file"),
                                          GTK_WINDOW(G_EDITOR_ITEM(bar)->ref),
@@ -299,14 +299,9 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar)
     {
         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 
-        binary = g_file_binary_new_from_file(filename);
+        content = g_file_content_new(filename);
 
-        if (binary != NULL)
-        {
-            g_signal_connect(binary, "disassembly-done",
-                             G_CALLBACK(g_study_project_add_loaded_binary), get_current_project());
-            g_loaded_binary_analyse(binary);
-        }
+        qck_study_new_content(content, PCS_ROOT);
 
         g_free(filename);
 
diff --git a/src/plugins/plugin-int.h b/src/plugins/plugin-int.h
index acaf735..f786c08 100644
--- a/src/plugins/plugin-int.h
+++ b/src/plugins/plugin-int.h
@@ -39,37 +39,40 @@
 /* Prend acte du [dé]chargement du greffon. */
 typedef bool (* pg_management_fc) (GPluginModule *, GObject *);
 
+/* Exécute une action pendant un désassemblage de binaire. */
+typedef void (* pg_process_disassembly_fc) (const GPluginModule *, PluginAction, GLoadedBinary *);
+
+
+
+
 /* Indique si le format peut être pris en charge ici. */
-typedef bool (* pg_format_is_matching) (const GPluginModule *, GBinContent **);
+//typedef bool (* pg_format_is_matching) (const GPluginModule *, GBinContent **);
 
 /* Procède à une opération liée au format de fichier uniquement. */
 typedef bool (* pg_handle_format) (const GPluginModule *, PluginAction, GBinFormat *);
 
-/* Exécute une action pendant un désassemblage de binaire. */
-typedef void (* pg_process_disassembly) (const GPluginModule *, PluginAction, GLoadedBinary *);
-
 
 
 
 
 
 /* Précise le nom associé au greffon. */
-typedef char * (* get_plugin_name_fc) (void);
+//typedef char * (* get_plugin_name_fc) (void);
 
 /* Procède à l'initialisation du greffon. */
-typedef bool (* init_plugin_fc) (GPluginModule *, GObject *);
+//typedef bool (* init_plugin_fc) (GPluginModule *, GObject *);
 
 /* Procède à l'extinction du greffon. */
-typedef void (* exit_plugin_fc) (GPluginModule *);
+//typedef void (* exit_plugin_fc) (GPluginModule *);
 
 /* Fournit une indication sur le type d'opération(s) menée(s). */
-typedef PluginAction (* get_plugin_action_fc) (const GPluginModule *);
+//typedef PluginAction (* get_plugin_action_fc) (const GPluginModule *);
 
 /* Identifie un format à associer à un contenu binaire. */
 //typedef MatchingFormatAction (* is_matching_fc) (const GPluginModule *, char **, bin_t **, off_t *);
 
 /* Exécute une action définie sur un binaire chargé. */
-typedef bool (* execute_action_on_binary_fc) (const GPluginModule *, GLoadedBinary *, PluginAction);
+//typedef bool (* execute_action_on_binary_fc) (const GPluginModule *, GLoadedBinary *, PluginAction);
 
 /* Exécute une action relative à un débogueur. */
 //typedef bool (* execute_on_debugger_fc) (const GPluginModule *, GBinaryDebugger *, PluginAction);
@@ -88,6 +91,7 @@ struct _GPluginModule
     pg_management_fc init;                  /* Procédure d'initialisation  */
     pg_management_fc exit;                  /* Procédure d'extinction      */
 
+    pg_process_disassembly_fc process_disass; /* Catégorie 'désassemblage' */
 
 
     //char *name;                             /* Nom associé au greffon      */
@@ -95,18 +99,17 @@ struct _GPluginModule
 
     //init_plugin_fc init;                    /* Procédure d'initialisation  */
     //exit_plugin_fc exit;                    /* Procédure d'extinction      */
-    get_plugin_action_fc get_action;        /* Opération(s) menée(s)       */
+    //get_plugin_action_fc get_action;        /* Opération(s) menée(s)       */
 
     //is_matching_fc is_matching;             /* Recherche de correspondance */
 
-    execute_action_on_binary_fc exec_on_bin;/* Action sur un binaire       */
+    //execute_action_on_binary_fc exec_on_bin;/* Action sur un binaire       */
     //execute_on_debugger_fc handle_debugger; /* Action liée à un débogueur  */
 
 
-    pg_format_is_matching is_matching;      /* Recherche de correspondance */
+    //pg_format_is_matching is_matching;      /* Recherche de correspondance */
     pg_handle_format handle_format;         /* Manipulation du format      */
 
-    pg_process_disassembly proc_disass;     /* Catégorie 'désassemblage'   */
 
 };
 
diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c
index 9322bcb..c0e9fd1 100644
--- a/src/plugins/plugin.c
+++ b/src/plugins/plugin.c
@@ -37,6 +37,9 @@
 #include "plugin-int.h"
 
 
+#include "../core/formats.h"
+
+
 
 /* Initialise la classe des greffons. */
 static void g_plugin_module_class_init(GPluginModuleClass *);
@@ -162,8 +165,10 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
     GPluginModule *result;                  /* Structure à retourner       */
     plugin_abi_version_t current;           /* Version de l'ABI actuelle   */
     size_t i;                               /* Boucle de parcours          */
+    uint32_t action;                        /* Identifiant d'une action    */
     uint32_t category;                      /* Catégorie principale        */
     uint32_t sub;                           /* Sous-catégorie visée        */
+    format_match_fc matcher;                /* Routine de reconnaissance   */
 
     result = g_object_new(G_TYPE_PLUGIN_MODULE, NULL);
 
@@ -215,8 +220,9 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
 
     for (i = 0; i < result->interface->actions_count; i++)
     {
-        category = MASK_PLUGIN_CATEGORY(result->interface->actions[i]);
-        sub = MASK_PLUGIN_SUB_CATEGORY(result->interface->actions[i]);
+        action = result->interface->actions[i];
+        category = MASK_PLUGIN_CATEGORY(action);
+        sub = MASK_PLUGIN_SUB_CATEGORY(action);
 
         switch (category)
         {
@@ -254,8 +260,18 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
                 {
                     case DPS_FORMAT:
 
-                        switch (result->interface->actions[i])
+                        switch (action)
                         {
+                            case PGA_FORMAT_MATCHER:
+
+                                if (!load_plugin_symbol(result->module,
+                                                        "is_format_matching", &matcher))
+                                    goto bad_plugin;
+
+                                if (!register_format_matcher(matcher, result))
+                                    goto bad_plugin;
+
+                                break;
 
                             case PGA_FORMAT_LOADER_LAST:
                                 if (!load_plugin_symbol(result->module,
@@ -275,7 +291,7 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
 
                     case DPS_DISASSEMBLY:
                         if (!load_plugin_symbol(result->module,
-                                                "process_binary_disassembly", &result->proc_disass))
+                                                "process_binary_disassembly", &result->process_disass))
                             goto bad_plugin;
                         break;
 
@@ -504,6 +520,6 @@ bool g_plugin_module_handle_binary_format(const GPluginModule *plugin, PluginAct
 
 void g_plugin_module_process_disassembly_event(const GPluginModule *plugin, PluginAction action, GLoadedBinary *binary)
 {
-    plugin->proc_disass(plugin, action, binary);
+    plugin->process_disass(plugin, action, binary);
 
 }