Reorganize the code for immediate operands.

12 files changed, 1103 insertions, 897 deletions

diff --git a/plugins/pychrysalide/arch/operands/Makefile.am b/plugins/pychrysalide/arch/operands/Makefile.am
index 725096f..cf00ce2 100644
--- a/plugins/pychrysalide/arch/operands/Makefile.am
+++ b/plugins/pychrysalide/arch/operands/Makefile.am
@@ -5,6 +5,7 @@ libpychrysaarchoperands_la_SOURCES =	\
 	constants.h constants.c				\
 	feeder.h feeder.c					\
 	immediate.h immediate.c				\
+	known.h known.c						\
 	module.h module.c					\
 	proxy.h proxy.c						\
 	register.h register.c				\
diff --git a/plugins/pychrysalide/arch/operands/immediate.c b/plugins/pychrysalide/arch/operands/immediate.c
index 5f59c6b..62f6328 100644
--- a/plugins/pychrysalide/arch/operands/immediate.c
+++ b/plugins/pychrysalide/arch/operands/immediate.c
@@ -46,9 +46,6 @@
 
 
 
-/* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
-
-
 /* Crée un nouvel objet Python de type 'ImmOperand'. */
 static PyObject *py_imm_operand_new(PyTypeObject *, PyObject *, PyObject *);
 
@@ -78,19 +75,6 @@ static int py_imm_operand_set_display(PyObject *, PyObject *, void *);
 
 
 
