Restore full featured Python bindings for binary contents.

5 files changed, 106 insertions, 44 deletions

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