summaryrefslogtreecommitdiff
path: root/src/gtkext
diff options
context:
space:
mode:
Diffstat (limited to 'src/gtkext')
-rwxr-xr-xsrc/gtkext/graph/Makefile.am12
-rw-r--r--src/gtkext/graph/dot.c12
-rw-r--r--src/gtkext/graph/edge.c400
-rw-r--r--src/gtkext/graph/edge.h80
-rw-r--r--src/gtkext/graph/layout.c403
-rw-r--r--src/gtkext/graph/layout.h42
-rw-r--r--src/gtkext/graph/node-int.h79
-rw-r--r--src/gtkext/graph/node.c313
-rw-r--r--src/gtkext/graph/node.h56
-rwxr-xr-xsrc/gtkext/graph/nodes/Makefile.am17
-rw-r--r--src/gtkext/graph/nodes/flow.c732
-rw-r--r--src/gtkext/graph/nodes/flow.h86
-rw-r--r--src/gtkext/graph/nodes/virtual.c593
-rw-r--r--src/gtkext/graph/nodes/virtual.h70
-rw-r--r--src/gtkext/graph/params.h44
-rw-r--r--src/gtkext/graph/ranks.c267
-rw-r--r--src/gtkext/graph/ranks.h63
-rw-r--r--src/gtkext/gtkgraphview.c32
18 files changed, 3253 insertions, 48 deletions
diff --git a/src/gtkext/graph/Makefile.am b/src/gtkext/graph/Makefile.am
index a631a90..ead315a 100755
--- a/src/gtkext/graph/Makefile.am
+++ b/src/gtkext/graph/Makefile.am
@@ -3,10 +3,16 @@ noinst_LTLIBRARIES = libgtkextgraph.la
libgtkextgraph_la_SOURCES = \
dot.h dot.c \
+ edge.h edge.c \
layout.h layout.c \
- node.h node.c
+ node.h node.c \
+ params.h \
+ ranks.h ranks.c
-libgtkextgraph_la_LDFLAGS =
+libgtkextgraph_la_LIBADD = \
+ nodes/libgtkextgraphnodes.la
+
+libgtkextgraph_la_LDFLAGS =
INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) $(LIBGRAPH_CFLAGS)
@@ -15,4 +21,4 @@ AM_CPPFLAGS =
AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-SUBDIRS =
+SUBDIRS = nodes
diff --git a/src/gtkext/graph/dot.c b/src/gtkext/graph/dot.c
index 18c4800..e7bbf84 100644
--- a/src/gtkext/graph/dot.c
+++ b/src/gtkext/graph/dot.c
@@ -69,7 +69,7 @@ graph_layout *create_graph_layout(char *cmds)
- //printf("CMDS =======\n%s\n\n=================\n", cmds);
+ printf("CMDS =======\n%s\n\n=================\n", cmds);
ret = gvLayout(result->context, result->graph, "dot");
if (ret != 0) goto cdl_error;
@@ -161,7 +161,12 @@ void place_nodes_of_graph_layout(const graph_layout *layout, GtkGraphView *view,
for (iter = agfstnode(layout->graph); iter != NULL; iter = agnxtnode(layout->graph, iter))
{
node = find_graph_node_by_name(nodes, count, iter->name);
- g_graph_node_place(node, view, iter->u.coord.x, height - iter->u.coord.y);
+
+ /* S'il s'agit d'un noeud artificiel créé pour dot uniquement... */
+ if (node == NULL) continue;
+
+ g_graph_node_place_old(node, view, iter->u.coord.x, height - iter->u.coord.y);
+
}
}
@@ -233,6 +238,9 @@ GtkLinkRenderer **create_links_from_graph_layout(const graph_layout *layout, siz
node = find_graph_node_by_name(nodes, ncount, agtail(eiter)->name);
+ /* S'il s'agit d'un noeud artificiel créé pour dot uniquement... */
+ if (node == NULL) continue;
+
g_graph_node_connect(node,
lines->list[0].list[0].x,
height - lines->list[0].list[0].y,
diff --git a/src/gtkext/graph/edge.c b/src/gtkext/graph/edge.c
new file mode 100644
index 0000000..0eb0230
--- /dev/null
+++ b/src/gtkext/graph/edge.c
@@ -0,0 +1,400 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * edge.c - liens entre les noeuds d'un graphique
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "edge.h"
+
+
+#include <math.h>
+
+
+
+/* Lien graphique entre deux noeuds graphiques (instance) */
+struct _GGraphEdge
+{
+ GObject parent; /* A laisser en premier */
+
+ GFlowNode *src_node; /* Bloc de départ du lien */
+ node_slot_t *src_slot; /* Numéro d'ancrage initial */
+ GFlowNode *dest_node; /* Bloc d'arrivée du lien */
+ node_slot_t *dest_slot; /* Numéro d'ancrage final */
+
+ EdgeColor color; /* Couleur du rendu */
+ GdkPoint *points; /* Points de la ligne dessinée */
+ size_t count; /* Quantité de ces points */
+
+};
+
+/* Lien graphique entre deux noeuds graphiques (classe) */
+struct _GGraphEdgeClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+#define SLOT_VERT_SEP 20
+
+#define ARROW_LENGHT 10
+#define ARROW_DEGREES 10
+
+
+/* Initialise la classe des liens graphiques entre deux noeuds. */
+static void g_graph_edge_class_init(GGraphEdgeClass *);
+
+/* Initialise une encapsulation de bloc virtuel. */
+static void g_graph_edge_init(GGraphEdge *);
+
+/* Supprime toutes les références externes. */
+static void g_graph_edge_dispose(GGraphEdge *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_graph_edge_finalize(GGraphEdge *);
+
+/* Dessine une flèche au bout du lien représenté. */
+static void draw_link_arrow(cairo_t *, gint, gint, gint, gint);
+
+
+
+/* Indique le type définit par la GLib pour les liens graphiques entre noeuds. */
+G_DEFINE_TYPE(GGraphEdge, g_graph_edge, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des liens graphiques entre deux noeuds. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_edge_class_init(GGraphEdgeClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_edge_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_graph_edge_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = instance à initialiser. *
+* *
+* Description : Initialise un lien graphique entre deux noeuds graphiques. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_edge_init(GGraphEdge *edge)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_edge_dispose(GGraphEdge *edge)
+{
+ g_object_unref(G_OBJECT(edge->src_node));
+ g_object_unref(G_OBJECT(edge->dest_node));
+
+ G_OBJECT_CLASS(g_graph_edge_parent_class)->dispose(G_OBJECT(edge));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_edge_finalize(GGraphEdge *edge)
+{
+ G_OBJECT_CLASS(g_graph_edge_parent_class)->finalize(G_OBJECT(edge));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : src_node = bloc de départ du lien. *
+* src_slot = point d'ancrage associé. *
+* dest_node = bloc d'arrivée du lien. *
+* dest_slot = point d'ancrage associé. *
+* color = couleur de rendu à l'écran. *
+* *
+* Description : Etablit un lien graphique entre deux noeuds graphiques. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphEdge *g_graph_edge_new(GFlowNode *src_node, node_slot_t *src_slot, GFlowNode *dest_node, node_slot_t *dest_slot, EdgeColor color)
+{
+ GGraphEdge *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_GRAPH_EDGE, NULL);
+
+ g_object_ref(G_OBJECT(src_node));
+ g_object_ref(G_OBJECT(dest_node));
+
+ result->src_node = src_node;
+ result->src_slot = src_slot;
+ result->dest_node = dest_node;
+ result->dest_slot = dest_slot;
+
+ result->color = color;
+
+ return G_GRAPH_EDGE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = ligne de rendu à mettre à jour. *
+* *
+* Description : Etablit le tracé du lien graphique entre deux noeuds. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_edge_compute(GGraphEdge *edge)
+{
+ GdkPoint start; /* Point de départ */
+ GdkPoint end; /* Point d'arrivée */
+
+ start = g_flow_node_get_point_from_slot(edge->src_node, false, edge->src_slot);
+ end = g_flow_node_get_point_from_slot(edge->dest_node, true, edge->dest_slot);
+
+ printf(" -- (%d ; %d) - (%d ; %d)\n",
+ start.x, start.y,
+ end.x, end.y);
+
+
+ /* Point de départ */
+
+ edge->count = 2;
+ edge->points = (GdkPoint *)calloc(edge->count, sizeof(GdkPoint));
+
+ edge->points[0] = start;
+ edge->points[1] = start;
+ edge->points[1].y += SLOT_VERT_SEP;
+
+ /* Points de jonction */
+
+
+
+ /* Point d'arrivée */
+
+ edge->count += 2;
+ edge->points = (GdkPoint *)realloc(edge->points, edge->count * sizeof(GdkPoint));
+
+ edge->points[edge->count - 1] = end;
+ edge->points[edge->count - 2] = end;
+ edge->points[edge->count - 2].y -= SLOT_VERT_SEP;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = ligne de rendu à manipuler. *
+* drawable = surface de rendu à utiliser. *
+* gc = contexte graphique du dessin. *
+* *
+* Description : Dessine les liens graphiques enregistrés dans le moteur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_edge_draw(const GGraphEdge *edge, GdkDrawable *drawable, GdkGC *gc)
+{
+ cairo_t *cairo; /* Gestionnaire de rendu */
+
+ cairo = gdk_cairo_create(drawable);
+
+ _g_graph_edge_draw(edge, cairo, true);
+
+ cairo_destroy(cairo);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : edge = ligne de rendu à manipuler. *
+* cairo = assistant pour le rendu graphique. *
+* arrow = indique le besoin en flèche à l'arrivée. *
+* *
+* Description : Dessine les liens graphiques enregistrés dans le moteur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void _g_graph_edge_draw(const GGraphEdge *edge, cairo_t *cairo, bool arrow)
+{
+ size_t i; /* Boucle de parcours */
+
+ switch (edge->color)
+ {
+ default:
+ case EGC_DEFAULT:
+ cairo_set_source_rgb(cairo, 0, 0, 0);
+ break;
+ case EGC_GREEN:
+ cairo_set_source_rgb(cairo, 0, 0.6, 0);
+ break;
+ case EGC_RED:
+ cairo_set_source_rgb(cairo, 0.8, 0, 0);
+ break;
+ case EGC_BLUE:
+ cairo_set_source_rgb(cairo, 0, 0, 0.8);
+ break;
+ case EGC_DASHED_GRAY:
+ cairo_set_source_rgb(cairo, 0.4, 0.4, 0.4);
+ break;
+ }
+
+ switch (edge->color)
+ {
+ default:
+ case EGC_DEFAULT:
+ case EGC_GREEN:
+ case EGC_RED:
+ case EGC_BLUE:
+ cairo_set_dash(cairo, (double []) { 6.0 }, 0, 0.0);
+ break;
+ case EGC_DASHED_GRAY:
+ cairo_set_dash(cairo, (double []) { 6.0 }, 1, 0.0);
+ break;
+ }
+
+ /**
+ * Si on ne veut pas de flèche, on doit se destiner à un aperçu...
+ * Dans ce cas, pour plus de lisibilité, on double la taille d'impression.
+ * Et pour faire ressortir les boucles, on double encore les liens associés.
+ */
+ cairo_set_line_width(cairo, arrow ? 1 : (edge->color == EGC_BLUE ? 4 : 2));
+
+ cairo_move_to(cairo, edge->points[0].x + 0.5, edge->points[0].y);
+
+ for (i = 1; i < edge->count; i++)
+ cairo_line_to(cairo, edge->points[i].x + 0.5, edge->points[i].y);
+
+ cairo_stroke(cairo);
+
+ if (arrow)
+ draw_link_arrow(cairo,
+ edge->points[edge->count - 2].x,
+ edge->points[edge->count - 2].y,
+ edge->points[edge->count - 1].x,
+ edge->points[edge->count - 1].y);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : cairo = gestionnaire de rendu graphique. *
+* start_x = abscisse du début du segment final. *
+* start_y = ordonnée du début du segment final. *
+* end_x = abscisse de fin de segment et pointe de flèche. *
+* end_y = ordonnée de fin de segment et pointe de flèche. *
+* *
+* Description : Dessine une flèche au bout du lien représenté. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void draw_link_arrow(cairo_t *cairo, gint start_x, gint start_y, gint end_x, gint end_y)
+{
+ double angle; /* Angle du triangle à remplir */
+ double factor_x; /* Direction de la flèche #1 */
+ double factor_y; /* Direction de la flèche #2 */
+ double x1; /* Abscisse du point n°1 */
+ double y1; /* Ordonnée du point n°1 */
+ double x2; /* Abscisse du point n°2 */
+ double y2; /* Ordonnée du point n°2 */
+
+ angle = atan2(end_y - start_y, end_x - start_x) + M_PI;
+
+ factor_x = -1;
+ factor_y = -1;
+
+ x1 = end_x + factor_x * ARROW_LENGHT * cos(angle - ARROW_DEGREES);
+ y1 = end_y + factor_y * ARROW_LENGHT * sin(angle - ARROW_DEGREES);
+ x2 = end_x + factor_x * ARROW_LENGHT * cos(angle + ARROW_DEGREES);
+ y2 = end_y + factor_y * ARROW_LENGHT * sin(angle + ARROW_DEGREES);
+
+ cairo_move_to(cairo, end_x, end_y);
+
+ cairo_line_to(cairo, x1, y1);
+ cairo_line_to(cairo, x2, y2);
+
+ cairo_move_to(cairo, end_x, end_y);
+
+ cairo_fill(cairo);
+
+}
diff --git a/src/gtkext/graph/edge.h b/src/gtkext/graph/edge.h
new file mode 100644
index 0000000..31e4a97
--- /dev/null
+++ b/src/gtkext/graph/edge.h
@@ -0,0 +1,80 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * edge.h - prototypes pour les liens entre les noeuds d'un graphique
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_EDGE_H
+#define _GTKEXT_GRAPH_EDGE_H
+
+
+#include <glib-object.h>
+
+
+#include "nodes/flow.h"
+
+
+
+#define G_TYPE_GRAPH_EDGE g_graph_edge_get_type()
+#define G_GRAPH_EDGE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_edge_get_type(), GGraphEdge))
+#define G_IS_GRAPH_EDGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_edge_get_type()))
+#define G_GRAPH_EDGE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_edge_get_type(), GGraphEdgeIface))
+#define G_GRAPH_EDGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_EDGE, GGraphEdgeClass))
+
+
+/* Lien graphique entre deux noeuds graphiques (instance) */
+typedef struct _GGraphEdge GGraphEdge;
+
+/* Lien graphique entre deux noeuds graphiques (classe) */
+typedef struct _GGraphEdgeClass GGraphEdgeClass;
+
+
+/* Couleur de représentation */
+typedef enum _EdgeColor
+{
+ EGC_DEFAULT, /* Noir, par défaut */
+ EGC_GREEN, /* Condition vérifiée */
+ EGC_RED, /* Condition non vérifiée */
+ EGC_BLUE, /* Boucle détectée */
+ EGC_DASHED_GRAY, /* Exception omniprésente */
+
+ EGC_COUNT
+
+} EdgeColor;
+
+
+/* Indique le type définit par la GLib pour les liens graphiques entre noeuds. */
+GType g_graph_edge_get_type(void);
+
+/* Etablit un lien graphique entre deux noeuds graphiques. */
+GGraphEdge *g_graph_edge_new(GFlowNode *, node_slot_t *, GFlowNode *, node_slot_t *, EdgeColor);
+
+/* Etablit le tracé du lien graphique entre deux noeuds. */
+void g_graph_edge_compute(GGraphEdge *);
+
+/* Dessine les liens graphiques enregistrés dans le moteur. */
+void g_graph_edge_draw(const GGraphEdge *, GdkDrawable *, GdkGC *);
+
+/* Dessine les liens graphiques enregistrés dans le moteur. */
+void _g_graph_edge_draw(const GGraphEdge *, cairo_t *, bool);
+
+
+
+#endif /* _GTKEXT_GRAPH_EDGE_H */
diff --git a/src/gtkext/graph/layout.c b/src/gtkext/graph/layout.c
index 1748c40..377ad52 100644
--- a/src/gtkext/graph/layout.c
+++ b/src/gtkext/graph/layout.c
@@ -31,6 +31,7 @@
#include "dot.h"
#include "node.h"
+#include "nodes/flow.h"
#include "../gtkbufferview.h"
#include "../../analysis/binary.h"
#include "../../analysis/blocks/flow.h"
@@ -38,6 +39,9 @@
+/* Taille maximale des noms de classement */
+#define RANK_DESC_LEN 128
+
/* Taille maximale des introductions aux clusters */
#define CLUSTER_DESC_LEN 128
@@ -51,12 +55,20 @@ typedef struct _visitor_dot_params
GGraphNode **nodes; /* Intermédiaires en place */
size_t count; /* Quantité de noeuds en place */
+ char **ranks; /* Profondeurs des blocs */
+
unsigned int level; /* Profondeur de la visite */
char *cmds; /* Description à envoyer à dot */
} visitor_dot_params;
+/* Construit les rangs pour dot en parcourant les noeuds. */
+static bool rank_graph_nodes(GInstrBlock *, BlockVisitOrder, visitor_dot_params *);
+
+/* Etablit le classement de tous les prochains noeuds pour dot. */
+static void build_graph_ranking(visitor_dot_params *);
+
/* Construit les commandes pour dot en parcourant les noeuds. */
static bool register_graph_nodes(GInstrBlock *, BlockVisitOrder, visitor_dot_params *);
@@ -100,6 +112,11 @@ bool build_graph_view(GtkGraphView *view, GInstrBlock *blocks, GtkViewPanel **vi
params.level = 1;
params.cmds = strdup("digraph G {\n overlap=false;\n splines=ortho;\n compound=true;\n");
+ params.ranks = (char **)calloc(count, sizeof(char *));
+
+ g_instr_block_visit(blocks, (instr_block_visitor_cb)rank_graph_nodes, &params);
+ build_graph_ranking(&params);
+
g_instr_block_visit(blocks, (instr_block_visitor_cb)register_graph_nodes, &params);
params.cmds = complete_graph_links(view, views, count, params.cmds);
@@ -133,6 +150,96 @@ bool build_graph_view(GtkGraphView *view, GInstrBlock *blocks, GtkViewPanel **vi
* order = position dans la visite. *
* params = informations à mettre à jour pour dot. *
* *
+* Description : Construit les rangs pour dot en parcourant les noeuds. *
+* *
+* Retour : true si le parcours a été jusqu'à son terme, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool rank_graph_nodes(GInstrBlock *block, BlockVisitOrder order, visitor_dot_params *params)
+{
+ vmpa_t start; /* Adresse de départ d'un bloc */
+ GGraphNode *node; /* Noeud rattaché */
+ unsigned int rank; /* Classement du bloc lié */
+
+ if (G_IS_FLOW_BLOCK(block))
+ {
+ g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(block), &start, NULL);
+ node = find_graph_node_by_start_address(params->nodes, params->count, start);
+
+ rank = g_flow_block_get_rank(G_FLOW_BLOCK(block));
+ /* BUG_ON(count >= params->count) */
+
+ params->ranks[rank] = g_graph_node_append_name_to_rank(node, params->ranks[rank]);
+
+ }
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : params = informations à mettre à jour pour dot. *
+* *
+* Description : Etablit le classement de tous les prochains noeuds pour dot. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void build_graph_ranking(visitor_dot_params *params)
+{
+ unsigned int id; /* Identifiant unique */
+ size_t i; /* Boucle de parcours #1 */
+ char buffer[RANK_DESC_LEN]; /* Tampon pour les commandes */
+ unsigned int j; /* Boucle de parcours #2 */
+
+ id = 0;
+
+ for (i = 0; i < params->count; i++)
+ {
+ if (params->ranks[i] == NULL)
+ continue;
+
+ snprintf(buffer, CLUSTER_DESC_LEN, DOT_IDENT "{ rank = same; rk%u;", id++);
+ params->cmds = stradd(params->cmds, buffer);
+
+ params->cmds = stradd(params->cmds, params->ranks[i]);
+
+ params->cmds = stradd(params->cmds, " }\n");
+
+ }
+
+ params->cmds = stradd(params->cmds, DOT_IDENT);
+
+ for (j = 0; j < id; j++)
+ {
+ if (j == 0)
+ snprintf(buffer, CLUSTER_DESC_LEN, "rk%u", j);
+ else
+ snprintf(buffer, CLUSTER_DESC_LEN, " -> rk%u", j);
+
+ params->cmds = stradd(params->cmds, buffer);
+
+ }
+
+ params->cmds = stradd(params->cmds, "\n");
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'instructions concerné par la visite. *
+* order = position dans la visite. *
+* params = informations à mettre à jour pour dot. *
+* *
* Description : Construit les commandes pour dot en parcourant les noeuds. *
* *
* Retour : true si le parcours a été jusqu'à son terme, false sinon. *
@@ -312,3 +419,299 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
return desc;
}
+
+
+
+
+
+#include "ranks.h"
+#include "nodes/virtual.h"
+
+
+
+
+/* Mise en disposition de blocs en graphique (instance) */
+struct _GGraphLayout
+{
+ GObject parent; /* A laisser en premier */
+
+ GGraphNode *nodes; /* Noeuds graphiques gérés */
+ GGraphRanks *ranks; /* Classement en rangs */
+
+ GGraphEdge **edges; /* Liens entre les noeuds */
+ size_t edges_count; /* Quantité de ces liens */
+
+};
+
+/* Mise en disposition de blocs en graphique (classe) */
+struct _GGraphLayoutClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des mises en disposition graphique. */
+static void g_graph_layout_class_init(GGraphLayoutClass *);
+
+/* Initialise une mise en disposition de blocs en graphique. */
+static void g_graph_layout_init(GGraphLayout *);
+
+/* Supprime toutes les références externes. */
+static void g_graph_layout_dispose(GGraphLayout *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_graph_layout_finalize(GGraphLayout *);
+
+
+
+/* Indique le type définit par la GLib pour les mises en disposition graphique. */
+G_DEFINE_TYPE(GGraphLayout, g_graph_layout, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des mises en disposition graphique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_layout_class_init(GGraphLayoutClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_layout_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_graph_layout_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = instance à initialiser. *
+* *
+* Description : Initialise une mise en disposition de blocs en graphique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_layout_init(GGraphLayout *layout)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_layout_dispose(GGraphLayout *layout)
+{
+ g_object_unref(G_OBJECT(layout->nodes));
+ g_object_unref(G_OBJECT(layout->ranks));
+
+ G_OBJECT_CLASS(g_graph_layout_parent_class)->dispose(G_OBJECT(layout));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_layout_finalize(GGraphLayout *layout)
+{
+ G_OBJECT_CLASS(g_graph_layout_parent_class)->finalize(G_OBJECT(layout));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : blocks = ensemble des blocs basiques déjà découpés. *
+* views = morceaux de code à afficher de façon organisée. *
+* count = quantité de ces morceaux de code. *
+* *
+* Description : Construit un graphique à partir de blocs basiques. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphLayout *g_graph_layout_new(GInstrBlock *blocks, GtkBufferView **views, size_t count)
+{
+ GGraphLayout *result; /* Structure à retourner */
+ size_t i; /* Boucle de parcours */
+
+ result = g_object_new(G_TYPE_GRAPH_LAYOUT, NULL);
+
+ result->nodes = convert_blocks_into_nodes(blocks, views, count);
+
+ /* Traitement des positions horizontales */
+
+ g_graph_node_set_position(result->nodes, (gint []) { 0 }, NULL);
+ g_virtual_node_organize_x_line(G_VIRTUAL_NODE(result->nodes));
+
+ /* Traitement des positions verticales */
+
+ result->ranks = g_graph_ranks_new(count);
+
+ bool _register_cb(GFlowNode *node, GGraphRanks *ranks)
+ {
+ g_flow_node_register_rank(node, ranks);
+ return true;
+ }
+
+ g_graph_node_visit_flow_nodes(result->nodes, (graph_node_visitor_cb)_register_cb, result->ranks);
+
+ g_graph_ranks_compute_y_line(result->ranks);
+
+ bool _apply_cb(GFlowNode *node, GGraphRanks *ranks)
+ {
+ g_flow_node_apply_rank(node, ranks);
+ return true;
+ }
+
+ g_graph_node_visit_flow_nodes(result->nodes, (graph_node_visitor_cb)_apply_cb, result->ranks);
+
+ /* Mise en place des liens */
+
+ bool _do_links_cb(GFlowNode *node, GGraphLayout *layout)
+ {
+ g_flow_node_link(node, layout, layout->nodes);
+ return true;
+ }
+
+ g_graph_node_visit_flow_nodes(result->nodes, (graph_node_visitor_cb)_do_links_cb, result);
+
+ for (i = 0; i < result->edges_count; i++)
+ g_graph_edge_compute(result->edges[i]);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = disposition en graphique à compléter. *
+* edge = lien entre noeuds à conserver. *
+* *
+* Description : Ajoute un lien entre deux noeuds au graphique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_layout_add_edge(GGraphLayout *layout, GGraphEdge *edge)
+{
+ layout->edges = (GGraphEdge **)realloc(layout->edges,
+ ++layout->edges_count * sizeof(GGraphEdge *));
+
+ layout->edges[layout->edges_count - 1] = edge;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = disposition en graphique prête. *
+* view = support de destination finale. *
+* *
+* Description : Dispose chaque noeud sur la surface de destination donnée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_layout_place(GGraphLayout *layout, GtkGraphView *view)
+{
+ bool _place_cb(GFlowNode *node, GtkGraphView *view)
+ {
+ g_flow_node_place(node, view);
+ return true;
+ }
+
+ g_graph_node_visit_flow_nodes(layout->nodes, (graph_node_visitor_cb)_place_cb, view);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = graphique à représenter. *
+* drawable = surface de rendu à utiliser. *
+* gc = contexte graphique du dessin. *
+* *
+* Description : Dessine les liens graphiques enregistrés dans le moteur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_layout_draw(const GGraphLayout *layout, GdkDrawable *drawable, GdkGC *gc)
+{
+ size_t i; /* Boucle de parcours */
+
+ for (i = 0; i < layout->edges_count; i++)
+ g_graph_edge_draw(layout->edges[i], drawable, gc);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : layout = graphique à représenter. *
+* cairo = assistant pour le rendu graphique. *
+* arrow = indique le besoin en flèche à l'arrivée. *
+* *
+* Description : Dessine les liens graphiques enregistrés dans le moteur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void _g_graph_layout_draw(const GGraphLayout *layout, cairo_t *cairo, bool arrow)
+{
+ size_t i; /* Boucle de parcours */
+
+ for (i = 0; i < layout->edges_count; i++)
+ _g_graph_edge_draw(layout->edges[i], cairo, arrow);
+
+}
diff --git a/src/gtkext/graph/layout.h b/src/gtkext/graph/layout.h
index 7a3bf1e..6295cac 100644
--- a/src/gtkext/graph/layout.h
+++ b/src/gtkext/graph/layout.h
@@ -38,4 +38,46 @@ bool build_graph_view(GtkGraphView *, GInstrBlock *, GtkViewPanel **, size_t);
+
+
+#include "edge.h"
+#include "../gtkbufferview.h"
+
+
+
+
+#define G_TYPE_GRAPH_LAYOUT g_graph_layout_get_type()
+#define G_GRAPH_LAYOUT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_layout_get_type(), GGraphLayout))
+#define G_IS_GRAPH_LAYOUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_layout_get_type()))
+#define G_GRAPH_LAYOUT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_layout_get_type(), GGraphLayoutIface))
+#define G_GRAPH_LAYOUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_LAYOUT, GGraphLayoutClass))
+
+
+/* Mise en disposition de blocs en graphique (instance) */
+typedef struct _GGraphLayout GGraphLayout;
+
+/* Mise en disposition de blocs en graphique (classe) */
+typedef struct _GGraphLayoutClass GGraphLayoutClass;
+
+
+/* Indique le type définit par la GLib pour les mises en disposition graphique. */
+GType g_graph_layout_get_type(void);
+
+/* Construit un graphique à partir de blocs basiques. */
+GGraphLayout *g_graph_layout_new(GInstrBlock *, GtkBufferView **, size_t);
+
+/* Ajoute un lien entre deux noeuds au graphique. */
+void g_graph_layout_add_edge(GGraphLayout *, GGraphEdge *);
+
+/* Dispose chaque noeud sur la surface de destination donnée. */
+void g_graph_layout_place(GGraphLayout *, GtkGraphView *);
+
+/* Dessine les liens graphiques enregistrés dans le moteur. */
+void g_graph_layout_draw(const GGraphLayout *, GdkDrawable *, GdkGC *);
+
+/* Dessine les liens graphiques enregistrés dans le moteur. */
+void _g_graph_layout_draw(const GGraphLayout *, cairo_t *, bool);
+
+
+
#endif /* _GRAPH_LAYOUT_H */
diff --git a/src/gtkext/graph/node-int.h b/src/gtkext/graph/node-int.h
new file mode 100644
index 0000000..9ecb072
--- /dev/null
+++ b/src/gtkext/graph/node-int.h
@@ -0,0 +1,79 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * node-int.h - prototypes pour la gestion élémentaire des blocs sous forme de noeuds
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_NODE_INT_H
+#define _GTKEXT_GRAPH_NODE_INT_H
+
+
+#include "node.h"
+
+
+
+/* Fournit le rang du noeud dans le graphique. */
+typedef unsigned int (* get_node_rank_fc) (const GGraphNode *);
+
+/* Altère la position du noeud d'encapsulation. */
+typedef void (* node_set_pos_fc) (GGraphNode *, gint *, gint *);
+
+/* Fournit la position du noeud d'encapsulation. */
+typedef void (* node_get_pos_fc) (const GGraphNode *, gint *, gint *);
+
+/* Indique l'espace requis pour un noeud d'encapsulation. */
+typedef GtkAllocation (* node_get_alloc_fc) (const GGraphNode *);
+
+/* Parcourt tous les noeuds graphiques dans un ordre donné. */
+typedef bool (* visit_flow_nodes_fc) (GGraphNode *, graph_node_visitor_cb, void *);
+
+
+/* Intermédiaire entre le noeud dot et la bribe de code (instance) */
+struct _GGraphNode
+{
+ GObject parent; /* A laisser en premier */
+
+ get_node_rank_fc get_rank; /* Premier rang d'appartenance */
+ node_set_pos_fc set_pos; /* Définit l'emplacement */
+ node_get_pos_fc get_pos; /* Fournit l'emplacement */
+ node_get_alloc_fc get_alloc; /* Fournit l'espace nécessaire */
+ visit_flow_nodes_fc visit; /* Visite des noeuds d'exécut° */
+
+ GtkWidget *view; /* Morceau de code représenté */
+ char name[NODE_NAME_LEN]; /* Adresse sous forme humaine */
+
+ GtkAllocation alloc; /* Emplacement du bloc rattaché*/
+
+};
+
+
+/* Intermédiaire entre le noeud dot et la bribe de code (classe) */
+struct _GGraphNodeClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+ double dpi_x; /* Résolution en abscisse */
+ double dpi_y; /* Résolution en ordonnée */
+
+};
+
+
+
+#endif /* _GTKEXT_GRAPH_NODE_INT_H */
diff --git a/src/gtkext/graph/node.c b/src/gtkext/graph/node.c
index 879139a..bb8403f 100644
--- a/src/gtkext/graph/node.c
+++ b/src/gtkext/graph/node.c
@@ -29,7 +29,9 @@
#include <string.h>
-#include "../gtkbufferview.h"
+#include "node-int.h"
+#include "nodes/flow.h"
+#include "nodes/virtual.h"
#include "../../common/extstr.h"
@@ -37,30 +39,6 @@
/* -------------------------- GESTION DES NOEUDS A L'UNITE -------------------------- */
-/* Intermédiaire entre le noeud dot et la bribe de code (instance) */
-struct _GGraphNode
-{
- GObject parent; /* A laisser en premier */
-
- GtkWidget *view; /* Morceau de code représenté */
- char *name; /* Adresse sous forme humaine */
-
- GtkAllocation alloc; /* Emplacement du bloc rattaché*/
-
-};
-
-
-/* Intermédiaire entre le noeud dot et la bribe de code (classe) */
-struct _GGraphNodeClass
-{
- GObjectClass parent; /* A laisser en premier */
-
- double dpi_x; /* Résolution en abscisse */
- double dpi_y; /* Résolution en ordonnée */
-
-};
-
-
/* Taille maximale des lignes de description de noeud */
#define NODE_DESC_LEN 128
@@ -205,8 +183,6 @@ static void g_graph_node_dispose(GGraphNode *node)
static void g_graph_node_finalize(GGraphNode *node)
{
- free(node->name);
-
G_OBJECT_CLASS(g_graph_node_parent_class)->finalize(G_OBJECT(node));
}
@@ -227,23 +203,159 @@ static void g_graph_node_finalize(GGraphNode *node)
GGraphNode *g_graph_node_new(GtkWidget *view)
{
GGraphNode *result; /* Structure à retourner */
- size_t len; /* Taille du nom */
result = g_object_new(G_TYPE_GRAPH_NODE, NULL);
result->view = view;
g_object_ref(G_OBJECT(view));
- len = 3 + sizeof(GtkWidget *) * 2 + 1;
-
- result->name = (char *)calloc(len, sizeof(char));
- snprintf(result->name, len, "_%p", result->view);
+ snprintf(result->name, NODE_NAME_LEN, "_%p", result->view);
return result;
}
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Fournit le rang du noeud dans le graphique. *
+* *
+* Retour : Indice supérieur ou égal à zéro. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+unsigned int g_graph_node_get_rank(const GGraphNode *node)
+{
+ return node->get_rank(node);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à manipuler. *
+* x = éventuelle abscisse à intégrer ou NULL. *
+* y = éventuelle ordonnée à intégrer ou NULL. *
+* *
+* Description : Altère la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_node_set_position(GGraphNode *node, gint *x, gint *y)
+{
+ node->set_pos(node, x, y);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* x = éventuelle abscisse à recevoir ou NULL. [OUT] *
+* y = éventuelle ordonnée à recevoir ou NULL. [OUT] *
+* *
+* Description : Fournit la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_node_get_position(const GGraphNode *node, gint *x, gint *y)
+{
+ node->get_pos(node, x, y);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Indique l'espace requis pour un noeud d'encapsulation. *
+* *
+* Retour : Espace constitué, entièrement ou non. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GtkAllocation g_graph_node_get_allocation(const GGraphNode *node)
+{
+ return node->get_alloc(node);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique démarrant la visite. *
+* callback = ensemble de blocs à parcourir. *
+* data = donnée utilisateur à associer au parcours. *
+* *
+* Description : Parcourt tous les noeuds graphiques dans un ordre donné. *
+* *
+* Retour : true si le parcours a été jusqu'à son terme, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_graph_node_visit_flow_nodes(GGraphNode *node, graph_node_visitor_cb callback, void *data)
+{
+ return node->visit(node, callback, data);
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : node = intermédiaire à consulter. *
+* rank = description pour dot à compléter. *
+* *
+* Description : Inscrit le noeud au rang donné. *
+* *
+* Retour : Description dûment complétée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+char *g_graph_node_append_name_to_rank(const GGraphNode *node, char *rank)
+{
+ char buffer[NODE_DESC_LEN]; /* Tampon pour les commandes */
+
+ snprintf(buffer, NODE_DESC_LEN, " %s;", node->name);
+
+ if (rank == NULL)
+ rank = strdup(buffer);
+ else
+ rank = stradd(rank, buffer);
+
+ return rank;
+
+}
+
+
/******************************************************************************
* *
* Paramètres : node = intermédiaire à consulter. *
@@ -318,7 +430,7 @@ char *g_graph_node_register_for_dot(const GGraphNode *node, char *cmds, unsigned
* *
******************************************************************************/
-void g_graph_node_place(GGraphNode *node, GtkGraphView *view, gint x, gint y)
+void g_graph_node_place_old(GGraphNode *node, GtkGraphView *view, gint x, gint y)
{
GtkRequisition requisition; /* Taille à l'écran actuelle */
@@ -396,6 +508,141 @@ void g_graph_node_connect(const GGraphNode *node, gint x, gint y, GdkPoint **poi
/******************************************************************************
* *
+* Paramètres : views = liste de vues à parcourir. *
+* count = taille de la liste. *
+* addrt = adresse de début du noeud recherché. *
+* *
+* Description : Recherche une vue donnée dans une série de vues. *
+* *
+* Retour : Vue trouvée ou NULL si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GtkBufferView *find_graph_view_by_start_address(GtkBufferView **views, size_t count, vmpa_t addr)
+{
+ GtkBufferView *result; /* Trouvaille à remonter */
+ size_t i; /* Boucle de parcours */
+ GBufferView *buffer; /* Tampon d'une partie de code */
+ vmpa_t start; /* Adresse de départ du tampon */
+
+ result = NULL;
+
+ for (i = 0; i < count && result == NULL; i++)
+ {
+ buffer = gtk_buffer_view_get_buffer(GTK_BUFFER_VIEW(views[i]));
+ g_buffer_view_get_restrictions(buffer, &start, NULL);
+
+ if (start == addr)
+ result = views[i];
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = ensemble des blocs basiques déjà découpés. *
+* views = morceaux de code à afficher de façon organisée. *
+* count = quantité de ces morceaux de code. *
+* *
+* Description : Réalise une conversion de blocs en noeuds. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphNode *convert_blocks_into_nodes(GInstrBlock *block, GtkBufferView **views, size_t count)
+{
+ GGraphNode *result; /* Instance nouvelle à renvoyer*/
+ vmpa_t start; /* Adresse de départ */
+ GtkBufferView *view; /* Vue existante à retrouver */
+ size_t max; /* Nombre de blocs à gérer */
+ size_t i; /* Boucle de parcours */
+ GInstrBlock *sub_block; /* Sous-bloc intégré */
+ GGraphNode *child; /* Conversion à mémoriser */
+
+ result = NULL;
+
+ if (G_IS_FLOW_BLOCK(block))
+ {
+ g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(block), &start, NULL);
+ view = find_graph_view_by_start_address(views, count, start);
+
+ result = g_flow_node_new(G_FLOW_BLOCK(block), view);
+
+ }
+ else if (G_IS_VIRTUAL_BLOCK(block))
+ {
+ result = g_virtual_node_new(G_VIRTUAL_BLOCK(block));
+
+ max = g_virtual_block_count_children(G_VIRTUAL_BLOCK(block));
+
+ for (i = 0; i < max; i++)
+ {
+ sub_block = g_virtual_block_get_child(G_VIRTUAL_BLOCK(block), i);
+ child = convert_blocks_into_nodes(sub_block, views, count);
+
+ g_virtual_node_add_child(G_VIRTUAL_NODE(result), child);
+
+ }
+
+ }
+ /*else BUG_ON(1); */
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : nodes = noeud au sommet de la hiérarchie. *
+* instr = instruction à retrouver. *
+* *
+* Description : Recherche le noeud contenant une instruction donnée. *
+* *
+* Retour : Noeud trouvé ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphNode *find_node_for_instruction(GGraphNode *nodes, GArchInstruction *instr)
+{
+ GGraphNode *result; /* Trouvaille à retourner */
+ struct visit_params {
+ GArchInstruction *instr; /* Instruction recherchée */
+ GGraphNode *found; /* Remontée du noeud trouvé */
+ } params; /* Paramètres pour le parcours */
+
+ params.instr = instr;
+ params.found = NULL;
+
+ bool _find_node_cb(GFlowNode *node, struct visit_params *params)
+ {
+ if (g_flow_node_start_with(node, params->instr))
+ params->found = G_GRAPH_NODE(node);
+ return (params->found == NULL);
+ }
+
+ g_graph_node_visit_flow_nodes(nodes, (graph_node_visitor_cb)_find_node_cb, &params);
+
+ result = params.found;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : nodes = liste de noeuds à parcourir. *
* count = taille de la liste. *
* addrt = adresse de début du noeud recherché. *
diff --git a/src/gtkext/graph/node.h b/src/gtkext/graph/node.h
index 57d0932..ffe0a0d 100644
--- a/src/gtkext/graph/node.h
+++ b/src/gtkext/graph/node.h
@@ -25,14 +25,21 @@
#define _GRAPH_NODE_H
+#include "params.h"
+#include "ranks.h"
+#include "../gtkbufferview.h"
#include "../gtkgraphview.h"
-#include "../../arch/archbase.h"
+#include "../../arch/instruction.h"
+#include "../../analysis/block.h"
/* Indentation pour l'édition des commandes */
#define DOT_IDENT " "
+/* Taille maximale des noms de noeud ("_%p") */
+#define NODE_NAME_LEN (3 + sizeof(GtkWidget *) * 2 + 1)
+
/* -------------------------- GESTION DES NOEUDS A L'UNITE -------------------------- */
@@ -52,17 +59,50 @@ typedef struct _GGraphNode GGraphNode;
typedef struct _GGraphNodeClass GGraphNodeClass;
+/* Rappel à chaque noeud visité */
+typedef bool (* graph_node_visitor_cb) (GGraphNode *, void *);
+
+
/* Indique le type définit par la GLib pour le noeud. */
GType g_graph_node_get_type(void);
/* Constitue un intermédiaire entre un noeud dot et du code. */
GGraphNode *g_graph_node_new(GtkWidget *);
+
+
+/* Fournit le rang du noeud dans le graphique. */
+unsigned int g_graph_node_get_rank(const GGraphNode *);
+
+/* Altère la position du noeud d'encapsulation. */
+void g_graph_node_set_position(GGraphNode *, gint *, gint *);
+
+/* Fournit la position du noeud d'encapsulation. */
+void g_graph_node_get_position(const GGraphNode *, gint *, gint *);
+
+#define g_graph_node_has_x_position(node) \
+ ({ \
+ gint _x; \
+ g_graph_node_get_position(node, &_x, NULL); \
+ _x != UNINITIALIZED_NODE_POS; \
+ })
+
+/* Espace constitué, entièrement ou non. */
+GtkAllocation g_graph_node_get_allocation(const GGraphNode *);
+
+/* Parcourt tous les noeuds graphiques dans un ordre donné. */
+bool g_graph_node_visit_flow_nodes(GGraphNode *, graph_node_visitor_cb, void *);
+
+
+
+/* Inscrit le noeud au rang donné. */
+char *g_graph_node_append_name_to_rank(const GGraphNode *, char *);
+
/* Déclare l'intermédiaire en tant que noeud pour dot. */
char *g_graph_node_register_for_dot(const GGraphNode *, char *, unsigned int);
/* Place le morceau de code de l'intermédiaire à l'écran. */
-void g_graph_node_place(GGraphNode *, GtkGraphView *, gint , gint);
+void g_graph_node_place_old(GGraphNode *, GtkGraphView *, gint , gint);
/* Etablit une jonction ferme avec un noeud. */
void g_graph_node_connect(const GGraphNode *, gint, gint, GdkPoint **, size_t *);
@@ -72,6 +112,18 @@ void g_graph_node_connect(const GGraphNode *, gint, gint, GdkPoint **, size_t *)
/* ----------------------- MANIPULATION D'ENSEMBLES DE NOEUDS ----------------------- */
+/* Recherche une vue donnée dans une série de vues. */
+GtkBufferView *find_graph_view_by_start_address(GtkBufferView **, size_t, vmpa_t);
+
+/* Réalise une conversion de blocs en noeuds. */
+GGraphNode *convert_blocks_into_nodes(GInstrBlock *, GtkBufferView **, size_t);
+
+/* Recherche le noeud contenant une instruction donnée. */
+GGraphNode *find_node_for_instruction(GGraphNode *, GArchInstruction *);
+
+
+
+
/* Recherche un noeud donné dans une série de noeuds. */
GGraphNode *find_graph_node_by_start_address(GGraphNode **, size_t, vmpa_t);
diff --git a/src/gtkext/graph/nodes/Makefile.am b/src/gtkext/graph/nodes/Makefile.am
new file mode 100755
index 0000000..7bbe99a
--- /dev/null
+++ b/src/gtkext/graph/nodes/Makefile.am
@@ -0,0 +1,17 @@
+
+noinst_LTLIBRARIES = libgtkextgraphnodes.la
+
+libgtkextgraphnodes_la_SOURCES = \
+ flow.h flow.c \
+ virtual.h virtual.c
+
+libgtkextgraphnodes_la_LDFLAGS =
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS =
diff --git a/src/gtkext/graph/nodes/flow.c b/src/gtkext/graph/nodes/flow.c
new file mode 100644
index 0000000..d4506ea
--- /dev/null
+++ b/src/gtkext/graph/nodes/flow.c
@@ -0,0 +1,732 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * flow.c - encapsulation graphique des blocs d'exécution
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "flow.h"
+
+
+#include "../layout.h"
+#include "../node-int.h"
+
+
+
+/* Type d'un accrochage pour lien */
+struct _node_slot_t
+{
+ GArchInstruction *instr; /* Instruction liée */
+ size_t group_index; /* Rang dans le grp d'origine */
+
+ InstructionLinkType type; /* Type de lien à représenter */
+ size_t slot_index; /* Position dans l'accroche */
+ gint x; /* Abscisse graphique du rendu */
+
+};
+
+/* Encapsulation graphique d'un bloc d'exécution (instance) */
+struct _GFlowNode
+{
+ GGraphNode parent; /* A laisser en premier */
+
+ GFlowBlock *block; /* Bloc d'exécution associé */
+ GtkBufferView *view; /* Représentation graphique */
+
+ GtkAllocation alloc; /* Emplacement du bloc rattaché*/
+
+ node_slot_t *entries; /* Positions des pts d'entrées */
+ size_t entries_count; /* Nombre de ces points */
+ node_slot_t *exits; /* Positions des pts de sorties*/
+ size_t exits_count; /* Nombre de ces points */
+
+};
+
+/* Encapsulation graphique d'un bloc d'exécution (classe) */
+struct _GFlowNodeClass
+{
+ GGraphNodeClass parent; /* A laisser en premier */
+
+};
+
+
+#define SPACE_BETWEEN_SLOT 15
+
+
+/* Initialise la classe des encapsulations de bloc d'exécution. */
+static void g_flow_node_class_init(GFlowNodeClass *);
+
+/* Initialise une encapsulation de bloc d'exécution. */
+static void g_flow_node_init(GFlowNode *);
+
+/* Supprime toutes les références externes. */
+static void g_flow_node_dispose(GFlowNode *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_flow_node_finalize(GFlowNode *);
+
+/* Fournit le rang du noeud dans le graphique. */
+static unsigned int g_flow_node_get_rank(const GFlowNode *);
+
+/* Altère la position du noeud d'encapsulation. */
+static void g_flow_node_set_position(GFlowNode *, gint *, gint *);
+
+/* Fournit la position du noeud d'encapsulation. */
+static void g_flow_node_get_position(const GFlowNode *, gint *, gint *);
+
+/* Indique l'espace requis pour un noeud d'encapsulation. */
+static GtkAllocation g_flow_node_get_allocation(const GFlowNode *);
+
+/* Parcourt tous les blocs d'instructions dans un ordre donné. */
+static bool g_flow_node_visit_flow_nodes(GFlowNode *, graph_node_visitor_cb, void *);
+
+
+
+/* ------------------------ GESTION DES ACCROCHES D'UN NOEUD ------------------------ */
+
+
+/* Prépare les points d'entrées du noeud. */
+static void g_flow_node_setup_entry_slots(GFlowNode *);
+
+/* Prépare les points de sorties du noeud. */
+static void g_flow_node_setup_exit_slots(GFlowNode *);
+
+/* Etablit un lien entre deux noeuds graphiques. */
+static node_slot_t *g_flow_node_get_slot(const GFlowNode *, bool, GArchInstruction *, size_t);
+
+
+
+/* Indique le type définit par la GLib pour l'encapsulation d'un bloc d'exécution. */
+G_DEFINE_TYPE(GFlowNode, g_flow_node, G_TYPE_GRAPH_NODE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des encapsulations de bloc d'exécution. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_class_init(GFlowNodeClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_flow_node_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_flow_node_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance à initialiser. *
+* *
+* Description : Initialise une encapsulation de bloc d'exécution. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_init(GFlowNode *node)
+{
+ GGraphNode *base; /* Version basique */
+
+ base = G_GRAPH_NODE(node);
+
+ base->get_rank = (get_node_rank_fc)g_flow_node_get_rank;
+ base->set_pos = (node_set_pos_fc)g_flow_node_set_position;
+ base->get_pos = (node_get_pos_fc)g_flow_node_get_position;
+ base->get_alloc = (node_get_alloc_fc)g_flow_node_get_allocation;
+ base->visit = (visit_flow_nodes_fc)g_flow_node_visit_flow_nodes;
+
+ node->alloc.x = UNINITIALIZED_NODE_POS;
+ node->alloc.y = UNINITIALIZED_NODE_POS;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_dispose(GFlowNode *node)
+{
+ size_t i; /* Boucle de parcours */
+
+ g_object_unref(G_OBJECT(node->block));
+ g_object_unref(G_OBJECT(node->view));
+
+ for (i = 0; i < node->entries_count; i++)
+ g_object_unref(G_OBJECT(node->entries[i].instr));
+
+ for (i = 0; i < node->exits_count; i++)
+ g_object_unref(G_OBJECT(node->exits[i].instr));
+
+ G_OBJECT_CLASS(g_flow_node_parent_class)->dispose(G_OBJECT(node));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_finalize(GFlowNode *node)
+{
+ if (node->entries != NULL)
+ free(node->entries);
+
+ if (node->exits != NULL)
+ free(node->exits);
+
+ G_OBJECT_CLASS(g_flow_node_parent_class)->finalize(G_OBJECT(node));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'exécution représenté graphiquement. *
+* view = morceau d'affichage à représenter. *
+* *
+* Description : Encapsule graphiquement un bloc d'exécution. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphNode *g_flow_node_new(GFlowBlock *block, GtkBufferView *view)
+{
+ GFlowNode *result; /* Structure à retourner */
+ GtkRequisition requisition; /* Taille à l'écran actuelle */
+
+ result = g_object_new(G_TYPE_FLOW_NODE, NULL);
+
+ g_object_ref(G_OBJECT(block));
+ g_object_ref(G_OBJECT(view));
+
+ result->block = block;
+ result->view = view;
+
+ gtk_widget_size_request(GTK_WIDGET(result->view), &requisition);
+
+ result->alloc.width = requisition.width;
+ result->alloc.height = requisition.height;
+
+ g_flow_node_setup_entry_slots(result);
+ g_flow_node_setup_exit_slots(result);
+
+ return G_GRAPH_NODE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Fournit le rang du noeud dans le graphique. *
+* *
+* Retour : Indice supérieur ou égal à zéro. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static unsigned int g_flow_node_get_rank(const GFlowNode *node)
+{
+ return g_flow_block_get_rank(node->block);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à manipuler. *
+* x = éventuelle abscisse à intégrer ou NULL. *
+* y = éventuelle ordonnée à intégrer ou NULL. *
+* *
+* Description : Altère la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_set_position(GFlowNode *node, gint *x, gint *y)
+{
+ if (x != NULL) node->alloc.x = *x;
+ if (y != NULL) node->alloc.y = *y;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* x = éventuelle abscisse à recevoir ou NULL. [OUT] *
+* y = éventuelle ordonnée à recevoir ou NULL. [OUT] *
+* *
+* Description : Fournit la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_get_position(const GFlowNode *node, gint *x, gint *y)
+{
+ if (x != NULL) *x = node->alloc.x;
+ if (y != NULL) *y = node->alloc.y;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Indique l'espace requis pour un noeud d'encapsulation. *
+* *
+* Retour : Espace constitué, entièrement ou non. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GtkAllocation g_flow_node_get_allocation(const GFlowNode *node)
+{
+ GtkAllocation result; /* Valeurs à retourner */
+
+ result = node->alloc;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique démarrant la visite. *
+* callback = ensemble de blocs à parcourir. *
+* data = donnée utilisateur à associer au parcours. *
+* *
+* Description : Parcourt tous les blocs d'instructions dans un ordre donné. *
+* *
+* Retour : true si le parcours a été jusqu'à son terme, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_flow_node_visit_flow_nodes(GFlowNode *node, graph_node_visitor_cb callback, void *data)
+{
+ return callback(G_GRAPH_NODE(node), data);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* instr = instruction à considérer. *
+* *
+* Description : Précise si le noeud a pour première instruction celle donnée.*
+* *
+* Retour : true si la première instruction du noeud est celle indiquée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_flow_node_start_with(const GFlowNode *node, GArchInstruction *instr)
+{
+ GArchInstruction *first; /* Première instr. du noeud */
+
+ g_flow_block_get_boundary(node->block, &first, NULL);
+
+ /*
+ do
+ {
+ vmpa_t a1, a2;
+
+ g_arch_instruction_get_location(instr, NULL, NULL, &a1);
+ g_arch_instruction_get_location(first, NULL, NULL, &a2);
+
+ printf(" -- compare %p (0x%08lx) vs %p (0x%08lx)\n",
+ instr, a1, first, a2);
+
+ }
+ while (0);
+ */
+
+ return (first == instr);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* ranks = classement à mettre à jour. *
+* *
+* Description : Précise la hauteur minimale requise pour un noeud. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_flow_node_register_rank(const GFlowNode *node, GGraphRanks *ranks)
+{
+ unsigned int index; /* Indice du rang associé */
+
+ index = g_flow_block_get_next_rank(node->block);
+
+ g_graph_ranks_set_min_height(ranks, index, node->alloc.height);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à mettre à jour. *
+* ranks = classement à consulter. *
+* *
+* Description : Définit l'ordonnée de l'espace attribué à un noeud. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_flow_node_apply_rank(GFlowNode *node, GGraphRanks *ranks)
+{
+ unsigned int index; /* Indice du rang associé */
+
+ index = g_flow_block_get_next_rank(node->block);
+
+ node->alloc.y = g_graph_ranks_get_y_for_rank(ranks, index);
+
+}
+
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à mettre à jour. *
+* layout = disposition globale du graphique. *
+* nodes = ensemble des noeuds en place. *
+* *
+* Description : Etablit les liaison entre un noeud et ses suivants. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_flow_node_link(GFlowNode *node, GGraphLayout *layout, GGraphNode *nodes)
+{
+ GArchInstruction *last; /* Dernière instr. du noeud */
+ size_t i; /* Boucle de parcours */
+ GFlowNode *target; /* Bloc visé par le lien */
+ node_slot_t *dest_slot; /* Accrochage d'arrivée */
+ EdgeColor color; /* Couleur du lien à créer */
+ GGraphEdge *edge; /* Lien à mettre en place */
+
+ g_flow_block_get_boundary(node->block, NULL, &last);
+
+ for (i = 0; i < node->exits_count; i++)
+ {
+ target = G_FLOW_NODE(find_node_for_instruction(nodes, node->exits[i].instr));
+
+ dest_slot = g_flow_node_get_slot(target, true,
+ last, node->exits[i].group_index);
+
+ switch (node->exits[i].type)
+ {
+ case ILT_JUMP_IF_TRUE:
+ color = EGC_GREEN;
+ break;
+ case ILT_JUMP_IF_FALSE:
+ color = EGC_RED;
+ break;
+ case ILT_LOOP:
+ color = EGC_BLUE;
+ break;
+ case ILT_CATCH_EXCEPTION:
+ color = EGC_DASHED_GRAY;
+ break;
+ default:
+ color = EGC_DEFAULT;
+ break;
+
+ }
+
+ edge = g_graph_edge_new(node, &node->exits[i], target, dest_slot, color);
+ g_graph_layout_add_edge(layout, edge);
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = intermédiaire à consulter. *
+* view = support de destination. *
+* *
+* Description : Place un noeud sur son support final. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_flow_node_place(const GFlowNode *node, GtkGraphView *view)
+{
+ printf("alloc %p :: (%d ; %d) - (%d ; %d)\n",
+ node->view,
+ node->alloc.x, node->alloc.y,
+ node->alloc.width, node->alloc.height);
+
+ gtk_graph_view_put(view, GTK_WIDGET(node->view), &node->alloc);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* GESTION DES ACCROCHES D'UN NOEUD */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : node = intermédiaire à compléter. *
+* *
+* Description : Prépare les points d'entrées du noeud. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_setup_entry_slots(GFlowNode *node)
+{
+ GArchInstruction *first; /* Première instr. du noeud */
+ GArchInstruction **instrs; /* Instr. visée par une autre */
+ InstructionLinkType *types; /* Type de lien entre lignes */
+ size_t icount; /* Nombre de liens de dest. */
+ size_t i; /* Boucle de parcours */
+
+ g_flow_block_get_boundary(node->block, &first, NULL);
+ icount = g_arch_instruction_get_sources(first, &instrs, &types);
+
+ node->entries = (node_slot_t *)calloc(icount, sizeof(node_slot_t));
+ node->entries_count = icount;
+
+ for (i = 0; i < icount; i++)
+ {
+ g_object_ref(instrs[i]);
+ node->entries[i].instr = instrs[i];
+
+ node->entries[i].type = types[i];
+ node->entries[i].group_index = g_arch_instruction_compute_group_index(&instrs[i],
+ instrs, icount);
+ node->entries[i].slot_index = i;
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = intermédiaire à compléter. *
+* *
+* Description : Prépare les points de sorties du noeud. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_flow_node_setup_exit_slots(GFlowNode *node)
+{
+ GArchInstruction *last; /* Dernière instr. du noeud */
+ GArchInstruction **instrs; /* Instr. visée par une autre */
+ InstructionLinkType *types; /* Type de lien entre lignes */
+ size_t icount; /* Nombre de liens de dest. */
+ size_t i; /* Boucle de parcours */
+
+ g_flow_block_get_boundary(node->block, NULL, &last);
+ icount = g_arch_instruction_get_destinations(last, &instrs, &types, NULL);
+
+ node->exits = (node_slot_t *)calloc(icount, sizeof(node_slot_t));
+ node->exits_count = icount;
+
+ for (i = 0; i < icount; i++)
+ {
+ g_object_ref(instrs[i]);
+ node->exits[i].instr = instrs[i];
+
+ node->exits[i].type = types[i];
+ node->exits[i].group_index = g_arch_instruction_compute_group_index(&instrs[i],
+ instrs, icount);
+ node->exits[i].slot_index = i;
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* entry = indique le type d'accrochage recherché. *
+* instr = instruction visée. *
+* index = indice de groupe pour départager au besoin. *
+* *
+* Description : Etablit un lien entre deux noeuds graphiques. *
+* *
+* Retour : Lien graphique mis en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static node_slot_t *g_flow_node_get_slot(const GFlowNode *node, bool entry, GArchInstruction *instr, size_t index)
+{
+ node_slot_t *result; /* Emplacement à retourner */
+ node_slot_t *list; /* Liste à parcourir */
+ size_t count; /* Taille de cette liste */
+ size_t i; /* Boucle de parcours */
+
+ if (entry)
+ {
+ list = node->entries;
+ count = node->entries_count;
+ }
+ else
+ {
+ list = node->exits;
+ count = node->exits_count;
+ }
+
+ for (i = 0; i < count; i++)
+ {
+ result = list + i;
+
+ if (result->instr == instr/* && result->group_index == index*/)
+ break;
+
+ }
+
+ return (i == count ? NULL : result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* entry = indique le type d'accrochage recherché. *
+* slot = accroche dont l'emplacement est à définir. *
+* *
+* Description : Localise un point d'accroche à un noeud graphique. *
+* *
+* Retour : Emplacement réservé pour l'accroche fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GdkPoint g_flow_node_get_point_from_slot(const GFlowNode *node, bool entry, const node_slot_t *slot)
+{
+ GdkPoint result; /* Position à retourner */
+ node_slot_t *slots; /* Accroches à parcourir */
+ size_t count; /* Nombre de ces points */
+ gint slots_width; /* Largeur des accroches */
+ gint slots_left; /* Abscisse de la première */
+ size_t index; /* Indice de l'accroche visée */
+
+ if (entry)
+ {
+ result.y = node->alloc.y;
+
+ slots = node->entries;
+ count = node->entries_count;
+
+ }
+ else
+ {
+ result.y = node->alloc.y + node->alloc.height;
+
+ slots = node->exits;
+ count = node->exits_count;
+
+ }
+
+ slots_width = (count - 1) * SPACE_BETWEEN_SLOT;
+ slots_left = node->alloc.x + (node->alloc.width - slots_width) / 2;
+
+ index = (slot - slots)/* / sizeof(node_slot_t)*/;
+ /* BUG_ON(index >= count); */
+
+ result.x = slots_left + index * SPACE_BETWEEN_SLOT;
+
+ return result;
+
+}
diff --git a/src/gtkext/graph/nodes/flow.h b/src/gtkext/graph/nodes/flow.h
new file mode 100644
index 0000000..5a6268e
--- /dev/null
+++ b/src/gtkext/graph/nodes/flow.h
@@ -0,0 +1,86 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * flow.h - prototypes pour l'encapsulation graphique des blocs d'exécution
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_NODES_FLOW_H
+#define _GTKEXT_GRAPH_NODES_FLOW_H
+
+
+#include "../node.h"
+#include "../../../analysis/blocks/flow.h"
+
+
+
+/* Redéfinition depuis layout.h pour contourner une boucle. */
+typedef struct _GGraphLayout GGraphLayout;
+
+
+
+#define G_TYPE_FLOW_NODE g_flow_node_get_type()
+#define G_FLOW_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_flow_node_get_type(), GFlowNode))
+#define G_IS_FLOW_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_flow_node_get_type()))
+#define G_FLOW_NODE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_flow_node_get_type(), GFlowNodeIface))
+#define G_FLOW_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FLOW_NODE, GFlowNodeClass))
+
+
+/* Type d'un accrochage pour lien */
+typedef struct _node_slot_t node_slot_t;
+
+/* Encapsulation graphique d'un bloc d'exécution (instance) */
+typedef struct _GFlowNode GFlowNode;
+
+/* Encapsulation graphique d'un bloc d'exécution (classe) */
+typedef struct _GFlowNodeClass GFlowNodeClass;
+
+
+/* Indique le type définit par la GLib pour l'encapsulation d'un bloc d'exécution. */
+GType g_flow_node_get_type(void);
+
+/* Encapsule graphiquement un bloc d'exécution. */
+GGraphNode *g_flow_node_new(GFlowBlock *, GtkBufferView *);
+
+/* Précise si le noeud a pour première instruction celle donnée. */
+bool g_flow_node_start_with(const GFlowNode *, GArchInstruction *);
+
+/* Précise la hauteur minimale requise pour un noeud. */
+void g_flow_node_register_rank(const GFlowNode *, GGraphRanks *);
+
+/* Définit l'ordonnée de l'espace attribué à un noeud. */
+void g_flow_node_apply_rank(GFlowNode *, GGraphRanks *);
+
+/* Etablit les liaison entre un noeud et ses suivants. */
+void g_flow_node_link(GFlowNode *, GGraphLayout *, GGraphNode *);
+
+/* Place un noeud sur son support final. */
+void g_flow_node_place(const GFlowNode *, GtkGraphView *);
+
+
+
+/* ------------------------ GESTION DES ACCROCHES D'UN NOEUD ------------------------ */
+
+
+/* Localise un point d'accroche à un noeud graphique. */
+GdkPoint g_flow_node_get_point_from_slot(const GFlowNode *, bool, const node_slot_t *);
+
+
+
+#endif /* _GTKEXT_GRAPH_NODES_FLOW_H */
diff --git a/src/gtkext/graph/nodes/virtual.c b/src/gtkext/graph/nodes/virtual.c
new file mode 100644
index 0000000..2781644
--- /dev/null
+++ b/src/gtkext/graph/nodes/virtual.c
@@ -0,0 +1,593 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * virtual.c - encapsulation graphique des blocs virtuels
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "virtual.h"
+
+
+#include <malloc.h>
+#include <sys/param.h>
+
+
+#include "flow.h"
+#include "../node-int.h"
+
+
+
+/* Encapsulation graphique d'un bloc virtuel (instance) */
+struct _GVirtualNode
+{
+ GGraphNode parent; /* A laisser en premier */
+
+ GVirtualBlock *block; /* Bloc virtuel associé */
+
+ gint x; /* Abscisse du noeud */
+ gint y; /* Ordonnée du noeud */
+
+ GGraphNode **children; /* Noeuds englobés */
+ size_t count; /* Quantité de ces noeuds */
+
+};
+
+/* Encapsulation graphique d'un bloc virtuel (classe) */
+struct _GVirtualNodeClass
+{
+ GGraphNodeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des encapsulations de blocs virtuels. */
+static void g_virtual_node_class_init(GVirtualNodeClass *);
+
+/* Initialise une encapsulation de bloc virtuel. */
+static void g_virtual_node_init(GVirtualNode *);
+
+/* Supprime toutes les références externes. */
+static void g_virtual_node_dispose(GVirtualNode *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_virtual_node_finalize(GVirtualNode *);
+
+/* Fournit le rang du noeud dans le graphique. */
+static unsigned int g_virtual_node_get_rank(const GVirtualNode *);
+
+/* Altère la position du noeud d'encapsulation. */
+static void g_virtual_node_set_position(GVirtualNode *, gint *, gint *);
+
+/* Fournit la position du noeud d'encapsulation. */
+static void g_virtual_node_get_position(const GVirtualNode *, gint *, gint *);
+
+/* Indique l'espace requis pour un noeud d'encapsulation. */
+static GtkAllocation g_virtual_node_get_allocation(const GVirtualNode *);
+
+/* Parcourt tous les blocs d'instructions dans un ordre donné. */
+static bool g_virtual_node_visit_flow_nodes(GVirtualNode *, graph_node_visitor_cb, void *);
+
+/* Définit les abscisses relatives du contenu d'un noeud. */
+static void g_virtual_node_setup_x_line(GVirtualNode *);
+
+
+
+/* Indique le type définit par la GLib pour l'encapsulation d'un bloc virtuel. */
+G_DEFINE_TYPE(GVirtualNode, g_virtual_node, G_TYPE_GRAPH_NODE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des encapsulations de blocs virtuels. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_class_init(GVirtualNodeClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_virtual_node_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_virtual_node_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance à initialiser. *
+* *
+* Description : Initialise une encapsulation de bloc virtuel. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_init(GVirtualNode *node)
+{
+ GGraphNode *base; /* Version basique */
+
+ base = G_GRAPH_NODE(node);
+
+ base->get_rank = (get_node_rank_fc)g_virtual_node_get_rank;
+ base->set_pos = (node_set_pos_fc)g_virtual_node_set_position;
+ base->get_pos = (node_get_pos_fc)g_virtual_node_get_position;
+ base->get_alloc = (node_get_alloc_fc)g_virtual_node_get_allocation;
+ base->visit = (visit_flow_nodes_fc)g_virtual_node_visit_flow_nodes;
+
+ node->x = UNINITIALIZED_NODE_POS;
+ node->y = UNINITIALIZED_NODE_POS;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_dispose(GVirtualNode *node)
+{
+ size_t i; /* Boucle de parcours */
+
+ g_object_unref(G_OBJECT(node->block));
+
+ for (i = 0; i < node->count; i++)
+ g_object_unref(G_OBJECT(node->children[i]));
+
+ if (node->children != NULL)
+ free(node->children);
+
+ G_OBJECT_CLASS(g_virtual_node_parent_class)->dispose(G_OBJECT(node));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_finalize(GVirtualNode *node)
+{
+ G_OBJECT_CLASS(g_virtual_node_parent_class)->finalize(G_OBJECT(node));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc virtuel représenté graphiquement. *
+* view = morceau d'affichage à représenter. *
+* *
+* Description : Encapsule graphiquement un bloc virtuel. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphNode *g_virtual_node_new(GVirtualBlock *block)
+{
+ GVirtualNode *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_VIRTUAL_NODE, NULL);
+
+ g_object_ref(G_OBJECT(block));
+
+ result->block = block;
+
+ return G_GRAPH_NODE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Fournit le rang du noeud dans le graphique. *
+* *
+* Retour : Indice supérieur ou égal à zéro. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static unsigned int g_virtual_node_get_rank(const GVirtualNode *node)
+{
+ /* BUG_ON(node->count == 0) */
+
+ return g_graph_node_get_rank(node->children[0]);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à manipuler. *
+* x = éventuelle abscisse à intégrer ou NULL. *
+* y = éventuelle ordonnée à intégrer ou NULL. *
+* *
+* Description : Altère la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_set_position(GVirtualNode *node, gint *x, gint *y)
+{
+ if (x != NULL) node->x = *x;
+ if (y != NULL) node->y = *y;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* x = éventuelle abscisse à recevoir ou NULL. [OUT] *
+* y = éventuelle ordonnée à recevoir ou NULL. [OUT] *
+* *
+* Description : Fournit la position du noeud d'encapsulation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_get_position(const GVirtualNode *node, gint *x, gint *y)
+{
+ if (x != NULL) *x = node->x;
+ if (y != NULL) *y = node->y;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique à consulter. *
+* *
+* Description : Indique l'espace requis pour un noeud d'encapsulation. *
+* *
+* Retour : Espace constitué, entièrement ou non. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GtkAllocation g_virtual_node_get_allocation(const GVirtualNode *node)
+{
+ GtkAllocation result; /* Valeurs à retourner */
+ size_t i; /* Boucle de parcours */
+ GtkAllocation alloc; /* Allocation d'un sous-noeud */
+
+ result.x = node->x;
+ result.y = node->y;
+
+ result.width = 0;
+ result.height = 0;
+
+ for (i = 0; i < node->count; i++)
+ {
+ alloc = g_graph_node_get_allocation(node->children[i]);
+
+ result.width += alloc.width;
+ result.height += alloc.height;
+
+ }
+
+ if (node->count > 1)
+ {
+ result.width += (node->count - 1) * NODE_TOP_MARGIN;
+ result.height += (node->count - 1) * NODE_TOP_MARGIN;
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud graphique démarrant la visite. *
+* callback = ensemble de blocs à parcourir. *
+* data = donnée utilisateur à associer au parcours. *
+* *
+* Description : Parcourt tous les blocs d'instructions dans un ordre donné. *
+* *
+* Retour : true si le parcours a été jusqu'à son terme, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_virtual_node_visit_flow_nodes(GVirtualNode *node, graph_node_visitor_cb callback, void *data)
+{
+ bool result; /* Bilan à retourner */
+ size_t i; /* Boucle de parcours */
+
+ result = true;
+
+ for (i = 0; i < node->count && result; i++)
+ result = g_graph_node_visit_flow_nodes(node->children[i], callback, data);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à compléter. *
+* child = sous-noeud à insérer. *
+* *
+* Description : Ajoute un noeud au groupe courant. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_virtual_node_add_child(GVirtualNode *node, GGraphNode *child)
+{
+ node->children = (GGraphNode **)realloc(node->children,
+ ++node->count * sizeof(GGraphNode *));
+
+ node->children[node->count - 1] = child;
+
+ g_object_ref(G_OBJECT(child));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à consulter. *
+* *
+* Description : Compte le nombre de noeuds contenus dans le groupe courant. *
+* *
+* Retour : Quantité normalement non nulle. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_virtual_node_count_children(const GVirtualNode *node)
+{
+ return node->count;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à consulter. *
+* index = indice du sous-bloc recherché. *
+* *
+* Description : Renvoie un des noeuds contenus dans le groupe courant. *
+* *
+* Retour : Un des blocs du groupe. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphNode *g_virtual_node_get_child(const GVirtualNode *node, size_t index)
+{
+ if (index >= node->count)
+ return NULL;
+
+ else
+ return node->children[index];
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à traiter. *
+* *
+* Description : Organise le contenu du noeud selon l'axe des abscisses. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_virtual_node_organize_x_line(GVirtualNode *node)
+{
+ size_t i; /* Boucle de parcours */
+ gint min; /* Valeur minimale rencontrée */
+ gint x; /* Position d'un sous-noeud */
+
+ g_virtual_node_setup_x_line(node);
+
+ min = 0;
+
+ for (i = 0; i < node->count; i++)
+ {
+ g_graph_node_get_position(node->children[i], &x, NULL);
+ min = MIN(min, x);
+ }
+
+ printf("min =%d\n", min);
+
+ min = -min + GRAPH_LEFT_MARGIN;
+
+ g_virtual_node_offset_x_line(node, min);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à traiter. *
+* *
+* Description : Définit les abscisses relatives du contenu d'un noeud. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_virtual_node_setup_x_line(GVirtualNode *node)
+{
+ unsigned int rank_0; /* Rang du premier sous-noeud */
+ unsigned int rank_1; /* Rang du second sous-noeud */
+ size_t i; /* Boucle de parcours */
+ GGraphNode *child; /* Raccourci confortable */
+ gint last_pos; /* Dernière position */
+ GtkAllocation alloc; /* Espace pour l'affichage */
+
+ /* Si le rang d'entrée contient tous les éléments... */
+ if (node->count > 1)
+ {
+ rank_0 = g_graph_node_get_rank(node->children[0]);
+ rank_1 = g_graph_node_get_rank(node->children[1]);
+
+ if (rank_0 == rank_1)
+ {
+ g_graph_node_set_position(node->children[0], (gint []) { -(alloc.width / 2) }, NULL);
+
+ for (i = 1; i < node->count; i++)
+ {
+ /* Récupération de la position précédente */
+
+ child = node->children[i - 1];
+
+ g_graph_node_get_position(child, &last_pos, NULL);
+ alloc = g_graph_node_get_allocation(child);
+
+ last_pos += alloc.width + NODE_LEFT_MARGIN;
+
+ /* Application sur le noeud courant */
+
+ child = node->children[i];
+
+ alloc = g_graph_node_get_allocation(child);
+
+ g_graph_node_set_position(child, &last_pos, NULL);
+
+ }
+
+ }
+
+ }
+
+ for (i = 0; i < node->count; i++)
+ {
+ child = node->children[i];
+
+ /* Emplacement du fils */
+
+ if (!g_graph_node_has_x_position(child))
+ {
+ alloc = g_graph_node_get_allocation(child);
+
+ printf("alloc ? %d\n", alloc.width);
+
+ g_graph_node_set_position(child, (gint []) { -(alloc.width / 2) }, NULL);
+ }
+
+ /* Définitions éventuelles des emplacements liés */
+
+ if (G_IS_FLOW_NODE(child))
+ {
+
+
+ ;
+
+
+ }
+ else if (G_IS_VIRTUAL_NODE(child))
+ g_virtual_node_organize_x_line(G_VIRTUAL_NODE(child));
+
+ /*else BUG_ON(1); */
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = noeud d'encapsulation à traiter. *
+* xoffset = valeur du décallage. *
+* *
+* Description : Procède à un décallage du contenu sur l'axe des abscisses. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_virtual_node_offset_x_line(GVirtualNode *node, gint xoffset)
+{
+ size_t i; /* Boucle de parcours */
+ gint x; /* Position d'un sous-noeud */
+ GGraphNode *child; /* Raccourci confortable */
+
+ for (i = 0; i < node->count; i++)
+ {
+ child = node->children[i];
+
+ g_graph_node_get_position(child, &x, NULL);
+
+ printf("[%p] old=%d... ", child, x);
+
+ x += xoffset;
+ g_graph_node_set_position(child, &x, NULL);
+
+ printf("next=%d...\n", x);
+
+ }
+
+}
diff --git a/src/gtkext/graph/nodes/virtual.h b/src/gtkext/graph/nodes/virtual.h
new file mode 100644
index 0000000..440c675
--- /dev/null
+++ b/src/gtkext/graph/nodes/virtual.h
@@ -0,0 +1,70 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * virtual.h - prototypes pour l'encapsulation graphique des blocs virtuels
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_NODES_VIRTUAL_H
+#define _GTKEXT_GRAPH_NODES_VIRTUAL_H
+
+
+#include "../node.h"
+#include "../../../analysis/blocks/virtual.h"
+
+
+
+#define G_TYPE_VIRTUAL_NODE g_virtual_node_get_type()
+#define G_VIRTUAL_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_virtual_node_get_type(), GVirtualNode))
+#define G_IS_VIRTUAL_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_virtual_node_get_type()))
+#define G_VIRTUAL_NODE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_virtual_node_get_type(), GVirtualNodeIface))
+#define G_VIRTUAL_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_VIRTUAL_NODE, GVirtualNodeClass))
+
+
+/* Encapsulation graphique d'un bloc virtuel (instance) */
+typedef struct _GVirtualNode GVirtualNode;
+
+/* Encapsulation graphique d'un bloc virtuel (classe) */
+typedef struct _GVirtualNodeClass GVirtualNodeClass;
+
+
+/* Indique le type définit par la GLib pour l'encapsulation d'un bloc virtuel. */
+GType g_virtual_node_get_type(void);
+
+/* Encapsule graphiquement un bloc virtuel. */
+GGraphNode *g_virtual_node_new(GVirtualBlock *);
+
+/* Ajoute un noeud au groupe courant. */
+void g_virtual_node_add_child(GVirtualNode *, GGraphNode *);
+
+/* Compte le nombre de noeuds contenus dans le groupe courant. */
+size_t g_virtual_node_count_children(const GVirtualNode *);
+
+/* Renvoie un des noeuds contenus dans le groupe courant. */
+GGraphNode *g_virtual_node_get_child(const GVirtualNode *, size_t);
+
+/* Organise le contenu du noeud selon l'axe des abscisses. */
+void g_virtual_node_organize_x_line(GVirtualNode *);
+
+/* Procède à un décallage du contenu sur l'axe des abscisses. */
+void g_virtual_node_offset_x_line(GVirtualNode *, gint);
+
+
+
+#endif /* _GTKEXT_GRAPH_NODES_VIRTUAL_H */
diff --git a/src/gtkext/graph/params.h b/src/gtkext/graph/params.h
new file mode 100644
index 0000000..63960b8
--- /dev/null
+++ b/src/gtkext/graph/params.h
@@ -0,0 +1,44 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * params.h - prototypes pour la modulation des paramètres de rendu
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_PARAMS_H
+#define _GTKEXT_GRAPH_PARAMS_H
+
+
+
+
+/* Coordonnés d'un noeud non initialisées */
+#define UNINITIALIZED_NODE_POS G_MININT
+
+
+
+#define GRAPH_LEFT_MARGIN 15
+#define GRAPH_TOP_MARGIN 15
+
+#define NODE_LEFT_MARGIN 25
+#define NODE_TOP_MARGIN 55
+
+
+
+
+#endif /* _GTKEXT_GRAPH_PARAMS_H */
diff --git a/src/gtkext/graph/ranks.c b/src/gtkext/graph/ranks.c
new file mode 100644
index 0000000..6121907
--- /dev/null
+++ b/src/gtkext/graph/ranks.c
@@ -0,0 +1,267 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * ranks.c - calcul de l'ordonnée des différents classements
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "ranks.h"
+
+
+#include <malloc.h>
+#include <sys/param.h>
+
+
+#include "params.h"
+
+
+
+/* Information relatives à un rang de classement */
+typedef struct _rank_props
+{
+ gint top_margin; /* Espace supérieur pour liens */
+ gint height; /* Hauteur minimale */
+
+ gint final_y; /* Ordonnée finale */
+
+} rank_props;
+
+/* Calcul de l'ordonnée des différents classements (instance) */
+struct _GGraphRanks
+{
+ GObject parent; /* A laisser en premier */
+
+ rank_props *props; /* Propriétés des rangs */
+ unsigned int count; /* Nombre de rangs présents */
+
+};
+
+/* Calcul de l'ordonnée des différents classements (classe) */
+struct _GGraphRanksClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe de calcul de l'ordonnée des classements. */
+static void g_graph_ranks_class_init(GGraphRanksClass *);
+
+/* Initialise un calcul de l'ordonnée des classements. */
+static void g_graph_ranks_init(GGraphRanks *);
+
+/* Supprime toutes les références externes. */
+static void g_graph_ranks_dispose(GGraphRanks *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_graph_ranks_finalize(GGraphRanks *);
+
+
+
+/* Indique le type définit par la GLib pour le calcul de l'ordonnée des classements. */
+G_DEFINE_TYPE(GGraphRanks, g_graph_ranks, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe de calcul de l'ordonnée des classements.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_ranks_class_init(GGraphRanksClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_ranks_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_graph_ranks_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : ranks = instance à initialiser. *
+* *
+* Description : Initialise un calcul de l'ordonnée des classements. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_ranks_init(GGraphRanks *ranks)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : node = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_ranks_dispose(GGraphRanks *ranks)
+{
+ G_OBJECT_CLASS(g_graph_ranks_parent_class)->dispose(G_OBJECT(ranks));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : ranks = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_graph_ranks_finalize(GGraphRanks *ranks)
+{
+ if (ranks->props != NULL)
+ free(ranks->props);
+
+ G_OBJECT_CLASS(g_graph_ranks_parent_class)->finalize(G_OBJECT(ranks));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : count = nombre de rangs dans le classement au total. *
+* *
+* Description : Prépare de quoi se définir au mieux les ordonnées des noeuds.*
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GGraphRanks *g_graph_ranks_new(unsigned int count)
+{
+ GGraphRanks *result; /* Structure à retourner */
+ size_t i; /* Boucle de parcours */
+
+ result = g_object_new(G_TYPE_GRAPH_RANKS, NULL);
+
+ result->count = count;
+ result->props = (rank_props *)calloc(count, sizeof(rank_props));
+
+ for (i = 0; i < count; i++)
+ if (i == 0)
+ result->props[i].top_margin = GRAPH_TOP_MARGIN;
+ else
+ result->props[i].top_margin = NODE_TOP_MARGIN;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : ranks = ensemble des rangs de classement à manipuler. *
+* index = indice du rang visé. *
+* height = hauteur minimale requise pour le rang donné. *
+* *
+* Description : Note une hauteur minimale requise pour un rang du classement.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_ranks_set_min_height(GGraphRanks *ranks, unsigned int index, gint height)
+{
+ /*BUG_ON(index >= ranks->count) */
+
+ ranks->props[index].height = MAX(ranks->props[index].height, height);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : ranks = ensemble des rangs de classement à manipuler. *
+* *
+* Description : Calcule l'ordonnée finale de chaque rang du classement. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_graph_ranks_compute_y_line(GGraphRanks *ranks)
+{
+ size_t i; /* Boucle de parcours */
+
+ for (i = 0; i < ranks->count; i++)
+ {
+ ranks->props[i].final_y = ranks->props[i].top_margin;
+
+ if (i > 0)
+ ranks->props[i].final_y += ranks->props[i - 1].final_y + ranks->props[i - 1].height;
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : ranks = ensemble des rangs de classement à consulter. *
+* index = indice du rang visé. *
+* *
+* Description : Fournit la position verticale correspondant à un rang donné. *
+* *
+* Retour : Ordonnée à utiliser. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+gint g_graph_ranks_get_y_for_rank(const GGraphRanks *ranks, unsigned int index)
+{
+ /*BUG_ON(index >= ranks->count) */
+
+ return ranks->props[index].final_y;
+
+}
diff --git a/src/gtkext/graph/ranks.h b/src/gtkext/graph/ranks.h
new file mode 100644
index 0000000..627269f
--- /dev/null
+++ b/src/gtkext/graph/ranks.h
@@ -0,0 +1,63 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * ranks.h - prototypes pour le calcul de l'ordonnée des différents classements
+ *
+ * Copyright (C) 2013 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_RANKS_H
+#define _GTKEXT_GRAPH_RANKS_H
+
+
+#include <glib-object.h>
+
+
+
+#define G_TYPE_GRAPH_RANKS g_graph_ranks_get_type()
+#define G_GRAPH_RANKS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_ranks_get_type(), GGraphRanks))
+#define G_IS_GRAPH_RANKS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_ranks_get_type()))
+#define G_GRAPH_RANKS_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_ranks_get_type(), GGraphRanksIface))
+#define G_GRAPH_RANKS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_RANKS, GGraphRanksClass))
+
+
+/* Calcul de l'ordonnée des différents classements (instance) */
+typedef struct _GGraphRanks GGraphRanks;
+
+/* Calcul de l'ordonnée des différents classements (classe) */
+typedef struct _GGraphRanksClass GGraphRanksClass;
+
+
+/* Indique le type définit par la GLib pour le calcul de l'ordonnée des classements. */
+GType g_graph_ranks_get_type(void);
+
+/* Prépare de quoi se définir au mieux les ordonnées des noeuds. */
+GGraphRanks *g_graph_ranks_new(unsigned int);
+
+/* Note une hauteur minimale requise pour un rang du classement. */
+void g_graph_ranks_set_min_height(GGraphRanks *, unsigned int, gint);
+
+/* Calcule l'ordonnée finale de chaque rang du classement. */
+void g_graph_ranks_compute_y_line(GGraphRanks *);
+
+/* Fournit la position verticale correspondant à un rang donné. */
+gint g_graph_ranks_get_y_for_rank(const GGraphRanks *, unsigned int);
+
+
+
+#endif /* _GTKEXT_GRAPH_RANKS_H */
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index aeb66ae..cb5c587 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -47,6 +47,8 @@ struct _GtkGraphView
GtkAllocation *allocs; /* Emplacements prévisibles */
size_t children_count; /* Taille de cette liste */
+ GGraphLayout *layout; /* Disposition en graphique */
+
GtkLinkRenderer **links; /* Liste des liens graphiques */
size_t links_count; /* Nombre de ces liens */
@@ -214,8 +216,10 @@ static void gtk_graph_view_size_request(GtkWidget *widget, GtkRequisition *requi
* On s'assure de ne couper aucun lien.
*/
+ /*
for (i = 0; i < view->links_count; i++)
gtk_link_renderer_size_request(view->links[i], requisition);
+ */
/**
* Traitement purement cosmétique : on ajoute la même bordure aux bords
@@ -333,12 +337,8 @@ static void gtk_graph_view_size_allocate(GtkWidget *widget, GtkAllocation *alloc
static gboolean gtk_graph_view_expose(GtkWidget *widget, GdkEventExpose *event, GtkGraphView *view)
{
- size_t i; /* Boucle de parcours */
-
- for (i = 0; i < view->links_count; i++)
- gtk_link_renderer_draw(view->links[i],
- GDK_DRAWABLE(widget->window),
- GTK_VIEW_PANEL(view)->gc);
+ if (view->layout != NULL)
+ g_graph_layout_draw(view->layout, GDK_DRAWABLE(widget->window), GTK_VIEW_PANEL(view)->gc);
return FALSE;
@@ -393,8 +393,22 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
view->allocs = (GtkAllocation *)calloc(view->children_count,
sizeof(GtkAllocation));
+
+ printf("Passage !!!\n");
+
+ /*
build_graph_view(view, g_binary_routine_get_basic_blocks(view->routine),
view->children, view->children_count);
+ */
+
+ view->layout = g_graph_layout_new(g_binary_routine_get_basic_blocks(view->routine),
+ view->children, view->children_count);
+
+ printf("----\n");
+
+ g_graph_layout_place(view->layout, view);
+
+ printf("--- done !!!\n");
break;
@@ -519,8 +533,8 @@ static void gtk_graph_view_cache_glance(GtkGraphView *view, cairo_t *cairo, cons
cairo_scale(cairo, scale, scale);
- for (i = 0; i < view->links_count; i++)
- _gtk_link_renderer_draw(view->links[i], cairo, false);
+ if (view->layout != NULL)
+ _g_graph_layout_draw(view->layout, cairo, false);
}
@@ -629,6 +643,7 @@ static void gtk_graph_view_reset(GtkGraphView *view)
view->start = VMPA_MAX;
view->end = VMPA_MAX;
+ /*
for (i = 0; i < view->links_count; i++)
gtk_object_destroy(GTK_OBJECT(view->links[i]));
@@ -640,6 +655,7 @@ static void gtk_graph_view_reset(GtkGraphView *view)
view->links_count = 0;
}
+ */
for (i = 0; i < view->children_count; i++)
gtk_widget_destroy(GTK_WIDGET(view->children[i]));