Created a debugging layout and introduced a heavier use of GLib.

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

10 files changed, 1162 insertions, 588 deletions

diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index df380b5..e5f7689 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -3,6 +3,10 @@ lib_LIBRARIES = libanalysis.a
 
 libanalysis_a_SOURCES =					\
 	line.h line.c						\
+	line-int.h							\
+	line_code.h line_code.c				\
+	line_comment.h line_comment.c		\
+	line_prologue.h line_prologue.c		\
 	prototype.h prototype.c				\
 	variable.h variable.c
 
diff --git a/src/analysis/line-int.h b/src/analysis/line-int.h
new file mode 100644
index 0000000..142230e
--- /dev/null
+++ b/src/analysis/line-int.h
@@ -0,0 +1,88 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line-int.h - prototypes pour l'interface des représentations des lignes de rendu
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_LINE_INT_H
+#define _ANALYSIS_LINE_INT_H
+
+
+#include "line.h"
+
+
+#include "../common/dllist.h"
+
+
+
+/* Méthode de mise à jour du nombre d'octets maximal par instruction. */
+typedef void (* get_bin_len_fc) (GRenderingLine *, off_t *);
+
+/* Méthode de mise à jour d'une ligne de représentation. */
+typedef void (* refresh_markup_fc) (GRenderingLine *);
+
+
+/* Ligne de représentation générique (instance) */
+struct _GRenderingLine
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    DL_LIST_ITEM(link);                     /* Maillon de liste chaînée    */
+
+    uint64_t offset;                        /* Position en mémoire/physique*/
+
+    RenderingLineType type;                 /* Type de représentation      */
+    RenderingLineFlag flags;                /* Extension d'informations    */
+
+    PangoLayout *layout;                    /* Moteur de rendu du code/txt */
+
+    get_bin_len_fc get_bin_len;             /* Nbre d'octets représentés   */
+    off_t max_bin_len;                      /* Nombre global maximal       */
+
+    refresh_markup_fc refresh_markup;       /* Reconstruit la représentat° */
+
+};
+
+
+#define lines_list_next_iter(iter, head) dl_list_next_iter(iter, head, GRenderingLine, link)
+#define lines_list_add_tail(new, head) dl_list_add_tail(new, head, GRenderingLine, link)
+#define lines_list_splice_before(pos, head1, head2) dl_list_splice_before(pos, head1, head2, GRenderingLine, link)
+#define lines_list_for_each(pos, head) dl_list_for_each(pos, head, GRenderingLine, link)
+
+
+/* Ligne de représentation générique (classe) */
+struct _GRenderingLineClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+    /* Signaux */
+
+    void (* rendering_line_flags_changed) (GRenderingLine *);
+
+};
+
+
+
+/* Taille max d'une traduction */
+#define CODE_BUFFER_LEN 128
+
+
+
+#endif  /* _ANALYSIS_LINE_INT_H */
diff --git a/src/analysis/line.c b/src/analysis/line.c
index 21f0fd5..4fc0ac5 100644
--- a/src/analysis/line.c
+++ b/src/analysis/line.c
@@ -24,6 +24,10 @@
 #include "line.h"
 
 
+#include "line-int.h"
+
+
+
 #include <malloc.h>
 #include <stdio.h>
 #include <string.h>
@@ -40,121 +44,49 @@ extern GtkWidget *mywid;
 
 
 
+/* Initialise la classe des lignes de représentation. */
+static void g_rendering_line_class_init(GRenderingLineClass *);
 
+/* Initialise une instance de ligne de représentation. */
+static void g_rendering_line_init(GRenderingLine *);
 
-/* Méthode de mise à jour du nombre d'octets maximal par instruction. */
-typedef void (* get_bin_len_fc) (rendering_line *, off_t *);
-
-/* Méthode de mise à jour d'une ligne de représentation. */
-typedef void (* refresh_markup_fc) (rendering_line *);
-
-
-
-/* Ligne de représentation générique */
-struct _rendering_line
-{
-    DL_LIST_ITEM(link);                     /* Maillon de liste chaînée    */
-
-    uint64_t offset;                        /* Position en mémoire/physique*/
-
-    RenderingLineType type;                 /* Type de représentation      */
-    RenderingLineFlag flags;                /* Extension d'informations    */
-
-    PangoLayout *layout;                    /* Moteur de rendu du code/txt */
-
-    get_bin_len_fc get_bin_len;             /* Nbre d'octets représentés   */
-    off_t max_bin_len;                      /* Nombre global maximal       */
-
-    refresh_markup_fc refresh_markup;       /* Reconstruit la représentat° */
-
-};
-
-
-#define RENDERING_LINE(l) ((rendering_line *)l)
-
-
-#define lines_list_next_iter(iter, head) dl_list_next_iter(iter, head, rendering_line, link)
-#define lines_list_add_tail(new, head) dl_list_add_tail(new, head, rendering_line, link)
-#define lines_list_splice_before(pos, head1, head2) dl_list_splice_before(pos, head1, head2, rendering_line, link)
-#define lines_list_for_each(pos, head) dl_list_for_each(pos, head, rendering_line, link)
-
-
-/* Procède à l'initialisation des bases d'une représentation. */
-void init_rendering_line(rendering_line *);
-
-
-
-/* ------------------------- LIGNE EN TETE DE DESASSEMBLAGE ------------------------- */
-
-
-/* Ligne de représentation de prologue */
-typedef struct _prologue_line
-{
-    rendering_line basic;                   /* A laisser en premier        */
-
-    char *comment;                          /* Texte à afficher            */
-
-} prologue_line;
-
-
-/* Met à jour la ligne de représentation de prologue. */
-void refresh_prologue_markup(prologue_line *);
-
-
-
-/* ----------------------- COMMENTAIRES SUR UNE LIGNE ENTIERE ----------------------- */
-
-
-/* Ligne de commantaires entière */
-typedef struct _comment_line
-{
-    rendering_line basic;                   /* A laisser en premier        */
-
-    char *comment;                          /* Texte à afficher            */
-    const disass_options *options;          /* Options de représentation   */
-
-} comment_line;
 
 
-/* Met à jour la ligne de représentation de commentaires. */
-void refresh_comment_markup(comment_line *);
+/* Indique le type définit pour une ligne de représentation. */
+G_DEFINE_TYPE(GRenderingLine, g_rendering_line, G_TYPE_OBJECT);
 
 
 
-/* ------------------------ LIGNE DE CODE EN LANGAGE MACHINE ------------------------ */
-
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des lignes de représentation.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-/* Ligne de représentation de prologue */
-typedef struct _code_line
+static void g_rendering_line_class_init(GRenderingLineClass *klass)
 {
-    rendering_line basic;                   /* A laisser en premier        */
-
-    asm_instr *instr;                       /* Instruction représentée     */
-    const disass_options *options;          /* Options de représentation   */
-
-} code_line;
-
-
-/* Taille max d'une traduction */
-#define CODE_BUFFER_LEN 128
-
-
-/* Met à jour la nombre d'octets maximale par instruction. */
-void get_code_binary_len(code_line *, off_t *);
-
-/* Met à jour la ligne de représentation de code. */
-void refresh_code_markup(code_line *);
-
-
-
+    g_signal_new("rendering-line-flags-changed",
+                 G_TYPE_RENDERING_LINE,
+                 G_SIGNAL_RUN_LAST,
+                 G_STRUCT_OFFSET(GRenderingLineClass, rendering_line_flags_changed),
+                 NULL, NULL,
+                 g_cclosure_marshal_VOID__VOID,
+                 G_TYPE_NONE, 0, NULL);
 
