Cleaned and improved the binary views ; implemented some first steps for the graphical view.

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

3 files changed, 72 insertions, 19 deletions

diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 01ccfdd..61d344e 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -667,7 +667,7 @@ void disassemble_openida_binary(openida_binary *binary)
 
 
 
-    line = g_rendering_line_find_by_offset(binary->lines, get_exe_entry_point(binary->format));
+    line = g_rendering_line_find_by_address(binary->lines, NULL, get_exe_entry_point(binary->format));
     if (line != NULL) g_rendering_line_add_flag(line, RLF_ENTRY_POINT);
 
 
diff --git a/src/analysis/line.c b/src/analysis/line.c
index 2697f77..08ef3c1 100644
--- a/src/analysis/line.c
+++ b/src/analysis/line.c
@@ -126,6 +126,25 @@ static void g_rendering_line_init(GRenderingLine *line)
 *                                                                             *
 *  Paramètres  : line = ligne dont les informations sont à consulter.         *
 *                                                                             *
+*  Description : Fournit l'adresse physique ou en mémoire d'une ligne.        *
+*                                                                             *
+*  Retour      : Position physique ou en mémoire associée à la ligne.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+vmpa_t get_rendering_line_address(const GRenderingLine *line)
+{
+    return line->offset;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne dont les informations sont à consulter.         *
+*                                                                             *
 *  Description : Fournit le type d'une ligne.                                 *
 *                                                                             *
 *  Retour      : Type de la ligne fournie.                                    *
@@ -395,8 +414,9 @@ void g_rendering_line_insert_into_lines(GRenderingLine **lines, GRenderingLine *
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = liste de lignes de représentation à actualiser.       *
-*              : iter = position actuelle dans la liste.                      *
+*  Paramètres  : lines = liste de lignes de représentation à actualiser.      *
+*              : iter  = position actuelle dans la liste.                     *
+*                last  = dernière élément imposé du parcours ou NULL.         *
 *                                                                             *
 *  Description : Fournit l'élement suivant un autre pour un parcours.         *
 *                                                                             *
@@ -406,13 +426,14 @@ void g_rendering_line_insert_into_lines(GRenderingLine **lines, GRenderingLine *
 *                                                                             *
 ******************************************************************************/
 
-GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *lines, const GRenderingLine *iter)
+GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *lines, const GRenderingLine *iter, const GRenderingLine *last)
 {
     GRenderingLine *result;                 /* Elément suivant à renvoyer  */
 
     if (iter == NULL) iter = lines;
 
-    result = lines_list_next_iter(iter, lines);
+    if (iter == last) result = NULL;
+    else result = lines_list_next_iter(iter, lines);
 
     return result;
 
@@ -421,7 +442,8 @@ GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *lines, const GRen
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = liste de lignes de représentation à actualiser.       *
+*  Paramètres  : lines = liste de lignes de représentation à actualiser.      *
+*                last  = dernière élément imposé du parcours ou NULL.         *
 *                                                                             *
 *  Description : Met à jour le nombre d'octets maximal par instruction.       *
 *                                                                             *
@@ -431,7 +453,7 @@ GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *lines, const GRen
 *                                                                             *
 ******************************************************************************/
 
-void g_rendering_line_update_bin_len(GRenderingLine *lines)
+void g_rendering_line_update_bin_len(GRenderingLine *lines, const GRenderingLine *last)
 {
     GRenderingLine *iter;                   /* Boucle de parcours          */
     off_t bin_len;                          /* Taille d'instruction        */
@@ -439,13 +461,21 @@ void g_rendering_line_update_bin_len(GRenderingLine *lines)
     bin_len = 0;
 
     lines_list_for_each(iter, lines)
+    {
         if (iter->get_bin_len != NULL)
             iter->get_bin_len(iter, &bin_len);
 
+        if (iter == last) break;
+
+    }
+
     lines_list_for_each(iter, lines)
     {
-        iter->max_bin_len = bin_len * 2 + (bin_len - 1);
+        iter->max_bin_len = (bin_len > 0 ? bin_len * 2 + (bin_len - 1) : 0);
         iter->refresh_markup(iter);
+
+        if (iter == last) break;
+
     }
 
 }
@@ -454,6 +484,7 @@ void g_rendering_line_update_bin_len(GRenderingLine *lines)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : lines  = liste de lignes de représentation à actualiser.     *
+*                last   = dernière élément imposé du parcours ou NULL.        *
 *                width  = largeur maximale des lignes. [OUT]                  *
 *                height = hauteur maximale des lignes. [OUT]                  *
 *                alone  = hauteur d'une seule ligne. [OUT]                    *
@@ -466,7 +497,7 @@ void g_rendering_line_update_bin_len(GRenderingLine *lines)
 *                                                                             *
 ******************************************************************************/
 
-void g_rendering_line_get_size(GRenderingLine *lines, int *width, int *height, int *alone)
+void g_rendering_line_get_size(GRenderingLine *lines, const GRenderingLine *last, int *width, int *height, int *alone)
 {
     GRenderingLine *iter;                   /* Boucle de parcours          */
     int w;                                  /* Largeur de l'objet actuelle */
@@ -486,6 +517,8 @@ void g_rendering_line_get_size(GRenderingLine *lines, int *width, int *height, i
         if (iter == lines)
             *alone = h;
 
+        if (iter == last) break;
+
     }
 
 }
@@ -494,6 +527,7 @@ void g_rendering_line_get_size(GRenderingLine *lines, int *width, int *height, i
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : lines = liste de lignes à parcourir.                         *
+*                last  = dernière élément imposé du parcours ou NULL.         *
 *                y     = ordonnée à vérifier et à mettre à jour. [OUT]        *
 *                                                                             *
 *  Description : Recherche une ligne d'après sa position à l'écran.           *
@@ -504,7 +538,7 @@ void g_rendering_line_get_size(GRenderingLine *lines, int *width, int *height, i
 *                                                                             *
 ******************************************************************************/
 
-GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, gdouble *y)
+GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, const GRenderingLine *last, gdouble *y)
 {
     GRenderingLine *result;                 /* Trouvaille à retourner      */
     int h;                                  /* Hauteur de l'objet actuel   */
@@ -516,6 +550,12 @@ GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, gdouble *y)
         if (*y < h) break;
         else *y -= h;
 
+        if (result == last)
+        {
+            result = NULL;
+            break;
+        }
+
     }
 
     return result;
@@ -525,8 +565,9 @@ GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, gdouble *y)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : lines  = liste de lignes à parcourir.                        *
-*                offset = position en mémoire ou physique à chercher.         *
+*  Paramètres  : lines = liste de lignes à parcourir.                         *
+*                last  = dernière élément imposé du parcours ou NULL.         *
+*                addr  = position en mémoire ou physique à chercher.          *
 *                                                                             *
 *  Description : Recherche une ligne d'après sa position en mémoire/physique. *
 *                                                                             *
