Restore full featured Python bindings for binary contents.

11 files changed, 165 insertions, 71 deletions

diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index 909ced9..4eb0811 100644
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -1,5 +1,5 @@
 
-noinst_LTLIBRARIES  = libanalysis.la
+noinst_LTLIBRARIES  = libanalysis4.la # libanalysis.la
 
 libanalysis_la_SOURCES =				\
 	binary.h binary.c					\
@@ -30,9 +30,20 @@ libanalysis_la_LIBADD =					\
 	types/libanalysistypes.la
 
 
+libanalysis4_la_SOURCES =					\
+	content-int.h							\
+	content.h content.c
+
+libanalysis4_la_CFLAGS = $(TOOLKIT_CFLAGS)
+
+libanalysis4_la_LIBADD =					\
+	contents/libanalysiscontents.la
+
+
 devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
 
 dev_HEADERS = $(libanalysis_la_SOURCES:%c=)
 
 
-SUBDIRS = contents db disass human scan storage types
+#SUBDIRS = contents db disass human scan storage types
+SUBDIRS = contents
diff --git a/src/analysis/content-int.h b/src/analysis/content-int.h
index 3475b3f..36c95e7 100644
--- a/src/analysis/content-int.h
+++ b/src/analysis/content-int.h
@@ -26,16 +26,16 @@
 
 
 #include "content.h"
-#include "storage/serialize-int.h"
-
+//#include "storage/serialize-int.h"    // FIXME
 
 
+#if 0 // FIXME
 /* Associe un ensemble d'attributs au contenu binaire. */
 typedef void (* set_content_attributes) (GBinContent *, GContentAttributes *);
 
 /* Fournit l'ensemble des attributs associés à un contenu. */
 typedef GContentAttributes * (* get_content_attributes) (const GBinContent *);
-
+#endif
 /* Donne l'origine d'un contenu binaire. */
 typedef GBinContent * (* get_content_root_fc) (GBinContent *);
 
@@ -43,16 +43,16 @@ typedef GBinContent * (* get_content_root_fc) (GBinContent *);
 typedef char * (* describe_content_fc) (const GBinContent *, bool);
 
 /* Calcule une empreinte unique (SHA256) pour les données. */
-typedef void (* compute_checksum_fc) (GBinContent *, GChecksum *);
+typedef void (* compute_checksum_fc) (const GBinContent *, GChecksum *);
 
 /* Détermine le nombre d'octets lisibles. */
 typedef phys_t (* compute_size_fc) (const GBinContent *);
 
 /* Détermine la position initiale d'un contenu. */
-typedef void (* compute_start_pos_fc) (const GBinContent *, vmpa2t *);
+typedef bool (* compute_start_pos_fc) (const GBinContent *, vmpa2t *);
 
 /* Détermine la position finale d'un contenu. */
-typedef void (* compute_end_pos_fc) (const GBinContent *, vmpa2t *);
+typedef bool (* compute_end_pos_fc) (const GBinContent *, vmpa2t *);
 
 /* Avance la tête de lecture d'une certaine quantité de données. */
 typedef bool (* seek_fc) (const GBinContent *, vmpa2t *, phys_t);
@@ -83,13 +83,13 @@ typedef bool (* read_uleb128_fc) (const GBinContent *, vmpa2t *, uleb128_t *);
 
 /* Lit un nombre signé encodé au format LEB128. */
 typedef bool (* read_leb128_fc) (const GBinContent *, vmpa2t *, leb128_t *);
-
+#if 0 // FIXME
 /* Charge un objet depuis une mémoire tampon. */
 typedef bool (* load_content_cb) (GBinContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un objet dans une mémoire tampon. */
 typedef bool (* store_content_cb) (const GBinContent *, GObjectStorage *, packed_buffer_t *);
-
+#endif
 
 /* Accès à un contenu binaire quelconque (instance) */
 struct _GBinContent
@@ -103,8 +103,10 @@ struct _GBinContentClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+#if 0 // FIXME
     set_content_attributes set_attribs;     /* Enregistrement d'attributs  */
     get_content_attributes get_attribs;     /* Fourniture d'attributs      */
+#endif
 
     get_content_root_fc get_root;           /* Renvoie à l'origine         */
 
@@ -130,8 +132,10 @@ struct _GBinContentClass
     read_uleb128_fc read_uleb128;           /* Lecture d'un LEB non signé  */
     read_leb128_fc read_leb128;             /* Lecture d'un LEB signé      */
 
+#if 0 // FIXME
     load_content_cb load;                   /* Chargement                  */
     store_content_cb store;                 /* Enregistrement              */
+#endif
 
 };
 
