/* Chrysalide - Outil d'analyse de fichiers binaires
* gcodebuffer.h - prototypes pour l'affichage d'un fragment de code d'assemblage
*
* Copyright (C) 2010-2014 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* 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 .
*/
#include "gcodebuffer.h"
#include
#include
#include
#include "chrysamarshal.h"
#include "delayed-int.h"
/* -------------------------- PARCOURS DU CODE D'UN TAMPON -------------------------- */
#define G_TYPE_BUFFER_SCAN g_buffer_scan_get_type()
#define G_BUFFER_SCAN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_buffer_scan_get_type(), GDelayedExport))
#define G_IS_BUFFER_SCAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_buffer_scan_get_type()))
#define G_BUFFER_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BUFFER_SCAN, GDelayedExportClass))
#define G_IS_BUFFER_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BUFFER_SCAN))
#define G_BUFFER_SCAN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BUFFER_SCAN, GDelayedExportClass))
/* Ensembles binaires à désassembler (instance) */
typedef struct _GBufferScan
{
GDelayedWork parent; /* A laisser en premier */
GCodeBuffer *buffer; /* Tampon à manipuler */
vmpa_t start; /* Début du parcours ou 0 */
vmpa_t end; /* Fin du parcours ou VMPA_MAX */
char *message; /* Message de progression */
process_line_fc process; /* Fonction de traitement réel */
void *user_data; /* Données à faire suivre */
} GBufferScan;
/* Ensembles binaires à désassembler (classe) */
typedef struct _GBufferScanClass
{
GDelayedWorkClass parent; /* A laisser en premier */
} GBufferScanClass;
/* Indique le type défini pour les tâches d'exportation différée. */
static GType g_buffer_scan_get_type(void);
/* Initialise la classe des tâches d'exportation différée. */
static void g_buffer_scan_class_init(GBufferScanClass *);
/* Initialise une tâche d'exportation différée. */
static void g_buffer_scan_init(GBufferScan *);
/* Crée une tâche d'exportation différée. */
static GBufferScan *g_buffer_scan_new(GCodeBuffer *, vmpa_t, vmpa_t, const char *, process_line_fc, void *);
/* Assure l'exportation en différé. */
static void g_buffer_scan_process(GBufferScan *, GtkExtStatusBar *);
/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */
/* Tampon pour code désassemblé (instance) */
struct _GCodeBuffer
{
GObject parent; /* A laisser en premier */
BufferLineColumn main_column; /* Colonne principale */
GBufferLine **lines; /* Liste des lignes intégrées */
size_t count; /* Quantité en cache */
size_t used; /* Quantité utilisée */
size_t indent; /* Indentation des lignes */
};
/* Tampon pour code désassemblé (classe) */
struct _GCodeBufferClass
{
GObjectClass parent; /* A laisser en premier */
};
/* Taille des allocations de masse */
#define LINE_ALLOC_BULK 20
/* Procède à l'initialisation d'une classe de tampon de code. */
static void g_code_buffer_class_init(GCodeBufferClass *);
/* Procède à l'initialisation d'un tampon pour code désassemblé. */
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(GCodeBuffer *, const vmpa2t *, bool);
/* ---------------------- VUE PARTICULIERE D'UN TAMPON DE CODE ---------------------- */
/* Vue d'un tampon pour code désassemblé (instance) */
struct _GBufferView
{
GObject parent; /* A laisser en premier */
GCodeBuffer *buffer; /* Tampon de code visualisé */
vmpa2t *start; /* Première ligne intégrée */
vmpa2t *end; /* Dernière ligne intégrée */
size_t first_index; /* Indice de la première ligne */ /* FIXME : utiliser partout ? */
size_t last_index; /* Indice de la dernière ligne */ /* FIXME : idem */
gint line_height; /* Hauteur maximale des lignes */
gint max_widths[BLC_COUNT]; /* Taille cachée des colonnes */
gint left_margin; /* Marge gauche + espace */
gint left_text; /* Début d'impression du code */
gint last_width; /* Plus grande col. de fusion */
BufferLineColumn last_merge; /* Colonne de fusion extrême */
segcnt_list *highlighted; /* Segments mis en évidence */
bool external; /* Note l'origine de la liste */
};
/* Vue d'un tampon pour code désassemblé (classe) */
struct _GBufferViewClass
{
GObjectClass parent; /* A laisser en premier */
/* Signaux */
void (* need_redraw) (GBufferView *);
};
#define HEIGHT_CACHED(view) ((view)->line_height != -1)
#define WIDTHS_CACHED(view) ((view)->max_widths[0] != -1)
/* Procède à l'initialisation d'une classe de vue de tampon. */
static void g_buffer_view_class_init(GBufferViewClass *);
/* Procède à l'initialisation d'une vue d'un tampon pour code. */
static void g_buffer_view_init(GBufferView *);
/* Supprime toutes les références externes. */
static void g_buffer_view_dispose(GBufferView *);
/* Procède à la libération totale de la mémoire. */
static void g_buffer_view_finalize(GBufferView *);
/* Réinitialise le cache de la hauteur des lignes. */
static void g_buffer_view_reset_required_height(GBufferView *);
/* Réinitialise le cache des largeurs de colonne calculées. */
static void g_buffer_view_reset_required_widths(GBufferView *);
/* Calcule les largeurs requises par une visualisation. */
static void g_buffer_view_compute_required_widths(GBufferView *, const bool *);
/* ---------------------------------------------------------------------------------- */
/* PARCOURS DU CODE D'UN TAMPON */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour les tâches d'exportation différée. */
G_DEFINE_TYPE(GBufferScan, g_buffer_scan, G_TYPE_DELAYED_WORK);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des tâches d'exportation différée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_scan_class_init(GBufferScanClass *klass)
{
GDelayedWorkClass *work; /* Version en classe parente */
work = G_DELAYED_WORK_CLASS(klass);
work->run = (run_task_fc)g_buffer_scan_process;
}
/******************************************************************************
* *
* Paramètres : disass = instance à initialiser. *
* *
* Description : Initialise une tâche d'exportation différée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_scan_init(GBufferScan *disass)
{
}
/******************************************************************************
* *
* Paramètres : buffer = tampon à manipuler. *
* start = première adresse visée ou 0. *
* end = dernière adresse visée ou VMPA_MAX. *
* message = message à afficher lors de la progression. *
* process = fonction assurant le traitement effectif. *
* data = données utilisateur à faire suivre. *
* *
* Description : Crée une tâche d'exportation différée. *
* *
* Retour : Tâche créée. *
* *
* Remarques : - *
* *
******************************************************************************/
static GBufferScan *g_buffer_scan_new(GCodeBuffer *buffer, vmpa_t start, vmpa_t end, const char *message, process_line_fc process, void *data)
{
GBufferScan *result; /* Tâche à retourner */
result = g_object_new(G_TYPE_BUFFER_SCAN, NULL);
result->buffer = buffer;
g_object_ref(G_OBJECT(buffer));
result->start = start;
result->end = end;
result->message = strdup(message);
result->process = process;
result->user_data = data;
return result;
}
/******************************************************************************
* *
* Paramètres : scan = parcours à mener. *
* statusbar = barre de statut à tenir informée. *
* *
* Description : Assure l'exportation en différé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_scan_process(GBufferScan *scan, GtkExtStatusBar *statusbar)
{
size_t first; /* Première ligne visée */
size_t last; /* Dernière ligne visée + 1 */
GBufferLine **lines; /* Liste des lignes à traiter */
bstatus_id_t id; /* Identifiant de statut */
size_t i; /* Boucle de parcours */
/* TODO : lock scan->buffer->lines */
first = g_code_buffer_get_index_from_address(scan->buffer, scan->start, true);
last = g_code_buffer_get_index_from_address(scan->buffer, scan->end, false);
lines = scan->buffer->lines;
id = gtk_extended_status_bar_push(statusbar, scan->message, true);
if (scan->buffer->used > 0)
for (i = first; i <= last; i++)
{
if (!scan->process(scan->buffer, lines[i], scan->user_data))
break;
gtk_extended_status_bar_update_activity(statusbar, id,
(i - first) * 1.0 / (last - first));
}
/* TODO : unlock scan->buffer->lines */
gtk_extended_status_bar_remove(statusbar, id);
/* Avertit le commanditaire... */
scan->process(scan->buffer, NULL, scan->user_data);
}
/* ---------------------------------------------------------------------------------- */
/* TAMPON POUR CODE DESASSEMBLE */
/* ---------------------------------------------------------------------------------- */
/* Détermine le type du composant de tampon pour code désassemblé. */
G_DEFINE_TYPE(GCodeBuffer, g_code_buffer, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : class = classe de composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation d'une classe de tampon de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_buffer_class_init(GCodeBufferClass *class)
{
}
/******************************************************************************
* *
* Paramètres : buffer = composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation d'un tampon pour code désassemblé.*
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_buffer_init(GCodeBuffer *buffer)
{
}
/******************************************************************************
* *
* Paramètres : main = colonne à référencer comme étant la principale. *
* *
* Description : Crée un nouveau composant de tampon pour code désassemblé. *
* *
* Retour : Composant GTK créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBuffer *g_code_buffer_new(BufferLineColumn main)
{
GCodeBuffer *result; /* Composant à retourner */
result = g_object_new(G_TYPE_CODE_BUFFER, NULL);
result->main_column = main;
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(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 */
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 : - *
* *
******************************************************************************/
static size_t g_code_buffer_get_index_from_address(GCodeBuffer *buffer, const vmpa2t *addr, bool first)
{
size_t result; /* Indice à retourner */
GBufferLine **found; /* Renvoi vers une trouvaille */
const mrange_t *range; /* Couverture d'une ligne */
/**
* Si aucune adresse (ie. aucune limite ?) n'est précisée, on se base sur
* la direction pour trouver le bon indice.
*/
if (addr == NULL)
result = (first ? 0 : buffer->used - 1);
/**
* Sinon on parcourt méthodiquement toutes les lignes !
*/
else
{
#if 0
int cmp_addr_and_line(const vmpa2t *addr, const GBufferLine **line)
{
int status; /* Bilan d'une comparaison */
const mrange_t *lrange; /* Couverture d'une ligne */
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;
}
return status;
}
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;
}
}
if (found == NULL)
result = buffer->used;
else
{
result = found - buffer->lines;
//printf(" [index] [B] 0x%08x -> %zu\n", (unsigned int)addr->virtual, result);
if (first)
for (; result > 0; result--)
{
range = g_buffer_line_get_range(buffer->lines[result - 1]);
if (!mrange_contains_addr(range, addr)) break;
}
else
for (; (result + 1) < buffer->used; result++)
{
range = g_buffer_line_get_range(buffer->lines[result + 1]);
if (!mrange_contains_addr(range, addr)) break;
}
//printf(" [A] 0x%08x -> %zu\n", (unsigned int)addr->virtual, result);
}
}
return result;
}
/******************************************************************************
* *
* Paramètres : buffer = composant GTK à mettre à jour. *
* range = emplacement où va se situer la ligne. *
* *
* Description : Ajoute une nouvelle ligne à un tampon pour code désassemblé. *
* *
* Retour : Nouvelle ligne vierge à écrire. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *buffer, const mrange_t *range)
{
GBufferLine *result; /* Instance à retourner */
size_t i; /* Boucle de parcours */
if (buffer->used == buffer->count)
{
buffer->count += LINE_ALLOC_BULK;
buffer->lines = (GBufferLine **)realloc(buffer->lines,
buffer->count * sizeof(GBufferLine *));
}
result = g_buffer_line_new(range, buffer->main_column);
buffer->lines[buffer->used++] = result;
for (i = 0; i < buffer->indent; i++)
g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, " ", 4, RTT_RAW);
return result;
}
/******************************************************************************
* *
* 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] *
* *
* Description : Retrouve une ligne au sein d'un tampon avec une adresse. *
* *
* Retour : Line retrouvée ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_code_buffer_find_line_by_addr(const GCodeBuffer *buffer, const vmpa2t *addr, BufferLineFlags flags, size_t *idx)
{
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);
if (index == buffer->used)
result = NULL;
else
{
if (idx != NULL)
*idx = index;
result = buffer->lines[index];
if (flags != BLF_NONE)
while ((g_buffer_line_get_flags(result) & flags) == 0)
{
if ((index + 1) == buffer->used) break;
/* FIXME : vérifier que l'adresse est toujours celle recherchée ! */
if (idx != NULL)
(*idx)++;
result = buffer->lines[++index];
}
g_object_ref(G_OBJECT(result));
}
return result;
}
/******************************************************************************
* *
* Paramètres : buffer = tampon de lignes à consulter. *
* index = indice de la ligne recherchée. *
* *
* Description : Retrouve une ligne au sein d'un tampon avec un indice. *
* *
* Retour : Line retrouvée ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_code_buffer_find_line_by_index(const GCodeBuffer *buffer, size_t index)
{
GBufferLine *result; /* Ligne trouvée à retourner */
if (index < buffer->used)
result = buffer->lines[index];
else
result = NULL;
return result;
}
/******************************************************************************
* *
* Paramètres : buffer = composant GTK à mettre à jour. *
* *
* Description : Augmente l'indentation des prochaines lignes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_buffer_inc_indentation(GCodeBuffer *buffer)
{
buffer->indent++;
}
/******************************************************************************
* *
* Paramètres : buffer = composant GTK à mettre à jour. *
* *
* Description : Diminue l'indentation des prochaines lignes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_buffer_dec_indentation(GCodeBuffer *buffer)
{
/* BUG_ON(buffer->indent == 0) */
buffer->indent--;
}
/******************************************************************************
* *
* Paramètres : buffer = tampon de données à utiliser. *
* start = première adresse visée ou 0. *
* end = dernière adresse visée ou VMPA_MAX. *
* message = message à afficher lors de la progression. *
* process = fonction assurant le traitement effectif. *
* data = données utilisateur à faire suivre. *
* *
* Description : Lance un parcours des différentes lignes du tampon de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_code_scan(GCodeBuffer *buffer, vmpa_t start, vmpa_t end, const char *message, process_line_fc process, void *data)
{
GBufferScan *scan; /* Procédure de parcours */
GWorkQueue *queue; /* Gestionnaire de différés */
scan = g_buffer_scan_new(buffer, start, end, message, process, data);
queue = get_work_queue();
g_work_queue_schedule_work(queue, G_DELAYED_WORK(scan), DEFAULT_WORK_GROUP);
}
/* ---------------------------------------------------------------------------------- */
/* VUE PARTICULIERE D'UN TAMPON DE CODE */
/* ---------------------------------------------------------------------------------- */
/* Détermine le type de la vue d'un tampon pour code désassemblé. */
G_DEFINE_TYPE(GBufferView, g_buffer_view, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : class = classe de composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation d'une classe de vue de tampon. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_class_init(GBufferViewClass *class)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)g_buffer_view_dispose;
object->finalize = (GObjectFinalizeFunc)g_buffer_view_finalize;
g_signal_new("need-redraw",
G_TYPE_BUFFER_VIEW,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GBufferViewClass, need_redraw),
NULL, NULL,
g_cclosure_user_marshal_VOID__OBJECT,
G_TYPE_NONE, 0);
}
/******************************************************************************
* *
* Paramètres : buffer = composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation d'une vue d'un tampon pour code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_init(GBufferView *buffer)
{
buffer->first_index = 0;
g_buffer_view_reset_required_height(buffer);
g_buffer_view_reset_required_widths(buffer);
}
/******************************************************************************
* *
* Paramètres : view = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_dispose(GBufferView *view)
{
G_OBJECT_CLASS(g_buffer_view_parent_class)->dispose(G_OBJECT(view));
}
/******************************************************************************
* *
* Paramètres : view = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_finalize(GBufferView *view)
{
if (!view->external)
exit_segment_content_list(view->highlighted);
G_OBJECT_CLASS(g_buffer_view_parent_class)->finalize(G_OBJECT(view));
}
/******************************************************************************
* *
* Paramètres : buffer = tampon à représenter à l'écran. *
* widget = composant GTK de destination pour le rendu. *
* *
* Description : Crée une nouvelle vue d'un tampon pour code désassemblé. *
* *
* Retour : Composant GTK créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferView *g_buffer_view_new(GCodeBuffer *buffer, segcnt_list *highlighted)
{
GBufferView *result; /* Composant à retourner */
result = g_object_new(G_TYPE_BUFFER_VIEW, NULL);
g_object_ref(G_OBJECT(buffer));
result->buffer = buffer;
g_buffer_view_restrict(result, NULL, NULL);
if (highlighted != NULL)
result->highlighted = highlighted;
else
result->highlighted = init_segment_content_list();
result->external = (highlighted != NULL);
return result;
}
/******************************************************************************
* *
* Paramètres : view = visualisateur à mettre à jour. *
* first = première ligne à imprimer. *
* last = première ligne hors cadre. *
* *
* Description : Restreint le champ d'application de l'affichage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_view_restrict(GBufferView *view, const vmpa2t *start, const vmpa2t *end)
{
view->start = (start != NULL ? dup_vmpa(start) : NULL);
view->end = (end != NULL ? dup_vmpa(end) : NULL);
view->first_index = g_code_buffer_get_index_from_address(view->buffer, start, true);
view->last_index = g_code_buffer_get_index_from_address(view->buffer, end, false);
}
/******************************************************************************
* *
* Paramètres : view = visualisateur à mettre à jour. *
* first = première ligne à imprimer ou NULL. [OUT] *
* last = première ligne hors cadre ou NULL. [OUT] *
* *
* Description : Indique le champ d'application de l'affichage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_view_get_restrictions(GBufferView *view, vmpa2t *start, vmpa2t *end)
{
/* FIXME view->xxx == NULL -> plantage */
if (start != NULL) copy_vmpa(start, view->start);
if (end != NULL) copy_vmpa(end, view->end);
}
/******************************************************************************
* *
* Paramètres : view = visualisateur à consulter. *
* *
* Description : Fournit le tampon de code lié à un visualisateur donné. *
* *
* Retour : Tampon de code associé au gestionnaire d'affichage. *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBuffer *g_buffer_view_get_buffer(const GBufferView *view)
{
return view->buffer;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* *
* Description : Réinitialise le cache de la hauteur des lignes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_reset_required_height(GBufferView *view)
{
view->line_height = -1;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* *
* Description : Réinitialise le cache des largeurs de colonne calculées. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_reset_required_widths(GBufferView *view)
{
unsigned int i; /* Boucle de parcours */
for (i = 0; i < BLC_COUNT; i++)
view->max_widths[i] = -1;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à mettre à jour. *
* *
* Description : Calcule la hauteur requise par une visualisation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_compute_required_height(GBufferView *view)
{
view->line_height = 17;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à mettre à jour. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Calcule les largeurs requises par une visualisation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_view_compute_required_widths(GBufferView *view, const bool *display)
{
GBufferLine **lines; /* Liste des lignes à traiter */
size_t first; /* Première ligne intégrée */
size_t last; /* Dernière ligne intégrée */
size_t i; /* Boucle de parcours #1 */
unsigned int j; /* Boucle de parcours #2 */
gint width; /* Largeur d'une colonne */
BufferLineColumn merge; /* Début de fusion de colonnes */
if (!HEIGHT_CACHED(view))
g_buffer_view_compute_required_height(view);
lines = view->buffer->lines;
first = g_code_buffer_get_index_from_address(view->buffer, view->start, true);
last = g_code_buffer_get_index_from_address(view->buffer, view->end, false);
view->left_margin = 2 * view->line_height;
view->left_text = 2.5 * view->line_height;
view->last_width = 0;
view->last_merge = BLC_INVALID;
if (view->buffer->used > 0)
for (i = first; i <= last; i++)
{
for (j = 0; j < BLC_COUNT; j++)
{
width = g_buffer_line_get_column_width(lines[i], j);
view->max_widths[j] = MAX(view->max_widths[j], width);
}
width = g_buffer_line_get_merge_width(lines[i], &merge, display);
view->last_width = MAX(view->last_width, width);
if (merge != BLC_COUNT)
{
if (view->last_merge == BLC_INVALID)
view->last_merge = merge;
else
view->last_merge = MAX(view->last_merge, merge);
}
}
if (view->last_merge == BLC_INVALID)
view->last_merge = BLC_COUNT;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* *
* Description : Fournit la hauteur d'impression d'une ligne visualisée. *
* *
* Retour : Hauteur de ligne en pixel. *
* *
* Remarques : - *
* *
******************************************************************************/
gint g_buffer_view_get_line_height(GBufferView *view)
{
if (!HEIGHT_CACHED(view))
g_buffer_view_compute_required_height(view);
return view->line_height;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Fournit la largeur requise par une visualisation. *
* *
* Retour : Dimension calculée. *
* *
* Remarques : - *
* *
******************************************************************************/
gint g_buffer_view_get_width(GBufferView *view, const bool *display)
{
gint result; /* Taille à retourner */
gint col_width; /* Calcul selon les colonnes */
gint full_width; /* Calcul selon les fusions */
BufferLineColumn i; /* Boucle de parcours */
if (!WIDTHS_CACHED(view))
g_buffer_view_compute_required_widths(view, display);
result = view->left_text;
col_width = 0;
full_width = 0;
/* Première méthode */
for (i = 0; i < BLC_COUNT; i++)
{
if (i < BLC_DISPLAY && !display[i]) continue;
col_width += view->max_widths[i];
if ((i + 1) < BLC_COUNT)
col_width += COL_MARGIN;
}
/* Seconde méthode */
for (i = 0; i < view->last_merge; i++)
{
if (i < BLC_DISPLAY && !display[i]) continue;
full_width += view->max_widths[i];
if ((i + 1) < view->last_merge)
full_width += COL_MARGIN;
}
full_width += view->last_width + COL_MARGIN;
/* Mise en concurrence et poursuite... */
result += + MAX(col_width, full_width);
return result;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Fournit la largeur requise pour dépasser les marges gauches. *
* *
* Retour : Dimension calculée. *
* *
* Remarques : - *
* *
******************************************************************************/
gint g_buffer_view_get_margin(GBufferView *view, const bool *display)
{
gint result; /* Taille à retourner */
BufferLineColumn i; /* Boucle de parcours */
if (!WIDTHS_CACHED(view))
g_buffer_view_compute_required_widths(view, display);
result = view->left_text;
for (i = 0; i < BLC_DISPLAY; i++)
{
if (!display[i]) continue;
result += view->max_widths[i] + COL_MARGIN;
}
return result;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* *
* Description : Fournit la hauteur requise par une visualisation. *
* *
* Retour : Dimension calculée. *
* *
* Remarques : - *
* *
******************************************************************************/
gint g_buffer_view_get_height(const GBufferView *view)
{
gint result; /* Taille à retourner */
size_t first; /* Première ligne intégrée */
size_t last; /* Dernière ligne intégrée */
result = view->line_height;
first = g_code_buffer_get_index_from_address(view->buffer, view->start, true);
last = g_code_buffer_get_index_from_address(view->buffer, view->end, false);
result *= (last - first + 1);
return result;
}
/******************************************************************************
* *
* 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. *
* display = règles d'affichage des colonnes modulables. *
* caret = position du curseur à construire. [OUT] *
* *
* Description : Calcule la position idéale de curseur pour un point donné. *
* *
* Retour : Adresse si une a pu être déterminée, NULL sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, gint x, gint y, const bool *display, GdkRectangle *caret)
{
gint remaining; /* Copie de travail modifiable */
size_t index; /* Indice de ligne de tampon */
GBufferLine *line; /* Ligne à la position courante*/
GBufferSegment *segment; /* Segment présent sur la place*/
remaining = x;
line = g_buffer_view_find_line_and_segment_at(view, &remaining, y, &index, display, &segment);
if (line == NULL) return NULL;
if (segment == NULL) printf(" -- no segment\n");
if (segment == NULL) return NULL;
printf("\n[BASE] orig = %d tronc = %d reste = %d dernier = %d largeur = %d\n",
x, x - remaining, remaining, g_buffer_segment_get_caret_position(segment, remaining),
g_buffer_segment_get_width(segment));
printf(" '%s'\n", g_buffer_segment_get_text(segment, false));
caret->x = /*view->left_text +*/ (x - remaining) + g_buffer_segment_get_caret_position(segment, remaining);
caret->y = (index - view->first_index) * view->line_height;
caret->width = 2;
caret->height = view->line_height;
return get_mrange_addr(g_buffer_line_get_range(line));
}
/******************************************************************************
* *
* Paramètres : view = vue de tampon à mettre à jour. *
* line = ligne correspondant à la position. *
* index = indice de cette même ligne dans le tampon. *
* x = abscisse de la zone principale à traiter. *
* display = règles d'affichage des colonnes modulables. *
* caret = position du curseur à construire. [OUT] *
* *
* Description : Calcule la position idéale de curseur pour un point donné. *
* *
* Retour : Adresse si une a pu être déterminée, NULL sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
const vmpa2t *g_buffer_view_compute_caret_full(GBufferView *view, GBufferLine *line, size_t index, gint x, const bool *display, GdkRectangle *caret)
{
gint offset; /* Point de travail modifiable */
gint base; /* Position absolue de segment */
GBufferSegment *segment; /* Segment visé par le pointeur*/
offset = x;
offset -= view->left_text;
if (offset < 0) return NULL;
segment = g_buffer_line_get_segment_at(line, view->max_widths, display, &base, &offset, GDK_SCROLL_LEFT, true);
if (segment == NULL) return NULL;
caret->x = view->left_text + base + offset;
printf("caret Y : %zu -> %zu\n", view->first_index, index);
caret->y = (index - view->first_index) * view->line_height;
caret->width = 2;
caret->height = view->line_height;
return get_mrange_addr(g_buffer_line_get_range(line));
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* caret = position du curseur à faire évoluer. *
* ctrl = indique la demande d'un parcours rapide. *
* dir = direction du parcours. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Déplace le curseur au sein d'une vue de tampon. *
* *
* Retour : true si un déplacement a été effectué, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, const bool *display)
{
bool result; /* Bilan à retourner */
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;
offset -= view->left_text;
if (offset < 0) return false;
segment = g_buffer_line_get_segment_at(line, view->max_widths, display, &base, &offset, dir, false);
if (segment == NULL) printf(" ===== NO SEG...\n");
if (segment == NULL) return false;
printf(" ====== FIRST SEG :: %p ('%s')\n", segment, g_buffer_segment_get_text(segment, false));
ref_x = offset;
//if (dir == GDK_SCROLL_LEFT || dir == GDK_SCROLL_RIGHT)
result = g_buffer_segment_move_caret(segment, &offset, ctrl, dir);
//else
//result = true;
printf(" ====== MOVE 1 ? %d\n", result);
///////////////////
if (!result)
{
base = 0;
segment = g_buffer_line_find_near_segment(line, segment, view->max_widths, display, dir, &offset);
printf(" ====== NEAR SEG :: %p ('%s')\n", segment, segment ? g_buffer_segment_get_text(segment, false) : NULL);
if (segment != NULL)
{
result = true;
//result = g_buffer_segment_move_caret(segment, &offset, ctrl, dir);
/*
if (result)
caret->x -= COL_MARGIN;
*/
printf(" ====== MOVE 2 ? %d (offset=%d)\n", result, offset);
}
}
if (result)
printf(" ====== NEW CARET: %d -> %d\n", caret->x, view->left_text + base + offset);
else
printf(" ====== NO NEW CARET!\n");
if (result)
caret->x = view->left_text + base + offset;
return result;
}
/******************************************************************************
* *
* Paramètres : view = vue de tampon à mettre à jour. *
* caret = position du curseur à faire évoluer. *
* ctrl = indique la demande d'un parcours rapide. *
* dir = direction du parcours. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Déplace le curseur au sein d'une vue de tampon. *
* *
* Retour : Adresse si une a pu être déterminée, VMPA_INVALID sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
const vmpa2t *g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, const bool *display)
{
const vmpa2t *result; /* Actualisation à renvoyer */
size_t index; /* Indice de ligne de tampon */
GBufferLine *line; /* Ligne sous le pointeur */
bool computed; /* Récursivité pris en compte */
gint lheight; /* Hauteur d'une ligne */
gint left_pos; /* Retour à la ligne */
gint right_pos; /* Position d'extrème droite */
BufferLineColumn i; /* Boucle de parcours */
size_t first; /* Première ligne intégrée */
size_t last; /* Dernière ligne intégrée */
bool moved; /* Mémorisation d'une évolut° */
gint tmp_x; /* Copie de travail modifiable */
GBufferSegment *segment; /* Segment visé par le pointeur*/
result = NULL;
computed = false;
line = g_buffer_view_find_line_at(view, caret->y, &index);
if (line == NULL) return NULL;
lheight = g_buffer_view_get_line_height(view);
switch (dir)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN:
lheight = g_buffer_view_get_line_height(view);
break;
case GDK_SCROLL_LEFT:
case GDK_SCROLL_RIGHT:
left_pos = view->left_text;
if (display[BLC_PHYSICAL]) left_pos += view->max_widths[BLC_PHYSICAL] + COL_MARGIN;
if (display[BLC_VIRTUAL]) left_pos += view->max_widths[BLC_VIRTUAL] + COL_MARGIN;
if (display[BLC_BINARY]) left_pos += view->max_widths[BLC_BINARY] + COL_MARGIN;
right_pos = left_pos;
for (i = BLC_ASSEMBLY_HEAD; i < BLC_COUNT; i++)
right_pos += view->max_widths[i] + COL_MARGIN;
left_pos = view->left_text;
break;
default: /* GDK_SCROLL_SMOOTH */
break;
}
first = view->first_index;
last = view->last_index;
switch (dir)
{
case GDK_SCROLL_UP:
if (index > first)
{
line = view->buffer->lines[index - 1];
result = g_buffer_view_compute_caret_full(view, line, index - 1, caret->x, display, caret);
}
break;
case GDK_SCROLL_DOWN:
if (index < last)
{
line = view->buffer->lines[index + 1];
result = g_buffer_view_compute_caret_full(view, line, index + 1, caret->x, display, caret);
}
break;
case GDK_SCROLL_LEFT:
/*
line = g_buffer_view_find_line_at(view, caret->y, &index);
if (line == NULL) break;
*/
moved = _g_buffer_view_move_caret(view, line, caret, ctrl, GDK_SCROLL_LEFT, display);
if (moved)
result = get_mrange_addr(g_buffer_line_get_range(line));
else if (index > first)
{
line = view->buffer->lines[index - 1];
result = g_buffer_view_compute_caret_full(view, line, index - 1, INT_MAX, display, caret);
}
break;
case GDK_SCROLL_RIGHT:
/*
line = g_buffer_view_find_line_at(view, caret->y, &index);
if (line == NULL) break;
*/
moved = _g_buffer_view_move_caret(view, line, caret, ctrl, GDK_SCROLL_RIGHT, display);
if (moved)
result = get_mrange_addr(g_buffer_line_get_range(line));
else if (index < last)
{
line = view->buffer->lines[index + 1];
result = g_buffer_view_compute_caret_full(view, line, index + 1, left_pos, display, caret);
}
break;
default: /* GDK_SCROLL_SMOOTH */
break;
}
printf(" --- CARET --- moved = %d index = %d result = %p\n",
moved, index, result);
/*
if (result && !computed)
result = g_buffer_view_compute_caret_full(view, caret->x, caret->y, caret, display, NULL);
*/
return result;
}
/******************************************************************************
* *
* Paramètres : view = vue de tampon à mettre à jour. *
* *
* Description : Supprime toute mise en évidence de segments. *
* *
* Retour : true si un besoin d'actualisation d'affichage se fait sentir.*
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_view_unhighlight_segments(GBufferView *view)
{
bool result; /* Bilan d'action à renvoyer */
result = reset_segment_content_list(view->highlighted);
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. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Surligne tous les segments similaires à celui sous la souris.*
* *
* Retour : true si un besoin d'actualisation d'affichage se fait sentir.*
* *
* Remarques : - *
* *
******************************************************************************/
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)
need_redraw = g_buffer_view_unhighlight_segments(view);
else
need_redraw = false;
line = 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);
if (need_redraw)
g_signal_emit_by_name(view, "need-redraw");
return true;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à représenter. *
* cr = contexte graphique dédié à la procédure. *
* fake_x = abscisse réelle du point 0 à l'écran. *
* fake_y = ordonnée réelle du point 0 à l'écran. *
* area = position et surface à traiter. *
* display = règles d'affichage des colonnes modulables. *
* selected = ordonnée d'une ligne sélectionnée ou NULL. *
* *
* Description : Imprime la visualisation du tampon de code désassemblé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint fake_x, gint fake_y, const cairo_rectangle_int_t *area, const bool *display, const gint *selected)
{
gint real_x; /* Abscisse réelle pour tampon */
gint real_y; /* Ordonnée réelle pour tampon */
size_t first; /* Première ligne visée */
size_t last; /* Dernière ligne visée + 1 */
gint y; /* Point de départ + décallage */
GBufferLine **lines; /* Liste des lignes à traiter */
bool wait_selection; /* Sélection déjà passée ? */
gint rel_selected; /* Position relative de sélect°*/
size_t i; /* Boucle de parcours */
real_x = fake_x + view->left_text;
real_y = fake_y + area->y;
first = view->first_index;
first += (real_y / view->line_height);
last = first + (area->height / view->line_height);
if (area->height % view->line_height > 0) last++;
last = MIN(last, view->last_index);
y = area->y - (real_y % view->line_height);
lines = view->buffer->lines;
wait_selection = true;
if (selected != NULL)
rel_selected = *selected - fake_y;
if (view->buffer->used > 0)
for (i = first; i <= last; i++)
{
/* Si sélection, on sousligne la ligne concernée */
if (wait_selection && selected != NULL && rel_selected == y)
{
cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.05);
cairo_rectangle(cr, area->x, y, area->width, view->line_height);
cairo_fill(cr);
wait_selection = false;
}
g_buffer_line_draw(lines[i], cr, view->max_widths, real_x, y, display, view->highlighted);
y += view->line_height;
}
}
/******************************************************************************
* *
* Paramètres : view = visualisation à représenter. *
* ctx = éléments à disposition pour l'exportation. *
* type = type d'exportation attendue. *
* display = règles d'affichage des colonnes modulables. *
* *
* Description : Exporte le contenu du tampon de code désassemblé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_view_export(const GBufferView *view, buffer_export_context *ctx, BufferExportType type, const bool *display)
{
size_t start; /* Première ligne visée */
size_t end; /* Dernière ligne avant limite */
GBufferLine **lines; /* Liste des lignes à traiter */
size_t i; /* Boucle de parcours */
start = g_code_buffer_get_index_from_address(view->buffer, view->start, true);
end = g_code_buffer_get_index_from_address(view->buffer, view->end, false);
lines = view->buffer->lines;
switch (type)
{
case BET_HTML:
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\t\n");
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\n");
break;
default:
break;
}
if (view->buffer->used > 0)
for (i = start; i <= end; i++)
g_buffer_line_export(lines[i], ctx, type, display);
switch (type)
{
case BET_HTML:
dprintf(ctx->fd, "
\n");
dprintf(ctx->fd, "\n");
dprintf(ctx->fd, "\n");
break;
default:
break;
}
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* 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] *
* *
* Description : Retrouve une ligne au sein d'un tampon avec une adresse. *
* *
* Retour : Line retrouvée ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_buffer_view_find_line_by_addr(const GBufferView *view, const vmpa2t *addr, BufferLineFlags flags, size_t *idx)
{
GBufferLine *result; /* Ligne trouvée à retourner */
phys_t length; /* Taille de la vue */
mrange_t vrange; /* Couverture de la vue */
bool allowed; /* Rechercher validée ? */
/* Vérification des bornes */
if (view->start != NULL/* && view->end != NULL*/)
{
length = compute_vmpa_diff(view->start, view->end);
init_mrange(&vrange, view->start, length);
allowed = mrange_contains_addr_inclusive(&vrange, addr);
}
else allowed = true;
/* Lancement des recherches ? */
if (allowed)
result = g_code_buffer_find_line_by_addr(view->buffer, addr, flags, idx);
else
result = NULL;
return result;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* index = indice de la ligne recherchée. *
* *
* Description : Retrouve une ligne au sein d'un tampon avec un indice. *
* *
* Retour : Line retrouvée ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_buffer_view_find_line_by_index(const GBufferView *view, size_t index)
{
GBufferLine *result; /* Ligne trouvée à retourner */
bool allowed; /* Rechercher validée ? */
/* Vérification des bornes */
allowed = (view->first_index <= index && index < view->last_index);
/* Lancement des recherches ? */
if (allowed)
result = view->buffer->lines[index];
else
result = NULL;
return result;
}
/******************************************************************************
* *
* Paramètres : view = visualisation à consulter. *
* y = ordonnée comprise dans la ligne recherchée. *
* idx = indice de la ligne trouvée ou NULL. [OUT] *
* *
* Description : Fournit la ligne présente à une ordonnée donnée. *
* *
* Retour : Ligne retrouvée ou NULL si aucune. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_buffer_view_find_line_at(GBufferView *view, gint y, size_t *idx)
{
gint lheight; /* Hauteur d'une ligne */
size_t index; /* Indice attendu */
lheight = g_buffer_view_get_line_height(view);
index = y / lheight;
index += view->first_index;
if (idx != NULL)
*idx = index;
return (index < view->buffer->used ? view->buffer->lines[index] : NULL);
}
/******************************************************************************
* *
* Paramètres : view = composant GTK à consulter. *
* addr = adresse à présenter à l'écran. *
* x = position horizontale au sein du composant. [OUT] *
* y = position verticale au sein du composant. [OUT] *
* code = s'arrête si possible à une ligne avec code. *
* *
* Description : Indique la position d'affichage d'une adresse donnée. *
* *
* Retour : true si l'adresse fait partie du composant, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_view_get_address_coordinates(GBufferView *view, const vmpa2t *addr, gint *x, gint *y, bool code)
{
bool result; /* Bilan à retourner */
gint lheight; /* Hauteur d'une ligne */
size_t first; /* Première ligne intégrée */
size_t last; /* Dernière ligne intégrée */
size_t i; /* Boucle de parcours */
const mrange_t *range; /* Emplacement parcouru */
result = false;
*x = 0;
*y = 0;
lheight = g_buffer_view_get_line_height(view);
first = g_code_buffer_get_index_from_address(view->buffer, view->start, true);
last = g_code_buffer_get_index_from_address(view->buffer, view->end, false);
for (i = first; i <= last; i++)
{
/**
* Si l'adresse recherchée est plus petite que l'adresse de départ,
* on va effectuer un parcours complet pour rien.
*
* On considère cependant que le seul cas où celà peut arriver
* est lorsque que des découpages en blocs sont impliqués.
*
* Les découpages conduisent alors à la formation de petites zones,
* rapides à parcourir.
*/
range = g_buffer_line_get_range(view->buffer->lines[i]);
result = mrange_contains_addr(range, addr);
if (result) break;
*y += lheight;
}
if (result && code)
for (; i <= last; i++)
{
if (g_buffer_line_get_flags(view->buffer->lines[i]) & BLF_HAS_CODE) break;
if (i == last) break;
range = g_buffer_line_get_range(view->buffer->lines[i + 1]);
if (!mrange_contains_addr(range, addr)) break;
*y += lheight;
}
return result;
}