+}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = adresse de la structure commune.                      *
+*  Paramètres  : line = instance à initialiser.                               *
 *                                                                             *
-*  Description : Procède à l'initialisation des bases d'une représentation.   *
+*  Description : Initialise une instance de ligne de représentation.          *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -162,7 +94,7 @@ void refresh_code_markup(code_line *);
 *                                                                             *
 ******************************************************************************/
 
-void init_rendering_line(rendering_line *line)
+static void g_rendering_line_init(GRenderingLine *line)
 {
     DL_LIST_ITEM_INIT(&line->link);
 
@@ -171,8 +103,25 @@ void init_rendering_line(rendering_line *line)
     line->get_bin_len = NULL;
     line->refresh_markup = NULL;
 
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne dont les informations sont à consulter.         *
+*                                                                             *
+*  Description : Fournit le type d'une ligne.                                 *
+*                                                                             *
+*  Retour      : Type de la ligne fournie.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+RenderingLineType get_rendering_line_type(const GRenderingLine *line)
+{
+    return line->type;
+
 }
 
 
@@ -189,10 +138,12 @@ void init_rendering_line(rendering_line *line)
 *                                                                             *
 ******************************************************************************/
 
-void add_rendering_line_flag(rendering_line *line, RenderingLineFlag flag)
+void g_rendering_line_add_flag(GRenderingLine *line, RenderingLineFlag flag)
 {
     line->flags |= flag;
 
+    g_signal_emit_by_name(line, "rendering-line-flags-changed");
+
 }
 
 
@@ -209,61 +160,67 @@ void add_rendering_line_flag(rendering_line *line, RenderingLineFlag flag)
 *                                                                             *
 ******************************************************************************/
 
-void remove_rendering_line_flag(rendering_line *line, RenderingLineFlag flag)
+void g_rendering_line_remove_flag(GRenderingLine *line, RenderingLineFlag flag)
 {
     line->flags &= ~flag;
 
+    g_signal_emit_by_name(line, "rendering-line-flags-changed");
+
 }
 
 
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line = ligne dont les informations sont à mettre à jour.     *
+*                flag = extension d'information à ajouter ou retirer.         *
 *                                                                             *
-*  Description : Fournit les informations supplémentaires d'une ligne.        *
+*  Description : Bascule l'état d'une information sur d'une ligne.            *
 *                                                                             *
-*  Retour      : Extensions d'informations courantes.                         *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-RenderingLineFlag get_rendering_line_flags(const rendering_line *line)
+void g_rendering_line_toggle_flag(GRenderingLine *line, RenderingLineFlag flag)
 {
-    return line->flags;
-
-}
+    line->flags = (line->flags & ~flag) | (line->flags ^ flag);
 
+    g_signal_emit_by_name(line, "rendering-line-flags-changed");
 
+}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : lines = liste de lignes à compléter, ou NULL.                *
-*                line  = nouvelle ligne à intégrer à l'ensemble.              *
+*  Paramètres  : line = ligne dont les informations sont à consulter.         *
 *                                                                             *
-*  Description : Ajoute une ligne à un ensemble existant.                     *
+*  Description : Fournit les informations supplémentaires d'une ligne.        *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Extensions d'informations courantes.                         *
 *                                                                             *
