From 30258fa96ad48eed68924f259ec5464fc4fd8094 Mon Sep 17 00:00:00 2001
From: Cyrille Bagard <nocbos@gmail.com>
Date: Sun, 11 Apr 2010 16:39:38 +0000
Subject: Provided a faster than GTK display buffer.
git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@150 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a
---
ChangeLog | 34 +++
src/analysis/exporter-int.h | 10 +
src/analysis/exporter.c | 92 +++++++++
src/analysis/exporter.h | 8 +-
src/analysis/line_code.c | 84 +++++++-
src/arch/immediate.c | 91 +++++---
src/arch/instruction.c | 60 +++++-
src/arch/x86/operand.c | 206 ++++++++++++++++++
src/arch/x86/registers.c | 33 ++-
src/glibext/Makefile.am | 5 +-
src/glibext/gbufferline.c | 359 ++++++++++++++++++++++++++++++++
src/glibext/gbufferline.h | 86 ++++++++
src/glibext/gbuffersegment.c | 391 +++++++++++++++++++++++++++++++++++
src/glibext/gbuffersegment.h | 65 ++++++
src/glibext/gcodebuffer.c | 483 +++++++++++++++++++++++++++++++++++++++++++
src/glibext/gcodebuffer.h | 102 +++++++++
src/gtkext/gtkblockview.c | 217 +++++++++++--------
src/gtkext/gtkextstatusbar.c | 13 +-
src/plugins/pglist.c | 2 +-
19 files changed, 2218 insertions(+), 123 deletions(-)
create mode 100644 src/glibext/gbufferline.c
create mode 100644 src/glibext/gbufferline.h
create mode 100644 src/glibext/gbuffersegment.c
create mode 100644 src/glibext/gbuffersegment.h
create mode 100644 src/glibext/gcodebuffer.c
create mode 100644 src/glibext/gcodebuffer.h
diff --git a/ChangeLog b/ChangeLog
index 33225ce..f72f72b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,37 @@
+10-04-11 Cyrille Bagard <nocbos@gmail.com>
+
+ * src/analysis/exporter.c:
+ * src/analysis/exporter.h:
+ * src/analysis/exporter-int.h:
+ * src/analysis/line_code.c:
+ * src/arch/immediate.c:
+ * src/arch/instruction.c:
+ * src/arch/x86/operand.c:
+ * src/arch/x86/registers.c:
+ Export content into the new display buffer format (line of code only).
+
+ * src/glibext/gbufferline.c:
+ * src/glibext/gbufferline.h:
+ * src/glibext/gbuffersegment.c:
+ * src/glibext/gbuffersegment.h:
+ * src/glibext/gcodebuffer.c:
+ * src/glibext/gcodebuffer.h:
+ New entries: provide a faster than GTK display buffer.
+
+ * src/glibext/Makefile.am:
+ Add the gbufferline.[ch], gbuffersegment.[ch] and gcodebuffer.[ch]
+ files to libglibext_la_SOURCES.
+
+ * src/gtkext/gtkblockview.c:
+ Display the view using the new internal display buffer.
+
+ * src/gtkext/gtkextstatusbar.c:
+ Improve the processing time: skip all cases which don't change
+ the progress status enough (< 1%).
+
+ * src/plugins/pglist.c:
+ Disable all plugins (again).
+
10-04-05 Cyrille Bagard <nocbos@gmail.com>
* configure.ac:
diff --git a/src/analysis/exporter-int.h b/src/analysis/exporter-int.h
index 3218bcf..421770e 100644
--- a/src/analysis/exporter-int.h
+++ b/src/analysis/exporter-int.h
@@ -33,6 +33,9 @@
typedef void (* add_text_fc) (GContentExporter *, GRenderingOptions *, MainRendering, FILE *);
/* Ajoute à un texte GTK le contenu de la ligne de rendu. */
+typedef void (* export_buffer_fc) (GContentExporter *, GBufferLine *, GRenderingOptions *);
+
+/* Ajoute à un texte GTK le contenu de la ligne de rendu. */
typedef void (* add_to_gtk_buffer_fc) (GContentExporter *, MainRendering, GtkTextBuffer *, GtkTextIter *, size_t [SAR_COUNT]);
/* Traduit une instruction en version humainement lisible. */
@@ -46,6 +49,7 @@ struct _GContentExporter
GObject parent; /* A laisser en premier */
add_text_fc add_text; /* Remplissage simple */
+ export_buffer_fc export_buffer; /* Constitution du texte GTK */
add_to_gtk_buffer_fc add_to_gtk_buffer; /* Constitution du texte GTK */
add_arch_to_gtk_buffer_fc add_arch_to_gtk_buffer; /* Constitution... */
@@ -58,6 +62,9 @@ struct _GContentExporterClass
{
GObjectClass parent; /* A laisser en premier */
+ PangoContext *context; /* Contexte graphique Pango */
+ PangoAttrList *attribs[RTT_COUNT]; /* Décorateurs pour tampons */
+
GtkTextTag *tags[RTT_COUNT]; /* Décorateurs pour les textes */
};
@@ -66,6 +73,9 @@ struct _GContentExporterClass
/* Ajoute du texte simple à un fichier ouvert en écriture. */
void g_content_exporter_insert_text(GContentExporter *, FILE *, const char *, size_t, RenderingTagType);
+/* Ajoute du texte à un tampon de code via l'instance spécifiée. */
+void g_content_exporter_insert_into_buffer(GContentExporter *, GBufferLine *, BufferLineColumn, const char *, size_t, RenderingTagType);
+
/* Ajoute du texte à un texte GTK via l'instance spécifiée. */
void g_content_exporter_insert_with_gtk_tag(GContentExporter *, GtkTextBuffer *, GtkTextIter *, const char *, size_t, RenderingTagType);
diff --git a/src/analysis/exporter.c b/src/analysis/exporter.c
index e1e9160..5820fd6 100644
--- a/src/analysis/exporter.c
+++ b/src/analysis/exporter.c
@@ -46,9 +46,49 @@ G_DEFINE_TYPE(GContentExporter, g_content_exporter, G_TYPE_OBJECT);
static void g_content_exporter_class_init(GContentExporterClass *klass)
{
+ GdkScreen *screen; /* Ecran pour GDK */
+ PangoFontDescription *font_desc; /* Police de caractère */
GtkTextTagTable *table; /* Seule table globale valable */
GtkTextTag *tag;
+ /* Exportation vers un tampon de code */
+
+ screen = gdk_screen_get_default();
+
+ font_desc = pango_font_description_from_string("mono 10");
+
+ klass->context = gdk_pango_context_get_for_screen(screen);
+
+ pango_context_set_font_description(klass->context, font_desc);
+ pango_context_set_base_dir(klass->context, PANGO_DIRECTION_LTR);
+ pango_context_set_language(klass->context, gtk_get_default_language());
+
+ klass->attribs[RTT_RAW] = pango_attr_list_new();
+
+ klass->attribs[RTT_COMMENT] = pango_attr_list_new();
+
+ klass->attribs[RTT_RAW_CODE] = pango_attr_list_new();
+
+ klass->attribs[RTT_INSTRUCTION] = pango_attr_list_new();
+
+ klass->attribs[RTT_IMMEDIATE] = pango_attr_list_new();
+
+ klass->attribs[RTT_REGISTER] = pango_attr_list_new();
+
+ klass->attribs[RTT_HOOK] = pango_attr_list_new();
+
+ klass->attribs[RTT_SIGNS] = pango_attr_list_new();
+
+ klass->attribs[RTT_LTGT] = pango_attr_list_new();
+
+ klass->attribs[RTT_SEGMENT] = pango_attr_list_new();
+
+ klass->attribs[RTT_STRING] = pango_attr_list_new();
+
+ klass->attribs[RTT_VAR_NAME] = pango_attr_list_new();
+
+
+
/* Décorateurs GTK */
table = get_gtk_tag_table();
@@ -207,6 +247,36 @@ void g_content_exporter_insert_text(GContentExporter *exporter, FILE *stream, co
/******************************************************************************
* *
* Paramètres : exporter = instance sachant exporter son contenu. *
+* buffer = espace où placer ledit contenu. *
+* column = colonne de la ligne visée par l'insertion. *
+* text = texte à insérer dans l'existant. *
+* length = taille du texte à traiter. *
+* type = type de décorateur à utiliser. *
+* *
+* Description : Ajoute du texte à un tampon de code via l'instance spécifiée.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_content_exporter_insert_into_buffer(GContentExporter *exporter, GBufferLine *buffer, BufferLineColumn column, const char *text, size_t length, RenderingTagType type)
+{
+ GContentExporterClass *class; /* Stockage de briques de base */
+ GBufferSegment *segment; /* Portion de texte à ajouter */
+
+ class = G_CONTENT_EXPORTER_GET_CLASS(exporter);
+
+ segment = g_buffer_segment_new(class->context, class->attribs[type], text, length);
+ g_buffer_line_add_segment(buffer, column, segment);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : exporter = instance sachant exporter son contenu. *
* buffer = zone de texte à venir compléter. *
* iter = point d'insertion du nouveau texte. [OUT] *
* text = texte à insérer dans l'existant. *
@@ -260,6 +330,28 @@ void g_content_exporter_add_text(GContentExporter *exporter, GRenderingOptions *
/******************************************************************************
* *
+* Paramètres : exporter = instance sachant exporter son contenu. *
+* line = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_content_exporter_to_buffer(GContentExporter *exporter, GBufferLine *line, GRenderingOptions *options)
+{
+ if (exporter->export_buffer != NULL)
+ exporter->export_buffer(exporter, line, options);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : exporter = instance sachant exporter son contenu. *
* rendering = support effectif final des lignes de code. *
* buffer = zone de texte à venir compléter. *
diff --git a/src/analysis/exporter.h b/src/analysis/exporter.h
index 524d800..297fd99 100644
--- a/src/analysis/exporter.h
+++ b/src/analysis/exporter.h
@@ -31,11 +31,14 @@
#include "roptions.h"
+#include "../glibext/gbufferline.h"
/* Types de partie de rendu */
typedef enum _RenderingTagType
{
+ RTT_RAW, /* Contenu brut */
+
RTT_COMMENT, /* Commentaire */
RTT_RAW_CODE, /* Code binaire brut */
@@ -59,7 +62,7 @@ typedef enum _RenderingTagType
} RenderingTagType;
-#define RTT_NONE RTT_COUNT
+#define RTT_NONE RTT_RAW /* TODO : remme */
#define G_TYPE_CONTENT_EXPORTER g_content_exporter_get_type()
@@ -89,6 +92,9 @@ GtkTextTagTable *_get_gtk_tag_table(GtkTextTagTable *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
void g_content_exporter_add_text(GContentExporter *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+void g_content_exporter_to_buffer(GContentExporter *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu de l'instance spécifiée. */
void g_content_exporter_add_to_gtk_buffer(GContentExporter *, MainRendering, GtkTextBuffer *, GtkTextIter *, size_t [SAR_COUNT]);
diff --git a/src/analysis/line_code.c b/src/analysis/line_code.c
index 7c80074..4761522 100644
--- a/src/analysis/line_code.c
+++ b/src/analysis/line_code.c
@@ -61,6 +61,9 @@ static void g_code_line_init(GCodeLine *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_code_line_add_text(GCodeLine *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_code_line_to_buffer(GCodeLine *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu de la ligne de code. */
static void g_code_line_add_to_gtk_buffer(GCodeLine *, MainRendering, GtkTextBuffer *, GtkTextIter *, size_t [SAR_COUNT]);
@@ -109,6 +112,7 @@ static void g_code_line_init(GCodeLine *line)
exporter_parent = G_CONTENT_EXPORTER(line);
exporter_parent->add_text = (add_text_fc)g_code_line_add_text;
+ exporter_parent->export_buffer = (export_buffer_fc)g_code_line_to_buffer;
exporter_parent->add_to_gtk_buffer = (add_to_gtk_buffer_fc)g_code_line_add_to_gtk_buffer;
line_parent = G_RENDERING_LINE(line);
@@ -121,7 +125,7 @@ static void g_code_line_init(GCodeLine *line)
/******************************************************************************
* *
-* Paramètres : line = ligne de représentation à actualiser. *
+* Paramètres : line = ligne de représentation à représenter. *
* options = options de rendu. *
* rendering = support effectif final des lignes de code. *
* stream = flux ouvert en écriture. *
@@ -184,7 +188,7 @@ static void g_code_line_add_text(GCodeLine *line, GRenderingOptions *options, Ma
else
snprintf(&bin_code[i * (2 + 1)], 3, "%02hhx", content[bin_offset + i]);
}
-
+
g_content_exporter_insert_text(exporter, stream, bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
free(bin_code);
@@ -212,6 +216,80 @@ static void g_code_line_add_text(GCodeLine *line, GRenderingOptions *options, Ma
/******************************************************************************
* *
+* Paramètres : line = ligne de représentation à représenter. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_code_line_to_buffer(GCodeLine *line, GBufferLine *buffer, GRenderingOptions *options)
+{
+ GContentExporter *exporter; /* Autre vision de la ligne #1 */
+ GRenderingLine *basic; /* Autre vision de la ligne #2 */
+ MemoryDataSize msize; /* Taille du bus d'adresses */
+ char address[VMPA_MAX_SIZE]; /* Adresse au format texte */
+ size_t len; /* Taille de l'élément inséré */
+ const bin_t *content; /* Contenu binaire global */
+ off_t bin_offset; /* Début de l'instruction */
+ off_t bin_len; /* Taille d'instruction */
+ char *bin_code; /* Tampon du code binaire */
+ off_t i; /* Boucle de parcours */
+
+ exporter = G_CONTENT_EXPORTER(line);
+ basic = G_RENDERING_LINE(line);
+
+ /* Eventuelle adresse virtuelle ou physique */
+
+ msize = g_arch_processor_get_memory_size(g_rendering_options_get_processor(line->options));
+
+ len = vmpa_to_string(G_RENDERING_LINE(line)->offset, msize, address);
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ADDRESS, address, len, RTT_RAW);
+
+ /* Eventuel code brut */
+
+ content = g_binary_format_get_content(G_BIN_FORMAT(g_rendering_options_get_format(line->options)), NULL);
+ g_arch_instruction_get_location(line->instr, &bin_offset, &bin_len, NULL);
+
+ bin_code = (char *)calloc(bin_len * 3, sizeof(char));
+
+ for (i = 0; i < bin_len; i++)
+ {
+ if ((i + 1) < bin_len)
+ snprintf(&bin_code[i * (2 + 1)], 4, "%02hhx ", content[bin_offset + i]);
+ else
+ snprintf(&bin_code[i * (2 + 1)], 3, "%02hhx", content[bin_offset + i]);
+ }
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_BINARY,
+ bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
+
+ free(bin_code);
+
+ /* Instruction proprement dite */
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(line->instr), buffer, options);
+
+ /* Commentaire ? */
+
+ if (basic->comment != NULL)
+ {
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_COMMENTS, "; ", 2, RTT_COMMENT);
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_COMMENTS,
+ basic->comment, strlen(basic->comment), RTT_COMMENT);
+ }
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : line = ligne de représentation à actualiser. *
* rendering = support effectif final des lignes de code. *
* buffer = zone de texte à venir compléter. *
@@ -282,7 +360,7 @@ static void g_code_line_add_to_gtk_buffer(GCodeLine *line, MainRendering renderi
else
snprintf(&bin_code[i * (2 + 1)], 3, "%02hhx", content[bin_offset + i]);
}
-
+
g_content_exporter_insert_with_gtk_tag(exporter, buffer, iter,
bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
diff --git a/src/arch/immediate.c b/src/arch/immediate.c
index b9b8a6e..61dc5f5 100644
--- a/src/arch/immediate.c
+++ b/src/arch/immediate.c
@@ -85,11 +85,14 @@ static void g_imm_operand_class_init(GImmOperandClass *);
static void g_imm_operand_init(GImmOperand *);
/* Construit la chaîne de caractères correspondant à l'opérande. */
-static void g_imm_operand_to_string(const GImmOperand *, AsmSyntax, char [VMPA_MAX_SIZE]);
+static size_t g_imm_operand_to_string(const GImmOperand *, AsmSyntax, char [VMPA_MAX_SIZE]);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_imm_operand_add_text(const GImmOperand *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_imm_operand_to_buffer(const GImmOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_imm_operand_add_to_gtk_buffer(const GImmOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -136,6 +139,7 @@ static void g_imm_operand_init(GImmOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_imm_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_imm_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_imm_operand_add_to_gtk_buffer;
}
@@ -352,57 +356,59 @@ bool g_imm_operand_is_negative(const GImmOperand *operand)
* *
* Description : Construit la chaîne de caractères correspondant à l'opérande.*
* *
-* Retour : - *
+* Retour : Nombre de caractères utilisés. *
* *
* Remarques : - *
* *
******************************************************************************/
-static void g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax syntax, char value[VMPA_MAX_SIZE])
+static size_t g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax syntax, char value[VMPA_MAX_SIZE])
{
+ size_t result; /* Longueur à retourner */
+
switch (syntax)
{
case ASX_INTEL:
switch (operand->size)
{
case MDS_UNDEFINED:
- snprintf(value, VMPA_MAX_SIZE, "0x???");
+ result = snprintf(value, VMPA_MAX_SIZE, "0x???");
break;
case AOS_8_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "0x%hhx", operand->unsigned_imm.val8);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hhx", operand->unsigned_imm.val8);
break;
case AOS_16_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "0x%hx", operand->unsigned_imm.val16);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hx", operand->unsigned_imm.val16);
break;
case AOS_32_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "0x%x", operand->unsigned_imm.val32);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%x", operand->unsigned_imm.val32);
break;
case AOS_64_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "0x%llx", operand->unsigned_imm.val64);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%llx", operand->unsigned_imm.val64);
break;
case AOS_8_BITS_SIGNED:
if (g_imm_operand_is_negative(operand))
- snprintf(value, VMPA_MAX_SIZE, "0x%hhx", ~operand->signed_imm.val8 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hhx", ~operand->signed_imm.val8 + 1);
else
- snprintf(value, VMPA_MAX_SIZE, "0x%hhx", operand->signed_imm.val8);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hhx", operand->signed_imm.val8);
break;
case AOS_16_BITS_SIGNED:
if (g_imm_operand_is_negative(operand))
- snprintf(value, VMPA_MAX_SIZE, "0x%hx", ~operand->signed_imm.val16 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hx", ~operand->signed_imm.val16 + 1);
else
- snprintf(value, VMPA_MAX_SIZE, "0x%hx", operand->signed_imm.val16);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%hx", operand->signed_imm.val16);
break;
case AOS_32_BITS_SIGNED:
if (g_imm_operand_is_negative(operand))
- snprintf(value, VMPA_MAX_SIZE, "0x%x", ~operand->signed_imm.val32 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%x", ~operand->signed_imm.val32 + 1);
else
- snprintf(value, VMPA_MAX_SIZE, "0x%x", operand->signed_imm.val32);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%x", operand->signed_imm.val32);
break;
case AOS_64_BITS_SIGNED:
if (g_imm_operand_is_negative(operand))
- snprintf(value, VMPA_MAX_SIZE, "0x%llx", ~operand->signed_imm.val64 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%llx", ~operand->signed_imm.val64 + 1);
else
- snprintf(value, VMPA_MAX_SIZE, "0x%llx", operand->signed_imm.val64);
+ result = snprintf(value, VMPA_MAX_SIZE, "0x%llx", operand->signed_imm.val64);
break;
}
break;
@@ -411,31 +417,31 @@ static void g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax syntax
switch (operand->size)
{
case MDS_UNDEFINED:
- snprintf(value, VMPA_MAX_SIZE, "$0x???");
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x???");
break;
case AOS_8_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%hhx", operand->unsigned_imm.val8);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%hhx", operand->unsigned_imm.val8);
break;
case AOS_16_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%hx", operand->unsigned_imm.val16);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%hx", operand->unsigned_imm.val16);
break;
case AOS_32_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%x", operand->unsigned_imm.val32);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%x", operand->unsigned_imm.val32);
break;
case AOS_64_BITS_UNSIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%llx", operand->unsigned_imm.val64);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%llx", operand->unsigned_imm.val64);
break;
case AOS_8_BITS_SIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%hhx", ~operand->signed_imm.val8 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%hhx", ~operand->signed_imm.val8 + 1);
break;
case AOS_16_BITS_SIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%hx", ~operand->signed_imm.val16 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%hx", ~operand->signed_imm.val16 + 1);
break;
case AOS_32_BITS_SIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%x", ~operand->signed_imm.val32 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%x", ~operand->signed_imm.val32 + 1);
break;
case AOS_64_BITS_SIGNED:
- snprintf(value, VMPA_MAX_SIZE, "$0x%llx", ~operand->signed_imm.val64 + 1);
+ result = snprintf(value, VMPA_MAX_SIZE, "$0x%llx", ~operand->signed_imm.val64 + 1);
break;
}
break;
@@ -445,6 +451,8 @@ static void g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax syntax
}
+ return result;
+
}
@@ -466,11 +474,38 @@ static void g_imm_operand_to_string(const GImmOperand *operand, AsmSyntax syntax
static void g_imm_operand_add_text(const GImmOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream)
{
char value[VMPA_MAX_SIZE]; /* Chaîne à imprimer */
+ size_t len; /* Taille de l'élément inséré */
+
+ len = g_imm_operand_to_string(operand, g_rendering_options_get_syntax(options), value);
+
+ g_content_exporter_insert_text(G_CONTENT_EXPORTER(operand), stream, value, len, RTT_IMMEDIATE);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_imm_operand_to_buffer(const GImmOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ char value[VMPA_MAX_SIZE]; /* Chaîne à imprimer */
+ size_t len; /* Taille de l'élément inséré */
- g_imm_operand_to_string(operand, g_rendering_options_get_syntax(options), value);
+ len = g_imm_operand_to_string(operand, g_rendering_options_get_syntax(options), value);
- g_content_exporter_insert_text(G_CONTENT_EXPORTER(operand), stream,
- value, strlen(value), RTT_IMMEDIATE);
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ value, len, RTT_IMMEDIATE);
}
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index ee220a5..eb8ec28 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -41,6 +41,9 @@ static void g_arch_instruction_init(GArchInstruction *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_arch_instruction_add_text(const GArchInstruction *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_arch_instruction_to_buffer(const GArchInstruction *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'une instruction. */
static void g_arch_instruction_add_to_gtk_buffer(const GArchInstruction *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -87,6 +90,7 @@ static void g_arch_instruction_init(GArchInstruction *instr)
parent = G_CONTENT_EXPORTER(instr);
parent->add_text = (add_text_fc)g_arch_instruction_add_text;
+ parent->export_buffer = (export_buffer_fc)g_arch_instruction_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_arch_instruction_add_to_gtk_buffer;
}
@@ -109,7 +113,7 @@ static void g_arch_instruction_init(GArchInstruction *instr)
static void g_arch_instruction_add_text(const GArchInstruction *instr, GRenderingOptions *options, MainRendering rendering, FILE *stream)
{
- GContentExporter *exporter; /* Autre vision de la ligne */
+ GContentExporter *exporter; /* Autre vision de l'objet */
const char *key; /* Mot clef principal */
size_t klen; /* Taille de ce mot clef */
size_t i; /* Boucle de parcours */
@@ -148,6 +152,60 @@ static void g_arch_instruction_add_text(const GArchInstruction *instr, GRenderin
/******************************************************************************
* *
+* Paramètres : instr = instruction d'assemblage à représenter. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_arch_instruction_to_buffer(const GArchInstruction *instr, GBufferLine *buffer, GRenderingOptions *options)
+{
+ GContentExporter *exporter; /* Autre vision de l'objet */
+ const char *key; /* Mot clef principal */
+ size_t klen; /* Taille de ce mot clef */
+ size_t i; /* Boucle de parcours */
+
+ exporter = G_CONTENT_EXPORTER(instr);
+
+ key = instr->get_text(instr,
+ g_rendering_options_get_format(options),
+ g_rendering_options_get_syntax(options));
+ klen = strlen(key);
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY_HEAD,
+ key, klen, RTT_INSTRUCTION);
+
+ if (instr->operands_count > 0)
+ {
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(G_ARCH_INSTRUCTION(instr)->operands[0]),
+ buffer, options);
+
+ for (i = 1; i < instr->operands_count; i++)
+ {
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ ",", 1, RTT_NONE/* FIXME */);
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ " ", 1, RTT_NONE);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(G_ARCH_INSTRUCTION(instr)->operands[i]),
+ buffer, options);
+
+ }
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : instr = instruction à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
diff --git a/src/arch/x86/operand.c b/src/arch/x86/operand.c
index 7d6437a..0a571a7 100644
--- a/src/arch/x86/operand.c
+++ b/src/arch/x86/operand.c
@@ -92,6 +92,9 @@ static void g_x86_register_operand_init(GX86RegisterOperand *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_register_operand_add_text(const GX86RegisterOperand *, GRenderingOptions *, MainRendering, FILE *);
+/*Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_register_operand_add_to_gtk_buffer(const GX86RegisterOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -130,6 +133,9 @@ static void g_x86_mod_rm_operand_init(GX86ModRMOperand *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_mod_rm_operand_add_to_gtk_buffer(const GX86ModRMOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -164,6 +170,9 @@ static void g_x86_relative_operand_init(GX86RelativeOperand *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_relative_operand_add_text(const GX86RelativeOperand *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_relative_operand_add_to_gtk_buffer(const GX86RelativeOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -198,6 +207,9 @@ static void g_x86_moffs_operand_init(GX86MOffsOperand *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_moffs_operand_add_to_gtk_buffer(const GX86MOffsOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -233,6 +245,9 @@ static void g_x86_data_operand_init(GX86DataOperand *);
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_data_operand_add_text(const GX86DataOperand *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_data_operand_to_buffer(const GX86DataOperand *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_data_operand_add_to_gtk_buffer(const GX86DataOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -330,6 +345,7 @@ static void g_x86_register_operand_init(GX86RegisterOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_x86_register_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_register_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_register_operand_add_to_gtk_buffer;
}
@@ -476,6 +492,27 @@ static void g_x86_register_operand_add_text(const GX86RegisterOperand *operand,
/******************************************************************************
* *
* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* buffer = zone de texte à venir compléter. *
@@ -543,6 +580,7 @@ static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_x86_mod_rm_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_mod_rm_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_mod_rm_operand_add_to_gtk_buffer;
}
@@ -732,6 +770,88 @@ static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *operand, GRend
/******************************************************************************
* *
* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ GContentExporter *exporter; /* Autre vision de l'opérande */
+ char tmp[2]; /* Echelle en puissance de 2 */
+
+ exporter = G_CONTENT_EXPORTER(operand);
+
+ switch (g_rendering_options_get_syntax(options))
+ {
+ case ASX_INTEL:
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "[", 1, RTT_HOOK);
+
+ if (operand->scale > 0)
+ {
+ snprintf(tmp, 2, "%d", (int)pow(2, operand->scale));
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ tmp, 1, RTT_IMMEDIATE);
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "*", 1, RTT_SIGNS);
+
+ }
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->index), buffer, options);
+
+ if (operand->base != NULL)
+ {
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "+", 1, RTT_SIGNS);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->base), buffer, options);
+
+ }
+
+ if (operand->displacement != NULL)
+ {
+ if (g_imm_operand_is_negative(operand->displacement))
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "-", 1, RTT_SIGNS);
+ else
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "+", 1, RTT_SIGNS);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->displacement), buffer, options);
+
+ }
+
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "]", 1, RTT_HOOK);
+
+ break;
+
+ case ASX_ATT:
+
+ /* TODO */
+ g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY,
+ "[ModRM]", 7, RTT_HOOK);
+
+ break;
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* buffer = zone de texte à venir compléter. *
@@ -920,6 +1040,7 @@ static void g_x86_relative_operand_init(GX86RelativeOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_x86_relative_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_relative_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_relative_operand_add_to_gtk_buffer;
}
@@ -1004,6 +1125,27 @@ static void g_x86_relative_operand_add_text(const GX86RelativeOperand *operand,
/******************************************************************************
* *
* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->immediate), buffer, options);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* buffer = zone de texte à venir compléter. *
@@ -1091,6 +1233,7 @@ static void g_x86_moffs_operand_init(GX86MOffsOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_x86_moffs_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_moffs_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_moffs_operand_add_to_gtk_buffer;
}
@@ -1158,6 +1301,30 @@ static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *operand, GRende
/******************************************************************************
* *
* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ "ds:", 3, RTT_SEGMENT);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->offset), buffer, options);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* buffer = zone de texte à venir compléter. *
@@ -1229,6 +1396,7 @@ static void g_x86_data_operand_init(GX86DataOperand *operand)
parent = G_CONTENT_EXPORTER(operand);
parent->add_text = (add_text_fc)g_x86_data_operand_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_data_operand_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_data_operand_add_to_gtk_buffer;
}
@@ -1299,6 +1467,44 @@ static void g_x86_data_operand_add_text(const GX86DataOperand *operand, GRenderi
/******************************************************************************
* *
* Paramètres : operand = opérande à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_data_operand_to_buffer(const GX86DataOperand *operand, GBufferLine *buffer, GRenderingOptions *options)
+{
+ GContentExporter *exporter; /* Autre vision de l'opérande */
+
+ exporter = G_CONTENT_EXPORTER(operand);
+
+ if (operand->dest)
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ "es:", 3, RTT_SEGMENT);
+ else
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ "ds:", 3, RTT_SEGMENT);
+
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ "[", 1, RTT_HOOK);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options);
+
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY,
+ "]", 1, RTT_HOOK);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* buffer = zone de texte à venir compléter. *
diff --git a/src/arch/x86/registers.c b/src/arch/x86/registers.c
index 90346f7..8a61d09 100644
--- a/src/arch/x86/registers.c
+++ b/src/arch/x86/registers.c
@@ -115,6 +115,9 @@ static void g_x86_register_to_string(const GX86Register *, AsmSyntax, char [MAX_
/* Ajoute du texte simple à un fichier ouvert en écriture. */
static void g_x86_register_add_text(const GX86Register *, GRenderingOptions *, MainRendering, FILE *);
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_x86_register_to_buffer(const GX86Register *, GBufferLine *, GRenderingOptions *);
+
/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_register_add_to_gtk_buffer(const GX86Register *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);
@@ -161,6 +164,7 @@ static void g_x86_register_init(GX86Register *reg)
parent = G_CONTENT_EXPORTER(reg);
parent->add_text = (add_text_fc)g_x86_register_add_text;
+ parent->export_buffer = (export_buffer_fc)g_x86_register_to_buffer;
parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_register_add_to_gtk_buffer;
}
@@ -497,7 +501,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
/******************************************************************************
* *
-* Paramètres : operand = opérande à transcrire. *
+* Paramètres : reg = registre X86 à transcrire. *
* options = options de rendu. *
* rendering = support effectif final des lignes de code. *
* stream = flux ouvert en écriture. *
@@ -525,6 +529,33 @@ static void g_x86_register_add_text(const GX86Register *reg, GRenderingOptions *
/******************************************************************************
* *
+* Paramètres : reg = registre X86 à transcrire. *
+* buffer = espace où placer ledit contenu. *
+* options = options de rendu. *
+* *
+* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_register_to_buffer(const GX86Register *reg, GBufferLine *buffer, GRenderingOptions *options)
+{
+ char key[MAX_REGNAME_LEN]; /* Mot clef principal */
+ size_t klen; /* Taille de ce mot clef */
+
+ g_x86_register_to_string(reg, g_rendering_options_get_syntax(options), key, &klen);
+
+ g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(reg), buffer, BLC_ASSEMBLY,
+ key, klen, RTT_REGISTER);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : operand = opérande à transcrire. *
* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am
index 334b49a..7712965 100644
--- a/src/glibext/Makefile.am
+++ b/src/glibext/Makefile.am
@@ -3,7 +3,10 @@ noinst_LTLIBRARIES = libglibext.la
libglibext_la_SOURCES = \
delayed-int.h \
- delayed.h delayed.c
+ delayed.h delayed.c \
+ gbufferline.h gbufferline.c \
+ gbuffersegment.h gbuffersegment.c \
+ gcodebuffer.h gcodebuffer.c
libglibext_la_LDFLAGS =
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
new file mode 100644
index 0000000..bfb77bb
--- /dev/null
+++ b/src/glibext/gbufferline.c
@@ -0,0 +1,359 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gbufferline.c - représentation de fragments de texte en ligne
+ *
+ * Copyright (C) 2010 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 "gbufferline.h"
+
+
+
+
+#include <malloc.h> /* FIXME : à virer */
+
+
+
+/* Informations sur le contenu d'une colonne */
+typedef struct _buffer_line_column
+{
+ GBufferSegment **segments;
+ size_t count;
+
+ int max_width; /* Largeur max. de l'espace */
+
+} buffer_line_column;
+
+
+
+/* Réinitialise une colonne de ligne. */
+static void reset_column(buffer_line_column *);
+
+/* Fournit la quantité de pixels requise pour l'impression. */
+static gint get_column_width(buffer_line_column *);
+
+/* Ajoute un fragment de texte à une colonne de ligne. */
+static void add_segment_to_column(buffer_line_column *, GBufferSegment *);
+
+/* Imprime le contenu d'une colonne de ligne de texte. */
+static void draw_segments_of_column(buffer_line_column *, GdkDrawable *, GdkGC *, gint, gint);
+
+
+
+
+/* Représentation de fragments de texte en ligne (instance) */
+struct _GBufferLine
+{
+ GObject parent; /* A laisser en premier */
+
+ buffer_line_column columns[BLC_COUNT]; /* Répartition du texte */
+
+};
+
+/* Représentation de fragments de texte en ligne (classe) */
+struct _GBufferLineClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Procède à l'initialisation d'une classe de représentation. */
+static void g_buffer_line_class_init(GBufferLineClass *);
+
+/* Procède à l'initialisation d'une représentation de fragments. */
+static void g_buffer_line_init(GBufferLine *);
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : column = colonne de ligne à mettre à jour. *
+* *
+* Description : Réinitialise une colonne de ligne. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void reset_column(buffer_line_column *column)
+{
+ column->max_width = -1;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : column = colonne de ligne à consulter. *
+* *
+* Description : Fournit la quantité de pixels requise pour l'impression. *
+* *
+* Retour : Largeur requise par la colonne, en pixel. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static gint get_column_width(buffer_line_column *column)
+{
+ size_t i;
+
+ if (column->max_width == -1)
+ {
+ column->max_width = 0;
+
+ for (i = 0; i < column->count; i++)
+ column->max_width += g_buffer_segment_get_width(column->segments[i]);
+
+ }
+
+ return column->max_width;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : column = colonne de ligne à venir compléter. *
+* segment = fragment de texte à ajouter à la colonne. *
+* *
+* Description : Ajoute un fragment de texte à une colonne de ligne. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void add_segment_to_column(buffer_line_column *column, GBufferSegment *segment)
+{
+
+ /* FIXME : à remplacer */
+
+
+ column->segments = (GBufferSegment **)realloc(column->segments, ++column->count * sizeof(GBufferSegment *));
+
+
+ column->segments[column->count - 1] = segment;
+
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : column = colonne de ligne de texte à manipuler. *
+* drawable = surface de rendu où travailler. *
+* gc = contexte graphique à utiliser pour les pinceaux. *
+* x_init = abscisse du point d'impression de départ. *
+* y = ordonnée du point d'impression. *
+* *
+* Description : Imprime le contenu d'une colonne de ligne de texte. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void draw_segments_of_column(buffer_line_column *column, GdkDrawable *drawable, GdkGC *gc, gint x_init, gint y)
+{
+ gint x;
+ size_t i;
+
+ x = x_init;
+
+ for (i = 0; i < column->count; i++)
+ g_buffer_segment_draw(column->segments[i], drawable, gc, &x, y);
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Détermine le type de la représentation de fragments de texte en ligne. */
+G_DEFINE_TYPE(GBufferLine, g_buffer_line, G_TYPE_OBJECT);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe de représentation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_line_class_init(GBufferLineClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : line = composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une représentation de fragments.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_line_init(GBufferLine *line)
+{
+ unsigned int i; /* Boucle de parcours */
+
+ for (i = 0; i < BLC_COUNT; i++)
+ reset_column(&line->columns[i]);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Crée une nouvelle représentation de fragments de texte. *
+* *
+* Retour : Composant GTK créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBufferLine *g_buffer_line_new(void)
+{
+ GBufferLine *result; /* Composant à retourner */
+
+ result = g_object_new(G_TYPE_BUFFER_LINE, NULL);
+ //result = g_new0(GBufferLine, 1);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : line = ligne à venir compléter. *
+* index = index de la colonne visée par la procédure. *
+* segment = fragment de texte à ajouter à la colonne. *
+* *
+* Description : Ajoute un fragment de texte à une colonne de ligne. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_line_add_segment(GBufferLine *line, BufferLineColumn index, GBufferSegment *segment)
+{
+ add_segment_to_column(&line->columns[index], segment);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : line = ligne à venir compléter. *
+* index = index de la colonne visée par la procédure. *
+* *
+* Description : Fournit la largeur requise pour une colonne de ligne donnée. *
+* *
+* Retour : Largeur en pixel requise. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+gint g_buffer_line_get_width(GBufferLine *line, BufferLineColumn index)
+{
+ return get_column_width(&line->columns[index]);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : line = ligne de texte à manipuler. *
+* drawable = surface de rendu où travailler. *
+* gc = contexte graphique à utiliser pour les pinceaux.*
+* max_widths = largeurs de colonne à respecter. *
+* x_init = abscisse du point d'impression de départ. *
+* y = ordonnée du point d'impression. *
+* *
+* Description : Imprime la ligne de texte représentée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_line_draw(GBufferLine *line, GdkDrawable *drawable, GdkGC *gc, const gint max_widths[BLC_COUNT], gint x_init, gint y)
+{
+ gint x; /* Point de départ d'impression*/
+ unsigned int i; /* Boucle de parcours */
+
+ x = x_init;
+
+ for (i = 0; i < BLC_COUNT; i++)
+ {
+ /* TODO : skip if... */
+
+ draw_segments_of_column(&line->columns[i], drawable, gc, x, y);
+ x += max_widths[i] + 23;
+
+ }
+
+}
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
new file mode 100644
index 0000000..4113c28
--- /dev/null
+++ b/src/glibext/gbufferline.h
@@ -0,0 +1,86 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gbufferline.h - prototypes pour la représentation de fragments de texte en ligne
+ *
+ * Copyright (C) 2010 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 _GLIBEXT_GBUFFERLINE_H
+#define _GLIBEXT_GBUFFERLINE_H
+
+
+#include <glib-object.h>
+
+
+#include "gbuffersegment.h"
+
+
+
+#define G_TYPE_BUFFER_LINE (g_buffer_line_get_type())
+#define G_BUFFER_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BUFFER_LINE, GBufferLine))
+#define G_BUFFER_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BUFFER_LINE, GBufferLineClass))
+#define G_IS_BUFFER_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BUFFER_LINE))
+#define G_IS_BUFFER_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BUFFER_LINE))
+#define G_BUFFER_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BUFFER_LINE, GBufferLineClass))
+
+
+
+/* Représentation de fragments de texte en ligne (instance) */
+typedef struct _GBufferLine GBufferLine;
+
+/* Représentation de fragments de texte en ligne (classe) */
+typedef struct _GBufferLineClass GBufferLineClass;
+
+
+/* Désignation des colonnes d'une ligne */
+typedef enum _BufferLineColumn
+{
+ BLC_ADDRESS, /* Adresse virtuelle */
+ BLC_BINARY, /* Contenu sous forme binaire */
+ BLC_ASSEMBLY_HEAD, /* Instruction pour assembleur */
+ BLC_ASSEMBLY, /* Code pour assembleur */
+ BLC_COMMENTS, /* Commentaires éventuels */
+
+ BLC_COUNT
+
+} BufferLineColumn;
+
+
+/* Accompagnement du dessin pour compléments */
+typedef void (* buffer_line_draw_fc) (GBufferLine *, GdkDrawable *, GdkGC *, gint, gint, void *);
+
+
+/* Détermine le type de la représentation de fragments de texte en ligne. */
+GType g_buffer_line_get_type(void);
+
+/* Crée une nouvelle représentation de fragments de texte. */
+GBufferLine *g_buffer_line_new(void);
+
+/* Ajoute un fragment de texte à une colonne de ligne. */
+void g_buffer_line_add_segment(GBufferLine *, BufferLineColumn, GBufferSegment *);
+
+/* Fournit la largeur requise pour une colonne de ligne donnée. */
+gint g_buffer_line_get_width(GBufferLine *, BufferLineColumn);
+
+/* Imprime la ligne de texte représentée. */
+void g_buffer_line_draw(GBufferLine *, GdkDrawable *, GdkGC *, const gint [BLC_COUNT], gint, gint);
+
+
+
+#endif /* _GLIBEXT_GBUFFERLINE_H */
diff --git a/src/glibext/gbuffersegment.c b/src/glibext/gbuffersegment.c
new file mode 100644
index 0000000..bcafa97
--- /dev/null
+++ b/src/glibext/gbuffersegment.c
@@ -0,0 +1,391 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gbuffersegment.c - concentration d'un fragment de caractères aux propriétés communes
+ *
+ * Copyright (C) 2010 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 "gbuffersegment.h"
+
+
+#include <stdbool.h>
+
+
+
+
+
+
+/* Fragment de caractères aux propriétés communes (instance) */
+struct _GBufferSegment
+{
+ GObject parent; /* A laisser en premier */
+
+ PangoGlyphString *glyphs; /* Caractères traités */
+ PangoFont *font; /* Police utilisée à l'analyse */
+
+ PangoRectangle logical; /* Dimension du texte */
+
+};
+
+/* Fragment de caractères aux propriétés communes (classe) */
+struct _GBufferSegmentClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+ PangoGlyphString *ascii_glyphs; /* Caractères ASCII prêts */
+ PangoFont *ascii_font; /* Police utilisée pour ASCII */
+ bool ascii_ready; /* Utilisation possible ? */
+
+ bool ascii_init_done; /* Initialisation tentée ? */
+
+};
+
+
+/* Procède à l'initialisation d'une classe de fragment de texte. */
+static void g_buffer_segment_class_init(GBufferSegmentClass *);
+
+/* Procède à l'initialisation d'un fragment de texte. */
+static void g_buffer_segment_init(GBufferSegment *);
+
+
+
+
+
+
+
+
+
+
+static bool ascii_glyph_table_init(GBufferSegmentClass *class, PangoContext *context)
+{
+ gint i; /* Boucle de parcours */
+ char ascii_chars[128]; /* Table de caractères ASCII */
+ PangoAttrList *attribs; /* Liste d'attributs (vide) */
+ GList *list; /* Liste d'éléments distincts */
+
+ if (!class->ascii_init_done)
+ {
+ class->ascii_init_done = true;
+
+ /* Construction d'une chaîne adéquate */
+
+ for (i = 0; i < 128; ++i)
+ switch (i)
+ {
+ case 0 ... 31:
+ ascii_chars[i] = '?';
+ break;
+ case 32 ... 127:
+ ascii_chars[i] = i;
+ break;
+ default:
+ ascii_chars[i] = '?';
+ break;
+ }
+
+ /* Analyse de la chaîne créée */
+
+ attribs = pango_attr_list_new();
+ list = pango_itemize(context, ascii_chars, 0, 128, attribs, NULL);
+
+ class->ascii_ready = (list != NULL && list->next == NULL);
+
+ if (class->ascii_ready)
+ {
+ PangoItem *item;
+ int width;
+
+ item = (PangoItem *)list->data;
+ //width = gui.char_width * PANGO_SCALE;
+
+ /* Remember the shape engine used for ASCII. */
+ //default_shape_engine = item->analysis.shape_engine;
+
+ class->ascii_font = item->analysis.font;
+ g_object_ref(class->ascii_font);
+
+ class->ascii_glyphs = pango_glyph_string_new();
+
+ pango_shape(ascii_chars, 128, &item->analysis, class->ascii_glyphs);
+
+ class->ascii_ready = (class->ascii_glyphs->num_glyphs == 128);
+
+
+
+#if 0
+ for (i = 0; i < class->ascii_glyphs->num_glyphs; i++)
+ {
+ PangoGlyphGeometry *geom;
+
+ geom = &class->ascii_glyphs->glyphs[i].geometry;
+ //geom->x_offset += MAX(0, width - geom->width) / 2;
+ //geom->width = /*width*/8 * PANGO_SCALE;
+ }
+#endif
+
+ }
+
+ g_list_foreach(list, (GFunc)&pango_item_free, NULL);
+ g_list_free(list);
+
+ pango_attr_list_unref(attribs);
+
+ }
+
+ return class->ascii_ready;
+
+}
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : context = contexte Pango pour l'analyse des caractères. *
+* attribs = propriétés de la zone de texte. *
+* text = chaîne de caractères à traiter. *
+* length = quantité de ces caractères. *
+* *
+* Description : Crée un nouveau fragment de texte avec des propriétés. *
+* *
+* Retour : Composant GTK créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_segment_prepare(GBufferSegment *segment, PangoContext *context, PangoAttrList *attribs, const char *text, size_t length)
+{
+ PangoGlyphString *glyphs; /* Caractères traités */
+
+ GList *item_list;
+ PangoItem *item;
+
+ PangoRectangle logical;
+
+
+ char *max;
+ char *iter;
+
+ GBufferSegmentClass *class;
+
+ size_t i;
+
+ PangoGlyphInfo *info;
+ gint *log_clusters;
+ PangoGlyphInfo *ref;
+
+ glyphs = pango_glyph_string_new();
+
+
+
+
+ /**
+ * Petite astuce empruntée à Vim...
+ * (cf. src/gui_gtk_x11.c, fonction gui_gtk2_draw_string()).
+ * On essaie de traiter à la main les morceaux de
+ * texte. Pour ceux en ASCII pur, le gain est non négligeable.
+ */
+
+ max = text + length;
+
+ for (iter = text; iter < max; iter++)
+ if (*iter & 0x80)
+ goto not_ascii;
+
+ class = G_BUFFER_SEGMENT_GET_CLASS(segment);
+
+ if (!ascii_glyph_table_init(class, context))
+ goto not_ascii;
+
+ pango_glyph_string_set_size(glyphs, length);
+
+ info = glyphs->glyphs;
+ log_clusters = glyphs->log_clusters;
+ ref = class->ascii_glyphs->glyphs;
+
+ for (i = 0; i < length; i++)
+ {
+ info[i] = ref[text[i]];
+ log_clusters[i] = i;
+ }
+
+ goto next;
+
+ not_ascii:
+
+ item_list = pango_itemize(context, text, 0, length, attribs, NULL);
+
+ /*
+ if (!(item_list != NULL && item_list->next == NULL))
+ printf("ouich\n");
+ */
+
+ item = (PangoItem *)item_list->data;
+ pango_shape(text, length, &item->analysis, glyphs);
+
+ //segment->font = item->analysis.font;/* TODO : ref ! */
+
+
+ next:
+
+
+ //pango_shape(text, length, &item->analysis, glyphs);
+
+
+ pango_glyph_string_extents(glyphs, class->ascii_font, NULL, &segment->logical);
+
+ segment->logical.y /= PANGO_SCALE;
+ segment->logical.width /= PANGO_SCALE;
+ segment->logical.height /= PANGO_SCALE;
+
+ segment->glyphs = glyphs;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Détermine le type du fragment de caractères aux propriétés communes. */
+G_DEFINE_TYPE(GBufferSegment, g_buffer_segment, G_TYPE_OBJECT);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe de fragment de texte.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_segment_class_init(GBufferSegmentClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : segment = composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'un fragment de texte. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_segment_init(GBufferSegment *segment)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = contexte Pango pour l'analyse des caractères. *
+* attribs = propriétés de la zone de texte. *
+* text = chaîne de caractères à traiter. *
+* length = quantité de ces caractères. *
+* *
+* Description : Crée un nouveau fragment de texte avec des propriétés. *
+* *
+* Retour : Composant GTK créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBufferSegment *g_buffer_segment_new(PangoContext *context, PangoAttrList *attribs, const char *text, size_t length)
+{
+ GBufferSegment *result; /* Composant à retourner */
+
+ result = g_object_new(G_TYPE_BUFFER_SEGMENT, NULL);
+ //result = g_new(GBufferSegment, 1);
+
+ g_buffer_segment_prepare(result, context, attribs, text, length);
+
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : segment = fragment de texte à consulter. *
+* *
+* Description : Fournit la quantité de pixels requise pour l'impression. *
+* *
+* Retour : Largeur requise par la colonne, en pixel. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+gint g_buffer_segment_get_width(const GBufferSegment *segment)
+{
+ return segment->logical.width;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : segment = fragment de texte à manipuler. *
+* drawable = surface de rendu où travailler. *
+* gc = contexte graphique à utiliser pour les pinceaux. *
+* x = abscisse du point d'impression (à maj). [OUT] *
+* y = ordonnée du point d'impression. *
+* *
+* Description : Imprime le fragment de texte représenté. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_segment_draw(GBufferSegment *segment, GdkDrawable *drawable, GdkGC *gc, gint *x, gint y)
+{
+ gdk_draw_glyphs(drawable, gc, G_BUFFER_SEGMENT_GET_CLASS(segment)->ascii_font,
+ *x, y - segment->logical.y, segment->glyphs);
+
+ *x += segment->logical.width;
+
+}
diff --git a/src/glibext/gbuffersegment.h b/src/glibext/gbuffersegment.h
new file mode 100644
index 0000000..28338b9
--- /dev/null
+++ b/src/glibext/gbuffersegment.h
@@ -0,0 +1,65 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gbuffersegment.h - prototypes pour la concentration d'un fragment de caractères aux propriétés communes
+ *
+ * Copyright (C) 2010 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 _GLIBEXT_GBUFFERSEGMENT_H
+#define _GLIBEXT_GBUFFERSEGMENT_H
+
+
+#include <glib-object.h>
+#include <gdk/gdk.h>
+#include <pango/pango.h>
+
+
+
+#define G_TYPE_BUFFER_SEGMENT (g_buffer_segment_get_type())
+#define G_BUFFER_SEGMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BUFFER_SEGMENT, GBufferSegment))
+#define G_BUFFER_SEGMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BUFFER_SEGMENT, GBufferSegmentClass))
+#define G_IS_BUFFER_SEGMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BUFFER_SEGMENT))
+#define G_IS_BUFFER_SEGMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BUFFER_SEGMENT))
+#define G_BUFFER_SEGMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BUFFER_SEGMENT, GBufferSegmentClass))
+
+
+
+/* Fragment de caractères aux propriétés communes (instance) */
+typedef struct _GBufferSegment GBufferSegment;
+
+/* Fragment de caractères aux propriétés communes (classe) */
+typedef struct _GBufferSegmentClass GBufferSegmentClass;
+
+
+
+/* Détermine le type du fragment de caractères aux propriétés communes. */
+GType g_buffer_segment_get_type(void);
+
+/* Crée un nouveau fragment de texte avec des propriétés. */
+GBufferSegment *g_buffer_segment_new(PangoContext *, PangoAttrList *, const char *, size_t);
+
+/* Fournit la quantité de pixels requise pour l'impression. */
+gint g_buffer_segment_get_width(const GBufferSegment *);
+
+/* Imprime le fragment de texte représenté. */
+void g_buffer_segment_draw(GBufferSegment *, GdkDrawable *, GdkGC *, gint *, gint);
+
+
+
+#endif /* _GLIBEXT_GBUFFERSEGMENT_H */
diff --git a/src/glibext/gcodebuffer.c b/src/glibext/gcodebuffer.c
new file mode 100644
index 0000000..fda2c01
--- /dev/null
+++ b/src/glibext/gcodebuffer.c
@@ -0,0 +1,483 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gcodebuffer.h - prototypes pour l'affichage d'un fragment de code d'assemblage
+ *
+ * Copyright (C) 2010 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 "gcodebuffer.h"
+
+
+#include <malloc.h>
+#include <sys/param.h>
+
+
+
+/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */
+
+
+/* Tampon pour code désassemblé (instance) */
+struct _GCodeBuffer
+{
+ GObject parent; /* A laisser en premier */
+
+ GBufferLine **lines; /* Liste des lignes intégrées */
+ size_t count; /* Quantité en cache */
+ size_t used; /* Quantité utilisée */
+
+};
+
+/* Tampon pour code désassemblé (classe) */
+struct _GCodeBufferClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Taille des allocations de masse */
+#define LINE_ALLOC_BULK 20
+
+
+/* Procède à l'initialisation d'une classe de tampon de code. */
+static void g_code_buffer_class_init(GCodeBufferClass *);
+
+/* Procède à l'initialisation d'un tampon pour code désassemblé. */
+static void g_code_buffer_init(GCodeBuffer *);
+
+
+
+/* ---------------------- VUE PARTICULIERE D'UN TAMPON DE CODE ---------------------- */
+
+
+/* Vue d'un tampon pour code désassemblé (instance) */
+struct _GBufferView
+{
+ GObject parent; /* A laisser en premier */
+
+ GCodeBuffer *buffer; /* Tampon de code visualisé */
+ size_t first; /* Première ligne intégrée */
+ size_t last; /* Dernière ligne intégrée */
+
+ gint line_height; /* Hauteur maximale des lignes */
+ gint max_widths[BLC_COUNT]; /* Taille cachée des colonnes */
+ gint left_margin; /* Marge gauche + espace */
+ gint left_text; /* Début d'impression du code */
+
+ buffer_line_draw_fc drawing_extra; /* Fonction d'accompagnement */
+ void *drawing_data; /* Donnée utilisateur */
+
+};
+
+/* Vue d'un tampon pour code désassemblé (classe) */
+struct _GBufferViewClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+#define WIDTHS_CACHED(view) ((view)->max_widths[0] != -1)
+
+
+/* Procède à l'initialisation d'une classe de vue de tampon. */
+static void g_buffer_view_class_init(GBufferViewClass *);
+
+/* Procède à l'initialisation d'une vue d'un tampon pour code. */
+static void g_buffer_view_init(GBufferView *);
+
+/* Réinitialise le cache des largeurs de colonne calculées. */
+static void g_buffer_view_reset_required_widths(GBufferView *);
+
+/* Calcule les dimensions requises par une visualisation. */
+static void g_buffer_view_compute_required_widths(GBufferView *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* TAMPON POUR CODE DESASSEMBLE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Détermine le type du composant de tampon pour code désassemblé. */
+G_DEFINE_TYPE(GCodeBuffer, g_code_buffer, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe de tampon de code. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_code_buffer_class_init(GCodeBufferClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : buffer = composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'un tampon pour code désassemblé.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_code_buffer_init(GCodeBuffer *buffer)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Crée un nouveau composant de tampon pour code désassemblé. *
+* *
+* Retour : Composant GTK créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GCodeBuffer *g_code_buffer_new(void)
+{
+ GCodeBuffer *result; /* Composant à retourner */
+
+ result = g_object_new(G_TYPE_CODE_BUFFER, NULL);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : buffer = composant GTK à mettre à jour. *
+* *
+* Description : Ajoute une nouvelle ligne à un tampon pour code désassemblé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *buffer)
+{
+ GBufferLine *result; /* Instance à retourner */
+
+ if (buffer->used == buffer->count)
+ {
+ buffer->count += LINE_ALLOC_BULK;
+ buffer->lines = (GBufferLine **)realloc(buffer->lines,
+ buffer->count * sizeof(GBufferLine *));
+ }
+
+ result = g_buffer_line_new();
+ buffer->lines[buffer->used++] = result;
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* VUE PARTICULIERE D'UN TAMPON DE CODE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Détermine le type de la vue d'un tampon pour code désassemblé. */
+G_DEFINE_TYPE(GBufferView, g_buffer_view, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe de vue de tampon. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_view_class_init(GBufferViewClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : buffer = composant GTK à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une vue d'un tampon pour code. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_view_init(GBufferView *buffer)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : buffer = tamon à représenter à l'écran. *
+* *
+* Description : Crée une nouvelle vue d'un tampon pour code désassemblé. *
+* *
+* Retour : Composant GTK créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBufferView *g_buffer_view_new(GCodeBuffer *buffer)
+{
+ GBufferView *result; /* Composant à retourner */
+
+ result = g_object_new(G_TYPE_BUFFER_VIEW, NULL);
+
+ result->buffer = buffer;
+ result->first = 0;
+ result->last = buffer->used;
+
+ g_buffer_view_reset_required_widths(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à consulter. *
+* *
+* Description : Réinitialise le cache des largeurs de colonne calculées. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_view_reset_required_widths(GBufferView *view)
+{
+ unsigned int i; /* Boucle de parcours */
+
+ for (i = 0; i < BLC_COUNT; i++)
+ view->max_widths[i] = -1;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à consulter. *
+* *
+* Description : Calcule les dimensions requises par une visualisation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_buffer_view_compute_required_widths(GBufferView *view)
+{
+ GBufferLine **lines; /* Liste des lignes à traiter */
+ size_t i; /* Boucle de parcours #1 */
+ unsigned int j; /* Boucle de parcours #2 */
+ gint width; /* Largeur d'une colonne */
+
+ lines = view->buffer->lines;
+
+ view->line_height = 17;
+
+ view->left_margin = 2 * view->line_height;
+ view->left_text = 2.5 * view->line_height;
+
+ for (i = view->first; i < view->last; i++)
+ for (j = 0; j < BLC_COUNT; j++)
+ {
+ width = g_buffer_line_get_width(lines[i], j);
+ view->max_widths[j] = MAX(view->max_widths[j], width);
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à consulter. *
+* *
+* Description : Fournit la hauteur d'impression d'une ligne visualisée. *
+* *
+* Retour : Hauteur de ligne en pixel. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+gint g_buffer_view_get_line_height(GBufferView *view)
+{
+ if (!WIDTHS_CACHED(view))
+ g_buffer_view_compute_required_widths(view);
+
+ return view->line_height;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à consulter. *
+* width = largeur requise pour une pleine visualisation. [OUT]*
+* height = hauteur requise pour une pleine visualisation. [OUT]*
+* *
+* Description : Fournit les dimensions requises par une visualisation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_view_get_size(GBufferView *view, gint *width, gint *height)
+{
+ unsigned int i; /* Boucle de parcours */
+
+ *width = 0;
+ *height = view->line_height;
+
+ if (!WIDTHS_CACHED(view))
+ g_buffer_view_compute_required_widths(view);
+
+ for (i = 0; i < BLC_COUNT; i++)
+ *width += view->max_widths[i];
+
+ *height *= (view->last - view->first);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à mettre à jour. *
+* method = procédure à appeler à chaque dessin de ligne. *
+* data = donnée utilisateur à passer lors des appels. *
+* *
+* Description : Définit à une procédure à appeler lors des dessins de ligne. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_view_define_extra_drawing(GBufferView *view, buffer_line_draw_fc method, void *data)
+{
+ view->drawing_extra = method;
+ view->drawing_data = data;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = visualisation à représenter. *
+* event = informations liées à l'événement. *
+* gc = contexte graphique à utiliser pour les pinceaux. *
+* fake_x = abscisse réelle du point 0 à l'écran. *
+* fake_y = ordonnée réelle du point 0 à l'écran. *
+* *
+* Description : Imprime la visualisation du tempon de code désassemblé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_buffer_view_draw(const GBufferView *view, const GdkEventExpose *event, GdkGC *gc, gint fake_x, gint fake_y)
+{
+ GdkDrawable *drawable; /* Surface de dessin */
+ gint real_x; /* Abscisse réelle pour tampon */
+ gint real_y; /* Ordonnée réelle pour tampon */
+
+ size_t first; /* Première ligne visée */
+ size_t last; /* Dernière ligne visée + 1 */
+ gint y; /* Point de départ + décallage */
+
+
+ GBufferLine **lines; /* Liste des lignes à traiter */
+ size_t i; /* Boucle de parcours */
+
+
+ drawable = GDK_DRAWABLE(event->window);
+
+
+ real_x = fake_x + view->left_text;
+ real_y = fake_y + event->area.y;
+
+
+
+ first = (real_y / view->line_height);
+ last = first + (event->area.height / view->line_height);
+ if (event->area.height % view->line_height > 0) last++;
+
+ y = event->area.y - (real_y % view->line_height);
+
+
+
+ lines = view->buffer->lines;
+
+ for (i = first; i < last; i++)
+ {
+ /* TODO : skip if... */
+
+ if (view->drawing_extra != NULL)
+ view->drawing_extra(lines[i], drawable, gc, fake_x, y, view->drawing_data);
+
+ g_buffer_line_draw(lines[i], drawable, gc, view->max_widths, real_x, y);
+
+ y += view->line_height;
+
+ }
+
+}
diff --git a/src/glibext/gcodebuffer.h b/src/glibext/gcodebuffer.h
new file mode 100644
index 0000000..9460530
--- /dev/null
+++ b/src/glibext/gcodebuffer.h
@@ -0,0 +1,102 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gcodebuffer.h - prototypes pour l'affichage d'un fragment de code d'assemblage
+ *
+ * Copyright (C) 2010 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 _GLIBEXT_GCODEBUFFER_H
+#define _GLIBEXT_GCODEBUFFER_H
+
+
+#include <glib-object.h>
+
+
+#include "gbufferline.h"
+
+
+
+/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */
+
+
+#define G_TYPE_CODE_BUFFER (g_code_buffer_get_type())
+#define G_CODE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_CODE_BUFFER, GCodeBuffer))
+#define G_CODE_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CODE_BUFFER, GCodeBufferClass))
+#define G_IS_CODE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_CODE_BUFFER))
+#define G_IS_CODE_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CODE_BUFFER))
+#define G_CODE_BUFFER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CODE_BUFFER, GCodeBufferClass))
+
+
+/* Tampon pour code désassemblé (instance) */
+typedef struct _GCodeBuffer GCodeBuffer;
+
+/* Tampon pour code désassemblé (classe) */
+typedef struct _GCodeBufferClass GCodeBufferClass;
+
+
+/* Détermine le type du composant de tampon pour code désassemblé. */
+GType g_code_buffer_get_type(void);
+
+/* Crée un nouveau composant de tampon pour code désassemblé. */
+GCodeBuffer *g_code_buffer_new(void);
+
+/* Ajoute une nouvelle ligne à un tampon pour code désassemblé. */
+GBufferLine *g_code_buffer_append_new_line(GCodeBuffer *);
+
+
+
+/* ---------------------- VUE PARTICULIERE D'UN TAMPON DE CODE ---------------------- */
+
+
+#define G_TYPE_BUFFER_VIEW (g_buffer_view_get_type())
+#define G_BUFFER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BUFFER_VIEW, GBufferView))
+#define G_BUFFER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BUFFER_VIEW, GBufferViewClass))
+#define G_IS_BUFFER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BUFFER_VIEW))
+#define G_IS_BUFFER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BUFFER_VIEW))
+#define G_BUFFER_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BUFFER_VIEW, GBufferViewClass))
+
+
+/* Vue d'un tampon pour code désassemblé (instance) */
+typedef struct _GBufferView GBufferView;
+
+/* Vue d'un tampon pour code désassemblé (classe) */
+typedef struct _GBufferViewClass GBufferViewClass;
+
+
+/* Détermine le type de la vue d'un tampon pour code désassemblé. */
+GType g_buffer_view_get_type(void);
+
+/* Crée une nouvelle vue d'un tampon pour code désassemblé. */
+GBufferView *g_buffer_view_new(GCodeBuffer *);
+
+/* Fournit la hauteur d'impression d'une ligne visualisée. */
+gint g_buffer_view_get_line_height(GBufferView *);
+
+/* Fournit les dimensions requises par une visualisation. */
+void g_buffer_view_get_size(GBufferView *, gint *, gint *);
+
+/* Définit à une procédure à appeler lors des dessins de ligne. */
+void g_buffer_view_define_extra_drawing(GBufferView *, buffer_line_draw_fc, void *);
+
+/* Imprime la visualisation du tempon de code désassemblé. */
+void g_buffer_view_draw(const GBufferView *, const GdkEventExpose *, GdkGC *, gint, gint);
+
+
+
+#endif /* _GLIBEXT_GCODEBUFFER_H */
diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c
index a4f0d3e..2ea7ae2 100644
--- a/src/gtkext/gtkblockview.c
+++ b/src/gtkext/gtkblockview.c
@@ -36,8 +36,11 @@
#include "../analysis/exporter.h"
#include "../common/dllist.h"
#include "../glibext/delayed-int.h"
+#include "../glibext/gcodebuffer.h"
+#include "../glibext/gbuffersegment.h"
+
#ifndef _
# define _(str) str
@@ -104,6 +107,7 @@ struct _GtkBlockView
bool show_vaddress; /* Affichage des adresses ? */
bool show_code; /* Affichage du code brut ? */
+ GBufferView *buffer_view; /* Code sous forme de texte */
GtkTextBuffer *buffer; /* Code sous forme de texte */
GtkTextLayout *layout; /* Disposition du texte */
@@ -114,6 +118,12 @@ struct _GtkBlockView
const exe_format *format; /* Format du contenu bianire */
+
+
+ GCodeBuffer *_buffer; /* Code sous forme de texte */
+
+
+
};
struct _GtkBlockViewClass
@@ -205,6 +215,10 @@ static void gtk_block_view_size_allocate(GtkWidget *widget,
static gboolean gtk_block_view_button_press(GtkWidget *, GdkEventButton *event);
+
+/* Imprime d'éventuelles informations liées à une ligne. */
+static void gtk_block_view_draw_line_extra(GBufferLine *, GdkDrawable *, GdkGC *, gint, gint, void *);
+
/* Met à jour l'affichage de la vue sous forme de bloc. */
static gboolean gtk_block_view_expose(GtkWidget *, GdkEventExpose *);
@@ -308,11 +322,16 @@ static void g_delayed_insertion_process(GDelayedInsertion *insertion, GtkExtStat
vmpa_t start; /* Adresse de début de parcours*/
vmpa_t end; /* Adresse de fin de parcours */
guint id; /* Identifiant de statut */
+ GRenderingOptions *options; /* Options de rendu */
GRenderingLine *iter; /* Boucle de parcours */
GtkTextIter pos; /* Point d'insertion */
- GtkTextMark *mark; /* Marquage de ligne associée */
+ GBufferLine *line; /* Ligne de destination */
+ //GtkTextMark *mark; /* Marquage de ligne associée */
vmpa_t done; /* Quantité déjà parcourue */
+ clock_t _start, _end;
+ double cpu_time_used;
+
view = insertion->view;
lines = GTK_BIN_VIEW(view)->lines;
@@ -332,6 +351,10 @@ static void g_delayed_insertion_process(GDelayedInsertion *insertion, GtkExtStat
id = gtk_extended_status_bar_push(statusbar, _("Inserting lines..."), true);
+ options = g_openida_binary_get_options(GTK_BIN_VIEW(view)->binary);
+
+ _start = clock();
+
for (iter = lines;
iter != NULL;
iter = g_rendering_line_get_next_iter(lines, iter, last))
@@ -339,8 +362,16 @@ static void g_delayed_insertion_process(GDelayedInsertion *insertion, GtkExtStat
g_signal_connect(iter, "rendering-line-flags-changed",
G_CALLBACK(gtk_block_view_update_margin), view);
- gdk_threads_enter();
+ //gdk_threads_enter();
+ line = g_code_buffer_append_new_line(view->_buffer);
+
+ g_content_exporter_to_buffer(G_CONTENT_EXPORTER(iter), line, options);
+ g_object_set_data(G_OBJECT(line), "line", iter);
+
+
+
+#if 0
if (iter != lines)
gtk_text_buffer_insert_with_tags(view->buffer, &pos, "\n", 1, NULL);
@@ -351,17 +382,33 @@ static void g_delayed_insertion_process(GDelayedInsertion *insertion, GtkExtStat
g_content_exporter_add_to_gtk_buffer(G_CONTENT_EXPORTER(iter), view->rendering,
view->buffer, &pos, insertion->lengths);
+#endif
+ /*
gdk_flush ();
gdk_threads_leave();
+ */
done = get_rendering_line_address(iter) + get_rendering_line_length(iter) - start;
gtk_extended_status_bar_update_activity(statusbar, id, done * 1.0 / end);
}
+
+ _end = clock();
+
+ cpu_time_used = ((double) (_end - _start)) / (CLOCKS_PER_SEC / 1000);
+
+ printf(" ### TEMPS passé ::: %g ms (pid = %d)\n", cpu_time_used, getpid());
+
+
gtk_extended_status_bar_remove(statusbar, id);
+ view->buffer_view = g_buffer_view_new(view->_buffer);
+
+ g_buffer_view_define_extra_drawing(view->buffer_view, gtk_block_view_draw_line_extra, view);
+
+
}
@@ -550,6 +597,10 @@ static void gtk_block_view_init(GtkBlockView *view)
}
+
+ view->_buffer = g_code_buffer_new();
+
+
}
@@ -568,16 +619,11 @@ static void gtk_block_view_init(GtkBlockView *view)
static void gtk_block_view_realize(GtkWidget *widget)
{
GtkBinViewClass *parent_class; /* Version pure du parent */
- PangoFontDescription *font_desc;
parent_class = GTK_BIN_VIEW_CLASS(g_type_class_peek_parent(GTK_BLOCK_VIEW_GET_CLASS(widget)));
GTK_WIDGET_CLASS(parent_class)->realize(widget);
- font_desc = pango_font_description_from_string("mono 10");
- gtk_widget_modify_font(widget, font_desc);
- pango_font_description_free(font_desc);
-
}
@@ -596,8 +642,11 @@ static void gtk_block_view_realize(GtkWidget *widget)
static void gtk_block_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
{
- gtk_text_layout_get_size(GTK_BLOCK_VIEW(widget)->layout,
- &requisition->width, &requisition->height);
+ g_buffer_view_get_size(GTK_BLOCK_VIEW(widget)->buffer_view,
+ &requisition->width, &requisition->height);
+
+ printf(" === size req :: (%d ; %d)\n",
+ requisition->width, requisition->height);
}
@@ -637,7 +686,7 @@ static void gtk_block_view_size_allocate(GtkWidget *widget, GtkAllocation *alloc
if (view->hadjustment == NULL || view->vadjustment == NULL)
return;
- gtk_text_layout_get_size(GTK_BLOCK_VIEW(view)->layout, &width, &height);
+ g_buffer_view_get_size(GTK_BLOCK_VIEW(view)->buffer_view, &width, &height);
gtk_bin_view_compute_allocation(view, &valloc);
@@ -786,6 +835,74 @@ static void gtk_block_view_compute_real_coord(GtkBlockView *view, gint *x, gint
/******************************************************************************
* *
+* Paramètres : line = ligne de texte à manipuler. *
+* drawable = surface de rendu où travailler. *
+* gc = contexte graphique à utiliser pour les pinceaux. *
+* x = abscisse du point d'impression décallé. *
+* y = ordonnée du point d'impression décallé. *
+* data = pointeur vers le composant GTK de support. *
+* *
+* Description : Imprime d'éventuelles informations liées à une ligne. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_block_view_draw_line_extra(GBufferLine *line, GdkDrawable *drawable, GdkGC *gc, gint x, gint y, void *data)
+{
+ GRenderingLine *rline; /* Ligne de rendu représentée */
+ GtkBlockViewClass *class; /* Classe contenant les images */
+ gint line_height; /* Hauteur d'une ligne */
+ RenderingLineFlag flags; /* Propriétés de la ligne */
+ int height; /* Hauteur de l'image */
+ GdkPixbuf *pixbuf; /* Données utiles au dessin */
+
+ rline = G_RENDERING_LINE(g_object_get_data(G_OBJECT(line), "line"));
+ class = GTK_BLOCK_VIEW_GET_CLASS(data);
+
+ line_height = g_buffer_view_get_line_height(GTK_BLOCK_VIEW(data)->buffer_view);
+
+ flags = g_rendering_line_get_flags(rline);
+
+ if (flags & RLF_RUNNING_BP)
+ pixbuf = class->stopped_pix;
+
+ else if (flags & RLF_BREAK_POINT)
+ pixbuf = class->breakpoint_pix;
+
+ else pixbuf = NULL;
+
+ if (pixbuf != NULL)
+ {
+ height = gdk_pixbuf_get_height(pixbuf);
+
+ gdk_draw_pixbuf(drawable, gc, pixbuf, 0, 0, x + 10,
+ y + (line_height - height) / 2,
+ gdk_pixbuf_get_width(pixbuf), height,
+ GDK_RGB_DITHER_NORMAL, 0, 0);
+
+ }
+
+ /* Le point d'entrée prime */
+ if (flags & RLF_ENTRY_POINT)
+ {
+ pixbuf = class->entry_pix;
+ height = gdk_pixbuf_get_height(pixbuf);
+
+ gdk_draw_pixbuf(drawable, gc, pixbuf, 0, 0, x + 10,
+ y + (line_height - height) / 2,
+ gdk_pixbuf_get_width(pixbuf), height,
+ GDK_RGB_DITHER_NORMAL, 0, 0);
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : view = composant GTK à redessiner. *
* event = informations liées à l'événement. *
* *
@@ -802,33 +919,18 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
GtkBlockView *view; /* Autre version du composant */
GtkBinView *bview; /* Autre version du composant */
GtkStyle *style; /* Style associé au composant */
+ GdkDrawable *drawable; /* Surface de dessin */
gint fake_x; /* Abscisse virtuelle */
gint fake_y; /* Ordonnée virtuelle */
GtkBinViewClass *parent_class; /* Version pure du parent */
- GtkTextIter iter; /* Point d'insertion */
- GdkRectangle rect; /* Zone d'un point */
- GtkTextMark *mark; /* Marquage de ligne associée */
- GRenderingLine *line; /* Ligne de rendu */
- RenderingLineFlag flags; /* Propriétés de la ligne */
- GdkPixbuf *pixbuf; /* Données utiles au dessin */
-
-
- //GdkGCValues values; /* Propriétés du contexte */
- //GdkColor white; /* Couleur du fond */
- //int width; /* Largeur de l'élément */
- //int height; /* Hauteur de l'élément */
- //int y; /* Ordonnée du haut d'une ligne*/
- //GRenderingLine *iter; /* Boucle de parcours */
-
-
- GList *child_exposes;
view = GTK_BLOCK_VIEW(widget);
-
widget = GTK_WIDGET(view);
bview = GTK_BIN_VIEW(widget);
- gdk_window_begin_paint_region(GDK_DRAWABLE(widget->window), event->region);
+ drawable = GDK_DRAWABLE(event->window);
+
+ gdk_window_begin_paint_region(drawable, event->region);
gdk_gc_set_clip_region(bview->gc, event->region);
@@ -842,12 +944,12 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
gdk_gc_set_foreground(bview->gc, &style->mid[GTK_WIDGET_STATE(widget)]);
- gdk_draw_rectangle(GDK_DRAWABLE(widget->window), bview->gc, TRUE,
+ gdk_draw_rectangle(drawable, bview->gc, TRUE,
fake_x, event->area.y, view->left_margin, event->area.y + event->area.height);
gdk_gc_set_foreground(bview->gc, &style->dark[GTK_WIDGET_STATE(widget)]);
- gdk_draw_line(GDK_DRAWABLE(widget->window), bview->gc,
+ gdk_draw_line(drawable, bview->gc,
fake_x + view->left_margin, event->area.y,
fake_x + view->left_margin, event->area.y + event->area.height);
@@ -857,58 +959,11 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
- /* Informations individuelles des lignes */
-
- gtk_text_layout_get_line_at_y(view->layout, &iter, fake_y, NULL);
- gtk_text_layout_get_iter_location(view->layout, &iter, &rect);
-
- while (rect.y < (fake_y + event->area.height))
- {
- gtk_block_view_compute_real_coord(view, &rect.x, &rect.y);
-
- mark = gtk_text_iter_get_marks(&iter)->data;
-
- line = g_object_get_data(G_OBJECT(mark), "line");
- if (line == NULL) break;
-
- flags = g_rendering_line_get_flags(line);
-
- if (flags & RLF_RUNNING_BP)
- pixbuf = GTK_BLOCK_VIEW_GET_CLASS(view)->stopped_pix;
-
- else if (flags & RLF_BREAK_POINT)
- pixbuf = GTK_BLOCK_VIEW_GET_CLASS(view)->breakpoint_pix;
-
- else pixbuf = NULL;
-
- if (pixbuf != NULL)
- gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
- gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
- GDK_RGB_DITHER_NORMAL, 0, 0);
-
- /* Le point d'entrée prime */
- if (flags & RLF_ENTRY_POINT)
- {
- pixbuf = GTK_BLOCK_VIEW_GET_CLASS(view)->entry_pix;
-
- gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
- gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
- GDK_RGB_DITHER_NORMAL, 0, 0);
-
- }
-
- if (!gtk_text_layout_move_iter_to_next_line(view->layout, &iter)) break;
- gtk_text_layout_get_iter_location(view->layout, &iter, &rect);
-
- }
-
/* Impression du désassemblage */
- gtk_text_layout_draw(GTK_BLOCK_VIEW(bview)->layout, widget, GDK_DRAWABLE(widget->window),
- NULL, -fake_x + view->left_text, fake_y, event->area.x, event->area.y,
- event->area.width, event->area.height, &child_exposes);
+ g_buffer_view_draw(view->buffer_view, event, bview->gc, fake_x, fake_y);
- gdk_window_end_paint(GDK_DRAWABLE(widget->window));
+ gdk_window_end_paint(drawable);
return TRUE;
@@ -1160,7 +1215,7 @@ void gtk_block_view_recompute_size_request(GtkBlockView *view)
gint width; /* Largeur de l'objet actuelle */
gint height; /* Hauteur de l'objet actuelle */
- gtk_text_layout_get_size(view->layout, &width, &height);
+ g_buffer_view_get_size(view->buffer_view, &width, &height);
width += -view->left_text + 1;
height += 1;
diff --git a/src/gtkext/gtkextstatusbar.c b/src/gtkext/gtkextstatusbar.c
index 79beda2..a177d18 100644
--- a/src/gtkext/gtkextstatusbar.c
+++ b/src/gtkext/gtkextstatusbar.c
@@ -174,20 +174,21 @@ void gtk_extended_status_bar_update_activity(GtkExtStatusBar *bar, guint id, gdo
if (bar->msg_count == 0) return;
- gdk_threads_enter();
-
if (id == bar->msg_id[bar->msg_count - 1] && bar->is_progressive[bar->msg_count - 1])
{
+ if (value != 1.0 && value - gtk_progress_bar_get_fraction(bar->progress) < 0.01)
+ return;
+
g_snprintf(percent, 5, "%.0f%%", value * 100);
+ gdk_threads_enter();
+
gtk_progress_bar_set_fraction(bar->progress, value);
gtk_progress_bar_set_text(bar->progress, percent);
- }
+ gdk_threads_leave();
- gdk_flush ();
-
- gdk_threads_leave();
+ }
}
diff --git a/src/plugins/pglist.c b/src/plugins/pglist.c
index f242cba..8139e08 100644
--- a/src/plugins/pglist.c
+++ b/src/plugins/pglist.c
@@ -130,7 +130,7 @@ void browse_directory_for_plugins(plugins_list *list, const char *dir)
int ret; /* Bilan du parcours */
char *filename; /* Elément à ausculter */
GPluginModule *plugin; /* Greffon à intégrer ou pas */
-
+ return;
ret = scandir(dir, &namelist, filter_dirs_or_mods, alphasort);
if (ret < 0)
{
--
cgit v0.11.2-87-g4458