Restore most features of core instructions.gtk4

1 files changed, 625 insertions, 241 deletions

diff --git a/plugins/pychrysalide/arch/instruction.c b/plugins/pychrysalide/arch/instruction.c
index 0a9ba16..49daa9c 100644
--- a/plugins/pychrysalide/arch/instruction.c
+++ b/plugins/pychrysalide/arch/instruction.c
@@ -27,13 +27,12 @@
 
 #include <assert.h>
 #include <malloc.h>
-#include <string.h>
 #include <pygobject.h>
 
 
 #include <i18n.h>
+#include <plugins/self.h>
 #include <arch/instruction-int.h>
-#include <plugins/dt.h>
 
 
 #include "constants.h"
@@ -41,30 +40,38 @@
 #include "vmpa.h"
 #include "../access.h"
 #include "../helpers.h"
-#include "../glibext/linegen.h"
-
-
-
-static G_DEFINE_QUARK(cached_keyword, get_cached_keyword);
+#include "../glibext/objhole.h"
+#include "../glibext/serialize.h"
 
 
 
 /* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */
 
 
-/* Accompagne la création d'une instance dérivée en Python. */
-static PyObject *py_arch_instruction_new(PyTypeObject *, PyObject *, PyObject *);
-
 /* Initialise la classe générique des instructions. */
-static void py_arch_instruction_init_gclass(GArchInstructionClass *, gpointer);
+static int py_arch_instruction_init_gclass(GArchInstructionClass *, PyTypeObject *);
 
-CREATE_DYN_ABSTRACT_CONSTRUCTOR(arch_instruction, G_TYPE_ARCH_INSTRUCTION, py_arch_instruction_init_gclass);
+CREATE_DYN_ABSTRACT_CONSTRUCTOR(arch_instruction, G_TYPE_ARCH_INSTRUCTION);
 
 /* Initialise une instance sur la base du dérivé de GObject. */
 static int py_arch_instruction_init(PyObject *, PyObject *, PyObject *);
 
+/* Indique l'encodage d'une instruction de façon détaillée. */
+static char *py_arch_instruction_get_encoding_wrapper(const GArchInstruction *);
+
 /* Fournit le nom humain de l'instruction manipulée. */
-static const char *py_arch_instruction_get_class_keyword(GArchInstruction *);
+static char *py_arch_instruction_get_keyword_wrapper(const GArchInstruction *);
+
+
+
+/* ------------------- DEFINITION DES LIAISONS ENTRE INSTRUCTIONS ------------------- */
+
+
+/* Fournit les origines d'une instruction donnée. */
+static PyObject *py_arch_instruction_get_sources(PyObject *, void *);
+
+/* Fournit les destinations d'une instruction donnée. */
+static PyObject *py_arch_instruction_get_destinations(PyObject *, void *);
 
 
 
@@ -72,10 +79,7 @@ static const char *py_arch_instruction_get_class_keyword(GArchInstruction *);
 
 
 /* Attache un opérande supplémentaire à une instruction. */
-static PyObject *py_arch_instruction_attach_extra_operand(PyObject *, PyObject *);
-
-/* Fournit tous les opérandes d'une instruction. */
-static PyObject *py_arch_instruction_get_operands(PyObject *, void *);
+static PyObject *py_arch_instruction_attach_operand(PyObject *, PyObject *);
 
 /* Remplace un opérande d'une instruction par un autre. */
 static PyObject *py_arch_instruction_replace_operand(PyObject *, PyObject *);
@@ -89,34 +93,35 @@ static PyObject *py_arch_instruction_find_operand_path(PyObject *, PyObject *);
 /* Obtient l'opérande correspondant à un chemin donné. */
 static PyObject *py_arch_instruction_get_operand_from_path(PyObject *, PyObject *);
 
+/* Fournit tous les opérandes d'une instruction. */
+static PyObject *py_arch_instruction_get_operands(PyObject *, void *);
 
 
-/* ------------------- DEFINITION DES LIAISONS ENTRE INSTRUCTIONS ------------------- */
 
+/* ------------------ LIAISON DE FONCTIONNALITES AVEC L'API PYTHON ------------------ */
 
-/* Fournit les origines d'une instruction donnée. */
-static PyObject *py_arch_instruction_get_sources(PyObject *, void *);
 
-/* Fournit les destinations d'une instruction donnée. */
-static PyObject *py_arch_instruction_get_destinations(PyObject *, void *);
+/* Ajoute une information complémentaire à une instruction. */
+static PyObject *py_arch_instruction_set_flag(PyObject *, PyObject *);
 
+/* Retire une information complémentaire à une instruction. */
+static PyObject *py_arch_instruction_unset_flag(PyObject *, PyObject *);
 
+/* Détermine si une instruction possède un fanion particulier. */
+static PyObject *py_arch_instruction_has_flag(PyObject *, PyObject *);
 
-/* --------------------- INSTRUCTIONS D'ARCHITECTURES EN PYTHON --------------------- */
+/* Fournit l'identifiant correspondant à un type d'instructions. */
+static PyObject *py_arch_instruction_get_type_id(PyObject *, void *);
 
+/* Indique l'encodage d'une instruction de façon détaillée. */
+static PyObject *py_arch_instruction_get_encoding(PyObject *, void *);
 
-/* Fournit l'identifiant unique pour un ensemble d'instructions. */
-static PyObject *py_arch_instruction_get_unique_id(PyObject *, void *);
+/* Indique l'encodage d'une instruction de façon détaillée. */
+static PyObject *py_arch_instruction_get_keyword(PyObject *, void *);
 
 /* Fournit la place mémoire d'une instruction. */
 static PyObject *py_arch_instruction_get_range(PyObject *, void *);
 