-*  Remarques   : La ligne est considérée comme étant insérée au bon endroit.  *
+*  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void add_line_to_rendering_lines(rendering_line **lines, rendering_line *line)
+RenderingLineFlag g_rendering_line_get_flags(const GRenderingLine *line)
 {
-    lines_list_add_tail(line, lines);
+    return line->flags;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : lines = liste de lignes à compléter, ou NULL.                *
-*                line  = nouvelle ligne à intégrer à l'ensemble.              *
-*                first = position de la ligne en cas d'adresse partagée.      *
+*  Paramètres  : line     = adresse de la structure à représenter.            *
+*                drawable = support de rendu pour le dessin.                  *
+*                gc       = contexte graphique à utiliser.                    *
+*                x0       = abscisse de la zone de rendu (marge).             *
+*                x1       = abscisse de la zone de rendu (texte).             *
+*                y        = ordonnée de la zone de rendu.                     *
+*                h        = hauteur réservée pour la ligne.                   *
 *                                                                             *
-*  Description : Insère une ligne dans un ensemble existant.                  *
+*  Description : Procède à l'initialisation des bases d'une représentation.   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -271,70 +228,83 @@ void add_line_to_rendering_lines(rendering_line **lines, rendering_line *line)
 *                                                                             *
 ******************************************************************************/
 
-void insert_line_into_rendering_lines(rendering_line **lines, rendering_line *line, bool first)
+void g_rendering_line_draw(GRenderingLine *line, GdkDrawable *drawable, GdkGC *gc, gint x0, gint x1, gint y, gint h)
 {
-    rendering_line *iter;                   /* Boucle de parcours          */
+    GdkPixbuf *pixbuf;                      /* Données utiles au dessin    */
 
-    lines_list_for_each(iter, *lines)
+    gdk_draw_layout(drawable, gc, x1, y, line->layout);
+
+    if (line->flags & RLF_BREAK_POINT)
+        pixbuf = gtk_widget_render_icon(mywid, "gtk-yes", GTK_ICON_SIZE_MENU, NULL);
+
+    else if (line->flags & RLF_RUNNING_BP)
+        pixbuf = gtk_widget_render_icon(mywid, "gtk-no", GTK_ICON_SIZE_MENU, NULL);
+
+    else pixbuf = NULL;
+
+    if (pixbuf != NULL)
     {
-        if (first && iter->offset >= line->offset) break;
-        else if (!first)
-        {
-            /* TODO */;
-        }
+        gdk_draw_pixbuf(drawable, gc, pixbuf, 0, 0, x0, y,
+                        gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+                        GDK_RGB_DITHER_NORMAL, 0, 0);
+
+        g_object_unref(pixbuf);
 
     }
 
-    if (iter == NULL)
-        lines_list_add_tail(line, lines);
+    /* Le point d'entrée prime */
 
-    else
+    if (line->flags & RLF_ENTRY_POINT)
+        pixbuf = gtk_widget_render_icon(mywid, "gtk-go-forward", GTK_ICON_SIZE_MENU, NULL);
+
+    else pixbuf = NULL;
+
+    if (pixbuf != NULL)
     {
-        if (first)
-            lines_list_splice_before(iter, lines, line);
-        else
-            /* TODO */;
+        gdk_draw_pixbuf(drawable, gc, pixbuf, 0, 0, x0, y,
+                        gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+                        GDK_RGB_DITHER_NORMAL, 0, 0);
+
+        g_object_unref(pixbuf);
+
     }
 
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                          TRAITEMENT DES LIGNES PAR GROUPE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : lines  = liste de lignes à parcourir.                        *
-*                offset = position en mémoire ou physique à chercher.         *
+*  Paramètres  : lines = liste de lignes à compléter, ou NULL.                *
+*                line  = nouvelle ligne à intégrer à l'ensemble.              *
 *                                                                             *
-*  Description : Recherche une ligne d'après sa position en mémoire/physique. *
+*  Description : Ajoute une ligne à un ensemble existant.                     *
 *                                                                             *
-*  Retour      : Ligne représentant l'adresse donnée, NULL si aucune trouvée. *
+*  Retour      : -                                                            *
 *                                                                             *
-*  Remarques   : -                                                            *
+*  Remarques   : La ligne est considérée comme étant insérée au bon endroit.  *
 *                                                                             *
 ******************************************************************************/
 
-rendering_line *find_offset_in_rendering_lines(rendering_line *lines, uint64_t offset)
+void g_rendering_line_add_to_lines(GRenderingLine **lines, GRenderingLine *line)
 {
-    rendering_line *result;
-
-    lines_list_for_each(result, lines)
-        if (result->offset == offset) break;
-
-    return result;
+    lines_list_add_tail(line, lines);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line     = adresse de la structure à représenter.            *
-*                drawable = support de rendu pour le dessin.                  *
-*                gc       = contexte graphique à utiliser.                    *
-*                x0       = abscisse de la zone de rendu (marge).             *
-*                x1       = abscisse de la zone de rendu (texte).             *
-*                y        = ordonnée de la zone de rendu.                     *
-*                h        = hauteur réservée pour la ligne.                   *
+*  Paramètres  : lines = liste de lignes à compléter, ou NULL.                *
+*                line  = nouvelle ligne à intégrer à l'ensemble.              *
+*                first = position de la ligne en cas d'adresse partagée.      *
 *                                                                             *
-*  Description : Procède à l'initialisation des bases d'une représentation.   *
+*  Description : Insère une ligne dans un ensemble existant.                  *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -342,36 +312,34 @@ rendering_line *find_offset_in_rendering_lines(rendering_line *lines, uint64_t o
 *                                                                             *
 ******************************************************************************/
 
-void draw_rendering_line(rendering_line *line, GdkDrawable *drawable, GdkGC *gc, gint x0, gint x1, gint y, gint h)
+void g_rendering_line_insert_into_lines(GRenderingLine **lines, GRenderingLine *line, bool first)
 {
-    GdkPixbuf *pixbuf;                      /* Données utiles au dessin    */
+    GRenderingLine *iter;                   /* Boucle de parcours          */
 
-    gdk_draw_layout(drawable, gc, x1, y, line->layout);
+    lines_list_for_each(iter, *lines)
+    {
+        if (first && iter->offset >= line->offset) break;
+        else if (!first)
+        {
+            /* TODO */;
+        }
 
-    if (line->flags & RLF_ENTRY_POINT)
-        pixbuf = gtk_widget_render_icon(mywid, "gtk-go-forward", GTK_ICON_SIZE_MENU, NULL);
+    }
 
-    else pixbuf = NULL;
+    if (iter == NULL)
+        lines_list_add_tail(line, lines);
 
-    if (pixbuf != NULL)
+    else
     {
-        gdk_draw_pixbuf(drawable, gc, pixbuf, 0, 0, x0, y,
-                        gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
-                        GDK_RGB_DITHER_NORMAL, 0, 0);
-
-        g_object_unref(pixbuf);
-
+        if (first)
+            lines_list_splice_before(iter, lines, line);
+        else
+            /* TODO */;
     }
 
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                          TRAITEMENT DES LIGNES PAR GROUPE                          */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line = liste de lignes de représentation à actualiser.       *
@@ -385,9 +353,9 @@ void draw_rendering_line(rendering_line *line, GdkDrawable *drawable, GdkGC *gc,
 *                                                                             *
 ******************************************************************************/
 
-rendering_line *g_rendering_line_get_next_iter(rendering_line *lines, const rendering_line *iter)
+GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *lines, const GRenderingLine *iter)
 {
-    rendering_line *result;                 /* Elément suivant à renvoyer  */
+    GRenderingLine *result;                 /* Elément suivant à renvoyer  */
 
     if (iter == NULL) iter = lines;
 
@@ -410,9 +378,9 @@ rendering_line *g_rendering_line_get_next_iter(rendering_line *lines, const rend
 *                                                                             *
 ******************************************************************************/
 
-void g_rendering_lines_update_bin_len(rendering_line *lines)
+void g_rendering_line_update_bin_len(GRenderingLine *lines)
 {
-    rendering_line *iter;                   /* Boucle de parcours          */
+    GRenderingLine *iter;                   /* Boucle de parcours          */
     off_t bin_len;                          /* Taille d'instruction        */
 
     bin_len = 0;
@@ -445,9 +413,9 @@ void g_rendering_lines_update_bin_len(rendering_line *lines)
 *                                                                             *
 ******************************************************************************/
 
-void g_rendering_lines_get_size(rendering_line *lines, int *width, int *height, int *alone)
+void g_rendering_line_get_size(GRenderingLine *lines, int *width, int *height, int *alone)
 {
-    rendering_line *iter;                   /* Boucle de parcours          */
+    GRenderingLine *iter;                   /* Boucle de parcours          */
     int w;                                  /* Largeur de l'objet actuelle */
     int h;                                  /* Hauteur de l'objet actuelle */
 
@@ -470,399 +438,58 @@ void g_rendering_lines_get_size(rendering_line *lines, int *width, int *height,
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                           LIGNE EN TETE DE DESASSEMBLAGE                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : comment = texte à afficher au final.                         *
-*                                                                             *
-*  Description : Crée une des lignes de description initiales.                *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-rendering_line *create_prologue_line(const char *comment)
-{
-    prologue_line *result;                  /* Structure à retourner       */
-
-    result = (prologue_line *)calloc(1, sizeof(prologue_line));
-
-    init_rendering_line(RENDERING_LINE(result));
-
-    RENDERING_LINE(result)->offset = 0;
-
-    RENDERING_LINE(result)->type = RLT_PROLOGUE;
-
-    RENDERING_LINE(result)->refresh_markup = (refresh_markup_fc)refresh_prologue_markup;
-
-    result->comment = strdup(comment);
-
-    return RENDERING_LINE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line = ligne de représentation à actualiser.                 *
-*                                                                             *
-*  Description : Met à jour la ligne de représentation de prologue.           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void refresh_prologue_markup(prologue_line *line)
-{
-    size_t len;                             /* Taille du contenu           */
-    char *content;                          /* Contenu réellement imprimé  */
-
-    len = strlen("<b><span foreground='#003300'>");
-    len += strlen("; ") + strlen(line->comment);
-    len += strlen("</span></b>");
-
-    content = (char *)calloc(len + 1, sizeof(char));
-
-    snprintf(content, len + 1, "<b><span foreground='#003300'>; %s</span></b>", line->comment);
-
-    pango_layout_set_markup(RENDERING_LINE(line)->layout, content, len);
-
-    free(content);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                         COMMENTAIRES SUR UNE LIGNE ENTIERE                         */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : offset  = position dans la mémoire ou le fichier.            *
-*                type    = type du commentaire.                               *
-*                comment = texte à afficher au final.                         *
-*                options = paramétrage du rendu.                              *
+*  Paramètres  : lines = liste de lignes à parcourir.                         *
+*                y     = ordonnée à vérifier et à mettre à jour. [OUT]        *
 *                                                                             *
-*  Description : Crée une ligne de commentaires entière.                      *
+*  Description : Recherche une ligne d'après sa position à l'écran.           *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-rendering_line *create_comment_line(uint64_t offset, RenderingLineType type, const char *comment, const disass_options *options)
-{
-    comment_line *result;                   /* Structure à retourner       */
-
-    result = (comment_line *)calloc(1, sizeof(comment_line));
-
-    init_rendering_line(RENDERING_LINE(result));
-
-    RENDERING_LINE(result)->offset = offset;
-
-    RENDERING_LINE(result)->type = type;
-
-    RENDERING_LINE(result)->refresh_markup = (refresh_markup_fc)refresh_comment_markup;
-
-    result->comment = strdup(comment);
-    result->options = options;
-
-    return RENDERING_LINE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line = ligne de représentation à actualiser.                 *
-*                                                                             *
-*  Description : Met à jour la ligne de représentation de commentaires.       *
-*                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Ligne représentant l'adresse donnée, NULL si aucune trouvée. *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void refresh_comment_markup(comment_line *line)
+GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, gdouble *y)
 {
-    size_t len;                             /* Taille du contenu           */
-    char *content;                          /* Contenu réellement imprimé  */
-    char buffer[CODE_BUFFER_LEN];           /* Zone tampon à utiliser      */
-    size_t clen;                            /* Taille du commentaire       */
-
-    len = strlen("<tt>") + 1;
-    content = (char *)calloc(len, sizeof(char));
-    strcpy(content, "<tt>");
+    GRenderingLine *result;                 /* Trouvaille à retourner      */
+    int h;                                  /* Hauteur de l'objet actuel   */
 
-    /* Eventuelle adresse virtuelle */
-
-    if (line->options->show_address)
-    {
-        switch (ADM_32BITS  /* FIXME */)
-        {
-            case ADM_32BITS:
-                snprintf(buffer, CODE_BUFFER_LEN,
-                         "<span foreground='#333333'>0x%08llx</span>",
-                         RENDERING_LINE(line)->offset);
-                break;
-
-            case ADM_64BITS:
-                snprintf(buffer, CODE_BUFFER_LEN,
-                         "<span foreground='#333333'>0x%16llx</span>",
-                         RENDERING_LINE(line)->offset);
-                break;
-
-        }
-
-        len += strlen(buffer);
-        content = (char *)realloc(content, len * sizeof(char));
-        strcat(content, buffer);
-
-    }
-
-    /* Eventuel code brut (sauté) */
-
-    if (line->options->show_code)
+    lines_list_for_each(result, lines)
     {
-        clen = (line->options->show_address ? strlen("\t") : 0);
-        clen += RENDERING_LINE(line)->max_bin_len;
-
-        content = (char *)realloc(content, (len + clen) * sizeof(char));
+        pango_layout_get_pixel_size(result->layout, NULL, &h);
 
-        if (line->options->show_address)
-        {
-            strcat(content, "\t");
-            len += strlen("\t");
-        }
-
-        memset(&content[len - 1], RENDERING_LINE(line)->type == RLT_PROTOTYPE ? '-' : ' ',
-               RENDERING_LINE(line)->max_bin_len);
-        len += RENDERING_LINE(line)->max_bin_len;
-
-        content[len] = '\0';
+        if (*y < h) break;
+        else *y -= h;
 
     }
 
-    /* Commentaire proprement dit */
-
-    clen = (line->options->show_address || line->options->show_code ? strlen("\t") : 0);
-    clen += strlen("<b><span foreground='#003300'>");
-    clen += strlen("; ") + strlen(line->comment);
-    clen += strlen("</span></b>");
-
-    content = (char *)realloc(content, (len + clen) * sizeof(char));
-
-    if (line->options->show_address || line->options->show_code)
-    {
-        strcat(content, "\t");
-        len += strlen("\t");
-        clen -= strlen("\t");
-    }
-
-    snprintf(&content[len - 1], clen + 1, "<b><span foreground='#003300'>; %s</span></b>", line->comment);
-
-    len += clen;
-
-    /* Finalisation */
-
-    len += strlen("</tt>");
-    content = (char *)realloc(content, len * sizeof(char));
-    strcat(content, "</tt>");
-
-    pango_layout_set_markup(RENDERING_LINE(line)->layout, content, len - 1);
-
-    free(content);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          LIGNE DE CODE EN LANGAGE MACHINE                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction à représenter.                         *
-*                options = paramétrage du rendu.                              *
-*                                                                             *
-*  Description : Crée une ligne de représentation de code binaire.            *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-rendering_line *create_code_line(asm_instr *instr, uint64_t offset, const disass_options *options)
-{
-    code_line *result;                      /* Structure à retourner       */
-
-    result = (code_line *)calloc(1, sizeof(code_line));
-
-    init_rendering_line(RENDERING_LINE(result));
-
-    RENDERING_LINE(result)->offset = offset;
-
-    RENDERING_LINE(result)->type = RLT_CODE;
-
-    RENDERING_LINE(result)->get_bin_len = (get_bin_len_fc)get_code_binary_len;
-    RENDERING_LINE(result)->refresh_markup = (refresh_markup_fc)refresh_code_markup;
-
-    result->instr = instr;
-    result->options = options;
-
-    return RENDERING_LINE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line = ligne de représentation à actualiser.                 *
-*                blen = longueur maximale à mettre à jour. [OUT]              *
-*                                                                             *
-*  Description : Met à jour le nombre d'octets maximal par instruction.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void get_code_binary_len(code_line *line, off_t *blen)
-{
-    off_t len;                              /* Taille propre à la ligne    */
-
-    get_asm_instr_offset_and_length(line->instr, NULL, &len);
-
-    *blen = MAX(*blen, len);
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = ligne de représentation à actualiser.                 *
+*  Paramètres  : lines  = liste de lignes à parcourir.                        *
+*                offset = position en mémoire ou physique à chercher.         *
 *                                                                             *
-*  Description : Met à jour la ligne de représentation de code.               *
+*  Description : Recherche une ligne d'après sa position en mémoire/physique. *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Ligne représentant l'adresse donnée, NULL si aucune trouvée. *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void refresh_code_markup(code_line *line)
+GRenderingLine *g_rendering_line_find_by_offset(GRenderingLine *lines, uint64_t offset)
 {
-    size_t len;                             /* Taille du contenu           */
-    char *content;                          /* Contenu réellement imprimé  */
-    off_t bin_offset;                       /* Début de l'instruction      */
-    off_t bin_len;                          /* Taille d'instruction        */
-    char buffer[CODE_BUFFER_LEN];           /* Zone tampon à utiliser      */
-    const uint8_t *exe_content;             /* Contenu binaire global      */
-    char *bin_code;                         /* Tampon du code binaire      */
-    off_t k;                                /* Boucle de parcours #2       */
-    off_t j;                                /* Boucle de parcours #1       */
-
-    len = strlen("<tt>") + 1;
-    content = (char *)calloc(len, sizeof(char));
-    strcpy(content, "<tt>");
-
-    if (line->options->show_code)
-        get_asm_instr_offset_and_length(line->instr, &bin_offset, &bin_len);
-
-    /* Eventuelle adresse virtuelle */
-
-    if (line->options->show_address)
-    {
-        switch (ADM_32BITS  /* FIXME */)
-        {
-            case ADM_32BITS:
-                snprintf(buffer, CODE_BUFFER_LEN,
-                         "<span foreground='#333333'>0x%08llx</span>",
-                         RENDERING_LINE(line)->offset);
-                break;
-
-            case ADM_64BITS:
-                snprintf(buffer, CODE_BUFFER_LEN,
-                         "<span foreground='#333333'>0x%16llx</span>",
-                         RENDERING_LINE(line)->offset);
-                break;
-
-        }
+    GRenderingLine *result;                 /* Trouvaille à retourner      */
 
-        len += strlen(buffer);
-        content = (char *)realloc(content, len * sizeof(char));
-        strcat(content, buffer);
-
-    }
-
-    /* Eventuel code brut */
-
-    if (line->options->show_code)
-    {
-        exe_content = get_exe_content(line->options->format, NULL);
-
-        bin_code = (char *)calloc(RENDERING_LINE(line)->max_bin_len + 1, sizeof(char));
-
-        k = 0;
-
-        for (j = 0; j < bin_len; j++)
-        {
-            if ((j + 1) < bin_len)
-                k += snprintf(&bin_code[j * (2 + 1)], 4, "%02hhx ", exe_content[bin_offset + j]);
-            else
-                k += snprintf(&bin_code[j * (2 + 1)], 3, "%02hhx", exe_content[bin_offset + j]);
-        }
- 
-        for (; k < RENDERING_LINE(line)->max_bin_len; k++)
-            snprintf(&bin_code[k], 2, " ");
-
-        if (line->options->show_address) len += strlen("\t");
-        len += strlen(bin_code);
-        content = (char *)realloc(content, len * sizeof(char));
-        if (line->options->show_address) strcat(content, "\t");
-        strcat(content, bin_code);
-
-        free(bin_code);
-
-    }
-
-    /* Instruction proprement dite */
-
-    print_hinstruction(line->options->proc, line->options->format,
-                       line->instr, buffer, CODE_BUFFER_LEN, ASX_INTEL/*FIXME*/);
-
-    if (line->options->show_address || line->options->show_code) len += strlen("\t");
-    len += strlen(buffer);
-
-    content = (char *)realloc(content, len * sizeof(char));
-    if (line->options->show_address || line->options->show_code) strcat(content, "\t");
-    strcat(content, buffer);
-
-    /* Finalisation */
-
-    len += strlen("</tt>");
-    content = (char *)realloc(content, len * sizeof(char));
-    strcat(content, "</tt>");
-
-    pango_layout_set_markup(RENDERING_LINE(line)->layout, content, len - 1);
+    lines_list_for_each(result, lines)
+        if (result->offset == offset) break;
 
-    free(content);
+    return result;
 
 }
diff --git a/src/analysis/line.h b/src/analysis/line.h
index abb2757..0213cab 100644
--- a/src/analysis/line.h
+++ b/src/analysis/line.h
@@ -48,7 +48,8 @@ typedef enum _RenderingLineFlag
 {
     RLF_NONE            = (0 << 0),         /* Ligne commune               */
     RLF_ENTRY_POINT     = (1 << 0),         /* Point d'entrée du prgm.     */
-    RLF_BREAK_POINT     = (1 << 1)          /* Point d'arrêt               */
+    RLF_BREAK_POINT     = (1 << 1),         /* Point d'arrêt               */
+    RLF_RUNNING_BP      = (1 << 2)          /* Point d'arrêt activé        */
 
 } RenderingLineFlag;
 
@@ -65,76 +66,65 @@ typedef struct _disass_options
 
 
 
-/* Ligne de représentation générique */
-typedef struct _rendering_line rendering_line;
+#define G_TYPE_RENDERING_LINE               g_rendering_line_get_type()
+#define G_RENDERING_LINE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_rendering_line_get_type(), GRenderingLine))
+#define G_IS_RENDERING_LINE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_rendering_line_get_type()))
+#define G_RENDERING_LINE_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_rendering_line_get_type(), GRenderingLineIface))
 
 
-/* Ajoute une information supplémentaire à une ligne. */
-void add_rendering_line_flag(rendering_line *, RenderingLineFlag);
-
-/* Retire une information supplémentaire d'une ligne. */
-void remove_rendering_line_flag(rendering_line *, RenderingLineFlag);
-
-/* Fournit les informations supplémentaires d'une ligne. */
-RenderingLineFlag get_rendering_line_flags(const rendering_line *);
+/* Ligne de représentation générique (instance) */
+typedef struct _GRenderingLine GRenderingLine;
 
+/* Ligne de représentation générique (classe) */
+typedef struct _GRenderingLineClass GRenderingLineClass;
 
 
+/* Indique le type définit pour une ligne de représentation. */
+GType g_rendering_line_get_type(void);
 
-/* Ajoute une ligne à un ensemble existant. */
-void add_line_to_rendering_lines(rendering_line **, rendering_line *);
+/* Fournit le type d'une ligne. */
+RenderingLineType get_rendering_line_type(const GRenderingLine *);
 
-/* Insère une ligne dans un ensemble existant.  */
-void insert_line_into_rendering_lines(rendering_line **, rendering_line *, bool);
+/* Ajoute une information supplémentaire à une ligne. */
+void g_rendering_line_add_flag(GRenderingLine *, RenderingLineFlag);
 
-/* Recherche une ligne d'après sa position en mémoire/physique. */
-rendering_line *find_offset_in_rendering_lines(rendering_line *, uint64_t);
+/* Retire une information supplémentaire d'une ligne. */
+void g_rendering_line_remove_flag(GRenderingLine *, RenderingLineFlag);
 
+/* Bascule l'état d'une information sur d'une ligne. */
+void g_rendering_line_toggle_flag(GRenderingLine *, RenderingLineFlag);
 
+/* Fournit les informations supplémentaires d'une ligne. */
+RenderingLineFlag g_rendering_line_get_flags(const GRenderingLine *);
 
 /* Procède à l'initialisation des bases d'une représentation. */
-void draw_rendering_line(rendering_line *, GdkDrawable *, GdkGC *, gint, gint, gint, gint);
+void g_rendering_line_draw(GRenderingLine *, GdkDrawable *, GdkGC *, gint, gint, gint, gint);
 
 
 
 /* ------------------------ TRAITEMENT DES LIGNES PAR GROUPE ------------------------ */
 
 
+/* Ajoute une ligne à un ensemble existant. */
+void g_rendering_line_add_to_lines(GRenderingLine **, GRenderingLine *);
+
+/* Insère une ligne dans un ensemble existant.  */
+void g_rendering_line_insert_into_lines(GRenderingLine **, GRenderingLine *, bool);
+
 /* Fournit l'élement suivant un autre pour un parcours. */
-rendering_line *g_rendering_line_get_next_iter(rendering_line *, const rendering_line *);
+GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *, const GRenderingLine *);
 
 /* Met à jour le nombre d'octets maximal par instruction. */
-void g_rendering_lines_update_bin_len(rendering_line *);
+void g_rendering_line_update_bin_len(GRenderingLine *);
 
 /* Fournit les dimensions de lignes de représentation. */
-void g_rendering_lines_get_size(rendering_line *, int *, int *, int *);
-
-
-
-/* ------------------------- LIGNE EN TETE DE DESASSEMBLAGE ------------------------- */
-
-
-/* Crée une des lignes de description initiales. */
-rendering_line *create_prologue_line(const char *);
-
-
-
-/* ----------------------- COMMENTAIRES SUR UNE LIGNE ENTIERE ----------------------- */
-
-
-/* Crée une ligne de commentaires entière. */
-rendering_line *create_comment_line(uint64_t, RenderingLineType, const char *, const disass_options *);
-
-
-
-/* ------------------------ LIGNE DE CODE EN LANGAGE MACHINE ------------------------ */
-
-
-/* Crée une ligne de représentation de code binaire. */
-rendering_line *create_code_line(asm_instr *, uint64_t, const disass_options *);
-
+void g_rendering_line_get_size(GRenderingLine *, int *, int *, int *);
 
+/* Recherche une ligne d'après sa position à l'écran. */
+GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *, gdouble *);
 
+/* Recherche une ligne d'après sa position en mémoire/physique. */
+GRenderingLine *g_rendering_line_find_by_offset(GRenderingLine *, uint64_t);
 
 
 
diff --git a/src/analysis/line_code.c b/src/analysis/line_code.c
new file mode 100644
index 0000000..2dd5a7c
--- /dev/null
+++ b/src/analysis/line_code.c
@@ -0,0 +1,283 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_code.c - représentation des lignes de code binaire.
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "line_code.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "line-int.h"
+
+
+
+/* Ligne de représentation de code binaire (instance) */
+struct _GCodeLine
+{
+    GRenderingLine parent;                  /* Instance parente            */
+
+    asm_instr *instr;                       /* Instruction représentée     */
+    const disass_options *options;          /* Options de représentation   */
+
+};
+
+
+/* Ligne de représentation de code binaire (classe) */
+struct _GCodeLineClass
+{
+    GRenderingLineClass parent;             /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des lignes de code binaire. */
+static void g_code_line_class_init(GCodeLineClass *);
+
+/* Initialise la classe des lignes de code binaire. */
+static void g_code_line_init(GCodeLine *);
+
+/* Met à jour le nombre d'octets maximal par instruction. */
+void g_code_line_get_binary_len(GCodeLine *, off_t *);
+
+/* Met à jour la ligne de représentation de code. */
+void g_code_line_refresh_markup(GCodeLine *);
+
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+G_DEFINE_TYPE(GCodeLine, g_code_line, G_TYPE_RENDERING_LINE);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des lignes de code binaire.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_code_line_class_init(GCodeLineClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise la classe des lignes de code binaire.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_code_line_init(GCodeLine *line)
+{
+    GRenderingLine *parent;                 /* Instance parente            */
+
+    parent = G_RENDERING_LINE(line);
+
+    parent->offset = 0;
+
+    parent->type = RLT_CODE;
+
+    parent->get_bin_len = (get_bin_len_fc)g_code_line_get_binary_len;
+    parent->refresh_markup = (refresh_markup_fc)g_code_line_refresh_markup;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de représentation à actualiser.                 *
+*                blen = longueur maximale à mettre à jour. [OUT]              *
+*                                                                             *
+*  Description : Met à jour le nombre d'octets maximal par instruction.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_code_line_get_binary_len(GCodeLine *line, off_t *blen)
+{
+    off_t len;                              /* Taille propre à la ligne    */
+
+    get_asm_instr_offset_and_length(line->instr, NULL, &len);
+
+    *blen = MAX(*blen, len);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de représentation à actualiser.                 *
+*                                                                             *
+*  Description : Met à jour la ligne de représentation de code.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_code_line_refresh_markup(GCodeLine *line)
+{
+    size_t len;                             /* Taille du contenu           */
+    char *content;                          /* Contenu réellement imprimé  */
+    off_t bin_offset;                       /* Début de l'instruction      */
+    off_t bin_len;                          /* Taille d'instruction        */
+    char buffer[CODE_BUFFER_LEN];           /* Zone tampon à utiliser      */
+    const uint8_t *exe_content;             /* Contenu binaire global      */
+    char *bin_code;                         /* Tampon du code binaire      */
+    off_t k;                                /* Boucle de parcours #2       */
+    off_t j;                                /* Boucle de parcours #1       */
+
+    len = strlen("<tt>") + 1;
+    content = (char *)calloc(len, sizeof(char));
+    strcpy(content, "<tt>");
+
+    if (line->options->show_code)
+        get_asm_instr_offset_and_length(line->instr, &bin_offset, &bin_len);
+
+    /* Eventuelle adresse virtuelle */
+
+    if (line->options->show_address)
+    {
+        switch (ADM_32BITS  /* FIXME */)
+        {
+            case ADM_32BITS:
+                snprintf(buffer, CODE_BUFFER_LEN,
+                         "<span foreground='#333333'>0x%08llx</span>",
+                         G_RENDERING_LINE(line)->offset);
+                break;
+
+            case ADM_64BITS:
+                snprintf(buffer, CODE_BUFFER_LEN,
+                         "<span foreground='#333333'>0x%16llx</span>",
+                         G_RENDERING_LINE(line)->offset);
+                break;
+
+        }
+
+        len += strlen(buffer);
+        content = (char *)realloc(content, len * sizeof(char));
+        strcat(content, buffer);
+
+    }
+
+    /* Eventuel code brut */
+
+    if (line->options->show_code)
+    {
+        exe_content = get_exe_content(line->options->format, NULL);
+
+        bin_code = (char *)calloc(G_RENDERING_LINE(line)->max_bin_len + 1, sizeof(char));
+
+        k = 0;
+
+        for (j = 0; j < bin_len; j++)
+        {
+            if ((j + 1) < bin_len)
+                k += snprintf(&bin_code[j * (2 + 1)], 4, "%02hhx ", exe_content[bin_offset + j]);
+            else
+                k += snprintf(&bin_code[j * (2 + 1)], 3, "%02hhx", exe_content[bin_offset + j]);
+        }
+ 
+        for (; k < G_RENDERING_LINE(line)->max_bin_len; k++)
+            snprintf(&bin_code[k], 2, " ");
+
+        if (line->options->show_address) len += strlen("\t");
+        len += strlen(bin_code);
+        content = (char *)realloc(content, len * sizeof(char));
+        if (line->options->show_address) strcat(content, "\t");
+        strcat(content, bin_code);
+
+        free(bin_code);
+
+    }
+
+    /* Instruction proprement dite */
+
+    print_hinstruction(line->options->proc, line->options->format,
+                       line->instr, buffer, CODE_BUFFER_LEN, ASX_INTEL/*FIXME*/);
+
+    if (line->options->show_address || line->options->show_code) len += strlen("\t");
+    len += strlen(buffer);
+
+    content = (char *)realloc(content, len * sizeof(char));
+    if (line->options->show_address || line->options->show_code) strcat(content, "\t");
+    strcat(content, buffer);
+
+    /* Finalisation */
+
+    len += strlen("</tt>");
+    content = (char *)realloc(content, len * sizeof(char));
+    strcat(content, "</tt>");
+
+    pango_layout_set_markup(G_RENDERING_LINE(line)->layout, content, len - 1);
+
+    free(content);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset  = emplacement physique ou en mémoire.                *
+*                instr   = instruction à représenter.                         *
+*                options = paramétrage du rendu.                              *
+*                                                                             *
+*  Description : Crée une ligne de code binaire.                              *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRenderingLine *g_code_line_new(uint64_t offset, asm_instr *instr, const disass_options *options)
+{
+    GCodeLine *result;                      /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_CODE_LINE, NULL);
+
+    G_RENDERING_LINE(result)->offset = offset;
+
+    result->instr = instr;
+    result->options = options;
+
+    return G_RENDERING_LINE(result);
+
+}
diff --git a/src/analysis/line_code.h b/src/analysis/line_code.h
new file mode 100644
index 0000000..3564038
--- /dev/null
+++ b/src/analysis/line_code.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_code.h - prototypes pour la représentation de code binaire
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_LINE_CODE_H
+#define _ANALYSIS_LINE_CODE_H
+
+
+#include <glib-object.h>
+
+
+#include "line.h"
+#include "../arch/processor.h"
+
+
+
+#define G_TYPE_CODE_LINE                (g_code_line_get_type())
+#define G_CODE_LINE(obj)                (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_CODE_LINE, GCodeLine))
+#define G_IS_CODE_LINE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_CODE_LINE))
+#define G_CODE_LINE_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CODE_LINE, GCodeLineClass))
+#define G_IS_CODE_LINE_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CODE_LINE))
+#define G_CODE_LINE_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CODE_LINE, GCodeLineClass))
+
+
+/* Ligne de représentation de code binaire (instance) */
+typedef struct _GCodeLine GCodeLine;
+
+/* Ligne de représentation de code binaire (classe) */
+typedef struct _GCodeLineClass GCodeLineClass;
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+GType g_code_line_get_type(void);
+
+/* Crée une ligne de code binaire. */
+GRenderingLine *g_code_line_new(uint64_t, asm_instr *, const disass_options *);
+
+
+
+#endif  /* _ANALYSIS_LINE_CODE_H */
diff --git a/src/analysis/line_comment.c b/src/analysis/line_comment.c
new file mode 100644
index 0000000..6df7b96
--- /dev/null
+++ b/src/analysis/line_comment.c
@@ -0,0 +1,237 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_comment.c - représentation des lignes commentaires entières
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "line_comment.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "line-int.h"
+
+
+
+/* Ligne de représentation de commentaires entière (instance) */
+struct _GCommentLine
+{
+    GRenderingLine parent;                  /* Instance parente            */
+
+    char *comment;                          /* Texte à afficher            */
+    const disass_options *options;          /* Options de représentation   */
+
+};
+
+
+/* Ligne de représentation de commentaires entière (classe) */
+struct _GCommentLineClass
+{
+    GRenderingLineClass parent;             /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des lignes de commentaires entière. */
+static void g_comment_line_class_init(GCommentLineClass *);
+
+/* Initialise la classe des lignes de commentaires entière. */
+static void g_comment_line_init(GCommentLine *);
+
+/* Met à jour la ligne de représentation de commentaires. */
+void g_comment_line_refresh_markup(GCommentLine *);
+
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+G_DEFINE_TYPE(GCommentLine, g_comment_line, G_TYPE_RENDERING_LINE);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des lignes de commentaires entière.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_comment_line_class_init(GCommentLineClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise la classe des lignes de commentaires entière.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_comment_line_init(GCommentLine *line)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de représentation à actualiser.                 *
+*                                                                             *
+*  Description : Met à jour la ligne de représentation de commentaires.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_comment_line_refresh_markup(GCommentLine *line)
+{
+    size_t len;                             /* Taille du contenu           */
+    char *content;                          /* Contenu réellement imprimé  */
+    char buffer[CODE_BUFFER_LEN];           /* Zone tampon à utiliser      */
+    size_t clen;                            /* Taille du commentaire       */
+
+    len = strlen("<tt>") + 1;
+    content = (char *)calloc(len, sizeof(char));
+    strcpy(content, "<tt>");
+
+    /* Eventuelle adresse virtuelle */
+
+    if (line->options->show_address)
+    {
+        switch (ADM_32BITS  /* FIXME */)
+        {
+            case ADM_32BITS:
+                snprintf(buffer, CODE_BUFFER_LEN,
+                         "<span foreground='#333333'>0x%08llx</span>",
+                         G_RENDERING_LINE(line)->offset);
+                break;
+
+            case ADM_64BITS:
+                snprintf(buffer, CODE_BUFFER_LEN,
+                         "<span foreground='#333333'>0x%16llx</span>",
+                         G_RENDERING_LINE(line)->offset);
+                break;
+
+        }
+
+        len += strlen(buffer);
+        content = (char *)realloc(content, len * sizeof(char));
+        strcat(content, buffer);
+
+    }
+
+    /* Eventuel code brut (sauté) */
+
+    if (line->options->show_code)
+    {
+        clen = (line->options->show_address ? strlen("\t") : 0);
+        clen += G_RENDERING_LINE(line)->max_bin_len;
+
+        content = (char *)realloc(content, (len + clen) * sizeof(char));
+
+        if (line->options->show_address)
+        {
+            strcat(content, "\t");
+            len += strlen("\t");
+        }
+
+        memset(&content[len - 1], G_RENDERING_LINE(line)->type == RLT_PROTOTYPE ? '-' : ' ',
+               G_RENDERING_LINE(line)->max_bin_len);
+        len += G_RENDERING_LINE(line)->max_bin_len;
+
+        content[len] = '\0';
+
+    }
+
+    /* Commentaire proprement dit */
+
+    clen = (line->options->show_address || line->options->show_code ? strlen("\t") : 0);
+    clen += strlen("<b><span foreground='#003300'>");
+    clen += strlen("; ") + strlen(line->comment);
+    clen += strlen("</span></b>");
+
+    content = (char *)realloc(content, (len + clen) * sizeof(char));
+
+    if (line->options->show_address || line->options->show_code)
+    {
+        strcat(content, "\t");
+        len += strlen("\t");
+        clen -= strlen("\t");
+    }
+
+    snprintf(&content[len - 1], clen + 1, "<b><span foreground='#003300'>; %s</span></b>", line->comment);
+
+    len += clen;
+
+    /* Finalisation */
+
+    len += strlen("</tt>");
+    content = (char *)realloc(content, len * sizeof(char));
+    strcat(content, "</tt>");
+
+    pango_layout_set_markup(G_RENDERING_LINE(line)->layout, content, len - 1);
+
+    free(content);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset  = emplacement physique ou en mémoire.                *
+*                comment = texte à afficher au final.                         *
+*                options = paramétrage du rendu.                              *
+*                                                                             *
+*  Description : Crée une ligne de commentaires entière.                      *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRenderingLine *g_comment_line_new(uint64_t offset, const char *comment, const disass_options *options)
+{
+    GCommentLine *result;                   /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_COMMENT_LINE, NULL);
+
+    G_RENDERING_LINE(result)->offset = offset;
+
+    result->comment = strdup(comment);
+
+    return G_RENDERING_LINE(result);
+
+}
diff --git a/src/analysis/line_comment.h b/src/analysis/line_comment.h
new file mode 100644
index 0000000..7d103f4
--- /dev/null
+++ b/src/analysis/line_comment.h
@@ -0,0 +1,58 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_comment.h - prototypes pour la représentation des lignes commentaires entières
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_LINE_COMMENT_H
+#define _ANALYSIS_LINE_COMMENT_H
+
+
+#include <glib-object.h>
+
+
+#include "line.h"
+
+
+
+#define G_TYPE_COMMENT_LINE                (g_comment_line_get_type())
+#define G_COMMENT_LINE(obj)                (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_COMMENT_LINE, GCommentLine))
+#define G_IS_COMMENT_LINE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_COMMENT_LINE))
+#define G_COMMENT_LINE_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_COMMENT_LINE, GCommentLineClass))
+#define G_IS_COMMENT_LINE_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_COMMENT_LINE))
+#define G_COMMENT_LINE_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_COMMENT_LINE, GCommentLineClass))
+
+
+/* Ligne de représentation de commentaires entière (instance) */
+typedef struct _GCommentLine GCommentLine;
+
+/* Ligne de représentation de commentaires entière (classe) */
+typedef struct _GCommentLineClass GCommentLineClass;
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+GType g_comment_line_get_type(void);
+
+/* Crée une ligne de commentaires entière. */
+GRenderingLine *g_comment_line_new(uint64_t, const char *, const disass_options *);
+
+
+
+#endif  /* _ANALYSIS_LINE_COMMENT_H */
diff --git a/src/analysis/line_prologue.c b/src/analysis/line_prologue.c
new file mode 100644
index 0000000..74b5642
--- /dev/null
+++ b/src/analysis/line_prologue.c
@@ -0,0 +1,168 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_prologue.c - représentation des lignes d'en-tête de désassemblage
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "line_prologue.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "line-int.h"
+
+
+
+/* Ligne de représentation de descriptions initiales (instance) */
+struct _GPrologueLine
+{
+    GRenderingLine parent;                  /* Instance parente            */
+
+    char *comment;                          /* Texte à afficher            */
+
+};
+
+
+/* Ligne de représentation de descriptions initiales (classe) */
+struct _GPrologueLineClass
+{
+    GRenderingLineClass parent;             /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des lignes de descriptions initiales. */
+static void g_prologue_line_class_init(GPrologueLineClass *);
+
+/* Initialise la classe des lignes de descriptions initiales. */
+static void g_prologue_line_init(GPrologueLine *);
+
+/* Met à jour la ligne de représentation de prologue. */
+void g_prologue_line_refresh_markup(GPrologueLine *);
+
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+G_DEFINE_TYPE(GPrologueLine, g_prologue_line, G_TYPE_RENDERING_LINE);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_prologue_line_class_init(GPrologueLineClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_prologue_line_init(GPrologueLine *line)
+{
+    GRenderingLine *parent;                 /* Instance parente            */
+
+    parent = G_RENDERING_LINE(line);
+
+    parent->offset = 0;
+
+    parent->type = RLT_PROLOGUE;
+
+    parent->refresh_markup = (refresh_markup_fc)g_prologue_line_refresh_markup;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de représentation à actualiser.                 *
+*                                                                             *
+*  Description : Met à jour la ligne de représentation de prologue.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_prologue_line_refresh_markup(GPrologueLine *line)
+{
+    size_t len;                             /* Taille du contenu           */
+    char *content;                          /* Contenu réellement imprimé  */
+
+    len = strlen("<b><span foreground='#003300'>");
+    len += strlen("; ") + strlen(line->comment);
+    len += strlen("</span></b>");
+
+    content = (char *)calloc(len + 1, sizeof(char));
+
+    snprintf(content, len + 1, "<b><span foreground='#003300'>; %s</span></b>", line->comment);
+
+    pango_layout_set_markup(G_RENDERING_LINE(line)->layout, content, len);
+
+    free(content);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : comment = texte à afficher au final.                         *
+*                                                                             *
+*  Description : Crée une des lignes de descriptions initiales.               *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRenderingLine *g_prologue_line_new(const char *comment)
+{
+    GPrologueLine *result;                  /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_PROLOGUE_LINE, NULL);
+
+    result->comment = strdup(comment);
+
+    return G_RENDERING_LINE(result);
+
+}
diff --git a/src/analysis/line_prologue.h b/src/analysis/line_prologue.h
new file mode 100644
index 0000000..45ee7fc
--- /dev/null
+++ b/src/analysis/line_prologue.h
@@ -0,0 +1,60 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * line_prologue.h - prototypes pour la représentation des lignes d'en-tête de désassemblage
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_LINE_PROLOGUE_H
+#define _ANALYSIS_LINE_PROLOGUE_H
+
+
+#include <glib-object.h>
+
+
+#include "line.h"
+
+
+
+#define G_TYPE_PROLOGUE_LINE                (g_prologue_line_get_type())
+#define G_PROLOGUE_LINE(obj)                (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_PROLOGUE_LINE, GPrologueLine))
+#define G_IS_PROLOGUE_LINE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_PROLOGUE_LINE))
+#define G_PROLOGUE_LINE_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PROLOGUE_LINE, GPrologueLineClass))
+#define G_IS_PROLOGUE_LINE_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PROLOGUE_LINE))
+#define G_PROLOGUE_LINE_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PROLOGUE_LINE, GPrologueLineClass))
+
+
+
+/* Ligne de représentation de descriptions initiales (instance) */
+typedef struct _GPrologueLine GPrologueLine;
+
+/* Ligne de représentation de descriptions initiales (classe) */
+typedef struct _GPrologueLineClass GPrologueLineClass;
+
+
+
+/* Indique le type définit par la GLib pour la ligne. */
+GType g_prologue_line_get_type(void);
+
+/* Crée une des lignes de descriptions initiales. */
+GRenderingLine *g_prologue_line_new(const char *);
+
+
+
+#endif  /* _ANALYSIS_LINE_PROLOGUE_H */