Restore most features of core instructions.gtk4

1 files changed, 83 insertions, 300 deletions

diff --git a/src/arch/instructions/undefined.c b/src/arch/instructions/undefined.c
index 15c63e7..75df493 100644
--- a/src/arch/instructions/undefined.c
+++ b/src/arch/instructions/undefined.c
@@ -2,7 +2,7 @@
 /* Chrysalide - Outil d'analyse de fichiers binaires
  * undefined.c - instructions au comportement non défini
  *
- * Copyright (C) 2016-2019 Cyrille Bagard
+ * Copyright (C) 2016-2025 Cyrille Bagard
  *
  *  This file is part of Chrysalide.
  *
@@ -25,63 +25,42 @@
 
 
 #include <assert.h>
+#include <string.h>
 
 
 #include <i18n.h>
 
 
 #include "undefined-int.h"
-#include "../../core/columns.h"
+#include "../../glibext/serialize-int.h"
 
 
 
+/* ------------------------- INSTRUCTION INCONNUE / DONNEES ------------------------- */
+
+
 /* Initialise la classe des instructions non définies. */
-static void g_undef_instruction_class_init(GUndefInstructionClass *);
+static void g_undefined_instruction_class_init(GUndefinedInstructionClass *);
 
 /* Initialise une instance d'instruction non définie. */
-static void g_undef_instruction_init(GUndefInstruction *);
+static void g_undefined_instruction_init(GUndefinedInstruction *);
 
 /* Supprime toutes les références externes. */
-static void g_undef_instruction_dispose(GUndefInstruction *);
+static void g_undefined_instruction_dispose(GObject *);
 
 /* Procède à la libération totale de la mémoire. */
