Defined the first steps for a new disassembling approach.

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

5 files changed, 133 insertions, 51 deletions

diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 63804a5..201c64b 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -80,7 +80,7 @@ struct _GBufferLine
 {
     GObject parent;                         /* A laisser en premier        */
 
-    vmpa_t addr;                            /* Adresse geographique        */
+    const vmpa2t *addr;                     /* Emplacement geographique    */
     BufferLineColumn main_column;           /* Colonne principale          */
 
     buffer_line_column columns[BLC_COUNT];  /* Répartition du texte        */
@@ -343,7 +343,7 @@ static void g_buffer_line_init(GBufferLine *line)
 {
     BufferLineColumn i;                     /* Boucle de parcours          */
 
-    for (i = BLC_ADDRESS; i < BLC_COUNT; i++)
+    for (i = 0; i < BLC_COUNT; i++)
         reset_column(&line->columns[i]);
 
     line->merge_start = BLC_COUNT;
@@ -354,7 +354,7 @@ static void g_buffer_line_init(GBufferLine *line)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : addr = adresse où va se situer la ligne.                     *
+*  Paramètres  : addr = emplacement où va se situer la ligne.                 *
 *                main = colonne à référencer comme étant la principale.       *
 *                                                                             *
 *  Description : Crée une nouvelle représentation de fragments de texte.      *
@@ -365,7 +365,7 @@ static void g_buffer_line_init(GBufferLine *line)
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_buffer_line_new(vmpa_t addr, BufferLineColumn main)
+GBufferLine *g_buffer_line_new(const vmpa2t *addr, BufferLineColumn main)
 {
     GBufferLine *result;                    /* Composant à retourner       */
 
@@ -393,7 +393,66 @@ GBufferLine *g_buffer_line_new(vmpa_t addr, BufferLineColumn main)
 
 vmpa_t g_buffer_line_get_address(const GBufferLine *line)
 {
-    return line->addr;
+    return 0/* FIXME line->addr*/;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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.            *
+*                full    = la portion est assez courte pour être entière ?    *
+*                                                                             *
+*  Description : Construit le tronc commun d'une ligne d'instruction.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, MemoryDataSize vsize, const bin_t *content, off_t length, bool full)
+{
+    size_t len;                             /* Taille de l'élément inséré  */
+    char *address;                          /* Adresse au format texte     */
+    char *bin_code;                         /* Tampon du code binaire      */
+    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       */
+    int ret;                                /* Progression dans l'écriture */
+
+    /* Adresse physique puis virtuelle */
+
+    address = vmpa2_phys_to_string(line->addr, psize, &len);
+    g_buffer_line_insert_text(line, BLC_PHYSICAL, address, len, RTT_RAW);
+
+    address = vmpa2_virt_to_string(line->addr, vsize, &len);
+    g_buffer_line_insert_text(line, BLC_VIRTUAL, address, len, RTT_RAW);
+
+    /* Code brut */
+
+    bin_code = (char *)calloc(length * 3 + 3, sizeof(char));
+
+    start = get_phy_addr(line->addr);
+    end = start + length;
+
+    for (i = start, iter = bin_code; i < end; i++, iter += ret)
+    {
+        if ((i + 1) < end)
+            ret = snprintf(iter, 4, "%02hhx ", content[i]);
+        else
+            ret = snprintf(iter, 6, "%02hhx%s", content[i], full ? "" : "...");
+
+    }
+
+    g_buffer_line_insert_text(line, BLC_BINARY, bin_code, iter - bin_code, RTT_RAW_CODE);
+
+    free(bin_code);
 
 }
 
@@ -441,7 +500,7 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint
 
     result = NULL;
 
-    for (i = BLC_ADDRESS; i < BLC_COUNT; i++)
+    for (i = 0; i < BLC_COUNT; i++)
     {
         /* FIXME : addr/code */
 
@@ -470,7 +529,8 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint
 *                caret = position du curseur à faire évoluer.                 *
 *                ctrl  = indique la demande d'un parcours rapide.             *
 *                dir   = direction du parcours.                               *
-*                addr  = indique si les positions doivent être affichées.     *
+*                phys  = indique si les positions doivent être affichées.     *
+*                virt  = indique si les adresses doivent être affichées.      *
 *                code  = indique si le code binaire doit être affiché.        *
 *                                                                             *
 *  Description : Déplace le curseur au sein d'une vue de tampon.              *
@@ -481,9 +541,11 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_line_move_caret(const GBufferLine *line, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool addr, bool code)
+bool g_buffer_line_move_caret(const GBufferLine *line, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool phys, bool virt, bool code)
 {
 
+    /* TODO : utiliser les arguments booléens */
+
     caret->x += (dir == GDK_SCROLL_RIGHT ? 10 : -10);
 
     return true;
@@ -512,7 +574,7 @@ GSList *g_buffer_line_highlight_all_same_segments(const GBufferLine *line, GSLis
 {
     BufferLineColumn i;                     /* Boucle de parcours          */
 
-    for (i = BLC_ADDRESS; i < BLC_COUNT; i++)
+    for (i = 0; i < BLC_COUNT; i++)
         list = highlight_all_same_segments(&line->columns[i], list, ref);
 
     return list;
@@ -621,7 +683,8 @@ gint g_buffer_line_get_column_width(GBufferLine *line, BufferLineColumn index)
 *                                                                             *
 *  Paramètres  : line  = ligne à venir compléter.                             *
 *                merge = précise la première colonne marquant la fusion. [OUT]*
-*                addr  = indique si les positions doivent être affichées.     *
+*                phys  = indique si les positions doivent être affichées.     *
+*                virt  = indique si les adresses doivent être affichées.      *
 *                code  = indique si le code binaire doit être affiché.        *
 *                                                                             *
 *  Description : Fournit la dernière largeur d'une ligne avec fusion.         *
@@ -632,12 +695,14 @@ gint g_buffer_line_get_column_width(GBufferLine *line, BufferLineColumn index)
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_line_get_merge_width(GBufferLine *line, BufferLineColumn *merge, bool addr, bool code)
+gint g_buffer_line_get_merge_width(GBufferLine *line, BufferLineColumn *merge, bool phys, bool virt, bool code)
 {
     gint result;                            /* Largeur à retourner         */
 
     result = 0;
 
+    /* TODO : wtf ?! quelle est l'utilité des arguments booléens ? */
+
     *merge = line->merge_start;
 
     if (line->merge_start < BLC_COUNT)
@@ -678,7 +743,8 @@ void g_buffer_line_start_merge_at(GBufferLine *line, BufferLineColumn start)
 *                max_widths = largeurs de colonne à respecter.                *
 *                x_init     = abscisse du point d'impression de départ.       *
 *                y          = ordonnée du point d'impression.                 *
-*                addr       = indique si les positions doivent être affichées.*
+*                phys       = indique si les positions doivent être affichées.*
+*                virt       = indique si les adresses doivent être affichées. *
 *                code       = indique si le code binaire doit être affiché.   *
 *                                                                             *
 *  Description : Imprime la ligne de texte représentée.                       *
@@ -689,7 +755,7 @@ void g_buffer_line_start_merge_at(GBufferLine *line, BufferLineColumn start)
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths[BLC_COUNT], gint x_init, gint y, bool addr, bool code)
+void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths[BLC_COUNT], gint x_init, gint y, bool phys, bool virt, bool code)
 {
     GBufferLineClass *class;                /* Stockage de briques de base */
     gint x;                                 /* Point de départ d'impression*/
@@ -702,9 +768,10 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
 
     x = x_init;
 
-    for (i = BLC_ADDRESS; i < BLC_COUNT; i++)
+    for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i == BLC_ADDRESS && !addr) continue;
+        if (i == BLC_PHYSICAL && !phys) continue;
+        if (i == BLC_VIRTUAL && !virt) continue;
         if (i == BLC_BINARY && !code) continue;
 
         draw_segments_of_column(&line->columns[i], cairo, x, y);
@@ -723,7 +790,8 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
 *  Paramètres  : line    = ligne de texte à manipuler.                        *
 *                fd      = flux ouvert en écriture.                           *
 *                type    = type d'exportation attendue.                       *
-*                addr    = indique si les positions doivent être affichées.   *
+*                phys    = indique si les positions doivent être affichées.   *
+*                virt    = indique si les adresses doivent être affichées.    *
 *                code    = indique si le code binaire doit être affiché.      *
 *                content = indique si le gros du contenu doit être affiché.   *
 *                                                                             *
@@ -735,15 +803,16 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_export(GBufferLine *line, int fd, BufferExportType type, bool addr, bool code, bool content)
+void g_buffer_line_export(GBufferLine *line, int fd, BufferExportType type, bool phys, bool virt, bool code, bool content)
 {
     BufferLineColumn i;                     /* Boucle de parcours          */
 
-    for (i = BLC_ADDRESS; i < BLC_COUNT; i++)
+    for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i == BLC_ADDRESS && !addr) continue;
+        if (i == BLC_PHYSICAL && !phys) continue;
+        if (i == BLC_VIRTUAL && !virt) continue;
         if (i == BLC_BINARY && !code) continue;
-        if (!(i == BLC_ADDRESS || i == BLC_BINARY) && !content) continue;
+        if (!(i == BLC_PHYSICAL || i == BLC_VIRTUAL || i == BLC_BINARY) && !content) continue;
 
         dprintf(fd, "TODO\n");
 
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
index 7d48cf3..fa64fe1 100644
--- a/src/glibext/gbufferline.h
+++ b/src/glibext/gbufferline.h
@@ -31,6 +31,7 @@
 
 #include "gbuffersegment.h"
 #include "../arch/archbase.h"
+#include "../arch/vmpa.h"
 
 
 
@@ -53,7 +54,8 @@ typedef struct _GBufferLineClass GBufferLineClass;
 /* Désignation des colonnes d'une ligne */
 typedef enum _BufferLineColumn
 {
-    BLC_ADDRESS,                            /* Adresse virtuelle           */
+    BLC_PHYSICAL,                           /* Position physique           */
+    BLC_VIRTUAL,                            /* Adresse virtuelle           */
     BLC_BINARY,                             /* Contenu sous forme binaire  */
     BLC_ASSEMBLY_HEAD,                      /* Instruction pour assembleur */
     BLC_ASSEMBLY,                           /* Code pour assembleur        */
@@ -81,16 +83,19 @@ typedef enum _BufferLineColumn
 GType g_buffer_line_get_type(void);
 
 /* Crée une nouvelle représentation de fragments de texte. */
-GBufferLine *g_buffer_line_new(vmpa_t, BufferLineColumn);
+GBufferLine *g_buffer_line_new(const vmpa2t *, BufferLineColumn);
 
 /* Indique l'adresse à laquelle se situe la ligne. */
 vmpa_t g_buffer_line_get_address(const GBufferLine *);
 
+/* 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);
+
 /* Ajoute un fragment de texte à une colonne de ligne. */
 void g_buffer_line_add_segment(GBufferLine *, BufferLineColumn, GBufferSegment *) __attribute__ ((deprecated));
 
 /* Déplace le curseur au sein d'une vue de tampon. */
-bool g_buffer_line_move_caret(const GBufferLine *, GdkRectangle *, bool, GdkScrollDirection, bool, bool);
+bool g_buffer_line_move_caret(const GBufferLine *, GdkRectangle *, bool, GdkScrollDirection, bool, bool, bool);
 
 /* Donne le segment présent à une abscisse donnée. */
 GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *, const gint [BLC_COUNT], gint *, bool);
@@ -108,16 +113,16 @@ char *g_buffer_line_get_text(const GBufferLine *);
 gint g_buffer_line_get_column_width(GBufferLine *, BufferLineColumn);
 
 /* Fournit la dernière largeur d'une ligne avec fusion. */
-gint g_buffer_line_get_merge_width(GBufferLine *, BufferLineColumn *, bool, bool);
+gint g_buffer_line_get_merge_width(GBufferLine *, BufferLineColumn *, bool, bool, bool);
 
 /* Définit la colonne à partir de laquelle la fusion opère. */
 void g_buffer_line_start_merge_at(GBufferLine *, BufferLineColumn);
 
 /* Imprime la ligne de texte représentée. */
-void g_buffer_line_draw(GBufferLine *, cairo_t *, const gint [BLC_COUNT], gint, gint, bool, bool);
+void g_buffer_line_draw(GBufferLine *, cairo_t *, const gint [BLC_COUNT], gint, gint, bool, bool, bool);
 
 /* Exporte la ligne de texte représentée. */
-void g_buffer_line_export(GBufferLine *, int, BufferExportType, bool, bool, bool);
+void g_buffer_line_export(GBufferLine *, int, BufferExportType, bool, bool, bool, bool);
 
 
 
diff --git a/src/glibext/gcodebuffer.c b/src/glibext/gcodebuffer.c
index 5be632c..708a089 100644
--- a/src/glibext/gcodebuffer.c
+++ b/src/glibext/gcodebuffer.c
@@ -182,7 +182,7 @@ static void g_buffer_view_reset_required_height(GBufferView *);
 static void g_buffer_view_reset_required_widths(GBufferView *);
 
 /* Calcule les largeurs requises par une visualisation. */
-static void g_buffer_view_compute_required_widths(GBufferView *, bool, bool);
+static void g_buffer_view_compute_required_widths(GBufferView *, bool, bool, bool);
 
 
 
@@ -466,7 +466,7 @@ static size_t g_code_buffer_get_index_from_address(GCodeBuffer *buffer, vmpa_t a
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : buffer = composant GTK à mettre à jour.                      *
-*                addr   = adresse où va se situer la ligne.                   *
+*                addr   = emplacement où va se situer la ligne.               *
 *                                                                             *
 *  Description : Ajoute une nouvelle ligne à un tampon pour code désassemblé. *
 *                                                                             *
@@ -476,7 +476,7 @@ static size_t g_code_buffer_get_index_from_address(GCodeBuffer *buffer, vmpa_t a
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *buffer, vmpa_t addr)
+GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *buffer, const vmpa2t *addr)
 {
     GBufferLine *result;                    /* Instance à retourner        */
     size_t i;                               /* Boucle de parcours          */
@@ -886,7 +886,8 @@ static void g_buffer_view_compute_required_height(GBufferView *view)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view = visualisation à mettre à jour.                        *
-*                addr = indique si les positions doivent être affichées.      *
+*                phys = indique si les positions doivent être affichées.      *
+*                virt = indique si les adresses doivent être affichées.       *
 *                code = indique si le code binaire doit être affiché.         *
 *                                                                             *
 *  Description : Calcule les largeurs requises par une visualisation.         *
@@ -897,7 +898,7 @@ static void g_buffer_view_compute_required_height(GBufferView *view)
 *                                                                             *
 ******************************************************************************/
 
-static void g_buffer_view_compute_required_widths(GBufferView *view, bool addr, bool code)
+static void g_buffer_view_compute_required_widths(GBufferView *view, bool phys, bool virt, bool code)
 {
     GBufferLine **lines;                    /* Liste des lignes à traiter  */
     size_t first;                           /* Première ligne intégrée     */
@@ -930,7 +931,7 @@ static void g_buffer_view_compute_required_widths(GBufferView *view, bool addr,
                 view->max_widths[j] = MAX(view->max_widths[j], width);
             }
 
-            width = g_buffer_line_get_merge_width(lines[i], &merge, addr, code);
+            width = g_buffer_line_get_merge_width(lines[i], &merge, phys, virt, code);
             view->last_width = MAX(view->last_width, width);
             if (merge != BLC_COUNT)
             {
@@ -973,7 +974,8 @@ gint g_buffer_view_get_line_height(GBufferView *view)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view = visualisation à consulter.                            *
-*                addr = indique si les positions doivent être affichées.      *
+*                phys = indique si les positions doivent être affichées.      *
+*                virt = indique si les adresses doivent être affichées.       *
 *                code = indique si le code binaire doit être affiché.         *
 *                                                                             *
 *  Description : Fournit la largeur requise par une visualisation.            *
@@ -984,7 +986,7 @@ gint g_buffer_view_get_line_height(GBufferView *view)
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_view_get_width(GBufferView *view, bool addr, bool code)
+gint g_buffer_view_get_width(GBufferView *view, bool phys, bool virt, bool code)
 {
     gint result;                            /* Taille à retourner          */
     gint col_width;                         /* Calcul selon les colonnes   */
@@ -992,7 +994,7 @@ gint g_buffer_view_get_width(GBufferView *view, bool addr, bool code)
     BufferLineColumn i;                     /* Boucle de parcours          */
 
     if (!WIDTHS_CACHED(view))
-        g_buffer_view_compute_required_widths(view, addr, code);
+        g_buffer_view_compute_required_widths(view, phys, virt, code);
 
     result = view->left_text;
 
@@ -1003,7 +1005,8 @@ gint g_buffer_view_get_width(GBufferView *view, bool addr, bool code)
 
     for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i == BLC_ADDRESS && !addr) continue;
+        if (i == BLC_PHYSICAL && !phys) continue;
+        if (i == BLC_VIRTUAL && !virt) continue;
         if (i == BLC_BINARY && !code) continue;
 
         col_width += view->max_widths[i];
@@ -1017,7 +1020,8 @@ gint g_buffer_view_get_width(GBufferView *view, bool addr, bool code)
 
     for (i = 0; i < view->last_merge; i++)
     {
-        if (i == BLC_ADDRESS && !addr) continue;
+        if (i == BLC_PHYSICAL && !phys) continue;
+        if (i == BLC_VIRTUAL && !virt) continue;
         if (i == BLC_BINARY && !code) continue;
 
         full_width += view->max_widths[i];
@@ -1118,7 +1122,8 @@ vmpa_t g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, size_t
 *                caret = position du curseur à faire évoluer.                 *
 *                ctrl  = indique la demande d'un parcours rapide.             *
 *                dir   = direction du parcours.                               *
-*                addr  = indique si les positions doivent être affichées.     *
+*                phys  = indique si les positions doivent être affichées.     *
+*                virt  = indique si les adresses doivent être affichées.      *
 *                code  = indique si le code binaire doit être affiché.        *
 *                                                                             *
 *  Description : Déplace le curseur au sein d'une vue de tampon.              *
@@ -1129,7 +1134,7 @@ vmpa_t g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, size_t
 *                                                                             *
 ******************************************************************************/
 
-vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool addr, bool code)
+vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool phys, bool virt, bool code)
 {
     bool result;                            /* Actualisation à renvoyer    */
     bool computed;                          /* Récursivité pris en compte  */
@@ -1153,7 +1158,8 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr
         case GDK_SCROLL_LEFT:
         case GDK_SCROLL_RIGHT:
             left_pos = view->left_text;
-            if (addr) left_pos += view->max_widths[BLC_ADDRESS] + COL_MARGIN;
+            if (phys) left_pos += view->max_widths[BLC_PHYSICAL] + COL_MARGIN;
+            if (virt) left_pos += view->max_widths[BLC_VIRTUAL] + COL_MARGIN;
             if (code) left_pos += view->max_widths[BLC_BINARY] + COL_MARGIN;
             right_pos = left_pos;
             for (i = BLC_ASSEMBLY_HEAD; i < BLC_COUNT; i++)
@@ -1184,13 +1190,13 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr
             line = g_buffer_view_find_line_at(view, caret->y, NULL);
             if (line == NULL) break;
 
-            result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_LEFT, addr, code);
+            result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_LEFT, phys, virt, code);
 
             if (caret->x < left_pos)
             {
                 caret->x = right_pos;
 
-                result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_UP, addr, code);
+                result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_UP, phys, virt, code);
 
                 if (result == VMPA_INVALID)
                     caret->x = left_pos;
@@ -1205,13 +1211,13 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr
             line = g_buffer_view_find_line_at(view, caret->y, NULL);
             if (line == NULL) break;
 
-            result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_RIGHT, addr, code);
+            result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_RIGHT, phys, virt, code);
 
             if (!result)
             {
                 caret->x = left_pos;
 
-                result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_DOWN, addr, code);
+                result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_DOWN, phys, virt, code);
 
                 if (result == VMPA_INVALID)
                     caret->x = right_pos;
@@ -1347,7 +1353,8 @@ void g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y)
 *                fake_x = abscisse réelle du point 0 à l'écran.               *
 *                fake_y = ordonnée réelle du point 0 à l'écran.               *
 *                area   = position et surface à traiter.                      *
-*                addr   = indique si les positions doivent être affichées.    *
+*                phys   = indique si les positions doivent être affichées.    *
+*                virt   = indique si les adresses doivent être affichées.     *
 *                code   = indique si le code binaire doit être affiché.       *
 *                                                                             *
 *  Description : Imprime la visualisation du tampon de code désassemblé.      *
@@ -1358,7 +1365,7 @@ void g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y)
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint fake_x, gint fake_y, const cairo_rectangle_int_t *area, bool addr, bool code)
+void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint fake_x, gint fake_y, const cairo_rectangle_int_t *area, bool phys, bool virt, bool code)
 {
     gint real_x;                            /* Abscisse réelle pour tampon */
     gint real_y;                            /* Ordonnée réelle pour tampon */
@@ -1395,7 +1402,7 @@ void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint fake_x, gint
             */
 
             g_buffer_line_draw(lines[i], cr,
-                               view->max_widths, real_x, y, addr, code);
+                               view->max_widths, real_x, y, phys, virt, code);
 
             y += view->line_height;
 
