summaryrefslogtreecommitdiff
path: root/src/glibext
diff options
context:
space:
mode:
Diffstat (limited to 'src/glibext')
-rw-r--r--src/glibext/gbinportion.c708
-rw-r--r--src/glibext/gbinportion.h67
2 files changed, 224 insertions, 551 deletions
diff --git a/src/glibext/gbinportion.c b/src/glibext/gbinportion.c
index 8fc7805..4137763 100644
--- a/src/glibext/gbinportion.c
+++ b/src/glibext/gbinportion.c
@@ -34,6 +34,7 @@
#include "../common/extstr.h"
+#include "../common/sort.h"
@@ -45,8 +46,6 @@ struct _GBinPortion
{
GObject parent; /* A laisser en premier */
- const unsigned int *level; /* Profondeur de la portion */
-
char *code; /* Code de la couleur de fond */
char *desc; /* Désignation humaine */
@@ -55,6 +54,9 @@ struct _GBinPortion
PortionAccessRights rights; /* Droits d'accès */
+ GBinPortion **subs; /* Portions incluses */
+ size_t count; /* Quantité d'inclusions */
+
};
/* Portion de données binaires quelconques (classe) */
@@ -77,58 +79,16 @@ static void g_binary_portion_dispose(GBinPortion *);
/* Procède à la libération totale de la mémoire. */
static void g_binary_portion_finalize(GBinPortion *);
-/* Définit le niveau de profondeur pour une branche de portions. */
-static void g_binary_portion_set_level(GBinPortion *, const unsigned int *);
-
/* Détermine l'aire d'une sous-portion. */
static bool g_binary_portion_compute_sub_area(const GBinPortion *, phys_t, const GdkRectangle *, GdkRectangle *);
-/* Détermine si une portion contient une adresse donnée. */
-static bool g_portion_layer_contains_addr(const GBinPortion *, const vmpa2t *);
-
-
-
-/* -------------------------- COUCHES DE PORTIONS BINAIRES -------------------------- */
-
-
-/* Couche de portions binaires quelconques (instance) */
-struct _GPortionLayer
-{
- GObject parent; /* A laisser en premier */
-
- phys_t length; /* Taille de portion globale */
- const char *name; /* Désignation de la couche */
-
- unsigned int level; /* Profondeur de la portion */
-
- GPortionLayer *sub_layer; /* Eventuelle couche inférieure*/
-
- GBinPortion **portions; /* Portions incluses */
- size_t count; /* Quantité d'inclusions */
-
-};
-
-/* Couche de portions binaires quelconques (classe) */
-struct _GPortionLayerClass
-{
- GObjectClass parent; /* A laisser en premier */
-
-};
-
-
-/* Initialise la classe des couches de portions binaires. */
-static void g_portion_layer_class_init(GPortionLayerClass *);
-/* Initialise une instance de couche de portions binaires. */
-static void g_portion_layer_init(GPortionLayer *);
-/* Supprime toutes les références externes. */
-static void g_portion_layer_dispose(GPortionLayer *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_portion_layer_finalize(GPortionLayer *);
+/* ------------------------ PARCOURS D'ENSEMBLES DE PORTIONS ------------------------ */
+/* Détermine si une portion contient une adresse donnée. */
+static bool g_portion_layer_contains_addr(const GBinPortion *, const vmpa2t *);
@@ -180,7 +140,6 @@ static void g_binary_portion_class_init(GBinPortionClass *klass)
static void g_binary_portion_init(GBinPortion *portion)
{
- portion->level = NULL;
}
@@ -231,6 +190,8 @@ static void g_binary_portion_finalize(GBinPortion *portion)
/******************************************************************************
* *
* Paramètres : code = désignation humaine de la couleur de fond. *
+* addr = emplacement de la section à conserver. *
+* size = taille de la section à conserver. *
* *
* Description : Crée une description de partie de code vierge. *
* *
@@ -240,7 +201,7 @@ static void g_binary_portion_finalize(GBinPortion *portion)
* *
******************************************************************************/
-GBinPortion *g_binary_portion_new(const char *code)
+GBinPortion *g_binary_portion_new(const char *code, const vmpa2t *addr, phys_t size)
{
GBinPortion *result; /* Structure à retourner */
@@ -248,27 +209,9 @@ GBinPortion *g_binary_portion_new(const char *code)
result->code = strdup(code);
- return result;
-
-}
+ init_mrange(&result->range, addr, size);
-
-/******************************************************************************
-* *
-* Paramètres : portion = description de partie à mettre à jour. *
-* level = niveau de profondeur à associer. *
-* *
-* Description : Définit le niveau de profondeur pour une branche de portions.*
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void g_binary_portion_set_level(GBinPortion *portion, const unsigned int *level)
-{
- portion->level = level;
+ return result;
}
@@ -291,31 +234,12 @@ int g_binary_portion_compare(const GBinPortion **a, const GBinPortion **b)
int result; /* Bilan à retourner */
const vmpa2t *addr_a; /* Adresse de la portion 'a' */
const vmpa2t *addr_b; /* Adresse de la portion 'b' */
- const unsigned int *level_a; /* Niveau de la portion 'a' */
- const unsigned int *level_b; /* Niveau de la portion 'b' */
addr_a = get_mrange_addr(&(*a)->range);
addr_b = get_mrange_addr(&(*b)->range);
result = cmp_vmpa(addr_a, addr_b);
- if (result == 0)
- {
- level_a = (*a)->level;
- level_b = (*b)->level;
-
- if (level_a != NULL && level_b != NULL)
- {
- if (*level_a < *level_b)
- result = -1;
-
- else if (*level_a > *level_b)
- result = 1;
-
- }
-
- }
-
return result;
}
@@ -365,27 +289,6 @@ const char *g_binary_portion_get_desc(const GBinPortion *portion)
/******************************************************************************
* *
* Paramètres : portion = description de partie à mettre à jour. *
-* addr = emplacement de la section à conserver. *
-* size = taille de la section à conserver. *
-* *
-* Description : Définit les valeurs utiles d'une partie de code binaire. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-void g_binary_portion_set_values(GBinPortion *portion, const vmpa2t *addr, phys_t size)
-{
- init_mrange(&portion->range, addr, size);
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : portion = description de partie à mettre à jour. *
* *
* Description : Fournit l'emplacement d'une partie de code binaire. *
* *
@@ -443,76 +346,6 @@ PortionAccessRights g_binary_portion_get_rights(const GBinPortion *portion)
/******************************************************************************
* *
-* Paramètres : portion = portion mère à consulter. *
-* full = taille totale de la couche parente. *
-* area = étendue de représentation de la portion mère. *
-* sub_area = étendue de représentation de la portion fille. *
-* *
-* Description : Détermine l'aire d'une sous-portion. *
-* *
-* Retour : true si la sous-surface a été calculée correctement. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool g_binary_portion_compute_sub_area(const GBinPortion *portion, phys_t full, const GdkRectangle *area, GdkRectangle *sub_area)
-{
- phys_t length; /* Taille de la portion */
- phys_t start; /* Position de départ */
-
- length = get_mrange_length(&portion->range);
-
- /* On saute les portions comme le segment GNU_STACK... */
- if (length == 0) return false;
-
- start = get_phy_addr(get_mrange_addr(&portion->range));
-
- sub_area->y = area->y;
- sub_area->height = area->height;
-
- sub_area->x = area->x + (start * area->width) / full;
- sub_area->width = (length * area->width) / full;
-
- return true;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : portion = portion mère à consulter. *
-* addr = adresse du point de recherche. *
-* *
-* Description : Détermine si une portion contient une adresse donnée. *
-* *
-* Retour : true ou false selon le résultat. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool g_portion_layer_contains_addr(const GBinPortion *portion, const vmpa2t *addr)
-{
- bool result; /* Bilan à retourner */
-
- result = false;
-
- /* Portion non allouée en mémoire -> adresse nulle ; on écarte */
- if (get_virt_addr(get_mrange_addr(&portion->range)) == 0)
- goto not_found;
-
- result = mrange_contains_addr(&portion->range, addr);
-
- not_found:
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
* Paramètres : portion = description de partie à consulter. *
* buffer = espace où placer ledit contenu. *
* msize = taille idéale des positions et adresses; *
@@ -686,52 +519,50 @@ void g_binary_portion_query_tooltip(GBinPortion *portion, GtkTooltip *tooltip)
/******************************************************************************
* *
-* Paramètres : portion = description de partie à consulter. *
-* cr = contexte graphique pour le dessin. *
-* area = étendue mise à disposition. *
+* Paramètres : portion = portion mère à consulter. *
+* full = taille totale de la couche parente. *
+* area = étendue de représentation de la portion mère. *
+* sub_area = étendue de représentation de la portion fille. *
* *
-* Description : Représente la portion sur une bande dédiée. *
+* Description : Détermine l'aire d'une sous-portion. *
* *
-* Retour : - *
+* Retour : true si la sous-surface a été calculée correctement. *
* *
* Remarques : - *
* *
******************************************************************************/
-void g_binary_portion_draw(const GBinPortion *portion, GtkStyleContext *context, cairo_t *cr, const GdkRectangle *area)
+static bool g_binary_portion_compute_sub_area(const GBinPortion *portion, phys_t full, const GdkRectangle *area, GdkRectangle *sub_area)
{
- //cairo_set_line_width(cr, 1.0);
+ phys_t length; /* Taille de la portion */
+ phys_t start; /* Position de départ */
- cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ length = get_mrange_length(&portion->range);
- gtk_style_context_save(context);
+ /* On saute les portions comme le segment GNU_STACK... */
+ if (length == 0) return false;
- gtk_style_context_add_class(context, portion->code);
+ start = get_phy_addr(get_mrange_addr(&portion->range));
- gtk_render_background(context, cr, area->x, area->y, area->width, area->height);
+ sub_area->y = area->y;
+ sub_area->height = area->height;
- gtk_render_frame(context, cr, area->x, area->y, area->width, area->height);
+ sub_area->x = area->x + (start * area->width) / full;
+ sub_area->width = (length * area->width) / full;
- gtk_style_context_restore(context);
+ return true;
}
-
-/* ---------------------------------------------------------------------------------- */
-/* COUCHES DE PORTIONS BINAIRES */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini par la GLib pour les couches de portions binaires. */
-G_DEFINE_TYPE(GPortionLayer, g_portion_layer, G_TYPE_OBJECT);
-
-
/******************************************************************************
* *
-* Paramètres : klass = classe à initialiser. *
+* Paramètres : portion = description de partie à consulter. *
+* context = contexte graphique associé à la procédure. *
+* cr = contexte graphique pour le dessin. *
+* area = étendue mise à disposition. *
* *
-* Description : Initialise la classe des couches de portions binaires. *
+* Description : Représente la portion sur une bande dédiée. *
* *
* Retour : - *
* *
@@ -739,70 +570,51 @@ G_DEFINE_TYPE(GPortionLayer, g_portion_layer, G_TYPE_OBJECT);
* *
******************************************************************************/
-static void g_portion_layer_class_init(GPortionLayerClass *klass)
+void g_binary_portion_draw(const GBinPortion *portion, GtkStyleContext *context, cairo_t *cr, const GdkRectangle *area)
{
- GObjectClass *object; /* Autre version de la classe */
-
- object = G_OBJECT_CLASS(klass);
+ phys_t full; /* Espace total représenté */
+ size_t i; /* Boucle de parcours */
+ GBinPortion *sub; /* Portion incluse à montrer */
+ GdkRectangle sub_area; /* Etendue d'une sous-portion */
- object->dispose = (GObjectFinalizeFunc/* ! */)g_portion_layer_dispose;
- object->finalize = (GObjectFinalizeFunc)g_portion_layer_finalize;
+ /* Dessin de la portion courante */
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
-}
+ gtk_style_context_save(context);
+ gtk_style_context_add_class(context, portion->code);
-/******************************************************************************
-* *
-* Paramètres : layer = instance à initialiser. *
-* *
-* Description : Initialise une instance de couche de portions binaires. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ gtk_render_background(context, cr, area->x, area->y, area->width, area->height);
-static void g_portion_layer_init(GPortionLayer *layer)
-{
- layer->level = 0;
+ gtk_render_frame(context, cr, area->x, area->y, area->width, area->height);
-}
+ gtk_style_context_restore(context);
+ /* Dessin des portions contenues */
-/******************************************************************************
-* *
-* Paramètres : layer = instance d'objet GLib à traiter. *
-* *
-* Description : Supprime toutes les références externes. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ full = get_mrange_length(&portion->range);
-static void g_portion_layer_dispose(GPortionLayer *layer)
-{
- size_t i; /* Boucle de parcours */
+ for (i = 0; i < portion->count; i++)
+ {
+ sub = portion->subs[i];
- if (layer->sub_layer != NULL)
- g_object_unref(G_OBJECT(layer->sub_layer));
+ if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area))
+ continue;
- for (i = 0; i < layer->count; i++)
- g_object_unref(G_OBJECT(layer->portions[i]));
+ g_binary_portion_draw(sub, context, cr, &sub_area);
- G_OBJECT_CLASS(g_portion_layer_parent_class)->dispose(G_OBJECT(layer));
+ }
}
/******************************************************************************
* *
-* Paramètres : layer = instance d'objet GLib à traiter. *
+* Paramètres : portion = portion principale à compléter. *
+* sub = portion à inclure dans la définition courante. *
* *
-* Description : Procède à la libération totale de la mémoire. *
+* Description : Procède à l'inclusion d'une portion dans une autre. *
* *
* Retour : - *
* *
@@ -810,204 +622,161 @@ static void g_portion_layer_dispose(GPortionLayer *layer)
* *
******************************************************************************/
-static void g_portion_layer_finalize(GPortionLayer *layer)
+void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub)
{
- if (layer->portions != NULL)
- free(layer->portions);
-
- G_OBJECT_CLASS(g_portion_layer_parent_class)->finalize(G_OBJECT(layer));
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : length =
-* name = désignation pouvant servir de suffixe aux portions. *
-* *
-* Description : Crée une nouvelle couche de portions binaires. *
-* *
-* Retour : Instance mise en place. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GPortionLayer *g_portion_layer_new(phys_t length, const char *name)
-{
- GPortionLayer *result; /* Structure à retourner */
-
- result = g_object_new(G_TYPE_BIN_PORTION, NULL);
-
- result->length = length;
- result->name = name;
-
- return result;
-
-}
+ bool found; /* Zone d'accueil trouvée ? */
+ size_t best; /* Meilleur point d'insertion */
+ const mrange_t *prange; /* Emplacement de portion #1 */
+ const mrange_t *srange; /* Emplacement de portion #2 */
+ GBinPortion tmp; /* Sauvegarde temporaire */
+ found = bsearch_index(sub, portion->subs, portion->count, sizeof(GBinPortion *),
+ (__compar_fn_t)g_binary_portion_compare, &best);
-/******************************************************************************
-* *
-* Paramètres : layer = couche rassemblant des portions à modifier. *
-* Paramètres : sub = couche inférieure à rattacher à la couche courante. *
-* *
-* Description : Attache une couche à une autre en tant que couche inférieure.*
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ if (!found)
+ portion->subs = qinsert(portion->subs, &portion->count, sizeof(GBinPortion *),
+ (__compar_fn_t)g_binary_portion_compare, &sub);
-void g_portion_layer_attach_sub(GPortionLayer *layer, GPortionLayer *sub)
-{
- void set_layers_length(GPortionLayer *parent, GPortionLayer *child)
+ else
{
- if (child->length == NO_LENGTH_YET)
+ /**
+ * On prend ici en compte le genre de situations suivantes :
+ *
+ * [21] .bss NOBITS 00088240 07823c 0018c8 00 WA 0 0 8
+ * [22] __libc_freeres_ptrs NOBITS 00089b08 07823c 000018 00 WA 0 0 4
+ * [23] .comment PROGBITS 00000000 07823c 000022 01 MS 0 0 1
+ *
+ * Pendant le désassemblage, la procédure n'aime pas trop les intersections
+ * de zones mémoire.
+ */
+
+ prange = g_binary_portion_get_range(portion->subs[best]);
+ srange = g_binary_portion_get_range(sub);
+
+ if (mrange_contains_mrange(prange, srange))
+ g_binary_portion_include(portion->subs[best], sub);
+
+ else
{
- assert(parent->length != NO_LENGTH_YET);
+ assert(mrange_contains_mrange(srange, prange));
- child->length = parent->length;
+ memcpy(&tmp, portion->subs[best], sizeof(GBinPortion));
+ memcpy(portion->subs[best], sub, sizeof(GBinPortion));
+ memcpy(sub, &tmp, sizeof(GBinPortion));
- if (child->sub_layer != NULL)
- set_layers_length(child, child->sub_layer);
+ g_binary_portion_include(portion->subs[best], sub);
}
}
- void set_layers_depth(GPortionLayer *parent, GPortionLayer *child)
- {
- child->level = parent->level + 1;
-
- if (child->sub_layer != NULL)
- set_layers_length(child, child->sub_layer);
-
- }
-
- set_layers_length(layer, sub);
-
- set_layers_depth(layer, sub);
-
- layer->sub_layer = sub;
-
}
/******************************************************************************
* *
-* Paramètres : layer = couche rassemblant les portions d'un même niveau. *
-* portion = portion à inclure dans la définition courante. *
+* Paramètres : portion = première couche amorçant la visite. *
+* visitor = fonction à appeler à chaque étape de la descente. *
+* data = adresse pointant vers des données de l'utilisateur.*
* *
-* Description : Procède à l'inclusion d'une portion dans une couche. *
+* Description : Parcourt un ensemble de portions binaires. *
* *
-* Retour : - *
+* Retour : true si la visite a été jusqu'à son terme, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
-void g_portion_layer_include(GPortionLayer *layer, GBinPortion *portion)
+bool g_binary_portion_visit(GBinPortion *portion, visit_portion_fc visitor, void *data)
{
- GPortionLayer *sub; /* Sous couche indispensable */
- bool conflict; /* Conflit dû aux débordements */
- const mrange_t *range; /* Emplacement de la portion */
- size_t i; /* Boucle de parcours */
- const mrange_t *other; /* Emplacements déjà occupés */
-
- /**
- * On prend ici en compte le genre de situations suivantes :
- *
- * [21] .bss NOBITS 00088240 07823c 0018c8 00 WA 0 0 8
- * [22] __libc_freeres_ptrs NOBITS 00089b08 07823c 000018 00 WA 0 0 4
- * [23] .comment PROGBITS 00000000 07823c 000022 01 MS 0 0 1
- *
- * Pendant le désassemblage, la procédure n'aime pas trop les intersections
- * de zones mémoire.
- */
+ bool result; /* Etat à retourner */
- conflict = false;
+ bool visit_portion(GBinPortion *p, GBinPortion *pp)
+ {
+ bool ret; /* Etat à retourner */
+ size_t i; /* Boucle de parcours */
- range = g_binary_portion_get_range(portion);
+ if (p->count == 0)
+ ret = visitor(p, pp, BPV_SHOW, data);
- for (i = 0; i < layer->count && !conflict; i++)
- {
- other = g_binary_portion_get_range(layer->portions[i]);
+ else
+ {
+ ret = visitor(p, pp, BPV_ENTER, data);
- conflict = mrange_intersects_mrange(range, other);
+ for (i = 0; i < p->count && ret; i++)
+ ret = visit_portion(p->subs[i], p);
- }
+ if (ret)
+ ret = visitor(p, pp, BPV_EXIT, data);
- /* La portion recouvre-t-elle une portion déjà existante ? */
- if (conflict)
- {
- if (layer->sub_layer == NULL)
- {
- sub = g_portion_layer_new(layer->length, layer->name);
- g_portion_layer_attach_sub(layer, sub);
}
- g_portion_layer_include(layer->sub_layer, portion);
+ return ret;
}
- /* Sinon on l'intègre dans la couche courante */
- else
- {
- layer->portions = (GBinPortion **)realloc(layer->portions,
- ++layer->count * sizeof(GBinPortion *));
+ result = visit_portion(portion, NULL);
- layer->portions[layer->count - 1] = portion;
+ return result;
- g_binary_portion_set_level(portion, &layer->level);
+}
- qsort(layer->portions, layer->count, sizeof(GBinPortion *), (__compar_fn_t)g_binary_portion_compare);
- }
-}
+/* ---------------------------------------------------------------------------------- */
+/* PARCOURS D'ENSEMBLES DE PORTIONS */
+/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
-* Paramètres : layer = couche première à parcourir intégralement. *
-* count = nombre de portions trouvées et renvoyées. [OUT] *
+* Paramètres : portion = couche de portions à parcourir pour les recherches.*
+* x = abscisse du point de recherche. *
+* area = étendue de portion mère, puis celle trouvée. [OUT] *
* *
-* Description : Fournit une liste triée de portions d'un binaire. *
+* Description : Recherche la portion présente à un point donné. *
* *
-* Retour : Liste de définitions de zones à libérer après usage. *
+* Retour : Portion trouvée à l'endroit indiqué. *
* *
* Remarques : - *
* *
******************************************************************************/
-GBinPortion **g_portion_layer_collect_all_portions(const GPortionLayer *layer, size_t *count)
+GBinPortion *g_binary_portion_find_at_pos(GBinPortion *portion, gint x, GdkRectangle *area)
{
- GBinPortion **result; /* Liste construite à renvoyer */
+ GBinPortion *result; /* Portion à retourner */
+ phys_t full; /* Espace total représenté */
+ size_t i; /* Boucle de parcours */
+ GBinPortion *sub; /* Portion incluse à traiter */
+ GdkRectangle sub_area; /* Etendue d'une sous-portion */
- GBinPortion **do_collect(const GPortionLayer *l, GBinPortion **lst, size_t *c)
- {
- size_t start; /* Indice de départ des ajouts */
- size_t i; /* Boucle de parcours */
+ result = NULL;
- start = *c;
- *c += l->count;
+ full = get_mrange_length(&portion->range);
- lst = (GBinPortion **)realloc(lst, *c * sizeof(GBinPortion *));
+ for (i = 0; i < portion->count && result == NULL; i++)
+ {
+ sub = portion->subs[i];
- for (i = 0; i < l->count; i++)
- lst[start + i] = l->portions[i];
+ if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area))
+ continue;
- return lst;
+ if (sub_area.x <= x && x < (sub_area.x + sub_area.width))
+ {
+ result = g_binary_portion_find_at_pos(sub, x, &sub_area);
- }
+ if (result != NULL)
+ *area = sub_area;
- *count = 0;
+ }
- result = do_collect(layer, NULL, count);
+ }
- qsort(result, *count, sizeof(GBinPortion *), (__compar_fn_t)g_binary_portion_compare);
+ if (result == NULL)
+ {
+ result = portion;
+ g_object_ref(G_OBJECT(result));
+ }
return result;
@@ -1016,44 +785,30 @@ GBinPortion **g_portion_layer_collect_all_portions(const GPortionLayer *layer, s
/******************************************************************************
* *
-* Paramètres : layer = couche de portions à parcourir pour les recherches. *
-* x = abscisse du point de recherche. *
-* area = étendue de portion mère, puis celle trouvée. [OUT] *
+* Paramètres : portion = portion mère à consulter. *
+* addr = adresse du point de recherche. *
* *
-* Description : Recherche la portion présente à un point donné. *
+* Description : Détermine si une portion contient une adresse donnée. *
* *
-* Retour : Portion trouvée à l'endroit indiqué. *
+* Retour : true ou false selon le résultat. *
* *
* Remarques : - *
* *
******************************************************************************/
-GBinPortion *g_portion_layer_find_portion_at_pos(const GPortionLayer *layer, gint x, GdkRectangle *area)
+static bool g_portion_layer_contains_addr(const GBinPortion *portion, const vmpa2t *addr)
{
- GBinPortion *result; /* Portion à retourner */
- size_t i; /* Boucle de parcours */
- GBinPortion *sub; /* Portion incluse à traiter */
- GdkRectangle sub_area; /* Etendue d'une sous-portion */
-
- if (layer->sub_layer != NULL)
- result = g_portion_layer_find_portion_at_pos(layer->sub_layer, x, area);
- else
- result = NULL;
+ bool result; /* Bilan à retourner */
- for (i = 0; i < layer->count && result == NULL; i++)
- {
- sub = layer->portions[i];
+ result = false;
- if (!g_binary_portion_compute_sub_area(sub, layer->length, area, &sub_area))
- continue;
+ /* Portion non allouée en mémoire -> adresse nulle ; on écarte */
+ if (get_virt_addr(get_mrange_addr(&portion->range)) == 0)
+ goto not_found;
- if (sub_area.x <= x && x < (sub_area.x + sub_area.width))
- {
- result = sub;
- *area = sub_area;
- }
+ result = mrange_contains_addr(&portion->range, addr);
- }
+ not_found:
return result;
@@ -1062,9 +817,9 @@ GBinPortion *g_portion_layer_find_portion_at_pos(const GPortionLayer *layer, gin
/******************************************************************************
* *
-* Paramètres : layer = couche de portions à parcourir pour les recherches. *
-* addr = adresse du point de recherche. *
-* area = étendue de portion mère, puis celle trouvée. [OUT] *
+* Paramètres : portion = couche de portions à parcourir pour les recherches.*
+* addr = adresse du point de recherche. *
+* area = étendue de portion mère, puis celle trouvée. [OUT] *
* *
* Description : Recherche la portion présente à une adresse donnée. *
* *
@@ -1074,31 +829,39 @@ GBinPortion *g_portion_layer_find_portion_at_pos(const GPortionLayer *layer, gin
* *
******************************************************************************/
-GBinPortion *g_portion_layer_find_portion_at_addr(const GPortionLayer *layer, const vmpa2t *addr, GdkRectangle *area)
+GBinPortion *g_binary_portion_find_at_addr(GBinPortion *portion, const vmpa2t *addr, GdkRectangle *area)
{
GBinPortion *result; /* Portion à retourner */
+ phys_t full; /* Espace total représenté */
size_t i; /* Boucle de parcours #1 */
GBinPortion *sub; /* Portion incluse à traiter */
GdkRectangle sub_area; /* Etendue d'une sous-portion */
- if (layer->sub_layer != NULL)
- result = g_portion_layer_find_portion_at_addr(layer->sub_layer, addr, area);
- else
- result = NULL;
+ result = NULL;
+
+ full = get_mrange_length(&portion->range);
- for (i = 0; i < layer->count && result == NULL; i++)
+ for (i = 0; i < portion->count && result == NULL; i++)
{
- sub = layer->portions[i];
+ sub = portion->subs[i];
if (!g_portion_layer_contains_addr(sub, addr))
continue;
- if (!g_binary_portion_compute_sub_area(sub, layer->length, area, &sub_area))
+ if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area))
continue;
- result = sub;
- *area = sub_area;
+ result = g_binary_portion_find_at_addr(sub, addr, &sub_area);
+
+ if (result != NULL)
+ *area = sub_area;
+
+ }
+ if (result == NULL)
+ {
+ result = portion;
+ g_object_ref(G_OBJECT(result));
}
return result;
@@ -1108,10 +871,10 @@ GBinPortion *g_portion_layer_find_portion_at_addr(const GPortionLayer *layer, co
/******************************************************************************
* *
-* Paramètres : layer = couche de portions à parcourir pour les recherches. *
-* x = abscisse du point de recherche. *
-* area = étendue de représentation de la portion mère. *
-* addr = adresse correspondante. [OUT] *
+* Paramètres : root = couche de portions à parcourir pour les recherches. *
+* x = abscisse du point de recherche. *
+* area = étendue de représentation de la portion mère. *
+* addr = adresse correspondante. [OUT] *
* *
* Description : Fournit la position correspondant à une adresse donnée. *
* *
@@ -1121,20 +884,22 @@ GBinPortion *g_portion_layer_find_portion_at_addr(const GPortionLayer *layer, co
* *
******************************************************************************/
-bool g_portion_layer_get_addr_from_pos(GPortionLayer *layer, gint x, const GdkRectangle *area, vmpa2t *addr)
+bool get_binary_portion_addr_from_pos(GBinPortion *root, gint x, const GdkRectangle *area, vmpa2t *addr)
{
GdkRectangle owner_area; /* Aire de contenance */
GBinPortion *owner; /* Conteneur propriétaire */
owner_area = *area;
- owner = g_portion_layer_find_portion_at_pos(layer, x, &owner_area);
+ owner = g_binary_portion_find_at_pos(root, x, &owner_area);
if (owner == NULL) return false;
copy_vmpa(addr, get_mrange_addr(&owner->range));
advance_vmpa(addr, (get_mrange_length(&owner->range) * (x - owner_area.x)) / owner_area.width);
+ g_object_unref(G_OBJECT(owner));
+
return true;
}
@@ -1142,10 +907,10 @@ bool g_portion_layer_get_addr_from_pos(GPortionLayer *layer, gint x, const GdkRe
/******************************************************************************
* *
-* Paramètres : layer = couche de portions à parcourir pour les recherches. *
-* addr = adresse du point de recherche. *
-* area = étendue de représentation de la portion mère. *
-* x = position correspondante. [OUT] *
+* Paramètres : root = couche de portions à parcourir pour les recherches. *
+* addr = adresse du point de recherche. *
+* area = étendue de représentation de la portion mère. *
+* x = position correspondante. [OUT] *
* *
* Description : Fournit l'adresse correspondant à une position donnée. *
* *
@@ -1155,7 +920,7 @@ bool g_portion_layer_get_addr_from_pos(GPortionLayer *layer, gint x, const GdkRe
* *
******************************************************************************/
-bool g_portion_layer_get_pos_from_addr(GPortionLayer *layer, const vmpa2t *addr, const GdkRectangle *area, gint *x)
+bool get_binary_portion_pos_from_addr(GBinPortion *root, const vmpa2t *addr, const GdkRectangle *area, gint *x)
{
GdkRectangle owner_area; /* Aire de contenance */
GBinPortion *owner; /* Conteneur propriétaire */
@@ -1163,46 +928,16 @@ bool g_portion_layer_get_pos_from_addr(GPortionLayer *layer, const vmpa2t *addr,
owner_area = *area;
- owner = g_portion_layer_find_portion_at_addr(layer, addr, &owner_area);
+ owner = g_binary_portion_find_at_addr(root, addr, &owner_area);
if (owner == NULL) return false;
diff = compute_vmpa_diff(addr, get_mrange_addr(&owner->range));
*x = owner_area.x + (diff * owner_area.width) / get_mrange_length(&owner->range);
- return true;
-
-}
-
+ g_object_unref(G_OBJECT(owner));
-/******************************************************************************
-* *
-* Paramètres : layer = première couche amorçant la visite. *
-* visitor = fonction à appeler à chaque étape de la descente. *
-* data = adresse pointant vers des données de l'utilisateur.*
-* *
-* Description : Parcours un ensemble de portions binaires. *
-* *
-* Retour : true si la visite a été jusqu'à son terme, false sinon. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-bool g_portion_layer_visit(const GPortionLayer *layer, visit_portion_fc visitor, void *data)
-{
- bool result; /* Etat à retourner */
- size_t i; /* Boucle de parcours */
-
- if (layer->sub_layer != NULL)
- result = g_portion_layer_visit(layer->sub_layer, visitor, data);
- else
- result = true;
-
- for (i = 0; i < layer->count && result; i++)
- result = visitor(layer->portions[i], data);
-
- return result;
+ return true;
}
@@ -1223,52 +958,17 @@ bool g_portion_layer_visit(const GPortionLayer *layer, visit_portion_fc visitor,
* *
******************************************************************************/
-gboolean g_portion_layer_query_tooltip(const GPortionLayer *layer, gint x, gint y, const GdkRectangle *area, GtkTooltip *tooltip)
+gboolean query_tooltip_for_binary_portion(GBinPortion *root, gint x, gint y, const GdkRectangle *area, GtkTooltip *tooltip)
{
GBinPortion *selected; /* Portion à décrire ici */
- selected = g_portion_layer_find_portion_at_pos(layer, x, (GdkRectangle []) { *area });
+ selected = g_binary_portion_find_at_pos(root, x, (GdkRectangle []) { *area });
if (selected == NULL) return FALSE;
g_binary_portion_query_tooltip(selected, tooltip);
- return TRUE;
-
-}
-
+ g_object_unref(G_OBJECT(selected));
-/******************************************************************************
-* *
-* Paramètres : layer = couche de portions à consulter. *
-* cr = contexte graphique pour le dessin. *
-* area = étendue mise à disposition. *
-* *
-* Description : Représente une couche de portions sur une bande dédiée. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-void g_portion_layer_draw(const GPortionLayer *layer, GtkStyleContext *context, cairo_t *cr, const GdkRectangle *area)
-{
- size_t i; /* Boucle de parcours */
- GBinPortion *sub; /* Portion incluse à montrer */
- GdkRectangle sub_area; /* Etendue d'une sous-portion */
-
- for (i = 0; i < layer->count; i++)
- {
- sub = layer->portions[i];
-
- if (!g_binary_portion_compute_sub_area(sub, layer->length, area, &sub_area))
- continue;
-
- g_binary_portion_draw(sub, context, cr, &sub_area);
-
- }
-
- if (layer->sub_layer != NULL)
- g_portion_layer_draw(layer->sub_layer, context, cr, area);
+ return TRUE;
}
diff --git a/src/glibext/gbinportion.h b/src/glibext/gbinportion.h
index b91af05..2aa5e1a 100644
--- a/src/glibext/gbinportion.h
+++ b/src/glibext/gbinportion.h
@@ -80,7 +80,7 @@ typedef enum _PortionAccessRights
GType g_binary_portion_get_type(void);
/* Crée une description de partie de code vierge. */
-GBinPortion *g_binary_portion_new(const char *);
+GBinPortion *g_binary_portion_new(const char *, const vmpa2t *, phys_t);
/* Etablit la comparaison ascendante entre deux portions. */
int g_binary_portion_compare(const GBinPortion **, const GBinPortion **);
@@ -91,9 +91,6 @@ void g_binary_portion_set_desc(GBinPortion *, const char *);
/* Fournit la description attribuée à une partie de code. */
const char *g_binary_portion_get_desc(const GBinPortion *);
-/* Définit les valeurs utiles d'une partie de code. */
-void g_binary_portion_set_values(GBinPortion *, const vmpa2t *, phys_t);
-
/* Fournit l'emplacement d'une partie de code binaire. */
const mrange_t *g_binary_portion_get_range(const GBinPortion *);
@@ -112,68 +109,44 @@ void g_binary_portion_query_tooltip(GBinPortion *, GtkTooltip *);
/* Représente la portion sur une bande dédiée. */
void g_binary_portion_draw(const GBinPortion *, GtkStyleContext *, cairo_t *, const GdkRectangle *);
+/* Procède à l'inclusion d'une portion dans une autre. */
+void g_binary_portion_include(GBinPortion *, GBinPortion *);
+/* Sens des visites */
+typedef enum _BinaryPortionVisit
+{
+ BPV_ENTER, /* Arrivée sur une branche */
+ BPV_SHOW, /* Visite d'une feuille */
+ BPV_EXIT /* Départ d'une branche */
-/* -------------------------- COUCHES DE PORTIONS BINAIRES -------------------------- */
-
-
-#define G_TYPE_PORTION_LAYER (g_portion_layer_get_type())
-#define G_PORTION_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_PORTION_LAYER, GPortionLayer))
-#define G_IS_PORTION_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_PORTION_LAYER))
-#define G_PORTION_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PORTION_LAYER, GPortionLayerClass))
-#define G_IS_PORTION_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PORTION_LAYER))
-#define G_PORTION_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PORTION_LAYER, GPortionLayerClass))
-
-
-/* Couche de portions binaires quelconques (instance) */
-typedef struct _GPortionLayer GPortionLayer;
-
-/* Couche de portions binaires quelconques (classe) */
-typedef struct _GPortionLayerClass GPortionLayerClass;
-
+} BinaryPortionVisit;
-/* Taille à définir lors d'un rattachement */
-#define NO_LENGTH_YET VMPA_NO_PHYSICAL
+/* Fonction appelée à chaque visite de portion.*/
+typedef bool (* visit_portion_fc) (GBinPortion *, GBinPortion *, BinaryPortionVisit, void *);
-/* Indique le type défini par la GLib pour les couches de portions binaires. */
-GType g_portion_layer_get_type(void);
+/* Parcourt un ensemble de portions binaires. */
+bool g_binary_portion_visit(GBinPortion *, visit_portion_fc, void *);
-/* Crée une nouvelle couche de portions binaires. */
-GPortionLayer *g_portion_layer_new(phys_t, const char *);
-/* Attache une couche à une autre en tant que couche inférieure. */
-void g_portion_layer_attach_sub(GPortionLayer *, GPortionLayer *);
-/* Procède à l'inclusion d'une portion dans une couche. */
-void g_portion_layer_include(GPortionLayer *, GBinPortion *);
+/* ------------------------ PARCOURS D'ENSEMBLES DE PORTIONS ------------------------ */
-/* Fournit une liste triée de portions d'un binaire. */
-GBinPortion **g_portion_layer_collect_all_portions(const GPortionLayer *, size_t *);
/* Recherche la portion présente à un point donné. */
-GBinPortion *g_portion_layer_find_portion_at_pos(const GPortionLayer *, gint, GdkRectangle *);
+GBinPortion *g_binary_portion_find_at_pos(GBinPortion *, gint, GdkRectangle *);
/* Recherche la portion présente à une adresse donnée. */
-GBinPortion *g_portion_layer_find_portion_at_addr(const GPortionLayer *, const vmpa2t *, GdkRectangle *);
+GBinPortion *g_binary_portion_find_at_addr(GBinPortion *, const vmpa2t *, GdkRectangle *);
/* Fournit la position correspondant à une adresse donnée. */
-bool g_portion_layer_get_addr_from_pos(GPortionLayer *, gint, const GdkRectangle *, vmpa2t *);
+bool get_binary_portion_addr_from_pos(GBinPortion *, gint, const GdkRectangle *, vmpa2t *);
/* Fournit l'adresse correspondant à une position donnée. */
-bool g_portion_layer_get_pos_from_addr(GPortionLayer *, const vmpa2t *, const GdkRectangle *, gint *);
-
-/* Fonction appelée à chaque visite de portion.*/
-typedef bool (* visit_portion_fc) (GBinPortion *, void *);
-
-/* Parcours un ensemble de portions binaires. */
-bool g_portion_layer_visit(const GPortionLayer *, visit_portion_fc, void *);
+bool get_binary_portion_pos_from_addr(GBinPortion *, const vmpa2t *, const GdkRectangle *, gint *);
/* Prépare une astuce concernant une portion pour son affichage. */
-gboolean g_portion_layer_query_tooltip(const GPortionLayer *, gint, gint, const GdkRectangle *, GtkTooltip *);
-
-/* Représente une couche de portions sur une bande dédiée. */
-void g_portion_layer_draw(const GPortionLayer *, GtkStyleContext *, cairo_t *, const GdkRectangle *);
+gboolean query_tooltip_for_binary_portion(GBinPortion *, gint, gint, const GdkRectangle *, GtkTooltip *);