-/* Définit la localisation d'une instruction. */
-static int py_arch_instruction_set_range(PyObject *, PyObject *, void *);
-
-/* Fournit le nom humain de l'instruction manipulée. */
-static PyObject *py_arch_instruction_get_keyword(PyObject *, void *);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -126,24 +131,23 @@ static PyObject *py_arch_instruction_get_keyword(PyObject *, void *);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : class  = classe à initialiser.                               *
-*                unused = données non utilisées ici.                          *
+*  Paramètres  : gclass  = classe GLib à initialiser.                         *
+*                pyclass = classe Python à initialiser.                       *
 *                                                                             *
 *  Description : Initialise la classe générique des instructions.             *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : 0 pour indiquer un succès de l'opération.                    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void py_arch_instruction_init_gclass(GArchInstructionClass *class, gpointer unused)
+static int py_arch_instruction_init_gclass(GArchInstructionClass *gclass, PyTypeObject *pyclass)
 {
-    GArchInstructionClass *instr;           /* Encore une autre vision...  */
-
-    instr = G_ARCH_INSTRUCTION_CLASS(class);
+    PY_CLASS_SET_WRAPPER(gclass->get_encoding, py_arch_instruction_get_encoding_wrapper);
+    PY_CLASS_SET_WRAPPER(gclass->get_keyword, py_arch_instruction_get_keyword_wrapper);
 
-    instr->get_keyword = (get_instruction_keyword_fc)py_arch_instruction_get_class_keyword;
+    return 0;
 
 }
 