diff --git a/src/glibext/gcodebuffer.h b/src/glibext/gcodebuffer.h
index 18d13f0..3167d41 100644
--- a/src/glibext/gcodebuffer.h
+++ b/src/glibext/gcodebuffer.h
@@ -60,7 +60,7 @@ GCodeBuffer *g_code_buffer_new(BufferLineColumn);
 #define g_code_buffer_append_new_line_fixme(b) g_code_buffer_append_new_line(b, 0ull)
 
 /* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
-GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *, vmpa_t);
+GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *, const vmpa2t *);
 
 /* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
 GBufferLine *g_code_buffer_insert_at(GCodeBuffer *, vmpa_t, bool);
@@ -122,7 +122,7 @@ GCodeBuffer *g_buffer_view_get_buffer(const GBufferView *);
 gint g_buffer_view_get_line_height(GBufferView *);
 
 /* Fournit la largeur requise par une visualisation. */
-gint g_buffer_view_get_width(GBufferView *, bool, bool);
+gint g_buffer_view_get_width(GBufferView *, bool, bool, bool);
 
 /* Fournit la hauteur requise par une visualisation. */
 gint g_buffer_view_get_height(const GBufferView *);
@@ -131,7 +131,7 @@ gint g_buffer_view_get_height(const GBufferView *);
 vmpa_t g_buffer_view_compute_caret(GBufferView *, GBufferLine *, size_t, gint, GdkRectangle *);
 
 /* Déplace le curseur au sein d'une vue de tampon. */