diff --git a/src/analysis/content.c b/src/analysis/content.c
index e12237f..89fc572 100644
--- a/src/analysis/content.c
+++ b/src/analysis/content.c
@@ -45,7 +45,9 @@ static void g_binary_content_class_init(GBinContentClass *);
 static void g_binary_content_init(GBinContent *);
 
 /* Procède à l'initialisation de l'interface de sérialisation. */
+#if 0 // FIXME
 static void g_binary_content_serializable_interface_init(GSerializableObjectIface *);
+#endif
 
 /* Supprime toutes les références externes. */
 static void g_binary_content_dispose(GBinContent *);
@@ -58,11 +60,13 @@ static void g_binary_content_finalize(GBinContent *);
 /* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */
 
 
+#if 0 // FIXME
 /* Charge un contenu depuis une mémoire tampon. */
 static bool g_binary_content_load(GBinContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un contenu dans une mémoire tampon. */
 static bool g_binary_content_store(const GBinContent *, GObjectStorage *, packed_buffer_t *);
+#endif
 
 
 
@@ -72,8 +76,11 @@ static bool g_binary_content_store(const GBinContent *, GObjectStorage *, packed
 
 
 /* Détermine le type d'un contenu binaire à parcourir. */
+#if 0 // FIXME
 G_DEFINE_TYPE_WITH_CODE(GBinContent, g_binary_content, G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_binary_content_serializable_interface_init));
+#endif
+G_DEFINE_TYPE(GBinContent, g_binary_content, G_TYPE_OBJECT);
 
 
 /******************************************************************************
@@ -130,12 +137,14 @@ static void g_binary_content_init(GBinContent *content)
 *                                                                             *
 ******************************************************************************/
 
+#if 0 // FIXME
 static void g_binary_content_serializable_interface_init(GSerializableObjectIface *iface)
 {
     iface->load = (load_serializable_object_cb)g_binary_content_load;
     iface->store = (store_serializable_object_cb)g_binary_content_store;
 
 }
+#endif
 
 
 /******************************************************************************
@@ -188,7 +197,7 @@ static void g_binary_content_finalize(GBinContent *content)
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 void g_binary_content_set_attributes(GBinContent *content, GContentAttributes *attribs)
 {
     GBinContentClass *class;                /* Classe de l'instance        */
@@ -224,7 +233,7 @@ GContentAttributes *g_binary_content_get_attributes(const GBinContent *content)
     return result;
 
 }
-
+#endif
 
 /******************************************************************************
 *                                                                             *
@@ -351,19 +360,22 @@ phys_t g_binary_content_compute_size(const GBinContent *content)
 *                                                                             *
 *  Description : Détermine la position initiale d'un contenu.                 *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_content_compute_start_pos(const GBinContent *content, vmpa2t *pos)
+bool g_binary_content_compute_start_pos(const GBinContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
     GBinContentClass *class;                /* Classe de l'instance        */
 
     class = G_BIN_CONTENT_GET_CLASS(content);
 
-    return class->compute_start_pos(content, pos);
+    result = class->compute_start_pos(content, pos);
+
+    return result;
 
 }
 
@@ -375,19 +387,22 @@ void g_binary_content_compute_start_pos(const GBinContent *content, vmpa2t *pos)
 *                                                                             *
 *  Description : Détermine la position finale d'un contenu.                   *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_binary_content_compute_end_pos(const GBinContent *content, vmpa2t *pos)
+bool g_binary_content_compute_end_pos(const GBinContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
     GBinContentClass *class;                /* Classe de l'instance        */
 
     class = G_BIN_CONTENT_GET_CLASS(content);
 
-    return class->compute_end_pos(content, pos);
+    result = class->compute_end_pos(content, pos);
+
+    return result;
 
 }
 
