Replaced all remaining raw accesses to binary contents with the GBinContent wrapper in binary formats.

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

4 files changed, 71 insertions, 29 deletions

diff --git a/src/glibext/gbincontent.c b/src/glibext/gbincontent.c
index 4ea0b03..0230e70 100644
--- a/src/glibext/gbincontent.c
+++ b/src/glibext/gbincontent.c
@@ -363,30 +363,64 @@ static const binary_part *g_binary_content_find_part(const GBinContent *content,
 *  Paramètres  : content = contenu binaire à venir lire.                      *
 *                addr    = position de la tête de lecture.                    *
 *                length  = quantité d'octets à lire.                          *
-*                out     = réceptacle disponible pour ces données. [OUT]      *
 *                                                                             *
-*  Description : Fournit une portion des données représentées.                *
+*  Description : Donne accès à une portion des données représentées.          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : Pointeur vers les données à lire ou NULL en cas d'échec.     *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool g_binary_content_get_raw(const GBinContent *content, vmpa2t *addr, phys_t length, bin_t *out)
+const bin_t *g_binary_content_get_raw_access(const GBinContent *content, vmpa2t *addr, phys_t length)
 {
-    bool result;
-    phys_t offset;
+    phys_t offset;                          /* Emplacement de départ       */
 
     /* FIXME */
 
     offset = get_phy_addr(addr);
 
-    memcpy(out, &content->parts[0].data[offset], length);
+    if ((offset + length) >= get_mrange_length(&content->parts[0].range))
+        return NULL;
 
     advance_vmpa(addr, length);
 
-    return true;
+    return &content->parts[0].data[offset];
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : content = contenu binaire à venir lire.                      *
+*                addr    = position de la tête de lecture.                    *
+*                length  = quantité d'octets à lire.                          *
+*                out     = réceptacle disponible pour ces données. [OUT]      *
+*                                                                             *
+*  Description : Fournit une portion des données représentées.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_binary_content_get_raw(const GBinContent *content, vmpa2t *addr, phys_t length, bin_t *out)
+{
+    bool result;                            /* Bilan à remonter            */
+    const bin_t *data;                      /* Pointeur vers données utiles*/
+
+    data = g_binary_content_get_raw_access(content, addr, length);
+
+    if (data != NULL)
+    {
+        result = true;
+        memcpy(out, data, length);
+    }
+    else
+        result = false;
+
+    return result;
 
 }
 
@@ -447,7 +481,6 @@ bool g_binary_content_read_u4(const GBinContent *content, vmpa2t *addr, bool *lo
 *                                                                             *
 *  Paramètres  : content = contenu binaire à venir lire.                      *
 *                addr    = position de la tête de lecture.                    *
-*                endian  = ordre des bits dans la source.                     *
 *                val     = lieu d'enregistrement de la lecture. [OUT]         *
 *                                                                             *
 *  Description : Lit un nombre non signé sur un octet.                        *
@@ -458,7 +491,7 @@ bool g_binary_content_read_u4(const GBinContent *content, vmpa2t *addr, bool *lo
 *                                                                             *
 ******************************************************************************/
 
-bool g_binary_content_read_u8(const GBinContent *content, vmpa2t *addr, SourceEndian endian, uint8_t *val)
+bool g_binary_content_read_u8(const GBinContent *content, vmpa2t *addr, uint8_t *val)
 {
     phys_t start;                           /* Tête de lecture relative    */
     const binary_part *part;                /* Zone de mémoire effective   */
diff --git a/src/glibext/gbincontent.h b/src/glibext/gbincontent.h
index 9dd7264..b1e9ec1 100644
--- a/src/glibext/gbincontent.h
+++ b/src/glibext/gbincontent.h
@@ -62,6 +62,8 @@ const gchar *g_binary_content_get_cheksum(GBinContent *);
 /* Détermine le nombre d'octets lisibles. */
 phys_t g_binary_content_compute_size(const GBinContent *);
 
+/* Donne accès à une portion des données représentées. */
+const bin_t *g_binary_content_get_raw_access(const GBinContent *, vmpa2t *, phys_t);
 
 /* Fournit une portion des données représentées. */
 bool g_binary_content_get_raw(const GBinContent *, vmpa2t *, phys_t, bin_t *);
@@ -72,7 +74,7 @@ bool g_binary_content_get_raw(const GBinContent *, vmpa2t *, phys_t, bin_t *);
 bool g_binary_content_read_u4(const GBinContent *, vmpa2t *, bool *, SourceEndian, uint8_t *);
 
 /* Lit un nombre non signé sur un octet. */
-bool g_binary_content_read_u8(const GBinContent *, vmpa2t *, SourceEndian, uint8_t *);
+bool g_binary_content_read_u8(const GBinContent *, vmpa2t *, uint8_t *);
 
 /* Lit un nombre non signé sur deux octets. */
 bool g_binary_content_read_u16(const GBinContent *, vmpa2t *, SourceEndian, uint16_t *);
@@ -85,7 +87,7 @@ bool g_binary_content_read_u64(const GBinContent *, vmpa2t *, SourceEndian, uint
 
 
 #define g_binary_content_read_s4(c, a, l, e, v) g_binary_content_read_u4(c, a, l, e, (uint8_t *)v)
-#define g_binary_content_read_s8(c, a, e, v) g_binary_content_read_u8(c, a, e, (uint8_t *)v)
+#define g_binary_content_read_s8(c, a, v) g_binary_content_read_u8(c, a, (uint8_t *)v)
 #define g_binary_content_read_s16(c, a, e, v) g_binary_content_read_u16(c, a, e, (uint16_t *)v)
 #define g_binary_content_read_s32(c, a, e, v) g_binary_content_read_u32(c, a, e, (uint32_t *)v)
 #define g_binary_content_read_s64(c, a, e, v) g_binary_content_read_u64(c, a, e, (uint64_t *)v)
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 238bfb3..859b6ac 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -621,8 +621,7 @@ void g_buffer_line_fill_mrange(GBufferLine *line, MemoryDataSize psize, MemoryDa
 *  Paramètres  : line    = ligne à venir compléter.                           *
 *                psize   = taille souhaitée de l'impression des positions.    *
 *                vsize   = taille souhaitée de l'impression des adresses.     *
-*                content = contenu binaire global.                            *
-*                length  = taille de l'extrait de code à afficher.            *
+*                content = contenu binaire global à venir lire.               *
 *                full    = la portion est assez courte pour être entière ?    *
 *                                                                             *
 *  Description : Construit le tronc commun d'une ligne d'instruction.         *
@@ -633,17 +632,17 @@ void g_buffer_line_fill_mrange(GBufferLine *line, MemoryDataSize psize, MemoryDa
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, MemoryDataSize vsize, const bin_t *content, off_t length, bool full)
+void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, MemoryDataSize vsize, const GBinContent *content, bool full)
 {
+    phys_t length;                          /* Taille de la couverture     */
     size_t required;                        /* Taille de traitement requise*/ 
     char static_buffer[64];                 /* Petit tampon local rapide   */
     char *bin_code;                         /* Tampon utilisé pour le code */
-    off_t start;                            /* Début de traitement         */
-    off_t end;                              /* Limite de traitement        */
-    off_t i;                                /* Boucle de parcours #1       */
-    char *iter;                             /* Boucle de parcours #2       */
+    vmpa2t pos;                             /* Boucle de parcours #1       */
+    phys_t i;                               /* Boucle de parcours #2       */
+    char *iter;                             /* Boucle de parcours #3       */
     int ret;                                /* Progression dans l'écriture */
-    bin_t byte;                             /* Octet à représenter         */
+    uint8_t byte;                           /* Octet à représenter         */
 
     static const char *charset = "0123456789abcdef";
 
@@ -653,6 +652,8 @@ void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, Memor
 
     /* Détermination du réceptacle */
 
+    length = get_mrange_length(&line->range);
+
     required = length * 3 + 3;
 
     if (required <= sizeof(static_buffer))
@@ -662,17 +663,22 @@ void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, Memor
 
     /* Code brut */
 
-    start = get_phy_addr(get_mrange_addr(&line->range));
-    end = start + length;
+    copy_vmpa(&pos, get_mrange_addr(&line->range));
 
-    for (i = start, iter = bin_code; i < end; i++, iter += ret)
+    for (i = 0, iter = bin_code; i < length; i++, iter += ret)
     {
-        byte = content[i];
-
-        iter[0] = charset[byte >> 4];
-        iter[1] = charset[byte & 0x0f];
+        if (!g_binary_content_read_u8(content, &pos, &byte))
+        {
+            iter[0] = '?';
+            iter[1] = '?';
+        }
+        else
+        {
+            iter[0] = charset[byte >> 4];
+            iter[1] = charset[byte & 0x0f];
+        }
 
-        if ((i + 1) < end)
+        if ((i + 1) < length)
         {
             iter[2] = ' ';
             ret = 3;
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
index 3a47ee7..e9e6fae 100644
--- a/src/glibext/gbufferline.h
+++ b/src/glibext/gbufferline.h
@@ -29,6 +29,7 @@
 #include <stdbool.h>
 
 
+#include "gbincontent.h"
 #include "gbuffersegment.h"
 #include "../arch/archbase.h"
 #include "../arch/vmpa.h"
@@ -109,7 +110,7 @@ const mrange_t *g_buffer_line_get_range(const GBufferLine *);
 void g_buffer_line_fill_mrange(GBufferLine *, MemoryDataSize, MemoryDataSize);
 
 /* Construit le tronc commun d'une ligne d'instruction. */
-void g_buffer_line_fill_for_instr(GBufferLine *, MemoryDataSize, MemoryDataSize, const bin_t *, off_t, bool);
+void g_buffer_line_fill_for_instr(GBufferLine *, MemoryDataSize, MemoryDataSize, const GBinContent *, bool);
 
 /* Ajoute un fragment de texte à une colonne de ligne. */
 void g_buffer_line_add_segment(GBufferLine *, BufferLineColumn, GBufferSegment *) __attribute__ ((deprecated));