@@ -536,12 +577,21 @@ GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *lines, gdouble *y)
 *                                                                             *
 ******************************************************************************/
 
-GRenderingLine *g_rendering_line_find_by_offset(GRenderingLine *lines, uint64_t offset)
+GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *lines, const GRenderingLine *last, vmpa_t addr)
 {
     GRenderingLine *result;                 /* Trouvaille à retourner      */
 
     lines_list_for_each(result, lines)
-        if (result->offset == offset) break;
+    {
+        if (result->offset == addr) break;
+
+        if (result == last)
+        {
+            result = NULL;
+            break;
+        }
+
+    }
 
     return result;
 
diff --git a/src/analysis/line.h b/src/analysis/line.h
index ae7698e..69deb57 100644
--- a/src/analysis/line.h
+++ b/src/analysis/line.h
@@ -83,6 +83,9 @@ typedef struct _GRenderingLineClass GRenderingLineClass;
 /* Indique le type définit pour une ligne de représentation. */
 GType g_rendering_line_get_type(void);
 
+/* Fournit l'adresse physique ou en mémoire d'une ligne. */
+vmpa_t get_rendering_line_address(const GRenderingLine *);
+
 /* Fournit le type d'une ligne. */
 RenderingLineType get_rendering_line_type(const GRenderingLine *);
 
@@ -113,19 +116,19 @@ void g_rendering_line_add_to_lines(GRenderingLine **, GRenderingLine *);
 void g_rendering_line_insert_into_lines(GRenderingLine **, GRenderingLine *, bool);
 
 /* Fournit l'élement suivant un autre pour un parcours. */
-GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *, const GRenderingLine *);
+GRenderingLine *g_rendering_line_get_next_iter(GRenderingLine *, const GRenderingLine *, const GRenderingLine *);
 
 /* Met à jour le nombre d'octets maximal par instruction. */
-void g_rendering_line_update_bin_len(GRenderingLine *);
+void g_rendering_line_update_bin_len(GRenderingLine *, const GRenderingLine *);
 
 /* Fournit les dimensions de lignes de représentation. */
-void g_rendering_line_get_size(GRenderingLine *, int *, int *, int *);
+void g_rendering_line_get_size(GRenderingLine *, const GRenderingLine *, int *, int *, int *);
 
 /* Recherche une ligne d'après sa position à l'écran. */
-GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *, gdouble *);
+GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *, const GRenderingLine *, gdouble *);
 
 /* Recherche une ligne d'après sa position en mémoire/physique. */
-GRenderingLine *g_rendering_line_find_by_offset(GRenderingLine *, uint64_t);
+GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *, const GRenderingLine *, vmpa_t);