@@ -164,17 +168,25 @@ static void py_arch_instruction_init_gclass(GArchInstructionClass *class, gpoint
 
 static int py_arch_instruction_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    unsigned short int uid;                 /* Indentifiant unique de type */
-    const char *keyword;                    /* Désignation d'instruction   */
+    unsigned short int tid;                 /* Indentifiant unique de type */
     int ret;                                /* Bilan de lecture des args.  */
     GArchInstruction *instr;                /* Instruction à manipuler     */
-    GQuark cache_key;                       /* Emplacement local           */
 
-    static char *kwlist[] = { "uid", "keyword", NULL };
+#define ARCH_INSTRUCTION_DOC                                            \
+    "The ArchInstruction object provides a base class for instructions" \
+    " of any architecture.\n"                                           \
+    " operands of any kind for new architectures.\n"                    \
+    "\n"                                                                \
+    "Calls to the *__init__* constructor of this abstract object expect"\
+    " one argument: an unique identifier, as an integer value.\n"       \
+    "\n"                                                                \
+    "The following methods have to be defined for new classes:\n"       \
+    "* pychrysalide.arch.ArchRegister._get_encoding();\n"               \
+    "* pychrysalide.arch.ArchRegister._get_keyword().\n"
 
     /* Récupération des paramètres */
 
-    ret = PyArg_ParseTupleAndKeywords(args, kwds, "Hs", kwlist, &uid, &keyword);
+    ret = PyArg_ParseTuple(args, "H", &tid);
     if (!ret) return -1;
 
     /* Initialisation d'un objet GLib */
@@ -186,13 +198,72 @@ static int py_arch_instruction_init(PyObject *self, PyObject *args, PyObject *kw
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    cache_key = get_cached_keyword_quark();
+    if (!g_arch_instruction_create(instr, tid))
+        return -1;
+
+    return 0;
 
-    g_object_set_qdata_full(G_OBJECT(instr), cache_key, strdup(keyword), g_free);
+}
 
-    g_arch_instruction_set_unique_id(G_ARCH_INSTRUCTION(instr), uid);
 
-    return 0;
+/******************************************************************************
+*                                                                             *
+*  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 char *py_arch_instruction_get_encoding_wrapper(const GArchInstruction *instr)
+{
+    char *result;                           /* Encodage à retourner        */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyObject *pyobj;                        /* Objet Python concerné       */
+    PyObject *pyret;                        /* Bilan d'exécution           */
+
+#define PLUGIN_MODULE_GET_ENCODING_WRAPPER PYTHON_WRAPPER_DEF       \
+(                                                                   \
+    _get_encoding, "$self, /",                                      \
+    METH_NOARGS,                                                    \
+    "Abstract method describing the encoding related to an"         \
+    " instruction.\n"                                               \
+    "\n"                                                            \
+    "The result should be the string value.\n"                      \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pyobj = pygobject_new(G_OBJECT(instr));
+
+    if (has_python_method(pyobj, "_get_encoding"))
+    {
+        pyret = run_python_method(pyobj, "_get_encoding", NULL);
+
+        if (pyret != NULL)
+        {
+            if (!PyUnicode_Check(pyret))
+                log_variadic_message(LMT_ERROR, _("The returned raw name must be a string"));
+
+            else
+                result = strdup(PyUnicode_DATA(pyret));
+
+        }
+
+        Py_XDECREF(pyret);
+
+    }
+
+    Py_DECREF(pyobj);
+
+    PyGILState_Release(gstate);
+
+    return result;
 
 }
 
@@ -209,15 +280,50 @@ static int py_arch_instruction_init(PyObject *self, PyObject *args, PyObject *kw
 *                                                                             *
 ******************************************************************************/
 
-static const char *py_arch_instruction_get_class_keyword(GArchInstruction *instr)
+static char *py_arch_instruction_get_keyword_wrapper(const GArchInstruction *instr)
 {
-    const char *result;                     /* Désignation à retourner     */
-    GQuark cache_key;                       /* Emplacement local           */
+    char *result;                           /* Etiquette à retourner       */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyObject *pyobj;                        /* Objet Python concerné       */
+    PyObject *pyret;                        /* Bilan d'exécution           */
+
+#define PLUGIN_MODULE_GET_KEYWORD_WRAPPER PYTHON_WRAPPER_DEF        \
+(                                                                   \
+    _get_keyword, "$self, /",                                       \
+    METH_NOARGS,                                                    \
+    "Abstract method giving the official name of the assembly"      \
+    " instruction.\n"                                               \
+    "\n"                                                            \
+    "The result should be the string value.\n"                      \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pyobj = pygobject_new(G_OBJECT(instr));
+
+    if (has_python_method(pyobj, "_get_keyword"))
+    {
+        pyret = run_python_method(pyobj, "_get_keyword", NULL);
+
+        if (pyret != NULL)
+        {
+            if (!PyUnicode_Check(pyret))
+                log_variadic_message(LMT_ERROR, _("The returned raw name must be a string"));
 
-    cache_key = get_cached_keyword_quark();
+            else
+                result = strdup(PyUnicode_DATA(pyret));
 
-    result = g_object_get_qdata(G_OBJECT(instr), cache_key);
-    assert(result != NULL);
+        }
+
+        Py_XDECREF(pyret);
+
+    }
+
+    Py_DECREF(pyobj);
+
+    PyGILState_Release(gstate);
 
     return result;
 
@@ -226,94 +332,201 @@ static const char *py_arch_instruction_get_class_keyword(GArchInstruction *instr
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                             MANIPULATION DES OPERANDES                             */
+/*                     DEFINITION DES LIAISONS ENTRE INSTRUCTIONS                     */
 /* ---------------------------------------------------------------------------------- */
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self = architecture concernée par la procédure.              *
-*                args = instruction représentant le point de départ.          *
+*  Paramètres  : self   = instruction d'architecture à manipuler.             *
+*                unused = adresse non utilisée ici.                           *
 *                                                                             *
-*  Description : Attache un opérande supplémentaire à une instruction.        *
+*  Description : Fournit les origines d'une instruction donnée.               *
 *                                                                             *
-*  Retour      : None.                                                        *
+*  Retour      : Nombre de ces origines.                                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_attach_extra_operand(PyObject *self, PyObject *args)
+static PyObject *py_arch_instruction_get_sources(PyObject *self, void *unused)
 {
-    GArchOperand *op;                       /* Opérande concerné à ajouter */
-    int ret;                                /* Bilan de lecture des args.  */
-    GArchInstruction *instr;                /* Instruction manipulée       */
+    PyObject *result;                       /* Instance à retourner        */
+    GArchInstruction *instr;                /* Version native              */
+    size_t count;                           /* Nombre de liens présents    */
+    size_t i;                               /* Boucle de parcours          */
 
-    ret = PyArg_ParseTuple(args, "O&", convert_to_arch_operand, &op);
-    if (!ret) return NULL;
+
+    GArchInstruction *src;                  /* Instruction en source       */
+    InstructionLinkType src_type;           /* Type de lien                */
+    PyObject *linked;                       /* Source de lien Python       */
+    PyObject *lnk_type;                     /* Nature du lien en Python    */
+#ifndef NDEBUG
+    int ret;                                /* Bilan d'une écriture d'arg. */
+#endif
+
+#define ARCH_INSTRUCTION_SOURCES_ATTRIB PYTHON_GET_DEF_FULL                 \
+(                                                                           \
+    sources, py_arch_instruction,                                           \
+    "Provide the instructions list driving to the current instruction.\n"   \
+    "\n"                                                                    \
+    "Each item of the resulting tuple is a pair of"                         \
+    " pychrysalide.arch.ArchInstruction instance and"                       \
+    " pychrysalide.arch.ArchInstruction.InstructionLinkType value."         \
+)
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    g_object_ref(G_OBJECT(op));
+    g_thick_object_lock(G_THICK_OBJECT(instr));
+
+    count = g_arch_instruction_count_src_links(instr);
+
+    result = PyTuple_New(count);
+
+    for (i = 0; i < count; i++)
+    {
+        src = g_arch_instruction_get_linked_source(instr, i, &src_type);
+
+        linked = pygobject_new(G_OBJECT(src));
+        lnk_type = cast_with_constants_group_from_type(get_python_arch_instruction_type(),
+                                                       "InstructionLinkType", src_type);
+
+#ifndef NDEBUG
+        ret = PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, lnk_type));
+        assert(ret == 0);
+#else
+        PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, lnk_type));
+#endif
+
+        unref_object(src);
+
+    }
 
-    g_arch_instruction_attach_extra_operand(instr, op);
+    g_thick_object_unlock(G_THICK_OBJECT(instr));
 
-    Py_RETURN_NONE;
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self   = objet représentant une instruction.                 *
+*  Paramètres  : self   = instruction d'architecture à manipuler.             *
 *                unused = adresse non utilisée ici.                           *
 *                                                                             *
-*  Description : Fournit tous les opérandes d'une instruction.                *
+*  Description : Fournit les destinations d'une instruction donnée.           *
 *                                                                             *
-*  Retour      : Valeur associée à la propriété consultée.                    *
+*  Retour      : Nombre de ces destinations.                                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_operands(PyObject *self, void *unused)
+static PyObject *py_arch_instruction_get_destinations(PyObject *self, void *unused)
 {
     PyObject *result;                       /* Instance à retourner        */
     GArchInstruction *instr;                /* Version native              */
-    size_t count;                           /* Nombre d'opérandes présents */
+    size_t count;                           /* Nombre de liens présents    */
     size_t i;                               /* Boucle de parcours          */
-    GArchOperand *operand;                  /* Opérande à manipuler        */
-    PyObject *opobj;                        /* Version Python              */
+    GArchInstruction *dest;                 /* Instruction en source       */
+    InstructionLinkType dest_type;          /* Type de lien                */
+    PyObject *linked;                       /* Destination de lien Python  */
+    PyObject *lnk_type;                     /* Nature du lien en Python    */
 #ifndef NDEBUG
     int ret;                                /* Bilan d'une écriture d'arg. */
 #endif
 
+#define ARCH_INSTRUCTION_DESTINATIONS_ATTRIB PYTHON_GET_DEF_FULL            \
+(                                                                           \
+    destinations, py_arch_instruction,                                      \
+    "Provide the instructions list following the current instruction.\n"    \
+    "\n"                                                                    \
+    "Each item of the resulting tuple is a pair of"                         \
+    " pychrysalide.arch.ArchInstruction instance and"                       \
+    " pychrysalide.arch.ArchInstruction.InstructionLinkType value."         \
+)
+
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    g_arch_instruction_lock_operands(instr);
+    g_thick_object_lock(G_THICK_OBJECT(instr));
 
-    count = _g_arch_instruction_count_operands(instr);
+    count = g_arch_instruction_count_dest_links(instr);
 
     result = PyTuple_New(count);
 
     for (i = 0; i < count; i++)
     {
-        operand = _g_arch_instruction_get_operand(instr, i);
+        dest = g_arch_instruction_get_linked_destination(instr, i, &dest_type);
 
-        opobj = pygobject_new(G_OBJECT(operand));
+        linked = pygobject_new(G_OBJECT(dest));
+        lnk_type = cast_with_constants_group_from_type(get_python_arch_instruction_type(),
+                                                       "InstructionLinkType", dest_type);
 
 #ifndef NDEBUG
-        ret = PyTuple_SetItem(result, i, Py_BuildValue("O", opobj));
+        ret = PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, lnk_type));
         assert(ret == 0);
 #else
-        PyTuple_SetItem(result, i, Py_BuildValue("O", opobj));
+        PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, lnk_type));
 #endif
 
