Removed useless functions dealing with buffers and optimized some old code.

2 files changed, 59 insertions, 305 deletions

diff --git a/src/glibext/gcodebuffer.c b/src/glibext/gcodebuffer.c
index e00b127..1d4e6cd 100644
--- a/src/glibext/gcodebuffer.c
+++ b/src/glibext/gcodebuffer.c
@@ -137,12 +137,6 @@ static void g_code_buffer_class_init(GCodeBufferClass *);
 static void g_code_buffer_init(GCodeBuffer *);
 
 /* Convertit une adresse en indice de ligne. */
-static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *, const vmpa2t *, bool);
-
-/* Convertit une adresse en indice de ligne. */
-static size_t _g_code_buffer_get_index_from_address_new(const GCodeBuffer *, const vmpa2t *, bool);
-
-/* Convertit une adresse en indice de ligne. */
 static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *, const vmpa2t *, bool);
 
 /* Actualise les largeurs maximales par groupes de lignes. */
@@ -516,121 +510,6 @@ GCodeBuffer *g_code_buffer_new(BufferLineColumn main)
 *                                                                             *
 *  Description : Convertit une adresse en indice de ligne.                    *
 *                                                                             *
-*  Retour      : Indice de l'adresse trouvée, ou 0 en cas d'échec.            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, const vmpa2t *addr, bool first)
-{
-    size_t result;                          /* Indice à retourner          */
-
-    if (addr == VMPA_MAX)
-        return (buffer->used > 0 ? buffer->used - 1 : 0);
-
-    /* TODO : coder un parcours plus optimal ! */
-
-    return (first ? 0 : buffer->used - 1);
-
-#if 0
-
-    for (result = 0; result < buffer->used; result++)
-        if (g_buffer_line_get_address(buffer->lines[result]) == addr)
-            break;
-
-    if (!first)
-        for (; result < (buffer->used - 1); result++)
-            if (g_buffer_line_get_address(buffer->lines[result + 1]) != addr)
-                break;
-
-#endif
-
-    return result;
-
-}
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : buffer = composant GTK à mettre à jour.                      *
-*                addr   = adresse où va se situer la ligne.                   *
-*                first  = indique si on l'arrête à la première ou la dernière.*
-*                                                                             *
-*  Description : Convertit une adresse en indice de ligne.                    *
-*                                                                             *
-*  Retour      : Indice de l'adresse trouvée, ou 0 en cas d'échec.            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static size_t _g_code_buffer_get_index_from_address_new(const GCodeBuffer *buffer, const vmpa2t *addr, bool first)
-{
-    size_t result;                          /* Indice à retourner          */
-    const mrange_t *range;                  /* Couverture d'une ligne      */
-
-
-    /**
-     * FIXME
-     *
-     * Cette fonction ne semble plus avoir d'utilité.
-     *
-     * g_code_buffer_get_index_from_address() semble être un bon remplacement.
-     *
-     */
-
-    for (result = 0; result < buffer->used; result++)
-    {
-        range = g_buffer_line_get_range(buffer->lines[result]);
-
-        if (mrange_contains_addr(range, addr))
-        {
-            printf(":: STOP :: %x + %u  //  %x\n",
-                   range->addr.virtual, range->length, addr->virtual);
-            break;
-        }
-
-    }
-
-#if 0
-
-    size_t result;                          /* Indice à retourner          */
-
-    if (addr == VMPA_MAX)
-        return (buffer->used > 0 ? buffer->used - 1 : 0);
-
-    /* TODO : coder un parcours plus optimal ! */
-
-    return (first ? 0 : buffer->used - 1);
-
-#if 0
-
-    for (result = 0; result < buffer->used; result++)
-        if (g_buffer_line_get_address(buffer->lines[result]) == addr)
-            break;
-
-    if (!first)
-        for (; result < (buffer->used - 1); result++)
-            if (g_buffer_line_get_address(buffer->lines[result + 1]) != addr)
-                break;
-
-#endif
-
-#endif
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : buffer = composant GTK à mettre à jour.                      *
-*                addr   = adresse où va se situer la ligne.                   *
-*                first  = indique si on l'arrête à la première ou la dernière.*
-*                                                                             *
-*  Description : Convertit une adresse en indice de ligne.                    *
-*                                                                             *
 *  Retour      : Indice de l'adresse trouvée, ou le nombre de lignes sinon.   *
 *                                                                             *
 *  Remarques   : -                                                            *
@@ -657,8 +536,8 @@ static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, co
 
     else
     {
+        /* Recherche dichotomique grossière */
 
-#if 0
         int cmp_addr_and_line(const vmpa2t *addr, const GBufferLine **line)
         {
             int status;                     /* Bilan d'une comparaison     */
@@ -666,16 +545,7 @@ static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, co
 
             lrange = g_buffer_line_get_range(*line);
 
-            if (mrange_contains_addr(lrange, addr))
-                status = 0;
-
-            else
-            {
-                if (cmp_vmpa(addr, get_mrange_addr(lrange)) < 0)
-                    status = -1;
-                else
-                    status = 1;
-            }
+            status = cmp_mrange_with_vmpa(lrange, addr);
 
             return status;
 
@@ -683,27 +553,8 @@ static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, co
 
         found = bsearch(addr, buffer->lines, buffer->used, sizeof(GBufferLine *),
                         (__compar_fn_t)cmp_addr_and_line);
-#endif
-
-
-
-
-        found = NULL;
-
-
-
-        for (result = 0; result < buffer->used; result++)
-        {
-            range = g_buffer_line_get_range(buffer->lines[result]);
-
-            if (mrange_contains_addr(range, addr))
-            {
-                found = &buffer->lines[result];
-                break;
-            }
-
-        }
 
+        /* Dernier raffinage pour approcher la cible réelle */
 
         if (found == NULL)
             result = buffer->used;
@@ -712,8 +563,6 @@ static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, co
         {
             result = found - buffer->lines;
 
-            //printf("  [index] [B] 0x%08x -> %zu\n", (unsigned int)addr->virtual, result);
-
             if (first)
                 for (; result > 0; result--)
                 {
@@ -728,8 +577,6 @@ static size_t g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, co
                     if (!mrange_contains_addr(range, addr)) break;
                 }
 
-            //printf("          [A] 0x%08x -> %zu\n", (unsigned int)addr->virtual, result);
-
         }
 
     }
@@ -905,82 +752,6 @@ GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *buffer, const mrange_t *
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : buffer = composant GTK à mettre à jour.                      *
-*                addr   = adresse où va se situer la ligne.                   *
-*                before = emplacement de l'insertion.                         *
-*                                                                             *
-*  Description : Ajoute une nouvelle ligne à un tampon pour code désassemblé. *
-*                                                                             *
-*  Retour      : Nouvelle ligne vierge à écrire.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBufferLine *g_code_buffer_insert_at(GCodeBuffer *buffer, vmpa_t addr, bool before)
-{
-    GBufferLine *result;                    /* Instance à retourner        */
-    size_t index;                           /* Indice de la ligne visée    */
-
-    index = _g_code_buffer_get_index_from_address(buffer, addr, true /* FIXME : after */);
-    if (index == buffer->used) return NULL;
-
-    if (buffer->used == buffer->count)
-    {
-        buffer->count += LINE_ALLOC_BULK;
-        buffer->lines = (GBufferLine **)realloc(buffer->lines,
-                                                buffer->count * sizeof(GBufferLine *));
-    }
-
-    if (before)
-    {
-        memmove(&buffer->lines[index + 1], &buffer->lines[index],
-                sizeof(GBufferLine *) * (buffer->used - index));
-
-        buffer->used++;
-
-        result = g_buffer_line_new(addr, buffer->main_column);
-        buffer->lines[index] = result;
-
-    }
-
-
-    else
-    /* FIXME */
-        ;
-
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : buffer = composant GTK à mettre à jour.                      *
-*                line   = point d'insertion.                                  *
-*                                                                             *
-*  Description : Ajoute une nouvelle ligne à un tampon pour code désassemblé. *
-*                                                                             *
-*  Retour      : Nouvelle ligne vierge à écrire.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBufferLine *g_code_buffer_insert_after(GCodeBuffer *buffer, GBufferLine *line)
-{
-
-    /* FIXME */
-
-    return NULL;
-
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : buffer = composant GTK à mettre à jour.                      *
 *                addr   = adresse où retrouver la ligne recherchée.           *
 *                flags  = propriétés à vérifier en tout ou partie.            *
 *                idx    = indice de la ligne trouvée ou NULL. [OUT]           *
@@ -998,7 +769,7 @@ GBufferLine *g_code_buffer_find_line_by_addr(const GCodeBuffer *buffer, const vm
     GBufferLine *result;                    /* Instance à retourner        */
     size_t index;                           /* Indice de la ligne visée    */
 
-    index = _g_code_buffer_get_index_from_address_new(buffer, addr, true);
+    index = g_code_buffer_get_index_from_address(buffer, addr, true);
 
     if (index == buffer->used)
         result = NULL;
@@ -1680,60 +1451,6 @@ gint g_buffer_view_get_height(const GBufferView *view)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : view    = visualisation à consulter.                         *
-*                x       = abscisse comprise dans le segment recherché. [OUT] *
-*                y       = ordonnée comprise dans la ligne recherchée.        *
-*                idx     = indice de la ligne trouvée ou NULL. [OUT]          *
-*                display = règles d'affichage des colonnes modulables.        *
-*                segment = portion de texte recherchée ou NULL. [OUT]         *
-*                                                                             *
-*  Description : Fournit la ligne et son segment présents à une position.     *
-*                                                                             *
-*  Retour      : Ligne retrouvée ou NULL si aucune.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBufferLine *g_buffer_view_find_line_and_segment_at(GBufferView *view, gint *x, gint y, size_t *idx, const bool *display, GBufferSegment **segment)
-{
-    GBufferLine *result;                    /* Ligne trouvée à retourner   */
-    gint lheight;                           /* Hauteur d'une ligne         */
-    size_t index;                           /* Indice attendu              */
-
-    /* Recherche d'une ligne correspondante */
-
-    lheight = g_buffer_view_get_line_height(view);
-    index = view->first_index + y / lheight;
-
-    if (idx != NULL)
-        *idx = index;
-
-    result = (index < view->buffer->used ? view->buffer->lines[index] : NULL);
-
-    /* Recherche du segment visé éventuel */
-
-    if (result != NULL && segment != NULL)
-    {
-        if (*x < view->left_text)
-            *segment = NULL;
-
-        else
-        {
-            *x -= view->left_text;
-            *segment = g_buffer_line_get_segment_at(result, view->max_widths, display,
-                                                    (gint []) { 0 }, x, GDK_SCROLL_LEFT, true);
-        }
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : view    = vue de tampon à mettre à jour.                     *
 *                x       = abscisse de la zone principale à traiter.          *
 *                y       = ordonnée de la zone principale à traiter.          *
@@ -1855,9 +1572,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
     gint offset;                            /* Point de travail modifiable */
     gint base;                              /* Position absolue de segment */
     GBufferSegment *segment;                /* Segment visé par le pointeur*/
-    size_t first;                           /* Première ligne intégrée     */
 
-    gint ref_x;
 
 
     offset = caret->x;
@@ -1876,7 +1591,6 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
 
 
 
-    ref_x = offset;
 
 
 
@@ -1974,8 +1688,6 @@ const vmpa2t *g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, b
 
 
 
-    gint tmp_x;                             /* Copie de travail modifiable */
-    GBufferSegment *segment;                /* Segment visé par le pointeur*/
 
 
 
@@ -2090,10 +1802,10 @@ BufferLineColumn g_buffer_line_get_merge_start(const GBufferLine *line)
 
     }
 
-
+    /*
     printf(" --- CARET ---   moved = %d   index = %d   result = %p\n",
            moved, index, result);
-
+    */
 
 
     /*
@@ -2147,7 +1859,6 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view)
 bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const bool *display)
 {
     bool need_redraw;                       /* Besoin d'actualisation ?    */
-    GBufferLine *line;                      /* Ligne ciblée                */
     GBufferSegment *segment;                /* Segment sélectionnable      */
 
     if (view->highlighted != NULL)
@@ -2155,7 +1866,7 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const b
     else
         need_redraw = false;
 
-    line = g_buffer_view_find_line_and_segment_at(view, &x, y, NULL, display, &segment);
+    g_buffer_view_find_line_and_segment_at(view, &x, y, NULL, display, &segment);
 
     if (segment)
         need_redraw |= add_segment_content_to_selection_list(view->highlighted, segment);
@@ -2357,6 +2068,52 @@ GBufferLine *g_buffer_view_find_line_at(GBufferView *view, gint y, size_t *idx)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : view    = visualisation à consulter.                         *
+*                x       = abscisse comprise dans le segment recherché. [OUT] *
+*                y       = ordonnée comprise dans la ligne recherchée.        *
+*                idx     = indice de la ligne trouvée ou NULL. [OUT]          *
+*                display = règles d'affichage des colonnes modulables.        *
+*                segment = portion de texte recherchée ou NULL. [OUT]         *
+*                                                                             *
+*  Description : Fournit la ligne et son segment présents à une position.     *
+*                                                                             *
+*  Retour      : Ligne retrouvée ou NULL si aucune.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GBufferLine *g_buffer_view_find_line_and_segment_at(GBufferView *view, gint *x, gint y, size_t *idx, const bool *display, GBufferSegment **segment)
+{
+    GBufferLine *result;                    /* Ligne trouvée à retourner   */
+
+    /* Recherche d'une ligne correspondante */
+
+    result = g_buffer_view_find_line_at(view, y, idx);
+
+    /* Recherche du segment visé éventuel */
+
+    if (result != NULL && segment != NULL)
+    {
+        if (*x < view->left_text)
+            *segment = NULL;
+
+        else
+        {
+            *x -= view->left_text;
+            *segment = g_buffer_line_get_segment_at(result, view->max_widths, display,
+                                                    (gint []) { 0 }, x, GDK_SCROLL_LEFT, true);
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : view = composant GTK à consulter.                            *
 *                addr = adresse à présenter à l'écran.                        *
 *                x    = position horizontale au sein du composant. [OUT]      *
diff --git a/src/glibext/gcodebuffer.h b/src/glibext/gcodebuffer.h
index 517cdce..86e94d2 100644
--- a/src/glibext/gcodebuffer.h
+++ b/src/glibext/gcodebuffer.h
@@ -64,11 +64,8 @@ GCodeBuffer *g_code_buffer_new(BufferLineColumn);
 /* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
 GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *, const mrange_t *);
 
-/* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
-GBufferLine *g_code_buffer_insert_at(GCodeBuffer *, vmpa_t, bool);
-
-/* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
-GBufferLine *g_code_buffer_insert_after(GCodeBuffer *, GBufferLine *);
+/* FIXME */
+#define g_code_buffer_insert_at(buf, a, b) NULL
 
 /* Retrouve une ligne au sein d'un tampon avec une adresse. */
 GBufferLine *g_code_buffer_find_line_by_addr(const GCodeBuffer *, const vmpa2t *, BufferLineFlags, size_t *);
@@ -135,9 +132,6 @@ gint g_buffer_view_get_margin(GBufferView *, const bool *);
 /* Fournit la hauteur requise par une visualisation. */
 gint g_buffer_view_get_height(const GBufferView *);
 
-/* Fournit la ligne et son segment présents à une position. */
-GBufferLine *g_buffer_view_find_line_and_segment_at(GBufferView *, gint *, gint, size_t *, const bool *, GBufferSegment **);
-
 /* Calcule la position idéale de curseur pour un point donné. */
 const vmpa2t *g_buffer_view_compute_caret(GBufferView *, gint, gint, const bool *, GdkRectangle *);
 
@@ -163,7 +157,10 @@ GBufferLine *g_buffer_view_find_line_by_addr(const GBufferView *, const vmpa2t *
 GBufferLine *g_buffer_view_find_line_by_index(const GBufferView *, size_t );
 
 /* Fournit la ligne présente à une ordonnée donnée. */
-GBufferLine *g_buffer_view_find_line_at(GBufferView *, gint, size_t *) __attribute__ ((deprecated));
+GBufferLine *g_buffer_view_find_line_at(GBufferView *, gint, size_t *);
+
+/* Fournit la ligne et son segment présents à une position. */
+GBufferLine *g_buffer_view_find_line_and_segment_at(GBufferView *, gint *, gint, size_t *, const bool *, GBufferSegment **);
 
 /* Indique la position d'affichage d'une adresse donnée. */
 bool g_buffer_view_get_address_coordinates(GBufferView *, const vmpa2t *, gint *, gint *, bool);