-/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
-
-
-/* Crée un nouvel objet Python de type 'KnownImmOperand'. */
-static PyObject *py_known_imm_operand_new(PyTypeObject *, PyObject *, PyObject *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           OPERANDE POUR VALEUR IMMEDIATE                           */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : type = type de l'objet à instancier.                         *
@@ -675,189 +659,3 @@ int convert_to_imm_operand(PyObject *arg, void *dst)
     return result;
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                         REMPLACEMENT DE VALEURS IMMEDIATES                         */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : type = type de l'objet à instancier.                         *
-*                args = arguments fournis à l'appel.                          *
-*                kwds = arguments de type key=val fournis.                    *
-*                                                                             *
-*  Description : Crée un nouvel objet Python de type 'KnownImmOperand'.       *
-*                                                                             *
-*  Retour      : Instance Python mise en place.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static PyObject *py_known_imm_operand_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    PyObject *result;                       /* Instance à retourner        */
-    GImmOperand *imm;                       /* Opérande à remplacer        */
-    const char *alt;                        /* Impression alternative      */
-    int ret;                                /* Bilan de lecture des args.  */
-    GArchOperand *operand;                  /* Création GLib à transmettre */
-
-#define KNOWN_IMM_OPERAND_DOC                                               \
-    "The KnownImmOperand provides replacement of"                           \
-    " pychrysalide.arch.operands.ImmOperand instances by an alternative"    \
-    " text.\n"                                                              \
-    "\n"                                                                    \
-    "Instances can be created using the following constructor:\n"           \
-    "\n"                                                                    \
-    "    KnownImmOperand(imm, alt)"                                         \
-    "\n"                                                                    \
-    "Where imm is an operand of type pychrysalide.arch.operands.ImmOperand" \
-    " and alt is a string providing the text to be rendered at object"      \
-    " display."
-
-    ret = PyArg_ParseTuple(args, "O&s", convert_to_imm_operand, &imm, &alt);
-    if (!ret) return NULL;
-
-    operand = g_known_imm_operand_new(imm, alt);
-
-    result = pygobject_new(G_OBJECT(operand));
-
-    g_object_unref(operand);
-
-    return (PyObject *)result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Fournit un accès à une définition de type à diffuser.        *
-*                                                                             *
-*  Retour      : Définition d'objet pour Python.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-PyTypeObject *get_python_known_imm_operand_type(void)
-{
-    static PyMethodDef py_known_imm_operand_methods[] = {
-        { NULL }
-    };
-
-    static PyGetSetDef py_known_imm_operand_getseters[] = {
-        { NULL }
-    };
-
-    static PyTypeObject py_known_imm_operand_type = {
-
-        PyVarObject_HEAD_INIT(NULL, 0)
-
-        .tp_name        = "pychrysalide.arch.operands.KnownImmOperand",
-        .tp_basicsize   = sizeof(PyGObject),
-
-        .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
-
-        .tp_doc         = KNOWN_IMM_OPERAND_DOC,
-
-        .tp_methods     = py_known_imm_operand_methods,
-        .tp_getset      = py_known_imm_operand_getseters,
-        .tp_new         = py_known_imm_operand_new
-
-    };
-
-    return &py_known_imm_operand_type;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : module = module dont la définition est à compléter.          *
-*                                                                             *
-*  Description : Prend en charge l'objet 'pychrysalide.arch.KnownImmOperand'. *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool ensure_python_known_imm_operand_is_registered(void)
-{
-    PyTypeObject *type;                     /* Type Python 'ImmOperand'    */
-    PyObject *module;                       /* Module à recompléter        */
-    PyObject *dict;                         /* Dictionnaire du module      */
-
-    type = get_python_known_imm_operand_type();
-
-    if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
-    {
-        module = get_access_to_python_module("pychrysalide.arch.operands");
-
-        dict = PyModule_GetDict(module);
-
-        if (!ensure_python_imm_operand_is_registered())
-            return false;
-
-        if (!ensure_python_renamed_operand_is_registered())
-            return false;
-
-        if (!register_class_for_pygobject(dict, G_TYPE_KNOWN_IMM_OPERAND, type, get_python_imm_operand_type()))
-            return false;
-
-    }
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : arg = argument quelconque à tenter de convertir.             *
-*                dst = destination des valeurs récupérées en cas de succès.   *
-*                                                                             *
-*  Description : Tente de convertir en remplaçant d'opérande d'immédiat.      *
-*                                                                             *
-*  Retour      : Bilan de l'opération, voire indications supplémentaires.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-int convert_to_known_imm_operand(PyObject *arg, void *dst)
-{
-    int result;                             /* Bilan à retourner           */
-
-    result = PyObject_IsInstance(arg, (PyObject *)get_python_known_imm_operand_type());
-
-    switch (result)
-    {
-        case -1:
-            /* L'exception est déjà fixée par Python */
-            result = 0;
-            break;
-
-        case 0:
-            PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to known immediate operand");
-            break;
-
-        case 1:
-            *((GKnownImmOperand **)dst) = G_KNOWN_IMM_OPERAND(pygobject_get(arg));
-            break;
-
-        default:
-            assert(false);
-            break;
-
-    }
-
-    return result;
-
-}
diff --git a/plugins/pychrysalide/arch/operands/immediate.h b/plugins/pychrysalide/arch/operands/immediate.h
index 15d2c3e..4a1e6de 100644
--- a/plugins/pychrysalide/arch/operands/immediate.h
+++ b/plugins/pychrysalide/arch/operands/immediate.h
@@ -31,9 +31,6 @@
 
 
 
-/* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
-
-
 /* Fournit un accès à une définition de type à diffuser. */
 PyTypeObject *get_python_imm_operand_type(void);
 
@@ -45,18 +42,4 @@ int convert_to_imm_operand(PyObject *, void *);
 
 
 
-/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
-
-
-/* Fournit un accès à une définition de type à diffuser. */
-PyTypeObject *get_python_known_imm_operand_type(void);
-
-/* Prend en charge l'objet 'pychrysalide.arch.KnownImmOperand'. */
-bool ensure_python_known_imm_operand_is_registered(void);
-
-/* Tente de convertir en remplaçant d'opérande d'immédiat. */
-int convert_to_known_imm_operand(PyObject *, void *);
-
-
-
 #endif  /* _PLUGINS_PYCHRYSALIDE_ARCH_OPERANDS_IMMEDIATE_H */
diff --git a/plugins/pychrysalide/arch/operands/known.c b/plugins/pychrysalide/arch/operands/known.c
new file mode 100644
index 0000000..435ea0f
--- /dev/null
+++ b/plugins/pychrysalide/arch/operands/known.c
@@ -0,0 +1,224 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * known.c - équivalent Python du fichier "arch/operands/known.h"
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include "known.h"
+
+
+#include <assert.h>
+#include <pygobject.h>
+
+
+#include <arch/operands/known.h>
+
+
+#include "immediate.h"
+#include "rename.h"
+#include "../../access.h"
+#include "../../helpers.h"
+
+
+
+/* Crée un nouvel objet Python de type 'KnownImmOperand'. */
+static PyObject *py_known_imm_operand_new(PyTypeObject *, PyObject *, PyObject *);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de l'objet à instancier.                         *
+*                args = arguments fournis à l'appel.                          *
+*                kwds = arguments de type key=val fournis.                    *
+*                                                                             *
+*  Description : Crée un nouvel objet Python de type 'KnownImmOperand'.       *
+*                                                                             *
+*  Retour      : Instance Python mise en place.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_known_imm_operand_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyObject *result;                       /* Instance à retourner        */
+    GImmOperand *imm;                       /* Opérande à remplacer        */
+    const char *alt;                        /* Impression alternative      */
+    int ret;                                /* Bilan de lecture des args.  */
+    GArchOperand *operand;                  /* Création GLib à transmettre */
+
+#define KNOWN_IMM_OPERAND_DOC                                               \
+    "The KnownImmOperand provides replacement of"                           \
+    " pychrysalide.arch.operands.ImmOperand instances by an alternative"    \
+    " text.\n"                                                              \
+    "\n"                                                                    \
+    "Instances can be created using the following constructor:\n"           \
+    "\n"                                                                    \
+    "    KnownImmOperand(imm, alt)"                                         \
+    "\n"                                                                    \
+    "Where imm is an operand of type pychrysalide.arch.operands.ImmOperand" \
+    " and alt is a string providing the text to be rendered at object"      \
+    " display."
+
+    ret = PyArg_ParseTuple(args, "O&s", convert_to_imm_operand, &imm, &alt);
+    if (!ret) return NULL;
+
+    operand = g_known_imm_operand_new(imm, alt);
+
+    result = pygobject_new(G_OBJECT(operand));
+
+    g_object_unref(operand);
+
+    return (PyObject *)result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Fournit un accès à une définition de type à diffuser.        *
+*                                                                             *
+*  Retour      : Définition d'objet pour Python.                              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyTypeObject *get_python_known_imm_operand_type(void)
+{
+    static PyMethodDef py_known_imm_operand_methods[] = {
+        { NULL }
+    };
+
+    static PyGetSetDef py_known_imm_operand_getseters[] = {
+        { NULL }
+    };
+
+    static PyTypeObject py_known_imm_operand_type = {
+
+        PyVarObject_HEAD_INIT(NULL, 0)
+
+        .tp_name        = "pychrysalide.arch.operands.KnownImmOperand",
+        .tp_basicsize   = sizeof(PyGObject),
+
+        .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+
+        .tp_doc         = KNOWN_IMM_OPERAND_DOC,
+
+        .tp_methods     = py_known_imm_operand_methods,
+        .tp_getset      = py_known_imm_operand_getseters,
+        .tp_new         = py_known_imm_operand_new
+
+    };
+
+    return &py_known_imm_operand_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : module = module dont la définition est à compléter.          *
+*                                                                             *
+*  Description : Prend en charge l'objet 'pychrysalide.arch.KnownImmOperand'. *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool ensure_python_known_imm_operand_is_registered(void)
+{
+    PyTypeObject *type;                     /* Type Python 'ImmOperand'    */
+    PyObject *module;                       /* Module à recompléter        */
+    PyObject *dict;                         /* Dictionnaire du module      */
+
+    type = get_python_known_imm_operand_type();
+
+    if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
+    {
+        module = get_access_to_python_module("pychrysalide.arch.operands");
+
+        dict = PyModule_GetDict(module);
+
+        if (!ensure_python_imm_operand_is_registered())
+            return false;
+
+        if (!ensure_python_renamed_operand_is_registered())
+            return false;
+
+        if (!register_class_for_pygobject(dict, G_TYPE_KNOWN_IMM_OPERAND, type, get_python_imm_operand_type()))
+            return false;
+
+    }
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : arg = argument quelconque à tenter de convertir.             *
+*                dst = destination des valeurs récupérées en cas de succès.   *
+*                                                                             *
+*  Description : Tente de convertir en remplaçant d'opérande d'immédiat.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération, voire indications supplémentaires.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int convert_to_known_imm_operand(PyObject *arg, void *dst)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = PyObject_IsInstance(arg, (PyObject *)get_python_known_imm_operand_type());
+
+    switch (result)
+    {
+        case -1:
+            /* L'exception est déjà fixée par Python */
+            result = 0;
+            break;
+
+        case 0:
+            PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to known immediate operand");
+            break;
+
+        case 1:
+            *((GKnownImmOperand **)dst) = G_KNOWN_IMM_OPERAND(pygobject_get(arg));
+            break;
+
+        default:
+            assert(false);
+            break;
+
+    }
+
+    return result;
+
+}
diff --git a/plugins/pychrysalide/arch/operands/known.h b/plugins/pychrysalide/arch/operands/known.h
new file mode 100644
index 0000000..b5ced68
--- /dev/null
+++ b/plugins/pychrysalide/arch/operands/known.h
@@ -0,0 +1,45 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * known.h - prototypes pour l'équivalent Python du fichier "arch/operands/known.h"
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_ARCH_OPERANDS_KNOWN_H
+#define _PLUGINS_PYCHRYSALIDE_ARCH_OPERANDS_KNOWN_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_known_imm_operand_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.arch.KnownImmOperand'. */
+bool ensure_python_known_imm_operand_is_registered(void);
+
+/* Tente de convertir en remplaçant d'opérande d'immédiat. */
+int convert_to_known_imm_operand(PyObject *, void *);
+
+
+
+#endif  /* _PLUGINS_PYCHRYSALIDE_ARCH_OPERANDS_KNOWN_H */
diff --git a/plugins/pychrysalide/arch/operands/module.c b/plugins/pychrysalide/arch/operands/module.c
index f1669fb..89adecc 100644
--- a/plugins/pychrysalide/arch/operands/module.c
+++ b/plugins/pychrysalide/arch/operands/module.c
@@ -30,6 +30,7 @@
 
 #include "feeder.h"
 #include "immediate.h"
+#include "known.h"
 #include "proxy.h"
 #include "register.h"
 #include "rename.h"
diff --git a/src/arch/operands/Makefile.am b/src/arch/operands/Makefile.am
index 0cb5b02..4371457 100644
--- a/src/arch/operands/Makefile.am
+++ b/src/arch/operands/Makefile.am
@@ -4,7 +4,9 @@ noinst_LTLIBRARIES = libarchoperands.la
 libarchoperands_la_SOURCES =			\
 	feeder-int.h						\
 	feeder.h feeder.c					\
+	immediate-int.h						\
 	immediate.h immediate.c				\
+	known.h known.c						\
 	register-int.h						\
 	register.h register.c				\
 	proxy-int.h							\
diff --git a/src/arch/operands/immediate-int.h b/src/arch/operands/immediate-int.h
new file mode 100644
index 0000000..46bc3ce
--- /dev/null
+++ b/src/arch/operands/immediate-int.h
@@ -0,0 +1,85 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * immediate-int.h - définitions internes propres aux opérandes représentant des valeurs numériques
+ *
+ * Copyright (C) 2021 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERANDS_IMMEDIATE_INT_H
+#define _ARCH_OPERANDS_IMMEDIATE_INT_H
+
+
+#include "immediate.h"
+#include "../operand-int.h"
+
+
+
+/* Informations glissées dans la structure GObject de GArchOperand */
+typedef struct _immop_extra_data_t
+{
+    operand_extra_data_t parent;            /* A laisser en premier        */
+
+    MemoryDataSize size;                    /* Taille de l'opérande        */
+
+    /**
+     * Les deux éléments suivants sont de type ImmOperandDisplay ;
+     * leur espace de conservation est réduit au maximum afin d'éviter
+     * un recouvrement .
+     */
+
+    unsigned int def_display : 3;           /* Type par défaut d'affichage */
+    unsigned int display : 3;               /* Format général d'affichage  */
+
+} immop_extra_data_t;
+
+
+/* Définition d'un opérande de valeur numérique (instance) */
+struct _GImmOperand
+{
+    GArchOperand parent;                    /* Instance parente            */
+
+    uint64_t raw;                           /* Valeur transtypée           */
+
+};
+
+/* Définition d'un opérande de valeur numérique (classe) */
+struct _GImmOperandClass
+{
+    GArchOperandClass parent;               /* Classe parente              */
+
+};
+
+
+/**
+ * Accès aux informations éventuellement déportées.
+ */
+
+#if __SIZEOF_INT__ == __SIZEOF_LONG__
+
+#   define GET_IMM_OP_EXTRA(op) (immop_extra_data_t *)&op->extra
+
+#else
+
+#   define GET_IMM_OP_EXTRA(op) GET_GOBJECT_EXTRA(G_OBJECT(op), immop_extra_data_t)
+
+#endif
+
+
+
+#endif  /* _ARCH_OPERANDS_IMMEDIATE_INT_H */
diff --git a/src/arch/operands/immediate.c b/src/arch/operands/immediate.c
index cb4e457..00bfe99 100644
--- a/src/arch/operands/immediate.c
+++ b/src/arch/operands/immediate.c
@@ -31,20 +31,18 @@
 #include <malloc.h>
 #include <stdarg.h>
 #include <stdio.h>
-#include <string.h>
 
 
 #include <i18n.h>
 
 
+#include "immediate-int.h"
+#include "known.h"
 #include "rename-int.h"
 #include "targetable-int.h"
-#include "../operand-int.h"
 #include "../../common/asm.h"
 #include "../../common/extstr.h"
 #include "../../common/sort.h"
-#include "../../core/logs.h"
-#include "../../format/format.h"
 #include "../../gtkext/gtkblockdisplay.h"
 
 
@@ -52,57 +50,6 @@
 /* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
 
 
-/* Informations glissées dans la structure GObject de GArchOperand */
-typedef struct _immop_extra_data_t
-{
-    operand_extra_data_t parent;            /* A laisser en premier        */
-
-    MemoryDataSize size;                    /* Taille de l'opérande        */
-
-    /**
-     * Les deux éléments suivants sont de type ImmOperandDisplay ;
-     * leur espace de conservation est réduit au maximum afin d'éviter
-     * un recouvrement .
-     */
-
-    unsigned int def_display : 3;           /* Type par défaut d'affichage */
-    unsigned int display : 3;               /* Format général d'affichage  */
-
-} immop_extra_data_t;
-
-
-/* Définition d'un opérande de valeur numérique (instance) */
-struct _GImmOperand
-{
-    GArchOperand parent;                    /* Instance parente            */
-
-    uint64_t raw;                           /* Valeur transtypée           */
-
-};
-
-/* Définition d'un opérande de valeur numérique (classe) */
-struct _GImmOperandClass
-{
-    GArchOperandClass parent;               /* Classe parente              */
-
-};
-
-
-/**
- * Accès aux informations éventuellement déportées.
- */
-
-#if __SIZEOF_INT__ == __SIZEOF_LONG__
-
-#   define GET_IMM_OP_EXTRA(op) (immop_extra_data_t *)&op->extra
-
-#else
-
-#   define GET_IMM_OP_EXTRA(op) GET_GOBJECT_EXTRA(G_OBJECT(op), immop_extra_data_t)
-
-#endif
-
-
 /* Initialise la classe des opérandes de valeur immédiate. */
 static void g_imm_operand_class_init(GImmOperandClass *);
 
@@ -121,15 +68,20 @@ static void g_imm_operand_dispose(GImmOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_imm_operand_finalize(GImmOperand *);
 
-/* Compare un opérande avec un autre. */
-static int g_imm_operand_compare(const GImmOperand *, const GImmOperand *, bool);
-
 /* Construit la chaîne de caractères correspondant à l'opérande. */
 static size_t _g_imm_operand_to_string(const GImmOperand *, ImmOperandDisplay, char [IMM_MAX_SIZE]);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_imm_operand_print(const GImmOperand *, GBufferLine *);
 
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Compare un opérande avec un autre. */
+static int g_imm_operand_compare(const GImmOperand *, const GImmOperand *, bool);
+
 /* Construit un petit résumé concis de l'opérande. */
 static char *g_imm_operand_build_tooltip(const GImmOperand *, const GLoadedBinary *);
 
@@ -142,66 +94,21 @@ static bool g_imm_operand_unserialize(GImmOperand *, GAsmStorage *, GBinFormat *
 /* Sauvegarde un opérande dans une mémoire tampon. */
 static bool g_imm_operand_serialize(const GImmOperand *, GAsmStorage *, packed_buffer_t *);
 
-/* Obtient l'adresse de la cible visée par un opérande. */
-static bool g_imm_operand_get_addr(const GImmOperand *, const vmpa2t *, GBinFormat *, GArchProcessor *, vmpa2t *);
-
-/* Construit un opérande de représentation alternative. */
-static GRenamedOperand *g_imm_operand_build(const GImmOperand *, const char *);
-
-
-
-/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
-
-
-/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
-struct _GKnownImmOperand
-{
-    GImmOperand parent;                     /* Instance parente            */
-
-    char *alt_text;                         /* Alternative humaine         */
-
-};
-
-/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
-struct _GKnownImmOperandClass
-{
-    GImmOperandClass parent;                /* Classe parente              */
-
-};
 
 
-/* Initialise la classe des remplacements d'opérandes. */
-static void g_known_imm_operand_class_init(GKnownImmOperandClass *);
-
-/* Initialise un remplacement d'opérande de valeur immédiate. */
-static void g_known_imm_operand_init(GKnownImmOperand *);
-
-/* Procède à l'initialisation de l'interface de renommage. */
-static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *);
-
-/* Supprime toutes les références externes. */
-static void g_known_imm_operand_dispose(GKnownImmOperand *);
+/* ---------------------- COMMUNICATION D'UN CIBLAGE POTENTIEL ---------------------- */
 
-/* Procède à la libération totale de la mémoire. */
-static void g_known_imm_operand_finalize(GKnownImmOperand *);
 
-/* Compare un opérande avec un autre. */
-static int g_known_imm_operand_compare(const GKnownImmOperand *, const GKnownImmOperand *, bool);
+/* Obtient l'adresse de la cible visée par un opérande. */
+static bool g_imm_operand_get_addr(const GImmOperand *, const vmpa2t *, GBinFormat *, GArchProcessor *, vmpa2t *);
 
-/* Traduit un opérande en version humainement lisible. */
-static void g_known_imm_operand_print(const GKnownImmOperand *, GBufferLine *);
 
-/* Fournit l'empreinte d'un candidat à une centralisation. */
-static guint g_known_imm_operand_hash(const GKnownImmOperand *, bool);
 
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_known_imm_operand_unserialize(GKnownImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+/* ---------------------- CONSTRUCTION D'UN CONTENU ALTERNATIF ---------------------- */
 
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_known_imm_operand_serialize(const GKnownImmOperand *, GAsmStorage *, packed_buffer_t *);
 
-/* Fournit un texte comme représentation alternative d'opérande. */
-static const char *g_known_imm_operand_get_text(const GKnownImmOperand *);
+/* Construit un opérande de représentation alternative. */
+static GRenamedOperand *g_imm_operand_build(const GImmOperand *, const char *);
 
 
 
@@ -505,64 +412,6 @@ GArchOperand *g_imm_operand_new_from_value(MemoryDataSize size, uint64_t value)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : a    = premier opérande à consulter.                         *
-*                b    = second opérande à consulter.                          *
-*                lock = précise le besoin en verrouillage.                    *
-*                                                                             *
-*  Description : Compare un opérande avec un autre.                           *
-*                                                                             *
-*  Retour      : Bilan de la comparaison.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static int g_imm_operand_compare(const GImmOperand *a, const GImmOperand *b, bool lock)
-{
-    int result;                             /* Bilan à retourner           */
-    immop_extra_data_t *ea;                 /* Données insérées à modifier */
-    immop_extra_data_t *eb;                 /* Données insérées à modifier */
-    GArchOperandClass *class;               /* Classe parente normalisée   */
-
-    ea = GET_IMM_OP_EXTRA(a);
-    eb = GET_IMM_OP_EXTRA(b);
-
-    if (lock)
-    {
-        LOCK_GOBJECT_EXTRA(ea);
-        LOCK_GOBJECT_EXTRA(eb);
-    }
-
-    result = sort_unsigned_long(ea->size, eb->size);
-
-    if (result == 0)
-        sort_uint64_t(a->raw, b->raw);
-
-    if (result == 0)
-        result = sort_unsigned_long(ea->def_display, eb->def_display);
-
-    if (result == 0)
-        result = sort_unsigned_long(ea->display, eb->display);
-
-    if (result == 0)
-    {
-        class = G_ARCH_OPERAND_CLASS(g_imm_operand_parent_class);
-        result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
-    }
-
-    if (lock)
-    {
-        UNLOCK_GOBJECT_EXTRA(eb);
-        UNLOCK_GOBJECT_EXTRA(ea);
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : operand = structure dont le contenu est à consulter.         *
 *                                                                             *
 *  Description : Renseigne la taille de la valeur indiquée à la construction. *
@@ -1191,94 +1040,6 @@ static void g_imm_operand_print(const GImmOperand *operand, GBufferLine *line)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande à consulter.                              *
-*                binary  = informations relatives au binaire chargé.          *
-*                                                                             *
-*  Description : Construit un petit résumé concis de l'opérande.              *
-*                                                                             *
-*  Retour      : Chaîne de caractères à libérer après usage ou NULL.          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static char *g_imm_operand_build_tooltip(const GImmOperand *operand, const GLoadedBinary *binary)
-{
-    char *result;                           /* Description à retourner     */
-    char value[IMM_MAX_SIZE];               /* Conversion artificielle     */
-    char *conv;                             /* Affichage de la Conversion  */
-
-    if (operand->raw <= UCHAR_MAX && isprint(operand->raw))
-        switch (operand->raw)
-        {
-            case '&':
-                asprintf(&result, _("Character: '&amp;'"));
-                break;
-            case '<':
-                asprintf(&result, _("Character: '&lt;'"));
-                break;
-            case '>':
-                asprintf(&result, _("Character: '&gt;'"));
-                break;
-            default:
-                asprintf(&result, _("Character: '%c'"), (char)operand->raw);
-                break;
-        }
-
-    else
-        asprintf(&result, _("Character: &lt;not printable&gt;"));
-
-    /* Binaire */
-
-    _g_imm_operand_to_string(operand, IOD_BIN, value);
-
-    asprintf(&conv, _("Binary: %s"), value);
-
-    result = stradd(result, "\n");
-    result = stradd(result, conv);
-
-    free(conv);
-
-    /* Octal */
-
-    _g_imm_operand_to_string(operand, IOD_OCT, value);
-
-    asprintf(&conv, _("Octal: %s"), value);
-
-    result = stradd(result, "\n");
-    result = stradd(result, conv);
-
-    free(conv);
-
-    /* Décimal */
-
-    _g_imm_operand_to_string(operand, IOD_DEC, value);
-
-    asprintf(&conv, _("Decimal: %s"), value);
-
-    result = stradd(result, "\n");
-    result = stradd(result, conv);
-
-    free(conv);
-
-    /* Hexadécimal */
-
-    _g_imm_operand_to_string(operand, IOD_HEX, value);
-
-    asprintf(&conv, _("Hexadecimal: %s"), value);
-
-    result = stradd(result, "\n");
-    result = stradd(result, conv);
-
-    free(conv);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : operand = opérande à traiter.                                *
 *                pos     = valeur résultante. [OUT]                           *
 *                                                                             *
@@ -1401,6 +1162,158 @@ void g_imm_operand_as_uleb128(const GImmOperand *operand, uleb128_t *val)
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a    = premier opérande à consulter.                         *
+*                b    = second opérande à consulter.                          *
+*                lock = précise le besoin en verrouillage.                    *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_imm_operand_compare(const GImmOperand *a, const GImmOperand *b, bool lock)
+{
+    int result;                             /* Bilan à retourner           */
+    immop_extra_data_t *ea;                 /* Données insérées à modifier */
+    immop_extra_data_t *eb;                 /* Données insérées à modifier */
+    GArchOperandClass *class;               /* Classe parente normalisée   */
+
+    ea = GET_IMM_OP_EXTRA(a);
+    eb = GET_IMM_OP_EXTRA(b);
+
+    if (lock)
+    {
+        LOCK_GOBJECT_EXTRA(ea);
+        LOCK_GOBJECT_EXTRA(eb);
+    }
+
+    result = sort_unsigned_long(ea->size, eb->size);
+
+    if (result == 0)
+        sort_uint64_t(a->raw, b->raw);
+
+    if (result == 0)
+        result = sort_unsigned_long(ea->def_display, eb->def_display);
+
+    if (result == 0)
+        result = sort_unsigned_long(ea->display, eb->display);
+
+    if (result == 0)
+    {
+        class = G_ARCH_OPERAND_CLASS(g_imm_operand_parent_class);
+        result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
+    }
+
+    if (lock)
+    {
+        UNLOCK_GOBJECT_EXTRA(eb);
+        UNLOCK_GOBJECT_EXTRA(ea);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à consulter.                              *
+*                binary  = informations relatives au binaire chargé.          *
+*                                                                             *
+*  Description : Construit un petit résumé concis de l'opérande.              *
+*                                                                             *
+*  Retour      : Chaîne de caractères à libérer après usage ou NULL.          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_imm_operand_build_tooltip(const GImmOperand *operand, const GLoadedBinary *binary)
+{
+    char *result;                           /* Description à retourner     */
+    char value[IMM_MAX_SIZE];               /* Conversion artificielle     */
+    char *conv;                             /* Affichage de la Conversion  */
+
+    if (operand->raw <= UCHAR_MAX && isprint(operand->raw))
+        switch (operand->raw)
+        {
+            case '&':
+                asprintf(&result, _("Character: '&amp;'"));
+                break;
+            case '<':
+                asprintf(&result, _("Character: '&lt;'"));
+                break;
+            case '>':
+                asprintf(&result, _("Character: '&gt;'"));
+                break;
+            default:
+                asprintf(&result, _("Character: '%c'"), (char)operand->raw);
+                break;
+        }
+
+    else
+        asprintf(&result, _("Character: &lt;not printable&gt;"));
+
+    /* Binaire */
+
+    _g_imm_operand_to_string(operand, IOD_BIN, value);
+
+    asprintf(&conv, _("Binary: %s"), value);
+
+    result = stradd(result, "\n");
+    result = stradd(result, conv);
+
+    free(conv);
+
+    /* Octal */
+
+    _g_imm_operand_to_string(operand, IOD_OCT, value);
+
+    asprintf(&conv, _("Octal: %s"), value);
+
+    result = stradd(result, "\n");
+    result = stradd(result, conv);
+
+    free(conv);
+
+    /* Décimal */
+
+    _g_imm_operand_to_string(operand, IOD_DEC, value);
+
+    asprintf(&conv, _("Decimal: %s"), value);
+
+    result = stradd(result, "\n");
+    result = stradd(result, conv);
+
+    free(conv);
+
+    /* Hexadécimal */
+
+    _g_imm_operand_to_string(operand, IOD_HEX, value);
+
+    asprintf(&conv, _("Hexadecimal: %s"), value);
+
+    result = stradd(result, "\n");
+    result = stradd(result, conv);
+
+    free(conv);
+
+    return result;
+
+}
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = objet dont l'instance se veut unique.              *
@@ -1547,6 +1460,12 @@ static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *sto
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                        COMMUNICATION D'UN CIBLAGE POTENTIEL                        */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = operande à consulter.                              *
@@ -1578,6 +1497,12 @@ static bool g_imm_operand_get_addr(const GImmOperand *operand, const vmpa2t *src
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                        CONSTRUCTION D'UN CONTENU ALTERNATIF                        */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = operande à consulter.                              *
@@ -1600,397 +1525,3 @@ static GRenamedOperand *g_imm_operand_build(const GImmOperand *operand, const ch
     return result;
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                         REMPLACEMENT DE VALEURS IMMEDIATES                         */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
-G_DEFINE_TYPE_WITH_CODE(GKnownImmOperand, g_known_imm_operand, G_TYPE_IMM_OPERAND,
-                        G_IMPLEMENT_INTERFACE(G_TYPE_RENAMED_OPERAND, g_known_imm_operand_renamed_interface_init));
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des remplacements d'opérandes.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_class_init(GKnownImmOperandClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GArchOperandClass *operand;             /* Version de classe parente   */
-
-    object = G_OBJECT_CLASS(klass);
-    operand = G_ARCH_OPERAND_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_known_imm_operand_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_known_imm_operand_finalize;
-
-    operand->compare = (operand_compare_fc)g_known_imm_operand_compare;
-    operand->print = (operand_print_fc)g_known_imm_operand_print;
-
-    operand->hash = (operand_hash_fc)g_known_imm_operand_hash;
-
-    operand->unserialize = (unserialize_operand_fc)g_known_imm_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_known_imm_operand_serialize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = instance à initialiser.                            *
-*                                                                             *
-*  Description : Initialise un remplacement d'opérande de valeur immédiate.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_init(GKnownImmOperand *operand)
-{
-    operand->alt_text = NULL;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : iface = interface GLib à initialiser.                        *
-*                                                                             *
-*  Description : Procède à l'initialisation de l'interface de renommage.      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *iface)
-{
-    iface->get_text = (get_renamed_text_fc)g_known_imm_operand_get_text;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_dispose(GKnownImmOperand *operand)
-{
-    if (operand->alt_text != NULL)
-        free(operand->alt_text);
-
-    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->dispose(G_OBJECT(operand));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_finalize(GKnownImmOperand *operand)
-{
-    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->finalize(G_OBJECT(operand));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : old = opérande à venir copier avant son remplacement.        *
-*                alt = texte alternatif à présenter pour l'impression.        *
-*                                                                             *
-*  Description : Crée un opérande remplaçant visuellement une valeur.         *
-*                                                                             *
-*  Retour      : Instruction mise en place.                                   *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GArchOperand *g_known_imm_operand_new(const GImmOperand *old, const char *alt)
-{
-    GKnownImmOperand *result;               /* Remplacement à retourner    */
-    immop_extra_data_t *src;                /* Données insérées à consulter*/
-    immop_extra_data_t *dest;               /* Données insérées à modifier */
-
-    result = g_object_new(G_TYPE_KNOWN_IMM_OPERAND, NULL);
-
-    result->parent.raw = old->raw;
-
-    src = GET_IMM_OP_EXTRA(old);
-    dest = GET_IMM_OP_EXTRA(&result->parent);
-
-    LOCK_GOBJECT_EXTRA(src);
-
-    *(&dest->parent) = *(&src->parent);
-
-    dest->size = src->size;
-
-    dest->def_display = src->def_display;
-    dest->display = src->display;
-
-    UNLOCK_GOBJECT_EXTRA(src);
-
-    result->alt_text = strdup(alt);
-
-    return G_ARCH_OPERAND(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : a    = premier opérande à consulter.                         *
-*                b    = second opérande à consulter.                          *
-*                lock = précise le besoin en verrouillage.                    *
-*                                                                             *
-*  Description : Compare un opérande avec un autre.                           *
-*                                                                             *
-*  Retour      : Bilan de la comparaison.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static int g_known_imm_operand_compare(const GKnownImmOperand *a, const GKnownImmOperand *b, bool lock)
-{
-    int result;                             /* Bilan à retourner           */
-    lockable_obj_extra_t *ea;               /* Données insérées à consulter*/
-    lockable_obj_extra_t *eb;               /* Données insérées à consulter*/
-    GArchOperandClass *class;               /* Classe parente normalisée   */
-
-    ea = GET_GOBJECT_EXTRA(G_OBJECT(a), lockable_obj_extra_t);
-    eb = GET_GOBJECT_EXTRA(G_OBJECT(b), lockable_obj_extra_t);
-
-    if (lock)
-    {
-        LOCK_GOBJECT_EXTRA(ea);
-        LOCK_GOBJECT_EXTRA(eb);
-    }
-
-    result = strcmp(a->alt_text, b->alt_text);
-
-    if (result == 0)
-    {
-        class = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
-        result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
-    }
-
-    if (lock)
-    {
-        UNLOCK_GOBJECT_EXTRA(eb);
-        UNLOCK_GOBJECT_EXTRA(ea);
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = opérande à traiter.                                *
-*                line    = ligne tampon où imprimer l'opérande donné.         *
-*                                                                             *
-*  Description : Traduit un opérande en version humainement lisible.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_known_imm_operand_print(const GKnownImmOperand *operand, GBufferLine *line)
-{
-    size_t len;                             /* Taille de l'élément inséré  */
-
-    len = strlen(operand->alt_text);
-
-    g_buffer_line_append_text(line, DLC_ASSEMBLY, operand->alt_text, len, RTT_IMMEDIATE, G_OBJECT(operand));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = objet dont l'instance se veut unique.              *
-*                lock    = précise le besoin en verrouillage.                 *
-*                                                                             *
-*  Description : Fournit l'empreinte d'un candidat à une centralisation.      *
-*                                                                             *
-*  Retour      : Empreinte de l'élément représenté.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static guint g_known_imm_operand_hash(const GKnownImmOperand *operand, bool lock)
-{
-    guint result;                           /* Valeur à retourner          */
-    lockable_obj_extra_t *extra;            /* Données insérées à consulter*/
-    GArchOperandClass *class;               /* Classe parente normalisée   */
-
-    extra = GET_GOBJECT_EXTRA(G_OBJECT(operand), lockable_obj_extra_t);
-
-    if (lock)
-        LOCK_GOBJECT_EXTRA(extra);
-
-    class = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
-    result = class->hash(G_ARCH_OPERAND(operand), false);
-
-    result ^= g_str_hash(operand->alt_text);
-
-    if (lock)
-        UNLOCK_GOBJECT_EXTRA(extra);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    GArchOperandClass *parent;              /* Classe parente à consulter  */
-    unsigned short len;                     /* Taille du contenu alternatif*/
-
-    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
-
-    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
-
-    if (result)
-        result = extract_packed_buffer(pbuf, &len, sizeof(unsigned short), true);
-
-    if (result)
-        result = (len > 0);
-
-    if (result)
-    {
-        operand->alt_text = malloc(len);
-
-        result = extract_packed_buffer(pbuf, operand->alt_text, len, false);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_known_imm_operand_serialize(const GKnownImmOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    GArchOperandClass *parent;              /* Classe parente à consulter  */
-    size_t len;                             /* Taille du contenu alternatif*/
-
-    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
-
-    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
-
-    if (result)
-    {
-        len = strlen(operand->alt_text) + 1;
-        assert(len > 1);
-
-        if (len > (2 << (sizeof(unsigned short) * 8 - 1)))
-        {
-            log_variadic_message(LMT_ERROR, "Alternative text too long: '%s' (%zu bytes)",
-                                 operand->alt_text, len);
-            result = false;
-        }
-
-        else
-            result = extend_packed_buffer(pbuf, (unsigned short []) { len }, sizeof(unsigned short), true);
-
-        if (result)
-            result = extend_packed_buffer(pbuf, operand->alt_text, len, false);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = operande à consulter.                              *
-*                                                                             *
-*  Description : Fournit un texte comme représentation alternative d'opérande.*
-*                                                                             *
-*  Retour      : Chaîne de caractère de représentation alternative.           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static const char *g_known_imm_operand_get_text(const GKnownImmOperand *operand)
-{
-    const char *result;                     /* Texte à retourner           */
-
-    result = operand->alt_text;
-
-    return result;
-
-}
diff --git a/src/arch/operands/immediate.h b/src/arch/operands/immediate.h
index 1291962..7c1ff03 100644
--- a/src/arch/operands/immediate.h
+++ b/src/arch/operands/immediate.h
@@ -36,9 +36,6 @@
 
 
 
-/* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
-
-
 /* Etats particuliers d'un opérande de valeur immédiate */
 typedef enum _ImmOpFlag
 {
@@ -143,30 +140,4 @@ void g_imm_operand_as_uleb128(const GImmOperand *, uleb128_t *);
 
 
 
-/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
-
-
-#define G_TYPE_KNOWN_IMM_OPERAND            g_known_imm_operand_get_type()
-#define G_KNOWN_IMM_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperand))
-#define G_IS_KNOWN_IMM_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_KNOWN_IMM_OPERAND))
-#define G_KNOWN_IMM_OPERAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
-#define G_IS_KNOWN_IMM_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_KNOWN_IMM_OPERAND))
-#define G_KNOWN_IMM_OPERAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
-
-
-/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
-typedef struct _GKnownImmOperand GKnownImmOperand;
-
-/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
-typedef struct _GKnownImmOperandClass GKnownImmOperandClass;
-
-
-/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
-GType g_known_imm_operand_get_type(void);
-
-/* Crée un opérande remplaçant visuellement une valeur. */
-GArchOperand *g_known_imm_operand_new(const GImmOperand *, const char *);
-
-
-
 #endif  /* _ARCH_OPERANDS_IMMEDIATE_H */
diff --git a/src/arch/operands/known.c b/src/arch/operands/known.c
new file mode 100644
index 0000000..bf16674
--- /dev/null
+++ b/src/arch/operands/known.c
@@ -0,0 +1,506 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * known.c - opérandes représentant des valeurs numériques avec sémantique
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "known.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include "immediate-int.h"
+#include "rename-int.h"
+#include "../../core/logs.h"
+#include "../../gtkext/gtkblockdisplay.h"
+
+
+
+/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
+
+
+/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
+struct _GKnownImmOperand
+{
+    GImmOperand parent;                     /* Instance parente            */
+
+    char *alt_text;                         /* Alternative humaine         */
+
+};
+
+/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
+struct _GKnownImmOperandClass
+{
+    GImmOperandClass parent;                /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des remplacements d'opérandes. */
+static void g_known_imm_operand_class_init(GKnownImmOperandClass *);
+
+/* Initialise un remplacement d'opérande de valeur immédiate. */
+static void g_known_imm_operand_init(GKnownImmOperand *);
+
+/* Procède à l'initialisation de l'interface de renommage. */
+static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *);
+
+/* Supprime toutes les références externes. */
+static void g_known_imm_operand_dispose(GKnownImmOperand *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_known_imm_operand_finalize(GKnownImmOperand *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Compare un opérande avec un autre. */
+static int g_known_imm_operand_compare(const GKnownImmOperand *, const GKnownImmOperand *, bool);
+
+/* Traduit un opérande en version humainement lisible. */
+static void g_known_imm_operand_print(const GKnownImmOperand *, GBufferLine *);
+
+/* Fournit l'empreinte d'un candidat à une centralisation. */
+static guint g_known_imm_operand_hash(const GKnownImmOperand *, bool);
+
+/* Charge un opérande depuis une mémoire tampon. */
+static bool g_known_imm_operand_unserialize(GKnownImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+
+/* Sauvegarde un opérande dans une mémoire tampon. */
+static bool g_known_imm_operand_serialize(const GKnownImmOperand *, GAsmStorage *, packed_buffer_t *);
+
+
+
+/* ------------------------- AFFICHAGE D'UN CONTENU RENOMME ------------------------- */
+
+
+/* Fournit un texte comme représentation alternative d'opérande. */
+static const char *g_known_imm_operand_get_text(const GKnownImmOperand *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         REMPLACEMENT DE VALEURS IMMEDIATES                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
+G_DEFINE_TYPE_WITH_CODE(GKnownImmOperand, g_known_imm_operand, G_TYPE_IMM_OPERAND,
+                        G_IMPLEMENT_INTERFACE(G_TYPE_RENAMED_OPERAND, g_known_imm_operand_renamed_interface_init));
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des remplacements d'opérandes.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_class_init(GKnownImmOperandClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchOperandClass *operand;             /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+    operand = G_ARCH_OPERAND_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_known_imm_operand_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_known_imm_operand_finalize;
+
+    operand->compare = (operand_compare_fc)g_known_imm_operand_compare;
+    operand->print = (operand_print_fc)g_known_imm_operand_print;
+
+    operand->hash = (operand_hash_fc)g_known_imm_operand_hash;
+
+    operand->unserialize = (unserialize_operand_fc)g_known_imm_operand_unserialize;
+    operand->serialize = (serialize_operand_fc)g_known_imm_operand_serialize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise un remplacement d'opérande de valeur immédiate.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_init(GKnownImmOperand *operand)
+{
+    operand->alt_text = NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de renommage.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *iface)
+{
+    iface->get_text = (get_renamed_text_fc)g_known_imm_operand_get_text;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_dispose(GKnownImmOperand *operand)
+{
+    if (operand->alt_text != NULL)
+        free(operand->alt_text);
+
+    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->dispose(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_finalize(GKnownImmOperand *operand)
+{
+    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->finalize(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : old = opérande à venir copier avant son remplacement.        *
+*                alt = texte alternatif à présenter pour l'impression.        *
+*                                                                             *
+*  Description : Crée un opérande remplaçant visuellement une valeur.         *
+*                                                                             *
+*  Retour      : Instruction mise en place.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_known_imm_operand_new(const GImmOperand *old, const char *alt)
+{
+    GKnownImmOperand *result;               /* Remplacement à retourner    */
+    immop_extra_data_t *src;                /* Données insérées à consulter*/
+    immop_extra_data_t *dest;               /* Données insérées à modifier */
+
+    result = g_object_new(G_TYPE_KNOWN_IMM_OPERAND, NULL);
+
+    result->parent.raw = old->raw;
+
+    src = GET_IMM_OP_EXTRA(old);
+    dest = GET_IMM_OP_EXTRA(&result->parent);
+
+    LOCK_GOBJECT_EXTRA(src);
+
+    *(&dest->parent) = *(&src->parent);
+
+    dest->size = src->size;
+
+    dest->def_display = src->def_display;
+    dest->display = src->display;
+
+    UNLOCK_GOBJECT_EXTRA(src);
+
+    result->alt_text = strdup(alt);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a    = premier opérande à consulter.                         *
+*                b    = second opérande à consulter.                          *
+*                lock = précise le besoin en verrouillage.                    *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_known_imm_operand_compare(const GKnownImmOperand *a, const GKnownImmOperand *b, bool lock)
+{
+    int result;                             /* Bilan à retourner           */
+    lockable_obj_extra_t *ea;               /* Données insérées à consulter*/
+    lockable_obj_extra_t *eb;               /* Données insérées à consulter*/
+    GArchOperandClass *class;               /* Classe parente normalisée   */
+
+    ea = GET_GOBJECT_EXTRA(G_OBJECT(a), lockable_obj_extra_t);
+    eb = GET_GOBJECT_EXTRA(G_OBJECT(b), lockable_obj_extra_t);
+
+    if (lock)
+    {
+        LOCK_GOBJECT_EXTRA(ea);
+        LOCK_GOBJECT_EXTRA(eb);
+    }
+
+    result = strcmp(a->alt_text, b->alt_text);
+
+    if (result == 0)
+    {
+        class = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+        result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
+    }
+
+    if (lock)
+    {
+        UNLOCK_GOBJECT_EXTRA(eb);
+        UNLOCK_GOBJECT_EXTRA(ea);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_print(const GKnownImmOperand *operand, GBufferLine *line)
+{
+    size_t len;                             /* Taille de l'élément inséré  */
+
+    len = strlen(operand->alt_text);
+
+    g_buffer_line_append_text(line, DLC_ASSEMBLY, operand->alt_text, len, RTT_IMMEDIATE, G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = objet dont l'instance se veut unique.              *
+*                lock    = précise le besoin en verrouillage.                 *
+*                                                                             *
+*  Description : Fournit l'empreinte d'un candidat à une centralisation.      *
+*                                                                             *
+*  Retour      : Empreinte de l'élément représenté.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static guint g_known_imm_operand_hash(const GKnownImmOperand *operand, bool lock)
+{
+    guint result;                           /* Valeur à retourner          */
+    lockable_obj_extra_t *extra;            /* Données insérées à consulter*/
+    GArchOperandClass *class;               /* Classe parente normalisée   */
+
+    extra = GET_GOBJECT_EXTRA(G_OBJECT(operand), lockable_obj_extra_t);
+
+    if (lock)
+        LOCK_GOBJECT_EXTRA(extra);
+
+    class = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+    result = class->hash(G_ARCH_OPERAND(operand), false);
+
+    result ^= g_str_hash(operand->alt_text);
+
+    if (lock)
+        UNLOCK_GOBJECT_EXTRA(extra);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande d'assemblage à constituer.                *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                format  = format binaire chargé associé à l'architecture.    *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Charge un opérande depuis une mémoire tampon.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+    unsigned short len;                     /* Taille du contenu alternatif*/
+
+    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+
+    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &len, sizeof(unsigned short), true);
+
+    if (result)
+        result = (len > 0);
+
+    if (result)
+    {
+        operand->alt_text = malloc(len);
+
+        result = extract_packed_buffer(pbuf, operand->alt_text, len, false);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_known_imm_operand_serialize(const GKnownImmOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+    size_t len;                             /* Taille du contenu alternatif*/
+
+    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+
+    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+
+    if (result)
+    {
+        len = strlen(operand->alt_text) + 1;
+        assert(len > 1);
+
+        if (len > (2 << (sizeof(unsigned short) * 8 - 1)))
+        {
+            log_variadic_message(LMT_ERROR, "Alternative text too long: '%s' (%zu bytes)",
+                                 operand->alt_text, len);
+            result = false;
+        }
+
+        else
+            result = extend_packed_buffer(pbuf, (unsigned short []) { len }, sizeof(unsigned short), true);
+
+        if (result)
+            result = extend_packed_buffer(pbuf, operand->alt_text, len, false);
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           AFFICHAGE D'UN CONTENU RENOMME                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = operande à consulter.                              *
+*                                                                             *
+*  Description : Fournit un texte comme représentation alternative d'opérande.*
+*                                                                             *
+*  Retour      : Chaîne de caractère de représentation alternative.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_known_imm_operand_get_text(const GKnownImmOperand *operand)
+{
+    const char *result;                     /* Texte à retourner           */
+
+    result = operand->alt_text;
+
+    return result;
+
+}
diff --git a/src/arch/operands/known.h b/src/arch/operands/known.h
new file mode 100644
index 0000000..eb84d3b
--- /dev/null
+++ b/src/arch/operands/known.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * known.h - prototypes pour les opérandes représentant des valeurs numériques avec sémantique
+ *
+ * Copyright (C) 2021 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERANDS_KNOWN_H
+#define _ARCH_OPERANDS_KNOWN_H
+
+
+#include <glib-object.h>
+
+
+#include "immediate.h"
+#include "../operand.h"
+
+
+
+#define G_TYPE_KNOWN_IMM_OPERAND            g_known_imm_operand_get_type()
+#define G_KNOWN_IMM_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperand))
+#define G_IS_KNOWN_IMM_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_KNOWN_IMM_OPERAND))
+#define G_KNOWN_IMM_OPERAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
+#define G_IS_KNOWN_IMM_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_KNOWN_IMM_OPERAND))
+#define G_KNOWN_IMM_OPERAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
+
+
+/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
+typedef struct _GKnownImmOperand GKnownImmOperand;
+
+/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
+typedef struct _GKnownImmOperandClass GKnownImmOperandClass;
+
+
+/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
+GType g_known_imm_operand_get_type(void);
+
+/* Crée un opérande remplaçant visuellement une valeur. */
+GArchOperand *g_known_imm_operand_new(const GImmOperand *, const char *);
+
+
+
+#endif  /* _ARCH_OPERANDS_KNOWN_H */