-vmpa_t g_buffer_view_move_caret(GBufferView *, GdkRectangle *, bool, GdkScrollDirection, bool, bool);
+vmpa_t g_buffer_view_move_caret(GBufferView *, GdkRectangle *, bool, GdkScrollDirection, bool, bool, bool);
 
 /* Supprime toute mise en évidence de segments. */
 bool g_buffer_view_unhighlight_segments(GBufferView *);
@@ -140,7 +140,7 @@ bool g_buffer_view_unhighlight_segments(GBufferView *);
 void g_buffer_view_highlight_segments(GBufferView *, gint, gint);
 
 /* Imprime la visualisation du tampon de code désassemblé. */
-void g_buffer_view_draw(const GBufferView *, cairo_t *, gint, gint, const cairo_rectangle_int_t *, bool, bool);
+void g_buffer_view_draw(const GBufferView *, cairo_t *, gint, gint, const cairo_rectangle_int_t *, bool, bool, bool);
 
 /* Fournit la ligne présente à une ordonnée donnée. */
 GBufferLine *g_buffer_view_find_line_at(GBufferView *, gint, size_t *);
diff --git a/src/glibext/signal.h b/src/glibext/signal.h
index 8d139a7..c2a442d 100644
--- a/src/glibext/signal.h
+++ b/src/glibext/signal.h
@@ -26,6 +26,7 @@
 
 
 #include <glib-object.h>
+#include <gobject/gclosure.h>