-        g_object_unref(G_OBJECT(operand));
+        unref_object(dest);
 
     }
 
-    g_arch_instruction_unlock_operands(instr);
+    g_thick_object_unlock(G_THICK_OBJECT(instr));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                             MANIPULATION DES OPERANDES                             */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = architecture concernée par la procédure.              *
+*                args = instruction représentant le point de départ.          *
+*                                                                             *
+*  Description : Attache un opérande supplémentaire à une instruction.        *
+*                                                                             *
+*  Retour      : None.                                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_arch_instruction_attach_operand(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    GArchOperand *op;                       /* Opérande concerné à ajouter */
+    int ret;                                /* Bilan de lecture des args.  */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+
+#define ARCH_INSTRUCTION_ATTACH_OPERAND_METHOD PYTHON_METHOD_DEF        \
+(                                                                       \
+    attach_operand, "$self, operand, /",                                \
+    METH_VARARGS, py_arch_instruction,                                  \
+    "Add an extra operand to an instruction.\n"                         \
+    "\n"                                                                \
+    "The instruction has to be locked during the instruction.\n"        \
+    "\n"                                                                \
+    "The *operand* argument has to be a pychrysalide.arch.ArchOperand"  \
+    " instance."                                                        \
+)
+
+    ret = PyArg_ParseTuple(args, "O&", convert_to_arch_operand, &op);
+    if (!ret) return NULL;
+
+    instr = G_ARCH_INSTRUCTION(pygobject_get(self));
+
+    g_arch_instruction_attach_operand(instr, op);
+
+    result = Py_None;
+    Py_INCREF(result);
 
     return result;
 
@@ -342,6 +555,21 @@ static PyObject *py_arch_instruction_replace_operand(PyObject *self, PyObject *a
     GArchInstruction *instr;                /* Instruction manipulée       */
     bool status;                            /* Bilan de l'opération        */
 
+#define ARCH_INSTRUCTION_REPLACE_OPERAND_METHOD PYTHON_METHOD_DEF        \
+(                                                                       \
+    replace_operand, "$self, old, new, /",                               \
+    METH_VARARGS, py_arch_instruction,                                  \
+    "Replace an old instruction operand by a another one.\n"            \
+    "\n"                                                                \
+    "The instruction has to be locked during the instruction.\n"        \
+    "\n"                                                                \
+    "Both the *old* and *new* arguments have to be a"                   \
+    " pychrysalide.arch.ArchOperand instance.\n"                        \
+    "\n"                                                                \
+    "The status of the operation is returned as a boolean value: *True*"\
+    " if the operand has been replaced, *False* in case of failure."    \
+)
+
     ret = PyArg_ParseTuple(args, "O&O&", convert_to_arch_operand, &old, convert_to_arch_operand, &new);
     if (!ret) return NULL;
 
@@ -349,9 +577,6 @@ static PyObject *py_arch_instruction_replace_operand(PyObject *self, PyObject *a
 
     status = g_arch_instruction_replace_operand(instr, old, new);
 
-    if (status)
-        g_object_ref(G_OBJECT(new));
-
     result = status ? Py_True : Py_False;
     Py_INCREF(result);
 
@@ -381,6 +606,21 @@ static PyObject *py_arch_instruction_detach_operand(PyObject *self, PyObject *ar
     GArchInstruction *instr;                /* Instruction manipulée       */
     bool status;                            /* Bilan de l'opération        */
 
+#define ARCH_INSTRUCTION_DETACH_OPERAND_METHOD PYTHON_METHOD_DEF        \
+(                                                                       \
+    detach_operand, "$self, operand, /",                                \
+    METH_VARARGS, py_arch_instruction,                                  \
+    "Remove an operand from the instruction.\n"                         \
+    "\n"                                                                \
+    "The instruction has to be locked during the instruction.\n"        \
+    "\n"                                                                \
+    "The *operand* argument has to be a pychrysalide.arch.ArchOperand"  \
+    " instance.\n"                                                      \
+    "\n"                                                                \
+    "The status of the operation is returned as a boolean value: *True*"\
+    " if the operand has been removed, *False* in case of failure."     \
+)
+
     ret = PyArg_ParseTuple(args, "O&", convert_to_arch_operand, &target);
     if (!ret) return NULL;
 
@@ -500,7 +740,7 @@ static PyObject *py_arch_instruction_get_operand_from_path(PyObject *self, PyObj
     if (op != NULL)
     {
         result = pygobject_new(G_OBJECT(op));
-        g_object_unref(G_OBJECT(op));
+        unref_object(op);
     }
     else
     {
@@ -513,182 +753,258 @@ static PyObject *py_arch_instruction_get_operand_from_path(PyObject *self, PyObj
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                     DEFINITION DES LIAISONS ENTRE INSTRUCTIONS                     */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self   = instruction d'architecture à manipuler.             *
+*  Paramètres  : self   = objet représentant une instruction.                 *
 *                unused = adresse non utilisée ici.                           *
 *                                                                             *
-*  Description : Fournit les origines d'une instruction donnée.               *
+*  Description : Fournit tous les opérandes d'une instruction.                *
 *                                                                             *
-*  Retour      : Nombre de ces origines.                                      *
+*  Retour      : Valeur associée à la propriété consultée.                    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_sources(PyObject *self, void *unused)
+static PyObject *py_arch_instruction_get_operands(PyObject *self, void *unused)
 {
     PyObject *result;                       /* Instance à retourner        */
     GArchInstruction *instr;                /* Version native              */
-    size_t count;                           /* Nombre de liens présents    */
+    size_t count;                           /* Nombre d'opérandes présents */
     size_t i;                               /* Boucle de parcours          */
-    const instr_link_t *source;             /* Origine des liens           */
-    PyObject *linked;                       /* Source de lien Python       */
-    PyObject *type;                         /* Nature du lien en Python    */
+    GArchOperand *operand;                  /* Opérande à manipuler        */
+    PyObject *opobj;                        /* Version Python              */
 #ifndef NDEBUG
     int ret;                                /* Bilan d'une écriture d'arg. */
 #endif
 
-#define ARCH_INSTRUCTION_SOURCES_ATTRIB PYTHON_GET_DEF_FULL                 \
-(                                                                           \
-    sources, py_arch_instruction,                                           \
-    "Provide the instructions list driving to the current instruction.\n"   \
-    "\n"                                                                    \
-    "Each item of the resulting tuple is a pair of"                         \
-    " pychrysalide.arch.ArchInstruction instance and"                       \
-    " pychrysalide.arch.ArchInstruction.InstructionLinkType value."         \
+#define ARCH_INSTRUCTION_OPERANDS_ATTRIB PYTHON_GET_DEF_FULL    \
+(                                                               \
+    operands, py_arch_instruction,                              \
+    "List of instruction attached operands.\n"                  \
+    "\n"                                                        \
+    "The result is a list of pychrysalide.arch.ArchOperand"     \
+    " instances, which can be empty."                           \
 )
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    g_arch_instruction_lock_src(instr);
+    g_thick_object_lock(G_THICK_OBJECT(instr));
 
-    count = g_arch_instruction_count_sources(instr);
+    count = g_arch_instruction_count_operands(instr);
 
     result = PyTuple_New(count);
 
     for (i = 0; i < count; i++)
     {
-        source = g_arch_instruction_get_source(instr, i);
+        operand = g_arch_instruction_get_operand(instr, i);
 
-        linked = pygobject_new(G_OBJECT(source->linked));
-        type = cast_with_constants_group_from_type(get_python_arch_instruction_type(),
-                                                   "InstructionLinkType", source->type);
+        opobj = pygobject_new(G_OBJECT(operand));
 
 #ifndef NDEBUG
-        ret = PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, type));
+        ret = PyTuple_SetItem(result, i, Py_BuildValue("O", opobj));
         assert(ret == 0);
 #else
-        PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, type));
+        PyTuple_SetItem(result, i, Py_BuildValue("O", opobj));
 #endif
 
-        unref_instr_link(source);
+        unref_object(operand);
 
     }
 
-    g_arch_instruction_unlock_src(instr);
+    g_thick_object_unlock(G_THICK_OBJECT(instr));
 
     return result;
 
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                    LIAISON DE FONCTIONNALITES AVEC L'API PYTHON                    */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self   = instruction d'architecture à manipuler.             *
-*                unused = adresse non utilisée ici.                           *
+*  Paramètres  : self = architecture concernée par la procédure.              *
+*                args = instruction représentant le point de départ.          *
 *                                                                             *
-*  Description : Fournit les destinations d'une instruction donnée.           *
+*  Description : Ajoute une information complémentaire à une instruction.     *
 *                                                                             *
-*  Retour      : Nombre de ces destinations.                                  *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_destinations(PyObject *self, void *unused)
+static PyObject *py_arch_instruction_set_flag(PyObject *self, PyObject *args)
 {
-    PyObject *result;                       /* Instance à retourner        */
-    GArchInstruction *instr;                /* Version native              */
-    size_t count;                           /* Nombre de liens présents    */
-    size_t i;                               /* Boucle de parcours          */
-    const instr_link_t *dest;               /* Destination des liens       */
-    PyObject *linked;                       /* Destination de lien Python  */
-    PyObject *type;                         /* Nature du lien en Python    */
-#ifndef NDEBUG
-    int ret;                                /* Bilan d'une écriture d'arg. */
-#endif
-
-#define ARCH_INSTRUCTION_DESTINATIONS_ATTRIB PYTHON_GET_DEF_FULL            \
-(                                                                           \
-    destinations, py_arch_instruction,                                      \
-    "Provide the instructions list following the current instruction.\n"    \
-    "\n"                                                                    \
-    "Each item of the resulting tuple is a pair of"                         \
-    " pychrysalide.arch.ArchInstruction instance and"                       \
-    " pychrysalide.arch.ArchInstruction.InstructionLinkType value."         \
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int flag;                      /* Fanion(s) à appliquer       */
+    int ret;                                /* Bilan de lecture des args.  */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    bool status;                            /* Bilan à transmettre         */
+
+#define ARCH_INSTRUCTION_SET_FLAG_METHOD PYTHON_METHOD_DEF  \
+(                                                           \
+    set_flag, "$self, flag, /",                             \
+    METH_VARARGS, py_arch_instruction,                      \
+    "Add some flags to the instruction.\n"                  \
+    "\n"                                                    \
+    "This *flag* argument is an integer value containing"   \
+    " bits to apply to the instruction state.\n"            \
+    "\n"                                                    \
+    "The result is an boolean status: *True* for operation" \
+    " success, *False* otherwise."                          \
 )
 
+    ret = PyArg_ParseTuple(args, "I", &flag);
+    if (!ret) return NULL;
+
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    g_arch_instruction_lock_dest(instr);
+    status = g_arch_instruction_set_flag(instr, flag);
 
-    count = g_arch_instruction_count_destinations(instr);
+    result = status ? Py_True : Py_False;
+    Py_INCREF(result);
 
-    result = PyTuple_New(count);
+    return result;
 
-    for (i = 0; i < count; i++)
-    {
-        dest = g_arch_instruction_get_destination(instr, i);
+}
 
-        linked = pygobject_new(G_OBJECT(dest->linked));
-        type = cast_with_constants_group_from_type(get_python_arch_instruction_type(),
-                                                   "InstructionLinkType", dest->type);
 
-#ifndef NDEBUG
-        ret = PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, type));
-        assert(ret == 0);
-#else
-        PyTuple_SetItem(result, i, Py_BuildValue("(OO)", linked, type));
-#endif
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = architecture concernée par la procédure.              *
+*                args = instruction représentant le point de départ.          *
+*                                                                             *
+*  Description : Retire une information complémentaire à une instruction.     *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_arch_instruction_unset_flag(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int flag;                      /* Fanion(s) à appliquer       */
+    int ret;                                /* Bilan de lecture des args.  */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    bool status;                            /* Bilan à transmettre         */
+
+#define ARCH_INSTRUCTION_UNSET_FLAG_METHOD PYTHON_METHOD_DEF    \
+(                                                               \
+    unset_flag, "$self, flag, /",                               \
+    METH_VARARGS, py_arch_instruction,                          \
+    "Remove some flags from the instruction.\n"                 \
+    "\n"                                                        \
+    "This *flag* argument is an integer value containing"       \
+    " bits to delete from the instruction state.\n"             \
+    "\n"                                                        \
+    "The result is an boolean status: *True* for operation"     \
+    " success, *False* otherwise."                              \
+)
 
-        unref_instr_link(dest);
+    ret = PyArg_ParseTuple(args, "I", &flag);
+    if (!ret) return NULL;
 
-    }
+    instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    g_arch_instruction_unlock_dest(instr);
+    status = g_arch_instruction_unset_flag(instr, flag);
+
+    result = status ? Py_True : Py_False;
+    Py_INCREF(result);
 
     return result;
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = architecture concernée par la procédure.              *
+*                args = instruction représentant le point de départ.          *
+*                                                                             *
+*  Description : Détermine si une instruction possède un fanion particulier.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-/* ---------------------------------------------------------------------------------- */
-/*                       INSTRUCTIONS D'ARCHITECTURES EN PYTHON                       */
-/* ---------------------------------------------------------------------------------- */
+static PyObject *py_arch_instruction_has_flag(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à retourner           */
+    unsigned int flag;                      /* Fanion(s) à appliquer       */
+    int ret;                                /* Bilan de lecture des args.  */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    bool status;                            /* Bilan à transmettre         */
+
+#define ARCH_INSTRUCTION_HAS_FLAG_METHOD PYTHON_METHOD_DEF  \
+(                                                           \
+    has_flag, "$self, flag, /",                             \
+    METH_VARARGS, py_arch_instruction,                      \
+    "Tell if some flags are set for the instruction.\n"     \
+    "\n"                                                    \
+    "This *flag* argument is an integer value containing"   \
+    " bits to test for the instruction state.\n"            \
+    "\n"                                                    \
+    "The result is an boolean status: *True* if the bits"   \
+    " are active, *False* otherwise."                       \
+)
+
+    ret = PyArg_ParseTuple(args, "I", &flag);
+    if (!ret) return NULL;
+
+    instr = G_ARCH_INSTRUCTION(pygobject_get(self));
+
+    status = g_arch_instruction_has_flag(instr, flag);
+
+    result = status ? Py_True : Py_False;
+    Py_INCREF(result);
+
+    return result;
+
+}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self    = classe représentant une instruction.               *
-*                closure = adresse non utilisée ici.                          *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit l'identifiant unique pour un ensemble d'instructions.*
+*  Description : Fournit l'identifiant correspondant à un type d'instructions.*
 *                                                                             *
-*  Retour      : Identifiant unique par type d'instruction.                   *
+*  Retour      : Identifiant unique par type d'instruction et architecture.   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_unique_id(PyObject *self, void *closure)
+static PyObject *py_arch_instruction_get_type_id(PyObject *self, void *closure)
 {
-    PyObject *result;                       /* Conversion à retourner      */
-    GArchInstruction *instr;                /* Version native              */
-    itid_t uid;                             /* Identifiant unique associé  */
+    PyObject *result;                       /* Valeur à retourner          */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    itid_t tid;                             /* Identifiant à transmettre   */
+
+#define ARCH_INSTRUCTION_TYPE_ID_ATTRIB PYTHON_GET_DEF_FULL \
+(                                                           \
+    type_id, py_arch_instruction,                           \
+    "Provide the unique identifier given to this kind of"   \
+    " instruction.\n"                                       \
+    "\n"                                                    \
+    "The returned value is an integer."                     \
+)
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    uid = g_arch_instruction_get_unique_id(instr);
+    tid = g_arch_instruction_get_type_id(instr);
 
-    result = PyLong_FromUnsignedLong(uid);
+    result = PyLong_FromUnsignedLong(tid);
 
     return result;
 
@@ -697,27 +1013,61 @@ static PyObject *py_arch_instruction_get_unique_id(PyObject *self, void *closure
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self    = classe représentant une instruction.               *
-*                closure = adresse non utilisée ici.                          *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit la place mémoire d'une instruction.                  *
+*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
 *                                                                             *
-*  Retour      : Valeur associée à la propriété consultée.                    *
+*  Retour      : Description humaine de l'encodage utilisé.                   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_range(PyObject *self, void *closure)
+static PyObject *py_arch_instruction_get_encoding(PyObject *self, void *closure)
 {
-    PyObject *result;                       /* Conversion à retourner      */
-    GArchInstruction *instr;                /* Version native              */
-    const mrange_t *range;                  /* Espace mémoire à exporter   */
+    PyObject *result;                       /* Valeur à retourner          */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    char *encoding;                         /* Encodage d'une instruction  */
+
+#define ARCH_INSTRUCTION_ENCODING_ATTRIB PYTHON_GET_DEF_FULL    \
+(                                                               \
+    encoding, py_arch_instruction,                              \
+    "Describe the encoding related to an instruction.\n"        \
+    "\n"                                                        \
+    "The returned value is an arbitrary string value."          \
+)
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
-    range = g_arch_instruction_get_range(instr);
 
-    result = build_from_internal_mrange(range);
+    encoding = g_arch_instruction_get_encoding(instr);
+
+    if (encoding != NULL)
+    {
+        result = PyUnicode_FromString(encoding);
+
+        free(encoding);
+
+    }
+
+    else
+    {
+        /**
+         * La méthode de classe sollicitée a renvoyé une valeur nulle.
+         *
+         * Si cette méthode correspond à une implémentation Python
+         * (avec un appel à not_yet_implemented_method()), une exception
+         * est déjà en place.
+         *
+         * Si aucune exception n'a été prévue, un rattrapage est effectué ici.
+         */
+
+        if (PyErr_Occurred() == NULL)
+            PyErr_SetString(PyExc_NotImplementedError, _("unexpected NULL value as encoding"));
+
+        result = NULL;
+
+    }
 
     return result;
 
@@ -727,59 +1077,108 @@ static PyObject *py_arch_instruction_get_range(PyObject *self, void *closure)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
-*                value   = valeur fournie à intégrer ou prendre en compte.    *
-*                closure = adresse non utilisée ici.                          *
+*                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Définit la localisation d'une instruction.                   *
+*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
 *                                                                             *
-*  Retour      : Bilan de l'opération pour Python.                            *
+*  Retour      : Description humaine de l'encodage utilisé.                   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static int py_arch_instruction_set_range(PyObject *self, PyObject *value, void *closure)
+static PyObject *py_arch_instruction_get_keyword(PyObject *self, void *closure)
 {
-    int ret;                                /* Bilan d'analyse             */
-    mrange_t *range;                        /* Espace mémoire à manipuler  */
-    GArchInstruction *instr;                /* Version native              */
+    PyObject *result;                       /* Valeur à retourner          */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    char *keyword;                          /* Désignation d'une instruct° */
+
+#define ARCH_INSTRUCTION_KEYWORD_ATTRIB PYTHON_GET_DEF_FULL \
+(                                                           \
+    keyword, py_arch_instruction,                           \
+    "Give the official name of the assembly instruction.\n" \
+    "\n"                                                    \
+    "The returned value is a string value."                 \
+)
 
-    ret = PyObject_IsInstance(value, (PyObject *)get_python_mrange_type());
-    if (!ret) return -1;
+    instr = G_ARCH_INSTRUCTION(pygobject_get(self));
 
-    range = get_internal_mrange(value);
+    keyword = g_arch_instruction_get_keyword(instr);
 
-    instr = G_ARCH_INSTRUCTION(pygobject_get(self));
-    g_arch_instruction_set_range(instr, range);
+    if (keyword != NULL)
+    {
+        result = PyUnicode_FromString(keyword);
 
-    return 0;
+        free(keyword);
+
+    }
+
+    else
+    {
+        /**
+         * La méthode de classe sollicitée a renvoyé une valeur nulle.
+         *
+         * Si cette méthode correspond à une implémentation Python
+         * (avec un appel à not_yet_implemented_method()), une exception
+         * est déjà en place.
+         *
+         * Si aucune exception n'a été prévue, un rattrapage est effectué ici.
+         */
+
+        if (PyErr_Occurred() == NULL)
+            PyErr_SetString(PyExc_NotImplementedError, _("unexpected NULL value as keyword"));
+
+        result = NULL;
+
+    }
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : self   = classe représentant une instruction.                *
-*                unused = adresse non utilisée ici.                           *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit le nom humain de l'instruction manipulée.            *
+*  Description : Fournit la place mémoire d'une instruction.                  *
 *                                                                             *
-*  Retour      : Valeur associée à la propriété consultée.                    *
+*  Retour      : Définition de localisation ou *None*.                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_arch_instruction_get_keyword(PyObject *self, void *unused)
+static PyObject *py_arch_instruction_get_range(PyObject *self, void *closure)
 {
-    PyObject *result;                       /* Trouvailles à retourner     */
-    GArchInstruction *instr;                /* Version native              */
-    const char *kw;                         /* Valeur récupérée            */
+    PyObject *result;                       /* Valeur à retourner          */
+    GArchInstruction *instr;                /* Instruction manipulée       */
+    mrange_t range;                         /* Localisation d'instruction  */
+    bool valid;                             /* Validité de la localisation */
+
+#define ARCH_INSTRUCTION_RANGE_ATTRIB PYTHON_GET_DEF_FULL   \
+(                                                           \
+    range, py_arch_instruction,                             \
+    "Give access to the memory range covered by the"        \
+    " current instruction.\n"                               \
+    "\n"                                                    \
+    "The returned value is a pychrysalide.arch.mrange"      \
+    " instance or *None* if no location is currently"       \
+    " defined."                                             \
+)
 
     instr = G_ARCH_INSTRUCTION(pygobject_get(self));
-    kw = g_arch_instruction_get_keyword(instr);
 
-    result = PyUnicode_FromString(kw);
+    valid = g_arch_instruction_get_range(instr, &range);
+
+    if (valid)
+        result = build_from_internal_mrange(&range);
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
 
     return result;
 
@@ -801,45 +1200,25 @@ static PyObject *py_arch_instruction_get_keyword(PyObject *self, void *unused)
 PyTypeObject *get_python_arch_instruction_type(void)
 {
     static PyMethodDef py_arch_instruction_methods[] = {
-        {
-            "attach_operand", py_arch_instruction_attach_extra_operand,
-            METH_VARARGS,
-            "attach_operand($self, op, /)\n--\n\nAdd a new operand to the instruction."
-        },
-        {
-            "replace_operand", py_arch_instruction_replace_operand,
-            METH_VARARGS,
-            "replace_operand($self, old, new, /)\n--\n\nReplace an old instruction operand by a another one."
-        },
-        {
-            "detach_operand", py_arch_instruction_detach_operand,
-            METH_VARARGS,
-            "detach_operand($self, target, /)\n--\n\nRemove an operand from the instruction."
-        },
+        ARCH_INSTRUCTION_ATTACH_OPERAND_METHOD,
+        ARCH_INSTRUCTION_REPLACE_OPERAND_METHOD,
+        ARCH_INSTRUCTION_DETACH_OPERAND_METHOD,
         ARCH_INSTRUCTION_FIND_OPERAND_PATH_METHOD,
         ARCH_INSTRUCTION_GET_OPERAND_FROM_PATH_METHOD,
+        ARCH_INSTRUCTION_SET_FLAG_METHOD,
+        ARCH_INSTRUCTION_UNSET_FLAG_METHOD,
+        ARCH_INSTRUCTION_HAS_FLAG_METHOD,
         { NULL }
     };
 
     static PyGetSetDef py_arch_instruction_getseters[] = {
-        {
-            "uid", py_arch_instruction_get_unique_id, NULL,
-            "Provide the unique identification number given to this kind of instruction.", NULL
-        },
-        {
-            "range", py_arch_instruction_get_range, py_arch_instruction_set_range,
-            "Give access to the memory range covered by the current instruction.", NULL
-        },
-        {
-            "keyword", (getter)py_arch_instruction_get_keyword, (setter)NULL,
-            "Give le name of the assembly instruction.", NULL
-        },
-        {
-            "operands", (getter)py_arch_instruction_get_operands, (setter)NULL,
-            "Provide the list of instruction attached operands.", NULL
-        },
         ARCH_INSTRUCTION_SOURCES_ATTRIB,
         ARCH_INSTRUCTION_DESTINATIONS_ATTRIB,
+        ARCH_INSTRUCTION_OPERANDS_ATTRIB,
+        ARCH_INSTRUCTION_TYPE_ID_ATTRIB,
+        ARCH_INSTRUCTION_ENCODING_ATTRIB,
+        ARCH_INSTRUCTION_KEYWORD_ATTRIB,
+        ARCH_INSTRUCTION_RANGE_ATTRIB,
         { NULL }
     };
 
@@ -852,7 +1231,7 @@ PyTypeObject *get_python_arch_instruction_type(void)
 
         .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_BASETYPE,
 
-        .tp_doc         = "PyChrysalide instruction for a given architecture.",
+        .tp_doc         = ARCH_INSTRUCTION_DOC,
 
         .tp_methods     = py_arch_instruction_methods,
         .tp_getset      = py_arch_instruction_getseters,
@@ -893,9 +1272,14 @@ bool ensure_python_arch_instruction_is_registered(void)
 
         dict = PyModule_GetDict(module);
 
-        if (!ensure_python_line_generator_is_registered())
+        if (!ensure_python_thick_object_is_registered())
             return false;
 
+        if (!ensure_python_serializable_object_is_registered())
+            return false;
+
+        pyg_register_class_init(G_TYPE_ARCH_INSTRUCTION, (PyGClassInitFunc)py_arch_instruction_init_gclass);
+
         if (!register_class_for_pygobject(dict, G_TYPE_ARCH_INSTRUCTION, type))
             return false;