@@ -780,6 +795,7 @@ bool g_binary_content_read_leb128(const GBinContent *content, vmpa2t *addr, leb1
 *                                                                             *
 ******************************************************************************/
 
+#if 0 // FIXME
 static bool g_binary_content_load(GBinContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
@@ -820,3 +836,4 @@ static bool g_binary_content_store(const GBinContent *content, GObjectStorage *s
     return result;
 
 }
+#endif
diff --git a/src/analysis/content.h b/src/analysis/content.h
index ee79a9c..ad50c02 100644
--- a/src/analysis/content.h
+++ b/src/analysis/content.h
@@ -29,9 +29,8 @@
 #include <glib-object.h>
 
 
-#include "cattribs.h"
+//#include "cattribs.h" // FIXME
 #include "../arch/vmpa.h"
-#include "../common/endianness.h"
 #include "../common/leb128.h"
 
 
@@ -53,13 +52,13 @@ typedef struct _GBinContentClass GBinContentClass;
 
 /* Détermine le type d'un contenu binaire à parcourir. */
 GType g_binary_content_get_type(void) G_GNUC_CONST;
-
+#if 0 // FIXME
 /* Associe un ensemble d'attributs au contenu binaire. */
 void g_binary_content_set_attributes(GBinContent *, GContentAttributes *);
 
 /* Fournit l'ensemble des attributs associés à un contenu. */
 GContentAttributes *g_binary_content_get_attributes(const GBinContent *);
-
+#endif
 /* Donne l'origine d'un contenu binaire. */
 GBinContent *g_binary_content_get_root(GBinContent *);
 
@@ -73,10 +72,10 @@ const gchar *g_binary_content_get_checksum(GBinContent *);
 phys_t g_binary_content_compute_size(const GBinContent *);
 
 /* Détermine la position initiale d'un contenu. */
-void g_binary_content_compute_start_pos(const GBinContent *, vmpa2t *);
+bool g_binary_content_compute_start_pos(const GBinContent *, vmpa2t *);
 
 /* Détermine la position finale d'un contenu. */
-void g_binary_content_compute_end_pos(const GBinContent *, vmpa2t *);
+bool g_binary_content_compute_end_pos(const GBinContent *, vmpa2t *);
 
 /* Avance la tête de lecture d'une certaine quantité de données. */
 bool g_binary_content_seek(const GBinContent *, vmpa2t *, phys_t);
diff --git a/src/analysis/contents/encapsulated.c b/src/analysis/contents/encapsulated.c
index e0e6ed1..451c340 100644
--- a/src/analysis/contents/encapsulated.c
+++ b/src/analysis/contents/encapsulated.c
@@ -54,12 +54,13 @@ static void g_encaps_content_finalize(GEncapsContent *);
 
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
-
+#if 0 // FIXME
 /* Associe un ensemble d'attributs au contenu binaire. */
 static void g_encaps_content_set_attributes(GEncapsContent *, GContentAttributes *);
 
 /* Fournit l'ensemble des attributs associés à un contenu. */
 static GContentAttributes *g_encaps_content_get_attributes(const GEncapsContent *);
+#endif
 
 /* Donne l'origine d'un contenu binaire. */
 static GBinContent *g_encaps_content_get_root(GEncapsContent *);
@@ -68,16 +69,16 @@ static GBinContent *g_encaps_content_get_root(GEncapsContent *);
 static char *g_encaps_content_describe(const GEncapsContent *, bool);
 
 /* Fournit une empreinte unique (SHA256) pour les données. */
-static void g_encaps_content_compute_checksum(GEncapsContent *, GChecksum *);
+static void g_encaps_content_compute_checksum(const GEncapsContent *, GChecksum *);
 
 /* Détermine le nombre d'octets lisibles. */
 static phys_t g_encaps_content_compute_size(const GEncapsContent *);
 
 /* Détermine la position initiale d'un contenu. */
-static void g_encaps_content_compute_start_pos(const GEncapsContent *, vmpa2t *);
+static bool g_encaps_content_compute_start_pos(const GEncapsContent *, vmpa2t *);
 
 /* Détermine la position finale d'un contenu. */
-static void g_encaps_content_compute_end_pos(const GEncapsContent *, vmpa2t *);
+static bool g_encaps_content_compute_end_pos(const GEncapsContent *, vmpa2t *);
 
 /* Avance la tête de lecture d'une certaine quantité de données. */
 static bool g_encaps_content_seek(const GEncapsContent *, vmpa2t *, phys_t);
@@ -108,13 +109,13 @@ static bool g_encaps_content_read_uleb128(const GEncapsContent *, vmpa2t *, uleb
 
 /* Lit un nombre signé encodé au format LEB128. */
 static bool g_encaps_content_read_leb128(const GEncapsContent *, vmpa2t *, leb128_t *);
-
+#if 0 // FIXME
 /* Charge un contenu depuis une mémoire tampon. */
 static bool g_encaps_content_load(GEncapsContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un contenu dans une mémoire tampon. */
 static bool g_encaps_content_store(const GEncapsContent *, GObjectStorage *, packed_buffer_t *);
-
+#endif
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -150,8 +151,10 @@ static void g_encaps_content_class_init(GEncapsContentClass *klass)
 
     content = G_BIN_CONTENT_CLASS(klass);
 
+#if 0 // FIXME
     content->set_attribs = (set_content_attributes)g_encaps_content_set_attributes;
     content->get_attribs = (get_content_attributes)g_encaps_content_get_attributes;
+#endif
 
     content->get_root = (get_content_root_fc)g_encaps_content_get_root;
 
@@ -177,8 +180,10 @@ static void g_encaps_content_class_init(GEncapsContentClass *klass)
     content->read_uleb128 = (read_uleb128_fc)g_encaps_content_read_uleb128;
     content->read_leb128 = (read_leb128_fc)g_encaps_content_read_leb128;
 
+#if 0 // FIXME
     content->load = (load_content_cb)g_encaps_content_load;
     content->store = (store_content_cb)g_encaps_content_store;
+#endif
 
 }
 
@@ -408,7 +413,7 @@ GBinContent *g_encaps_content_get_endpoint(const GEncapsContent *content)
 /*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
 /* ---------------------------------------------------------------------------------- */
 
-
+#if 0 // FIXME
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : content = contenu binaire à actualiser.                      *
@@ -450,7 +455,7 @@ static GContentAttributes *g_encaps_content_get_attributes(const GEncapsContent
     return result;
 
 }
-
+#endif
 
 /******************************************************************************
 *                                                                             *
@@ -515,7 +520,7 @@ static char *g_encaps_content_describe(const GEncapsContent *content, bool full)
 *                                                                             *
 ******************************************************************************/
 
-static void g_encaps_content_compute_checksum(GEncapsContent *content, GChecksum *checksum)
+static void g_encaps_content_compute_checksum(const GEncapsContent *content, GChecksum *checksum)
 {
     GBinContentClass *class;                /* Classe de l'instance        */
 
@@ -556,15 +561,19 @@ static phys_t g_encaps_content_compute_size(const GEncapsContent *content)
 *                                                                             *
 *  Description : Détermine la position initiale d'un contenu.                 *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_encaps_content_compute_start_pos(const GEncapsContent *content, vmpa2t *pos)
+static bool g_encaps_content_compute_start_pos(const GEncapsContent *content, vmpa2t *pos)
 {
-    g_binary_content_compute_start_pos(content->endpoint, pos);
+    bool result;                            /* Bilan à retourner           */
+
+    result = g_binary_content_compute_start_pos(content->endpoint, pos);
+
+    return result;
 
 }
 
@@ -576,15 +585,19 @@ static void g_encaps_content_compute_start_pos(const GEncapsContent *content, vm
 *                                                                             *
 *  Description : Détermine la position finale d'un contenu.                   *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_encaps_content_compute_end_pos(const GEncapsContent *content, vmpa2t *pos)
+static bool g_encaps_content_compute_end_pos(const GEncapsContent *content, vmpa2t *pos)
 {
-    g_binary_content_compute_end_pos(content->endpoint, pos);
+    bool result;                            /* Bilan à retourner           */
+
+    result = g_binary_content_compute_end_pos(content->endpoint, pos);
+
+    return result;
 
 }
 
@@ -858,7 +871,7 @@ static bool g_encaps_content_read_leb128(const GEncapsContent *content, vmpa2t *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static bool g_encaps_content_load(GEncapsContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
@@ -979,3 +992,4 @@ static bool g_encaps_content_store(const GEncapsContent *content, GObjectStorage
     return result;
 
 }
+#endif
diff --git a/src/analysis/contents/file.c b/src/analysis/contents/file.c
index 545d869..791f8b6 100644
--- a/src/analysis/contents/file.c
+++ b/src/analysis/contents/file.c
@@ -62,13 +62,13 @@ static void g_file_content_finalize(GFileContent *);
 
 /* Fournit le nom associé au contenu binaire. */
 static char *g_file_content_describe(const GFileContent *, bool);
-
+#if 0 // FIXME
 /* Charge un contenu depuis une mémoire tampon. */
 static bool g_file_content_load(GFileContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un contenu dans une mémoire tampon. */
 static bool g_file_content_store(const GFileContent *, GObjectStorage *, packed_buffer_t *);
-
+#endif
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -106,8 +106,10 @@ static void g_file_content_class_init(GFileContentClass *klass)
 
     content->describe = (describe_content_fc)g_file_content_describe;
 
+#if 0 // FIXME
     content->load = (load_content_cb)g_file_content_load;
     content->store = (store_content_cb)g_file_content_store;
+#endif
 
 }
 
@@ -359,7 +361,7 @@ static char *g_file_content_describe(const GFileContent *content, bool full)
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static bool g_file_content_load(GFileContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
@@ -428,3 +430,4 @@ static bool g_file_content_store(const GFileContent *content, GObjectStorage *st
     return result;
 
 }
+#endif
diff --git a/src/analysis/contents/memory-int.h b/src/analysis/contents/memory-int.h
index d3012c7..692feb7 100644
--- a/src/analysis/contents/memory-int.h
+++ b/src/analysis/contents/memory-int.h
@@ -37,7 +37,9 @@ struct _GMemoryContent
 {
     GBinContent parent;                     /* A laisser en premier        */
 
+#if 0 // FIXME
     GContentAttributes *attribs;            /* Attributs liés au contenu   */
+#endif
 
     bin_t *data;                            /* Contenu binaire représenté  */
     phys_t length;                          /* Taille totale du contenu    */
diff --git a/src/analysis/contents/memory.c b/src/analysis/contents/memory.c
index f8ff863..f7d2bd0 100644
--- a/src/analysis/contents/memory.c
+++ b/src/analysis/contents/memory.c
@@ -62,11 +62,13 @@ static void g_memory_content_finalize(GMemoryContent *);
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
+#if 0 // FIXME
 /* Associe un ensemble d'attributs au contenu binaire. */
 static void g_memory_content_set_attributes(GMemoryContent *, GContentAttributes *);
 
 /* Fournit l'ensemble des attributs associés à un contenu. */
 static GContentAttributes *g_memory_content_get_attributes(const GMemoryContent *);
+#endif
 
 /* Donne l'origine d'un contenu binaire. */
 static GBinContent *g_memory_content_get_root(GMemoryContent *);
@@ -75,16 +77,16 @@ static GBinContent *g_memory_content_get_root(GMemoryContent *);
 static char *g_memory_content_describe(const GMemoryContent *, bool);
 
 /* Fournit une empreinte unique (SHA256) pour les données. */
-static void g_memory_content_compute_checksum(GMemoryContent *, GChecksum *);
+static void g_memory_content_compute_checksum(const GMemoryContent *, GChecksum *);
 
 /* Détermine le nombre d'octets lisibles. */
 static phys_t g_memory_content_compute_size(const GMemoryContent *);
 
 /* Détermine la position initiale d'un contenu. */
-static void g_memory_content_compute_start_pos(const GMemoryContent *, vmpa2t *);
+static bool g_memory_content_compute_start_pos(const GMemoryContent *, vmpa2t *);
 
 /* Détermine la position finale d'un contenu. */
-static void g_memory_content_compute_end_pos(const GMemoryContent *, vmpa2t *);
+static bool g_memory_content_compute_end_pos(const GMemoryContent *, vmpa2t *);
 
 /* Avance la tête de lecture d'une certaine quantité de données. */
 static bool g_memory_content_seek(const GMemoryContent *, vmpa2t *, phys_t);
@@ -116,12 +118,13 @@ static bool g_memory_content_read_uleb128(const GMemoryContent *, vmpa2t *, uleb
 /* Lit un nombre signé encodé au format LEB128. */
 static bool g_memory_content_read_leb128(const GMemoryContent *, vmpa2t *, leb128_t *);
 
+#if 0 // FIXME
 /* Charge un contenu depuis une mémoire tampon. */
 static bool g_memory_content_load(GMemoryContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un contenu dans une mémoire tampon. */
 static bool g_memory_content_store(const GMemoryContent *, GObjectStorage *, packed_buffer_t *);
-
+#endif
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -157,8 +160,10 @@ static void g_memory_content_class_init(GMemoryContentClass *klass)
 
     content = G_BIN_CONTENT_CLASS(klass);
 
+#if 0 // FIXME
     content->set_attribs = (set_content_attributes)g_memory_content_set_attributes;
     content->get_attribs = (get_content_attributes)g_memory_content_get_attributes;
+#endif
 
     content->get_root = (get_content_root_fc)g_memory_content_get_root;
 
@@ -184,8 +189,10 @@ static void g_memory_content_class_init(GMemoryContentClass *klass)
     content->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128;
     content->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128;
 
+#if 0 // FIXME
     content->load = (load_content_cb)g_memory_content_load;
     content->store = (store_content_cb)g_memory_content_store;
+#endif
 
 }
 
@@ -204,6 +211,7 @@ static void g_memory_content_class_init(GMemoryContentClass *klass)
 
 static void g_memory_content_init(GMemoryContent *content)
 {
+#if 0 // FIXME
     GContentAttributes *empty;              /* Jeu d'attributs vide        */
 
     content->attribs = NULL;
@@ -213,6 +221,7 @@ static void g_memory_content_init(GMemoryContent *content)
     g_binary_content_set_attributes(G_BIN_CONTENT(content), empty);
 
     g_object_unref(G_OBJECT(empty));
+#endif
 
     content->data = NULL;
     content->length = 0;
@@ -238,7 +247,9 @@ static void g_memory_content_init(GMemoryContent *content)
 
 static void g_memory_content_dispose(GMemoryContent *content)
 {
+#if 0 // FIXME
     g_clear_object(&content->attribs);
+#endif
 
     G_OBJECT_CLASS(g_memory_content_parent_class)->dispose(G_OBJECT(content));
 
@@ -362,7 +373,7 @@ bool g_memory_content_create(GMemoryContent *content, const bin_t *data, phys_t
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static void g_memory_content_set_attributes(GMemoryContent *content, GContentAttributes *attribs)
 {
     g_clear_object(&content->attribs);
@@ -397,7 +408,7 @@ static GContentAttributes *g_memory_content_get_attributes(const GMemoryContent
     return result;
 
 }
-
+#endif
 
 /******************************************************************************
 *                                                                             *
@@ -464,7 +475,7 @@ static char *g_memory_content_describe(const GMemoryContent *content, bool full)
 *                                                                             *
 ******************************************************************************/
 
-static void g_memory_content_compute_checksum(GMemoryContent *content, GChecksum *checksum)
+static void g_memory_content_compute_checksum(const GMemoryContent *content, GChecksum *checksum)
 {
     g_checksum_update(checksum, content->data, content->length);
 
@@ -501,16 +512,22 @@ static phys_t g_memory_content_compute_size(const GMemoryContent *content)
 *                                                                             *
 *  Description : Détermine la position initiale d'un contenu.                 *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_memory_content_compute_start_pos(const GMemoryContent *content, vmpa2t *pos)
+static bool g_memory_content_compute_start_pos(const GMemoryContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
     init_vmpa(pos, 0, VMPA_NO_VIRTUAL);
 
+    return result;
+
 }
 
 
@@ -521,18 +538,24 @@ static void g_memory_content_compute_start_pos(const GMemoryContent *content, vm
 *                                                                             *
 *  Description : Détermine la position finale d'un contenu.                   *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_memory_content_compute_end_pos(const GMemoryContent *content, vmpa2t *pos)
+static bool g_memory_content_compute_end_pos(const GMemoryContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
     g_memory_content_compute_start_pos(content, pos);
 
     advance_vmpa(pos, content->length);
 
+    return result;
+
 }
 
 
@@ -898,7 +921,7 @@ static bool g_memory_content_read_leb128(const GMemoryContent *content, vmpa2t *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static bool g_memory_content_load(GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
@@ -1004,3 +1027,4 @@ static bool g_memory_content_store(const GMemoryContent *content, GObjectStorage
     return result;
 
 }
+#endif
diff --git a/src/analysis/contents/restricted.c b/src/analysis/contents/restricted.c
index 9b4e1c8..95f513b 100644
--- a/src/analysis/contents/restricted.c
+++ b/src/analysis/contents/restricted.c
@@ -55,12 +55,13 @@ static void g_restricted_content_finalize(GRestrictedContent *);
 
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
-
+#if 0 // FIXME
 /* Associe un ensemble d'attributs au contenu binaire. */
 static void g_restricted_content_set_attributes(GRestrictedContent *, GContentAttributes *);
 
 /* Fournit l'ensemble des attributs associés à un contenu. */
 static GContentAttributes *g_restricted_content_get_attributes(const GRestrictedContent *);
+#endif
 
 /* Donne l'origine d'un contenu binaire. */
 static GBinContent *g_restricted_content_get_root(GRestrictedContent *);
@@ -69,16 +70,16 @@ static GBinContent *g_restricted_content_get_root(GRestrictedContent *);
 static char *g_restricted_content_describe(const GRestrictedContent *, bool);
 
 /* Calcule une empreinte unique (SHA256) pour les données. */
-static void g_restricted_content_compute_checksum(GRestrictedContent *, GChecksum *);
+static void g_restricted_content_compute_checksum(const GRestrictedContent *, GChecksum *);
 
 /* Détermine le nombre d'octets lisibles. */
 static phys_t g_restricted_content_compute_size(const GRestrictedContent *);
 
 /* Détermine la position initiale d'un contenu. */
-static void g_restricted_content_compute_start_pos(const GRestrictedContent *, vmpa2t *);
+static bool g_restricted_content_compute_start_pos(const GRestrictedContent *, vmpa2t *);
 
 /* Détermine la position finale d'un contenu. */
-static void g_restricted_content_compute_end_pos(const GRestrictedContent *, vmpa2t *);
+static bool g_restricted_content_compute_end_pos(const GRestrictedContent *, vmpa2t *);
 
 /* Avance la tête de lecture d'une certaine quantité de données. */
 static bool g_restricted_content_seek(const GRestrictedContent *, vmpa2t *, phys_t);
@@ -109,13 +110,13 @@ static bool g_restricted_content_read_uleb128(const GRestrictedContent *, vmpa2t
 
 /* Lit un nombre signé encodé au format LEB128. */
 static bool g_restricted_content_read_leb128(const GRestrictedContent *, vmpa2t *, leb128_t *);
-
+#if 0 // FIXME
 /* Charge un contenu depuis une mémoire tampon. */
 static bool g_restricted_content_load(GRestrictedContent *, GObjectStorage *, packed_buffer_t *);
 
 /* Sauvegarde un contenu dans une mémoire tampon. */
 static bool g_restricted_content_store(const GRestrictedContent *, GObjectStorage *, packed_buffer_t *);
-
+#endif
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -151,8 +152,10 @@ static void g_restricted_content_class_init(GRestrictedContentClass *klass)
 
     content = G_BIN_CONTENT_CLASS(klass);
 
+#if 0 // FIXME
     content->set_attribs = (set_content_attributes)g_restricted_content_set_attributes;
     content->get_attribs = (get_content_attributes)g_restricted_content_get_attributes;
+#endif
 
     content->get_root = (get_content_root_fc)g_restricted_content_get_root;
 
@@ -178,8 +181,10 @@ static void g_restricted_content_class_init(GRestrictedContentClass *klass)
     content->read_uleb128 = (read_uleb128_fc)g_restricted_content_read_uleb128;
     content->read_leb128 = (read_leb128_fc)g_restricted_content_read_leb128;
 
+#if 0 // FIXME
     content->load = (load_content_cb)g_restricted_content_load;
     content->store = (store_content_cb)g_restricted_content_store;
+#endif
 
 }
 
@@ -344,7 +349,7 @@ void g_restricted_content_get_range(const GRestrictedContent *content, mrange_t
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static void g_restricted_content_set_attributes(GRestrictedContent *content, GContentAttributes *attribs)
 {
     g_binary_content_set_attributes(content->internal, attribs);
@@ -373,6 +378,7 @@ static GContentAttributes *g_restricted_content_get_attributes(const GRestricted
     return result;
 
 }
+#endif
 
 
 /******************************************************************************
@@ -462,7 +468,7 @@ static char *g_restricted_content_describe(const GRestrictedContent *content, bo
 *                                                                             *
 ******************************************************************************/
 
-static void g_restricted_content_compute_checksum(GRestrictedContent *content, GChecksum *checksum)
+static void g_restricted_content_compute_checksum(const GRestrictedContent *content, GChecksum *checksum)
 {
     vmpa2t start;                           /* Point de départ             */
     phys_t i;                               /* Boucle de parcours          */
@@ -516,16 +522,22 @@ static phys_t g_restricted_content_compute_size(const GRestrictedContent *conten
 *                                                                             *
 *  Description : Détermine la position initiale d'un contenu.                 *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_restricted_content_compute_start_pos(const GRestrictedContent *content, vmpa2t *pos)
+static bool g_restricted_content_compute_start_pos(const GRestrictedContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
     copy_vmpa(pos, get_mrange_addr(&content->range));
 
+    return result;
+
 }
 
 
@@ -536,16 +548,22 @@ static void g_restricted_content_compute_start_pos(const GRestrictedContent *con
 *                                                                             *
 *  Description : Détermine la position finale d'un contenu.                   *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Validité finale de la position fournie.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void g_restricted_content_compute_end_pos(const GRestrictedContent *content, vmpa2t *pos)
+static bool g_restricted_content_compute_end_pos(const GRestrictedContent *content, vmpa2t *pos)
 {
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
     compute_mrange_end_addr(&content->range, pos);
 
+    return result;
+
 }
 
 
@@ -977,7 +995,7 @@ static bool g_restricted_content_read_leb128(const GRestrictedContent *content,
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 static bool g_restricted_content_load(GRestrictedContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
@@ -1019,3 +1037,4 @@ static bool g_restricted_content_store(const GRestrictedContent *content, GObjec
     return result;
 
 }
+#endif
diff --git a/src/analysis/db/misc/rlestr.c b/src/analysis/db/misc/rlestr.c
index a211723..4c767c4 100644
--- a/src/analysis/db/misc/rlestr.c
+++ b/src/analysis/db/misc/rlestr.c
@@ -354,7 +354,7 @@ bool pack_rle_string(const rle_string *str, packed_buffer_t *pbuf)
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
-
+#if 0 // FIXME
 bool load_rle_string(rle_string *str, const char *name, const bound_value *values, size_t count)
 {
     const bound_value *value;               /* Valeur à intégrer           */
@@ -426,3 +426,4 @@ bool store_rle_string(const rle_string *str, const char *name, bound_value **val
     return true;
 
 }
+#endif
diff --git a/src/analysis/db/misc/rlestr.h b/src/analysis/db/misc/rlestr.h
index aa2aa73..53c1055 100644
--- a/src/analysis/db/misc/rlestr.h
+++ b/src/analysis/db/misc/rlestr.h
@@ -96,13 +96,13 @@ bool pack_rle_string(const rle_string *, packed_buffer_t *);
 /* Définition du tronc commun pour les créations SQLite */
 #define SQLITE_RLESTR_CREATE(n)     \
     n " TEXT"
-
+#if 0 // FIXME
 /* Charge les valeurs utiles pour une chaîne de caractères. */
 bool load_rle_string(rle_string *, const char *, const bound_value *, size_t);
 
 /* Constitue les champs destinés à une insertion / modification. */
 bool store_rle_string(const rle_string *, const char *, bound_value **, size_t *);
-
+#endif
 
 
 #endif  /* _ANALYSIS_DB_MISC_RLESTR_H */