-static void g_undef_instruction_finalize(GUndefInstruction *);
-
-/* Indique l'encodage d'une instruction de façon détaillée. */
-static const char *g_undef_instruction_get_encoding(const GUndefInstruction *);
-
-/* Fournit le nom humain de l'instruction manipulée. */
-static const char *g_undef_instruction_get_keyword(const GUndefInstruction *);
-
-
-
-/* -------------------- CONSERVATION SUR DISQUE DES INSTRUCTIONS -------------------- */
-
-
-/* Charge une instruction depuis une mémoire tampon. */
-static bool g_undef_instruction_unserialize(GUndefInstruction *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde une instruction dans une mémoire tampon. */
-static bool g_undef_instruction_serialize(GUndefInstruction *, GAsmStorage *, packed_buffer_t *);
-
-
-
-/* ------------------------ OFFRE DE CAPACITES DE GENERATION ------------------------ */
-
-
-/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
-static void g_undef_instruction_print(GUndefInstruction *, GBufferLine *, size_t, size_t, const GBinContent *);
+static void g_undefined_instruction_finalize(GObject *);
 
 
 
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
-/* Charge un contenu depuis une mémoire tampon. */
-static bool g_undef_instruction_load(GUndefInstruction *, GObjectStorage *, packed_buffer_t *);
+/* Indique l'encodage d'une instruction de façon détaillée. */
+static char *g_undefined_instruction_get_encoding(const GArchInstruction *);
 
-/* Sauvegarde un contenu dans une mémoire tampon. */
-static bool g_undef_instruction_store(GUndefInstruction *, GObjectStorage *, packed_buffer_t *);
+/* Fournit le nom humain de l'instruction manipulée. */
+static char *g_undefined_instruction_get_keyword(const GArchInstruction *);
 
 
 
@@ -91,7 +70,9 @@ static bool g_undef_instruction_store(GUndefInstruction *, GObjectStorage *, pac
 
 
 /* Indique le type défini pour une instruction au comportement non défini. */
-G_DEFINE_TYPE(GUndefInstruction, g_undef_instruction, G_TYPE_ARCH_INSTRUCTION);
+G_DEFINE_TYPE_WITH_CODE(GUndefinedInstruction, g_undefined_instruction, G_TYPE_ARCH_INSTRUCTION,
+                        G_IMPLEMENT_INTERFACE_IF_SYM(g_token_generator_get_type, g_undefined_instruction_ui_token_generator_iface_init));
+
 
 
 /******************************************************************************
@@ -106,28 +87,20 @@ G_DEFINE_TYPE(GUndefInstruction, g_undef_instruction, G_TYPE_ARCH_INSTRUCTION);
 *                                                                             *
 ******************************************************************************/
 
-static void g_undef_instruction_class_init(GUndefInstructionClass *klass)
+static void g_undefined_instruction_class_init(GUndefinedInstructionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GArchInstructionClass *instr;           /* Encore une autre vision...  */
 
     object = G_OBJECT_CLASS(klass);
 
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_undef_instruction_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_undef_instruction_finalize;
+    object->dispose = g_undefined_instruction_dispose;
+    object->finalize = g_undefined_instruction_finalize;
 
     instr = G_ARCH_INSTRUCTION_CLASS(klass);
 
-    instr->get_encoding = (get_instruction_encoding_fc)g_undef_instruction_get_encoding;
-    instr->get_keyword = (get_instruction_keyword_fc)g_undef_instruction_get_keyword;
-
-    instr->unserialize = (unserialize_instruction_fc)g_undef_instruction_unserialize;
-    instr->serialize = (serialize_instruction_fc)g_undef_instruction_serialize;
-
-    instr->print = (print_instruction_fc)g_undef_instruction_print;
-
-    instr->load = (load_instruction_fc)g_undef_instruction_load;
-    instr->store = (store_instruction_fc)g_undef_instruction_store;
+    instr->get_encoding = g_undefined_instruction_get_encoding;
+    instr->get_keyword = g_undefined_instruction_get_keyword;
 
 }
 
@@ -144,16 +117,22 @@ static void g_undef_instruction_class_init(GUndefInstructionClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_undef_instruction_init(GUndefInstruction *instr)
+static void g_undefined_instruction_init(GUndefinedInstruction *instr)
 {
-    GET_UNDEF_INSTR_EXTRA(instr)->behavior = IEB_UNDEFINED;
+    undef_extra_data_t extra;               /* Données insérées à consulter*/
+
+    extra = GET_UNDEF_INSTR_EXTRA(instr);
+
+    extra.behavior = IEB_UNDEFINED;
+
+    SET_UNDEF_INSTR_EXTRA(instr, &extra);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
 *                                                                             *
@@ -163,16 +142,16 @@ static void g_undef_instruction_init(GUndefInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-static void g_undef_instruction_dispose(GUndefInstruction *instr)
+static void g_undefined_instruction_dispose(GObject *object)
 {
-    G_OBJECT_CLASS(g_undef_instruction_parent_class)->dispose(G_OBJECT(instr));
+    G_OBJECT_CLASS(g_undefined_instruction_parent_class)->dispose(object);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
 *  Description : Procède à la libération totale de la mémoire.                *
 *                                                                             *
@@ -182,9 +161,9 @@ static void g_undef_instruction_dispose(GUndefInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-static void g_undef_instruction_finalize(GUndefInstruction *instr)
+static void g_undefined_instruction_finalize(GObject *object)
 {
-    G_OBJECT_CLASS(g_undef_instruction_parent_class)->finalize(G_OBJECT(instr));
+    G_OBJECT_CLASS(g_undefined_instruction_parent_class)->finalize(object);
 
 }
 
@@ -201,16 +180,14 @@ static void g_undef_instruction_finalize(GUndefInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_undef_instruction_new(InstrExpectedBehavior behavior)
+GArchInstruction *g_undefined_instruction_new(InstrExpectedBehavior behavior)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    undef_extra_data_t *extra;              /* Données insérées à modifier */
 
-    result = g_object_new(G_TYPE_UNDEF_INSTRUCTION, NULL);
+    result = g_object_new(G_TYPE_UNDEFINED_INSTRUCTION, NULL);
 
-    extra = GET_UNDEF_INSTR_EXTRA(result);
-
-    extra->behavior = behavior;
+    if (!g_undefined_instruction_create(G_UNDEFINED_INSTRUCTION(result), behavior))
+        g_clear_object(&result);
 
     return result;
 
@@ -219,90 +196,10 @@ GArchInstruction *g_undef_instruction_new(InstrExpectedBehavior behavior)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr = instruction quelconque à consulter.                  *
-*                                                                             *
-*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
-*                                                                             *
-*  Retour      : Description humaine de l'encodage utilisé.                   *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static const char *g_undef_instruction_get_encoding(const GUndefInstruction *instr)
-{
-    const char *result;                     /* Description à retourner     */
-
-    result = _("Undefined");
-
-    return result;
-
-}
-
-
-/******************************************************************************
+*  Paramètres  : instr    = instance à initialiser pleinement.                *
+*                behavior = état réel du CPU après une passe de l'instruction.*
 *                                                                             *
-*  Paramètres  : instr = instruction d'assemblage à consulter.                *
-*                                                                             *
-*  Description : Fournit le nom humain de l'instruction manipulée.            *
-*                                                                             *
-*  Retour      : Mot clef de bas niveau.                                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-const char *g_undef_instruction_get_keyword(const GUndefInstruction *instr)
-{
-    const char *result;                     /* Désignation à retourner     */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
-
-    extra = GET_UNDEF_INSTR_EXTRA(instr);
-
-    switch (extra->behavior)
-    {
-        case IEB_NOP:
-            result = "nop";
-            break;
-
-        case IEB_UNDEFINED:
-            result = "undefined";
-            break;
-
-        case IEB_UNPREDICTABLE:
-            result = "unpredictable";
-            break;
-
-        case IEB_RESERVED:
-            result = "reserved";
-            break;
-
-        default:
-            assert(false);
-            result = NULL;
-            break;
-
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                      CONSERVATION SUR DISQUE DES INSTRUCTIONS                      */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge une instruction depuis une mémoire tampon.            *
+*  Description : Met en place une instruction au comportement indéfini.       *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -310,122 +207,24 @@ const char *g_undef_instruction_get_keyword(const GUndefInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_undef_instruction_unserialize(GUndefInstruction *instr, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+bool g_undefined_instruction_create(GUndefinedInstruction *instr, InstrExpectedBehavior behavior)
 {
     bool result;                            /* Bilan à retourner           */
-    GArchInstructionClass *parent;          /* Classe parente à consulter  */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
-    uint8_t val;                            /* Champ de bits manipulé      */
-
-    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
+    undef_extra_data_t extra;               /* Données insérées à modifier */
 
-    result = parent->unserialize(G_ARCH_INSTRUCTION(instr), storage, format, pbuf);
+    result = true;
 
-    if (result)
-    {
-        extra = GET_UNDEF_INSTR_EXTRA(instr);
-
-        LOCK_GOBJECT_EXTRA(extra);
-
-        result = extract_packed_buffer(pbuf, &val, sizeof(uint8_t), false);
-        extra->behavior = val;
-
-        UNLOCK_GOBJECT_EXTRA(extra);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Sauvegarde une instruction dans une mémoire tampon.          *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_undef_instruction_serialize(GUndefInstruction *instr, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    GArchInstructionClass *parent;          /* Classe parente à consulter  */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
-
-    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
-
-    result = parent->serialize(G_ARCH_INSTRUCTION(instr), storage, pbuf);
-
-    if (result)
-    {
-        extra = GET_UNDEF_INSTR_EXTRA(instr);
-
-        LOCK_GOBJECT_EXTRA(extra);
-
-        result = extend_packed_buffer(pbuf, (uint8_t []){ extra->behavior }, sizeof(uint8_t), false);
+    extra = GET_UNDEF_INSTR_EXTRA(instr);
 
-        UNLOCK_GOBJECT_EXTRA(extra);
+    extra.behavior = behavior;
 
-    }
+    SET_UNDEF_INSTR_EXTRA(instr, &extra);
 
     return result;
 
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                          OFFRE DE CAPACITES DE GENERATION                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à représenter.            *
-*                line    = ligne de rendu à compléter.                        *
-*                index   = indice de cette même ligne dans le tampon global.  *
-*                repeat  = indice d'utilisations successives du générateur.   *
-*                content = éventuel contenu binaire brut à imprimer.          *
-*                                                                             *
-*  Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_undef_instruction_print(GUndefInstruction *instr, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content)
-{
-    GArchInstruction *base;                 /* Version de base             */
-    const char *key;                        /* Mot clef principal          */
-    size_t klen;                            /* Taille de ce mot clef       */
-
-    base = G_ARCH_INSTRUCTION(instr);
-
-    g_buffer_line_fill_phys(line, DLC_PHYSICAL, MDS_32_BITS_UNSIGNED, get_mrange_addr(&base->range));
-
-    g_buffer_line_fill_virt(line, DLC_VIRTUAL, MDS_32_BITS_UNSIGNED, get_mrange_addr(&base->range));
-
-    g_buffer_line_fill_content(line, DLC_BINARY, content, &base->range, VMPA_NO_PHYSICAL);
-
-    /* Instruction proprement dite */
-
-    key = g_arch_instruction_get_keyword(base);
-    klen = strlen(key);
-
-    g_buffer_line_append_text(line, DLC_ASSEMBLY_HEAD, key, klen, RTT_ERROR, NULL);
-
-}
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : instr  = instruction à consulter.                            *
@@ -438,18 +237,14 @@ static void g_undef_instruction_print(GUndefInstruction *instr, GBufferLine *lin
 *                                                                             *
 ******************************************************************************/
 
-InstrExpectedBehavior g_undef_instruction_get_behavior(const GUndefInstruction *instr)
+InstrExpectedBehavior g_undefined_instruction_get_behavior(const GUndefinedInstruction *instr)
 {
     InstrExpectedBehavior result;           /* Comportement à retourner    */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
+    undef_extra_data_t extra;               /* Données insérées à consulter*/
 
     extra = GET_UNDEF_INSTR_EXTRA(instr);
 
-    LOCK_GOBJECT_EXTRA(extra);
-
-    result = extra->behavior;
-
-    UNLOCK_GOBJECT_EXTRA(extra);
+    result = extra.behavior;
 
     return result;
 
@@ -464,41 +259,21 @@ InstrExpectedBehavior g_undef_instruction_get_behavior(const GUndefInstruction *
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr   = élément GLib à constuire.                          *
-*                storage = conservateur de données à manipuler ou NULL.       *
-*                pbuf    = zone tampon à lire.                                *
+*  Paramètres  : instr = instruction quelconque à consulter.                  *
 *                                                                             *
-*  Description : Charge un contenu depuis une mémoire tampon.                 *
+*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : Description humaine de l'encodage utilisé.                   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool g_undef_instruction_load(GUndefInstruction *instr, GObjectStorage *storage, packed_buffer_t *pbuf)
+static char *g_undefined_instruction_get_encoding(const GArchInstruction *instr)
 {
-    bool result;                            /* Bilan à retourner           */
-    GArchInstructionClass *parent;          /* Classe parente à consulter  */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
-    uint8_t val;                            /* Champ de bits manipulé      */
-
-    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
-
-    result = parent->load(G_ARCH_INSTRUCTION(instr), storage, pbuf);
-
-    if (result)
-    {
-        extra = GET_UNDEF_INSTR_EXTRA(instr);
-
-        LOCK_GOBJECT_EXTRA(extra);
+    char *result;                           /* Description à retourner     */
 
-        result = extract_packed_buffer(pbuf, &val, sizeof(uint8_t), false);
-        extra->behavior = val;
-
-        UNLOCK_GOBJECT_EXTRA(extra);
-
-    }
+    result = strdup(_("Undefined"));
 
     return result;
 
@@ -507,37 +282,45 @@ static bool g_undef_instruction_load(GUndefInstruction *instr, GObjectStorage *s
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr   = élément GLib à consulter.                          *
-*                storage = conservateur de données à manipuler ou NULL.       *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : instr = instruction d'assemblage à consulter.                *
 *                                                                             *
-*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : Mot clef de bas niveau.                                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool g_undef_instruction_store(GUndefInstruction *instr, GObjectStorage *storage, packed_buffer_t *pbuf)
+static char *g_undefined_instruction_get_keyword(const GArchInstruction *instr)
 {
-    bool result;                            /* Bilan à retourner           */
-    GArchInstructionClass *parent;          /* Classe parente à consulter  */
-    undef_extra_data_t *extra;              /* Données insérées à consulter*/
-
-    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
+    char *result;                           /* Désignation à retourner     */
+    undef_extra_data_t extra;               /* Données insérées à consulter*/
 
-    result = parent->store(G_ARCH_INSTRUCTION(instr), storage, pbuf);
+    extra = GET_UNDEF_INSTR_EXTRA(instr);
 
-    if (result)
+    switch (extra.behavior)
     {
-        extra = GET_UNDEF_INSTR_EXTRA(instr);
+        case IEB_NOP:
+            result = strdup("nop");
+            break;
 
-        LOCK_GOBJECT_EXTRA(extra);
+        case IEB_UNDEFINED:
+            result = strdup("undefined");
+            break;
 
-        result = extend_packed_buffer(pbuf, (uint8_t []){ extra->behavior }, sizeof(uint8_t), false);
+        case IEB_UNPREDICTABLE:
+            result = strdup("unpredictable");
+            break;
 
-        UNLOCK_GOBJECT_EXTRA(extra);
+        case IEB_RESERVED:
+            result = strdup("reserved");
+            break;
+
+        default:
+            assert(false);
+            result = NULL;
+            break;
 
     }