Rename the registered items for ROST to make their name more expressive.

42 files changed, 265 insertions, 265 deletions

diff --git a/plugins/pychrysalide/analysis/scan/item.c b/plugins/pychrysalide/analysis/scan/item.c
index 3f46067..014ae24 100644
--- a/plugins/pychrysalide/analysis/scan/item.c
+++ b/plugins/pychrysalide/analysis/scan/item.c
@@ -42,24 +42,24 @@
 
 
 /* Initialise la classe des éléments appelables enregistrés. */
-static void py_registered_item_init_gclass(GRegisteredItemClass *, gpointer);
+static void py_scan_registered_item_init_gclass(GScanRegisteredItemClass *, gpointer);
 
-CREATE_DYN_ABSTRACT_CONSTRUCTOR(registered_item, G_TYPE_REGISTERED_ITEM, py_registered_item_init_gclass);
+CREATE_DYN_ABSTRACT_CONSTRUCTOR(scan_registered_item, G_TYPE_SCAN_REGISTERED_ITEM, py_scan_registered_item_init_gclass);
 
 /* Initialise une instance sur la base du dérivé de GObject. */
-static int py_registered_item_init(PyObject *, PyObject *, PyObject *);
+static int py_scan_registered_item_init(PyObject *, PyObject *, PyObject *);
 
 /* Indique le nom associé à une expression d'évaluation. */
-static char *py_registered_item_get_name_wrapper(const GRegisteredItem *);
+static char *py_scan_registered_item_get_name_wrapper(const GScanRegisteredItem *);
 
 /* Lance une résolution d'élément à solliciter. */
-static bool py_registered_item_resolve_wrapper(GRegisteredItem *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
+static bool py_scan_registered_item_resolve_wrapper(GScanRegisteredItem *, const char *, GScanContext *, GScanScope *, GScanRegisteredItem **);
 
 /* Réduit une expression à une forme plus simple. */
-static bool py_registered_item_reduce_wrapper(GRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
+static bool py_scan_registered_item_reduce_wrapper(GScanRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
 
 /* Effectue un appel à une fonction enregistrée. */
-static bool py_registered_item_run_call_wrapper(GRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+static bool py_scan_registered_item_run_call_wrapper(GScanRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 
@@ -67,10 +67,10 @@ static bool py_registered_item_run_call_wrapper(GRegisteredItem *, GScanExpressi
 
 
 /* Lance une résolution d'élément à appeler. */
-static PyObject *py_registered_item_resolve(PyObject *, PyObject *);
+static PyObject *py_scan_registered_item_resolve(PyObject *, PyObject *);
 
 /* Fournit le désignation associée à un composant nommé. */
-static PyObject *py_registered_item_get_name(PyObject *, void *);
+static PyObject *py_scan_registered_item_get_name(PyObject *, void *);
 
 
 
@@ -92,12 +92,12 @@ static PyObject *py_registered_item_get_name(PyObject *, void *);
 *                                                                             *
 ******************************************************************************/
 
-static void py_registered_item_init_gclass(GRegisteredItemClass *class, gpointer unused)
+static void py_scan_registered_item_init_gclass(GScanRegisteredItemClass *class, gpointer unused)
 {
-    class->get_name = py_registered_item_get_name_wrapper;
-    class->resolve = py_registered_item_resolve_wrapper;
-    class->reduce = py_registered_item_reduce_wrapper;
-    class->run_call = py_registered_item_run_call_wrapper;
+    class->get_name = py_scan_registered_item_get_name_wrapper;
+    class->resolve = py_scan_registered_item_resolve_wrapper;
+    class->reduce = py_scan_registered_item_reduce_wrapper;
+    class->run_call = py_scan_registered_item_run_call_wrapper;
 
 }
 
@@ -116,11 +116,11 @@ static void py_registered_item_init_gclass(GRegisteredItemClass *class, gpointer
 *                                                                             *
 ******************************************************************************/
 
-static int py_registered_item_init(PyObject *self, PyObject *args, PyObject *kwds)
+static int py_scan_registered_item_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
     int ret;                                /* Bilan de lecture des args.  */
 
-#define REGISTERED_ITEM_DOC                                         \
+#define SCAN_REGISTERED_ITEM_DOC                                    \
     "The *RegisteredItem* class is an abstract definition which is" \
     " the base for all keywords involved in a match condition"      \
     " expression.\n"                                                \
@@ -159,7 +159,7 @@ static int py_registered_item_init(PyObject *self, PyObject *args, PyObject *kwd
 *                                                                             *
 ******************************************************************************/
 
-static char *py_registered_item_get_name_wrapper(const GRegisteredItem *item)
+static char *py_scan_registered_item_get_name_wrapper(const GScanRegisteredItem *item)
 {
     char *result;                           /* Désignation à retourner     */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
@@ -167,12 +167,12 @@ static char *py_registered_item_get_name_wrapper(const GRegisteredItem *item)
     PyObject *pyname;                       /* Nom en objet Python         */
     int ret;                                /* Bilan d'une conversion      */
 
-#define REGISTERED_ITEM_NAME_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF      \
-(                                                                       \
-    _name,                                                              \
-    "Provide the keyword of the expression item to be evaluated.\n"     \
-    "\n"                                                                \
-    "The result has to be a string."                                    \
+#define SCAN_REGISTERED_ITEM_NAME_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF  \
+(                                                                           \
+    _name,                                                                  \
+    "Provide the keyword of the expression item to be evaluated.\n"         \
+    "\n"                                                                    \
+    "The result has to be a string."                                        \
 )
 
     result = NULL;
@@ -223,7 +223,7 @@ static char *py_registered_item_get_name_wrapper(const GRegisteredItem *item)
 *                                                                             *
 ******************************************************************************/
 
-static bool py_registered_item_resolve_wrapper(GRegisteredItem *item, const char *target, GScanContext *ctx, GScanScope *scope, GRegisteredItem **out)
+static bool py_scan_registered_item_resolve_wrapper(GScanRegisteredItem *item, const char *target, GScanContext *ctx, GScanScope *scope, GScanRegisteredItem **out)
 {
     bool result;                            /* Bilan à retourner           */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
@@ -232,7 +232,7 @@ static bool py_registered_item_resolve_wrapper(GRegisteredItem *item, const char
     PyObject *pyret;                        /* Bilan de consultation       */
     GObject *gobj_ret;                      /* Bilan natif de consultation */
 
-#define REGISTERED_ITEM_RESOLVE_WRAPPER PYTHON_WRAPPER_DEF              \
+#define SCAN_REGISTERED_ITEM_RESOLVE_WRAPPER PYTHON_WRAPPER_DEF         \
 (                                                                       \
     _cmp_rich, "$self, target, ctx, scope, /",                          \
     METH_VARARGS,                                                       \
@@ -267,9 +267,9 @@ static bool py_registered_item_resolve_wrapper(GRegisteredItem *item, const char
         {
             gobj_ret = pygobject_get(pyret);
 
-            if (G_IS_REGISTERED_ITEM(gobj_ret))
+            if (G_IS_SCAN_REGISTERED_ITEM(gobj_ret))
             {
-                *out = G_REGISTERED_ITEM(gobj_ret);
+                *out = G_SCAN_REGISTERED_ITEM(gobj_ret);
 
                 g_object_ref(G_OBJECT(*out));
                 result = true;
@@ -308,7 +308,7 @@ static bool py_registered_item_resolve_wrapper(GRegisteredItem *item, const char
 *                                                                             *
 ******************************************************************************/
 
-static bool py_registered_item_reduce_wrapper(GRegisteredItem *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+static bool py_scan_registered_item_reduce_wrapper(GScanRegisteredItem *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
     bool result;                            /* Bilan à retourner           */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
@@ -317,7 +317,7 @@ static bool py_registered_item_reduce_wrapper(GRegisteredItem *item, GScanContex
     PyObject *pyret;                        /* Bilan de consultation       */
     GObject *gobj_ret;                      /* Bilan natif de consultation */
 
-#define REGISTERED_ITEM_REDUCE_WRAPPER PYTHON_WRAPPER_DEF               \
+#define SCAN_REGISTERED_ITEM_REDUCE_WRAPPER PYTHON_WRAPPER_DEF          \
 (                                                                       \
     _cmp_rich, "$self, ctx, scope, /",                                  \
     METH_VARARGS,                                                       \
@@ -394,7 +394,7 @@ static bool py_registered_item_reduce_wrapper(GRegisteredItem *item, GScanContex
 *                                                                             *
 ******************************************************************************/
 
-static bool py_registered_item_run_call_wrapper(GRegisteredItem *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+static bool py_scan_registered_item_run_call_wrapper(GScanRegisteredItem *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
 {
     bool result;                            /* Bilan à retourner           */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
@@ -405,9 +405,9 @@ static bool py_registered_item_run_call_wrapper(GRegisteredItem *item, GScanExpr
     PyObject *pyret;                        /* Bilan de consultation       */
     GObject *gobj_ret;                      /* Bilan natif de consultation */
 
-#define REGISTERED_ITEM_CALL_WRAPPER PYTHON_WRAPPER_DEF                 \
+#define SCAN_REGISTERED_ITEM_CALL_WRAPPER PYTHON_WRAPPER_DEF            \
 (                                                                       \
-    _cmp_rich, "$self, args, ctx, scope, /",                                  \
+    _cmp_rich, "$self, args, ctx, scope, /",                            \
     METH_VARARGS,                                                       \
     "Abstract method used to replace the item and its arguments by an"  \
     " equivalent reduced value.\n"                                      \
@@ -494,21 +494,21 @@ static bool py_registered_item_run_call_wrapper(GRegisteredItem *item, GScanExpr
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_registered_item_resolve(PyObject *self, PyObject *args)
+static PyObject *py_scan_registered_item_resolve(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Bilan à retourner           */
     const char *target;                     /* Désignation de la cible     */
     GScanContext *ctx;                      /* Contexte d'analyse          */
     GScanScope *scope;                      /* Portée de variables locales */
     int ret;                                /* Bilan de lecture des args.  */
-    GRegisteredItem *item;                  /* Version native              */
+    GScanRegisteredItem *item;              /* Version native              */
     bool status;                            /* Bilan d'exécution           */
-    GRegisteredItem *resolved;              /* Elément trouvé              */
+    GScanRegisteredItem *resolved;          /* Elément trouvé              */
 
-#define REGISTERED_ITEM_RESOLVE_METHOD PYTHON_METHOD_DEF                \
+#define SCAN_REGISTERED_ITEM_RESOLVE_METHOD PYTHON_METHOD_DEF           \
 (                                                                       \
     resolve, "$self, target, /, ctx=None, scope=None",                  \
-    METH_VARARGS, py_registered_item,                                   \
+    METH_VARARGS, py_scan_registered_item,                              \
     "Resolve a name into a scan item."                                  \
     "\n"                                                                \
     "The *target* name is the only mandatory parameter and has to point"\
@@ -532,9 +532,9 @@ static PyObject *py_registered_item_resolve(PyObject *self, PyObject *args)
                            convert_to_scan_context, &ctx);
     if (!ret) return NULL;
 
-    item = G_REGISTERED_ITEM(pygobject_get(self));
+    item = G_SCAN_REGISTERED_ITEM(pygobject_get(self));
 
-    status = g_registered_item_resolve(item, target, ctx, scope, &resolved);
+    status = g_scan_registered_item_resolve(item, target, ctx, scope, &resolved);
 
     if (!status)
     {
@@ -573,23 +573,23 @@ static PyObject *py_registered_item_resolve(PyObject *self, PyObject *args)
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_registered_item_get_name(PyObject *self, void *closure)
+static PyObject *py_scan_registered_item_get_name(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Décompte à retourner        */
-    GRegisteredItem *item;                  /* Version native              */
+    GScanRegisteredItem *item;              /* Version native              */
     char *name;                             /* Désignation à convertir     */
 
-#define REGISTERED_ITEM_NAME_ATTRIB PYTHON_GET_DEF_FULL                 \
+#define SCAN_REGISTERED_ITEM_NAME_ATTRIB PYTHON_GET_DEF_FULL            \
 (                                                                       \
-    name, py_registered_item,                                           \
+    name, py_scan_registered_item,                                      \
     "Name linked to the registered item.\n"                             \
     "\n"                                                                \
     "The result should be a string, or *None* for the root namespace."  \
 )
 
-    item = G_REGISTERED_ITEM(pygobject_get(self));
+    item = G_SCAN_REGISTERED_ITEM(pygobject_get(self));
 
-    name = g_registered_item_get_name(item);
+    name = g_scan_registered_item_get_name(item);
 
     if (name == NULL)
     {
@@ -619,42 +619,42 @@ static PyObject *py_registered_item_get_name(PyObject *self, void *closure)
 *                                                                             *
 ******************************************************************************/
 
-PyTypeObject *get_python_registered_item_type(void)
+PyTypeObject *get_python_scan_registered_item_type(void)
 {
-    static PyMethodDef py_registered_item_methods[] = {
-        REGISTERED_ITEM_RESOLVE_WRAPPER,
-        REGISTERED_ITEM_REDUCE_WRAPPER,
-        REGISTERED_ITEM_CALL_WRAPPER,
-        REGISTERED_ITEM_RESOLVE_METHOD,
+    static PyMethodDef py_scan_registered_item_methods[] = {
+        SCAN_REGISTERED_ITEM_RESOLVE_WRAPPER,
+        SCAN_REGISTERED_ITEM_REDUCE_WRAPPER,
+        SCAN_REGISTERED_ITEM_CALL_WRAPPER,
+        SCAN_REGISTERED_ITEM_RESOLVE_METHOD,
         { NULL }
     };
 
-    static PyGetSetDef py_registered_item_getseters[] = {
-        REGISTERED_ITEM_NAME_ATTRIB_WRAPPER,
-        REGISTERED_ITEM_NAME_ATTRIB,
+    static PyGetSetDef py_scan_registered_item_getseters[] = {
+        SCAN_REGISTERED_ITEM_NAME_ATTRIB_WRAPPER,
+        SCAN_REGISTERED_ITEM_NAME_ATTRIB,
         { NULL }
     };
 
-    static PyTypeObject py_registered_item_type = {
+    static PyTypeObject py_scan_registered_item_type = {
 
         PyVarObject_HEAD_INIT(NULL, 0)
 
-        .tp_name        = "pychrysalide.analysis.scan.RegisteredItem",
+        .tp_name        = "pychrysalide.analysis.scan.ScanRegisteredItem",
         .tp_basicsize   = sizeof(PyGObject),
 
         .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_BASETYPE,
 
-        .tp_doc         = REGISTERED_ITEM_DOC,
+        .tp_doc         = SCAN_REGISTERED_ITEM_DOC,
 
-        .tp_methods     = py_registered_item_methods,
-        .tp_getset      = py_registered_item_getseters,
+        .tp_methods     = py_scan_registered_item_methods,
+        .tp_getset      = py_scan_registered_item_getseters,
 
-        .tp_init        = py_registered_item_init,
-        .tp_new         = py_registered_item_new,
+        .tp_init        = py_scan_registered_item_init,
+        .tp_new         = py_scan_registered_item_new,
 
     };
 
-    return &py_registered_item_type;
+    return &py_scan_registered_item_type;
 
 }
 
@@ -663,7 +663,7 @@ PyTypeObject *get_python_registered_item_type(void)
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Prend en charge l'objet 'pychrysalide...scan.RegisteredItem'.*
+*  Description : Prend en charge l'objet 'pychrysalide...ScanRegisteredItem'. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -671,13 +671,13 @@ PyTypeObject *get_python_registered_item_type(void)
 *                                                                             *
 ******************************************************************************/
 
-bool ensure_python_registered_item_is_registered(void)
+bool ensure_python_scan_registered_item_is_registered(void)
 {
-    PyTypeObject *type;                     /* Type Python 'RegisteredItem' */
+    PyTypeObject *type;                     /* Type 'ScanRegisteredItem'   */
     PyObject *module;                       /* Module à recompléter        */
     PyObject *dict;                         /* Dictionnaire du module      */
 
-    type = get_python_registered_item_type();
+    type = get_python_scan_registered_item_type();
 
     if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
     {
@@ -685,7 +685,7 @@ bool ensure_python_registered_item_is_registered(void)
 
         dict = PyModule_GetDict(module);
 
-        if (!register_class_for_pygobject(dict, G_TYPE_REGISTERED_ITEM, type))
+        if (!register_class_for_pygobject(dict, G_TYPE_SCAN_REGISTERED_ITEM, type))
             return false;
 
     }
@@ -708,11 +708,11 @@ bool ensure_python_registered_item_is_registered(void)
 *                                                                             *
 ******************************************************************************/
 
-int convert_to_registered_item(PyObject *arg, void *dst)
+int convert_to_scan_registered_item(PyObject *arg, void *dst)
 {
     int result;                             /* Bilan à retourner           */
 
-    result = PyObject_IsInstance(arg, (PyObject *)get_python_registered_item_type());
+    result = PyObject_IsInstance(arg, (PyObject *)get_python_scan_registered_item_type());
 
     switch (result)
     {
@@ -726,7 +726,7 @@ int convert_to_registered_item(PyObject *arg, void *dst)
             break;
 
         case 1:
-            *((GRegisteredItem **)dst) = G_REGISTERED_ITEM(pygobject_get(arg));
+            *((GScanRegisteredItem **)dst) = G_SCAN_REGISTERED_ITEM(pygobject_get(arg));
             break;
 
         default:
diff --git a/plugins/pychrysalide/analysis/scan/item.h b/plugins/pychrysalide/analysis/scan/item.h
index b3f1661..773908c 100644
--- a/plugins/pychrysalide/analysis/scan/item.h
+++ b/plugins/pychrysalide/analysis/scan/item.h
@@ -32,13 +32,13 @@
 
 
 /* Fournit un accès à une définition de type à diffuser. */
-PyTypeObject *get_python_registered_item_type(void);
+PyTypeObject *get_python_scan_registered_item_type(void);
 
-/* Prend en charge l'objet 'pychrysalide.analysis.scan.RegisteredItem'. */
-bool ensure_python_registered_item_is_registered(void);
+/* Prend en charge l'objet 'pychrysalide.analysis.scan.ScanRegisteredItem'. */
+bool ensure_python_scan_registered_item_is_registered(void);
 
 /* Tente de convertir en expression d'évaluation généraliste. */
-int convert_to_registered_item(PyObject *, void *);
+int convert_to_scan_registered_item(PyObject *, void *);
 
 
 
diff --git a/plugins/pychrysalide/analysis/scan/module.c b/plugins/pychrysalide/analysis/scan/module.c
index 2c5b1ef..9ae0e52 100644
--- a/plugins/pychrysalide/analysis/scan/module.c
+++ b/plugins/pychrysalide/analysis/scan/module.c
@@ -109,7 +109,7 @@ bool populate_analysis_scan_module(void)
     if (result) result = ensure_python_content_scanner_is_registered();
     if (result) result = ensure_python_scan_context_is_registered();
     if (result) result = ensure_python_scan_expression_is_registered();
-    if (result) result = ensure_python_registered_item_is_registered();
+    if (result) result = ensure_python_scan_registered_item_is_registered();
     if (result) result = ensure_python_scan_options_is_registered();
     if (result) result = ensure_python_scan_namespace_is_registered();
 
diff --git a/plugins/pychrysalide/analysis/scan/space.c b/plugins/pychrysalide/analysis/scan/space.c
index 79e0c28..c901cd9 100644
--- a/plugins/pychrysalide/analysis/scan/space.c
+++ b/plugins/pychrysalide/analysis/scan/space.c
@@ -122,7 +122,7 @@ static int py_scan_namespace_init(PyObject *self, PyObject *args, PyObject *kwds
 static PyObject *py_scan_namespace_register_item(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Bilan à retourner           */
-    GRegisteredItem *item;                  /* Elément d'évaluation à lier */
+    GScanRegisteredItem *item;              /* Elément d'évaluation à lier */
     int ret;                                /* Bilan de lecture des args.  */
     GScanNamespace *space;                  /* Version native              */
     bool status;                            /* Bilan de l'opération        */
@@ -140,7 +140,7 @@ static PyObject *py_scan_namespace_register_item(PyObject *self, PyObject *args)
     " *True* in case of success, *False* for a failure.\n"                      \
 )
 
-    ret = PyArg_ParseTuple(args, "O&", convert_to_registered_item, &item);
+    ret = PyArg_ParseTuple(args, "O&", convert_to_scan_registered_item, &item);
     if (!ret) return NULL;
 
     space = G_SCAN_NAMESPACE(pygobject_get(self));
diff --git a/src/analysis/scan/core.c b/src/analysis/scan/core.c
index 7b11504..461bfdc 100644
--- a/src/analysis/scan/core.c
+++ b/src/analysis/scan/core.c
@@ -238,7 +238,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
 
 #define REGISTER_FUNC(s, f)                                     \
     ({                                                          \
-        GRegisteredItem *__item;                                \
+        GScanRegisteredItem *__item;                            \
         bool __result;                                          \
         __item = f;                                             \
         __result = g_scan_namespace_register_item(s, __item);   \
@@ -272,7 +272,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     if (result)
     {
         ns = g_scan_namespace_new("console");
-        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+        result = g_scan_namespace_register_item(space, G_SCAN_REGISTERED_ITEM(ns));
 
         if (result) result = REGISTER_FUNC(ns, g_scan_console_log_function_new());
 
@@ -286,7 +286,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     if (result)
     {
         ns = g_scan_namespace_new("magic");
-        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+        result = g_scan_namespace_register_item(space, G_SCAN_REGISTERED_ITEM(ns));
 
         if (result) result = REGISTER_FUNC(ns, g_scan_magic_type_function_new());
         if (result) result = REGISTER_FUNC(ns, g_scan_mime_encoding_function_new());
@@ -302,7 +302,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     if (result)
     {
         ns = g_scan_namespace_new("math");
-        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+        result = g_scan_namespace_register_item(space, G_SCAN_REGISTERED_ITEM(ns));
 
         if (result) result = REGISTER_FUNC(ns, g_scan_math_to_string_function_new());
 
@@ -315,7 +315,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     if (result)
     {
         ns = g_scan_namespace_new("string");
-        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+        result = g_scan_namespace_register_item(space, G_SCAN_REGISTERED_ITEM(ns));
 
         if (result) result = REGISTER_FUNC(ns, g_scan_string_lower_function_new());
         if (result) result = REGISTER_FUNC(ns, g_scan_string_to_int_function_new());
@@ -330,7 +330,7 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     if (result)
     {
         ns = g_scan_namespace_new("time");
-        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+        result = g_scan_namespace_register_item(space, G_SCAN_REGISTERED_ITEM(ns));
 
         if (result) result = REGISTER_FUNC(ns, g_scan_time_make_function_new());
         if (result) result = REGISTER_FUNC(ns, g_scan_time_now_function_new());
diff --git a/src/analysis/scan/exprs/access-int.h b/src/analysis/scan/exprs/access-int.h
index 3216493..be37241 100644
--- a/src/analysis/scan/exprs/access-int.h
+++ b/src/analysis/scan/exprs/access-int.h
@@ -42,8 +42,8 @@ struct _GScanNamedAccess
 
     union
     {
-        GRegisteredItem *base;              /* Base de recherche           */
-        GRegisteredItem *resolved;          /* Elément ciblé au final      */
+        GScanRegisteredItem *base;          /* Base de recherche           */
+        GScanRegisteredItem *resolved;      /* Elément ciblé au final      */
         GObject *any;                       /* Accès indistinct            */
     };
 
@@ -67,7 +67,7 @@ struct _GScanNamedAccessClass
 bool g_scan_named_access_create(GScanNamedAccess *, const sized_string_t *);
 
 /* Prépare une réduction en menant une résolution locale. */
-GRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *, GScanContext *, GScanScope *);
+GScanRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *, GScanContext *, GScanScope *);
 
 
 
diff --git a/src/analysis/scan/exprs/access.c b/src/analysis/scan/exprs/access.c
index 0df46e6..a1331b0 100644
--- a/src/analysis/scan/exprs/access.c
+++ b/src/analysis/scan/exprs/access.c
@@ -281,7 +281,7 @@ static void g_scan_named_access_copy(GScanNamedAccess *dest, const GScanNamedAcc
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_scan_named_access_duplicate(const GScanNamedAccess *access, GRegisteredItem *resolved)
+GScanExpression *g_scan_named_access_duplicate(const GScanNamedAccess *access, GScanRegisteredItem *resolved)
 {
     GScanExpression *result;                /* Instance copiée à retourner */
     GType type;                             /* Type d'objet à copier       */
@@ -315,7 +315,7 @@ GScanExpression *g_scan_named_access_duplicate(const GScanNamedAccess *access, G
 *                                                                             *
 ******************************************************************************/
 
-void g_scan_named_access_set_base(GScanNamedAccess *access, GRegisteredItem *base)
+void g_scan_named_access_set_base(GScanNamedAccess *access, GScanRegisteredItem *base)
 {
     g_clear_object(&access->base);
 
@@ -372,10 +372,10 @@ void g_scan_named_access_attach_next(GScanNamedAccess *access, GScanNamedAccess
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *expr, GScanContext *ctx, GScanScope *scope)
+GScanRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *expr, GScanContext *ctx, GScanScope *scope)
 {
-    GRegisteredItem *result;                /* Etat synthétisé à retourner */
-    GRegisteredItem *base;                  /* Base de recherche courante  */
+    GScanRegisteredItem *result;            /* Etat synthétisé à retourner */
+    GScanRegisteredItem *base;              /* Base de recherche courante  */
 
     result = NULL;
 
@@ -387,9 +387,9 @@ GRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *
             g_object_ref(G_OBJECT(base));
         }
         else
-            base = G_REGISTERED_ITEM(get_rost_root_namespace());
+            base = G_SCAN_REGISTERED_ITEM(get_rost_root_namespace());
 
-        g_registered_item_resolve(base, expr->target, ctx, scope, &result);
+        g_scan_registered_item_resolve(base, expr->target, ctx, scope, &result);
 
     }
 
@@ -429,7 +429,7 @@ GRegisteredItem *_g_scan_named_access_prepare_reduction(const GScanNamedAccess *
 static ScanReductionState g_scan_named_access_reduce(const GScanNamedAccess *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
     ScanReductionState result;              /* Etat synthétisé à retourner */
-    GRegisteredItem *resolved;              /* Cible concrète obtenue      */
+    GScanRegisteredItem *resolved;          /* Cible concrète obtenue      */
     GScanExpression *new_next;              /* Nouvelle version du suivant */
     const char *current_rule;               /* Nom de la règle courante    */
     bool status;                            /* Bilan d'une autre règle     */
@@ -448,7 +448,7 @@ static ScanReductionState g_scan_named_access_reduce(const GScanNamedAccess *exp
          */
         if (expr->next == NULL)
         {
-            status = g_registered_item_reduce(resolved, ctx, scope, out);
+            status = g_scan_registered_item_reduce(resolved, ctx, scope, out);
 
             result = (status ? SRS_REDUCED : SRS_UNRESOLVABLE);
 
diff --git a/src/analysis/scan/exprs/access.h b/src/analysis/scan/exprs/access.h
index 7c007a9..bf83dd0 100644
--- a/src/analysis/scan/exprs/access.h
+++ b/src/analysis/scan/exprs/access.h
@@ -53,10 +53,10 @@ GType g_scan_named_access_get_type(void);
 GScanExpression *g_scan_named_access_new(const sized_string_t *);
 
 /* Reproduit un accès en place dans une nouvelle instance. */
-GScanExpression *g_scan_named_access_duplicate(const GScanNamedAccess *, GRegisteredItem *);
+GScanExpression *g_scan_named_access_duplicate(const GScanNamedAccess *, GScanRegisteredItem *);
 
 /* Définit une base de recherche pour la cible d'accès. */
-void g_scan_named_access_set_base(GScanNamedAccess *, GRegisteredItem *);
+void g_scan_named_access_set_base(GScanNamedAccess *, GScanRegisteredItem *);
 
 /* Complète la chaine d'accès à des expressions. */
 void g_scan_named_access_attach_next(GScanNamedAccess *, GScanNamedAccess *);
diff --git a/src/analysis/scan/exprs/call.c b/src/analysis/scan/exprs/call.c
index f68159f..74e0cba 100644
--- a/src/analysis/scan/exprs/call.c
+++ b/src/analysis/scan/exprs/call.c
@@ -264,7 +264,7 @@ static ScanReductionState g_scan_pending_call_reduce(const GScanPendingCall *exp
 {
     ScanReductionState result;              /* Etat synthétisé à retourner */
     GScanNamedAccess *access;               /* Autre vision de l'expression*/
-    GRegisteredItem *resolved;              /* Cible concrète obtenue      */
+    GScanRegisteredItem *resolved;          /* Cible concrète obtenue      */
     size_t i;                               /* Boucle de parcours #1       */
     GScanExpression *arg;                   /* Argument réduit à échanger  */
     GScanExpression *new;                   /* Nouvelle réduction obtenue  */
@@ -358,15 +358,15 @@ static ScanReductionState g_scan_pending_call_reduce(const GScanPendingCall *exp
         else if (result == SRS_PENDING)
         {
             if (new_args == NULL)
-                valid = g_registered_item_run_call(resolved,
-                                                   expr->args,
-                                                   expr->count,
-                                                   ctx, scope, &final);
+                valid = g_scan_registered_item_run_call(resolved,
+                                                        expr->args,
+                                                        expr->count,
+                                                        ctx, scope, &final);
             else
-                valid = g_registered_item_run_call(resolved,
-                                                   new_args,
-                                                   expr->count,
-                                                   ctx, scope, &final);
+                valid = g_scan_registered_item_run_call(resolved,
+                                                        new_args,
+                                                        expr->count,
+                                                        ctx, scope, &final);
 
             if (valid && final != NULL)
             {
@@ -376,7 +376,7 @@ static ScanReductionState g_scan_pending_call_reduce(const GScanPendingCall *exp
                  *
                  * Ce cas de figure ne se rencontre normalement qu'en bout de chaîne.
                  */
-                if (!G_IS_REGISTERED_ITEM(final))
+                if (!G_IS_SCAN_REGISTERED_ITEM(final))
                 {
                     if (access->next != NULL)
                         result = SRS_UNRESOLVABLE;
@@ -395,7 +395,7 @@ static ScanReductionState g_scan_pending_call_reduce(const GScanPendingCall *exp
                 {
                     assert(access->next != NULL);
 
-                    new_next = g_scan_named_access_duplicate(access->next, G_REGISTERED_ITEM(final));
+                    new_next = g_scan_named_access_duplicate(access->next, G_SCAN_REGISTERED_ITEM(final));
 
                     result = g_scan_expression_reduce(new_next, ctx, scope, out);
 
diff --git a/src/analysis/scan/item-int.h b/src/analysis/scan/item-int.h
index 0ec4e46..76431c9 100644
--- a/src/analysis/scan/item-int.h
+++ b/src/analysis/scan/item-int.h
@@ -33,27 +33,27 @@
 
 
 /* Indique le nom associé à une expression d'évaluation. */
-typedef char * (* get_registered_item_name_fc) (const GRegisteredItem *);
+typedef char * (* get_registered_item_name_fc) (const GScanRegisteredItem *);
 
 /* Lance une résolution d'élément à solliciter. */
-typedef bool (* resolve_registered_item_fc) (GRegisteredItem *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
+typedef bool (* resolve_registered_item_fc) (GScanRegisteredItem *, const char *, GScanContext *, GScanScope *, GScanRegisteredItem **);
 
 /* Réduit une expression à une forme plus simple. */
-typedef bool (* reduce_registered_item_fc) (GRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
+typedef bool (* reduce_registered_item_fc) (GScanRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
 
 /* Effectue un appel à une fonction enregistrée. */
-typedef bool (* run_registered_item_call_fc) (GRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+typedef bool (* run_registered_item_call_fc) (GScanRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 /* Expression d'évaluation généraliste (instance) */
-struct _GRegisteredItem
+struct _GScanRegisteredItem
 {
     GObject parent;                         /* A laisser en premier        */
 
 };
 
 /* Expression d'évaluation généraliste (classe) */
-struct _GRegisteredItemClass
+struct _GScanRegisteredItemClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
diff --git a/src/analysis/scan/item.c b/src/analysis/scan/item.c
index d819f59..930a334 100644
--- a/src/analysis/scan/item.c
+++ b/src/analysis/scan/item.c
@@ -35,16 +35,16 @@
 
 
 /* Initialise la classe des éléments appelables enregistrés. */
-static void g_registered_item_class_init(GRegisteredItemClass *);
+static void g_scan_registered_item_class_init(GScanRegisteredItemClass *);
 
 /* Initialise une instance d'élément appelable enregistré. */
-static void g_registered_item_init(GRegisteredItem *);
+static void g_scan_registered_item_init(GScanRegisteredItem *);
 
 /* Supprime toutes les références externes. */
-static void g_registered_item_dispose(GRegisteredItem *);
+static void g_scan_registered_item_dispose(GScanRegisteredItem *);
 
 /* Procède à la libération totale de la mémoire. */
-static void g_registered_item_finalize(GRegisteredItem *);
+static void g_scan_registered_item_finalize(GScanRegisteredItem *);
 
 
 
@@ -54,7 +54,7 @@ static void g_registered_item_finalize(GRegisteredItem *);
 
 
 /* Indique le type défini pour un élément appelable et enregistré. */
-G_DEFINE_TYPE(GRegisteredItem, g_registered_item, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GScanRegisteredItem, g_scan_registered_item, G_TYPE_OBJECT);
 
 
 /******************************************************************************
@@ -69,14 +69,14 @@ G_DEFINE_TYPE(GRegisteredItem, g_registered_item, G_TYPE_OBJECT);
 *                                                                             *
 ******************************************************************************/
 
-static void g_registered_item_class_init(GRegisteredItemClass *klass)
+static void g_scan_registered_item_class_init(GScanRegisteredItemClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
 
     object = G_OBJECT_CLASS(klass);
 
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_registered_item_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_registered_item_finalize;
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_registered_item_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_registered_item_finalize;
 
 }
 
@@ -93,7 +93,7 @@ static void g_registered_item_class_init(GRegisteredItemClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_registered_item_init(GRegisteredItem *item)
+static void g_scan_registered_item_init(GScanRegisteredItem *item)
 {
 
 }
@@ -111,9 +111,9 @@ static void g_registered_item_init(GRegisteredItem *item)
 *                                                                             *
 ******************************************************************************/
 
-static void g_registered_item_dispose(GRegisteredItem *item)
+static void g_scan_registered_item_dispose(GScanRegisteredItem *item)
 {
-    G_OBJECT_CLASS(g_registered_item_parent_class)->dispose(G_OBJECT(item));
+    G_OBJECT_CLASS(g_scan_registered_item_parent_class)->dispose(G_OBJECT(item));
 
 }
 
@@ -130,9 +130,9 @@ static void g_registered_item_dispose(GRegisteredItem *item)
 *                                                                             *
 ******************************************************************************/
 
-static void g_registered_item_finalize(GRegisteredItem *item)
+static void g_scan_registered_item_finalize(GScanRegisteredItem *item)
 {
-    G_OBJECT_CLASS(g_registered_item_parent_class)->finalize(G_OBJECT(item));
+    G_OBJECT_CLASS(g_scan_registered_item_parent_class)->finalize(G_OBJECT(item));
 
 }
 
@@ -149,12 +149,12 @@ static void g_registered_item_finalize(GRegisteredItem *item)
 *                                                                             *
 ******************************************************************************/
 
-char *g_registered_item_get_name(const GRegisteredItem *item)
+char *g_scan_registered_item_get_name(const GScanRegisteredItem *item)
 {
     char *result;                           /* Désignation à retourner     */
-    GRegisteredItemClass *class;            /* Classe à activer            */
+    GScanRegisteredItemClass *class;        /* Classe à activer            */
 
-    class = G_REGISTERED_ITEM_GET_CLASS(item);
+    class = G_SCAN_REGISTERED_ITEM_GET_CLASS(item);
 
     result = class->get_name(item);
 
@@ -179,14 +179,14 @@ char *g_registered_item_get_name(const GRegisteredItem *item)
 *                                                                             *
 ******************************************************************************/
 
-bool g_registered_item_resolve(GRegisteredItem *item, const char *target, GScanContext *ctx, GScanScope *scope, GRegisteredItem **out)
+bool g_scan_registered_item_resolve(GScanRegisteredItem *item, const char *target, GScanContext *ctx, GScanScope *scope, GScanRegisteredItem **out)
 {
     bool result;                            /* Bilan à retourner           */
-    GRegisteredItemClass *class;            /* Classe à activer            */
+    GScanRegisteredItemClass *class;        /* Classe à activer            */
 
     *out = NULL;
 
-    class = G_REGISTERED_ITEM_GET_CLASS(item);
+    class = G_SCAN_REGISTERED_ITEM_GET_CLASS(item);
 
     if (class->resolve == NULL)
         result = false;
@@ -221,14 +221,14 @@ bool g_registered_item_resolve(GRegisteredItem *item, const char *target, GScanC
 *                                                                             *
 ******************************************************************************/
 
-bool g_registered_item_reduce(GRegisteredItem *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+bool g_scan_registered_item_reduce(GScanRegisteredItem *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
     bool result;                            /* Bilan à retourner           */
-    GRegisteredItemClass *class;            /* Classe à activer            */
+    GScanRegisteredItemClass *class;        /* Classe à activer            */
 
     *out = NULL;
 
-    class = G_REGISTERED_ITEM_GET_CLASS(item);
+    class = G_SCAN_REGISTERED_ITEM_GET_CLASS(item);
 
     if (class->reduce == NULL)
         result = false;
@@ -265,14 +265,14 @@ bool g_registered_item_reduce(GRegisteredItem *item, GScanContext *ctx, GScanSco
 *                                                                             *
 ******************************************************************************/
 
-bool g_registered_item_run_call(GRegisteredItem *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+bool g_scan_registered_item_run_call(GScanRegisteredItem *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
 {
     bool result;                            /* Bilan à retourner           */
-    GRegisteredItemClass *class;            /* Classe à activer            */
+    GScanRegisteredItemClass *class;        /* Classe à activer            */
 
     *out = NULL;
 
-    class = G_REGISTERED_ITEM_GET_CLASS(item);
+    class = G_SCAN_REGISTERED_ITEM_GET_CLASS(item);
 
     if (class->run_call == NULL)
         result = false;
diff --git a/src/analysis/scan/item.h b/src/analysis/scan/item.h
index fee1e2c..904064e 100644
--- a/src/analysis/scan/item.h
+++ b/src/analysis/scan/item.h
@@ -34,35 +34,35 @@
 
 
 
-#define G_TYPE_REGISTERED_ITEM            g_registered_item_get_type()
-#define G_REGISTERED_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_REGISTERED_ITEM, GRegisteredItem))
-#define G_IS_REGISTERED_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_REGISTERED_ITEM))
-#define G_REGISTERED_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_REGISTERED_ITEM, GRegisteredItemClass))
-#define G_IS_REGISTERED_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_REGISTERED_ITEM))
-#define G_REGISTERED_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_REGISTERED_ITEM, GRegisteredItemClass))
+#define G_TYPE_SCAN_REGISTERED_ITEM            g_scan_registered_item_get_type()
+#define G_SCAN_REGISTERED_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_REGISTERED_ITEM, GScanRegisteredItem))
+#define G_IS_SCAN_REGISTERED_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_REGISTERED_ITEM))
+#define G_SCAN_REGISTERED_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_REGISTERED_ITEM, GScanRegisteredItemClass))
+#define G_IS_SCAN_REGISTERED_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_REGISTERED_ITEM))
+#define G_SCAN_REGISTERED_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_REGISTERED_ITEM, GScanRegisteredItemClass))
 
 
 /* Expression d'évaluation généraliste (instance) */
-typedef struct _GRegisteredItem GRegisteredItem;
+typedef struct _GScanRegisteredItem GScanRegisteredItem;
 
 /* Expression d'évaluation généraliste (classe) */
-typedef struct _GRegisteredItemClass GRegisteredItemClass;
+typedef struct _GScanRegisteredItemClass GScanRegisteredItemClass;
 
 
 /* Indique le type défini pour un élément appelable et enregistré. */
-GType g_registered_item_get_type(void);
+GType g_scan_registered_item_get_type(void);
 
 /* Indique le nom associé à une expression d'évaluation. */
-char *g_registered_item_get_name(const GRegisteredItem *);
+char *g_scan_registered_item_get_name(const GScanRegisteredItem *);
 
 /* Lance une résolution d'élément à solliciter. */
-bool g_registered_item_resolve(GRegisteredItem *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
+bool g_scan_registered_item_resolve(GScanRegisteredItem *, const char *, GScanContext *, GScanScope *, GScanRegisteredItem **);
 
 /* Réduit une expression à une forme plus simple. */
-bool g_registered_item_reduce(GRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
+bool g_scan_registered_item_reduce(GScanRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
 
 /* Effectue un appel à une fonction enregistrée. */
-bool g_registered_item_run_call(GRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+bool g_scan_registered_item_run_call(GScanRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 
diff --git a/src/analysis/scan/items/console/log.c b/src/analysis/scan/items/console/log.c
index 02b6207..90e8f03 100644
--- a/src/analysis/scan/items/console/log.c
+++ b/src/analysis/scan/items/console/log.c
@@ -66,7 +66,7 @@ static bool g_scan_console_log_function_run_call(GScanConsoleLogFunction *, GSca
 
 
 /* Indique le type défini pour un afficheur de messages arbitraires. */
-G_DEFINE_TYPE(GScanConsoleLogFunction, g_scan_console_log_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanConsoleLogFunction, g_scan_console_log_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanConsoleLogFunction, g_scan_console_log_function, G_TYPE_REGIS
 static void g_scan_console_log_function_class_init(GScanConsoleLogFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_console_log_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_console_log_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_console_log_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_console_log_function_run_call;
diff --git a/src/analysis/scan/items/console/log.h b/src/analysis/scan/items/console/log.h
index 3e72ad8..95fc55f 100644
--- a/src/analysis/scan/items/console/log.h
+++ b/src/analysis/scan/items/console/log.h
@@ -41,10 +41,10 @@
 
 
 /* Mesure de la quantité de données scannées (instance) */
-typedef GRegisteredItem GScanConsoleLogFunction;
+typedef GScanRegisteredItem GScanConsoleLogFunction;
 
 /* Mesure de la quantité de données scannées (classe) */
-typedef GRegisteredItemClass GScanConsoleLogFunctionClass;
+typedef GScanRegisteredItemClass GScanConsoleLogFunctionClass;
 
 
 /* Indique le type défini pour un afficheur de messages arbitraires. */
diff --git a/src/analysis/scan/items/count.c b/src/analysis/scan/items/count.c
index 9040ec4..339c490 100644
--- a/src/analysis/scan/items/count.c
+++ b/src/analysis/scan/items/count.c
@@ -64,7 +64,7 @@ static bool g_scan_count_function_run_call(GScanCountFunction *, GScanExpression
 
 
 /* Indique le type défini pour un décompte d'ensemble. */
-G_DEFINE_TYPE(GScanCountFunction, g_scan_count_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanCountFunction, g_scan_count_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -82,14 +82,14 @@ G_DEFINE_TYPE(GScanCountFunction, g_scan_count_function, G_TYPE_REGISTERED_ITEM)
 static void g_scan_count_function_class_init(GScanCountFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_count_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_count_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_count_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_count_function_run_call;
@@ -165,9 +165,9 @@ static void g_scan_count_function_finalize(GScanCountFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_count_function_new(void)
+GScanRegisteredItem *g_scan_count_function_new(void)
 {
-    GScanCountFunction *result;              /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_COUNT_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/count.h b/src/analysis/scan/items/count.h
index 2429e40..d83714e 100644
--- a/src/analysis/scan/items/count.h
+++ b/src/analysis/scan/items/count.h
@@ -41,17 +41,17 @@
 
 
 /* Mesure de la quantité de données scannées (instance) */
-typedef GRegisteredItem GScanCountFunction;
+typedef GScanRegisteredItem GScanCountFunction;
 
 /* Mesure de la quantité de données scannées (classe) */
-typedef GRegisteredItemClass GScanCountFunctionClass;
+typedef GScanRegisteredItemClass GScanCountFunctionClass;
 
 
 /* Indique le type défini pour un décompte d'ensemble. */
 GType g_scan_count_function_get_type(void);
 
 /* Constitue une fonction de décompte d'éléments d'un ensemble. */
-GRegisteredItem *g_scan_count_function_new(void);
+GScanRegisteredItem *g_scan_count_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/datasize.c b/src/analysis/scan/items/datasize.c
index 55e2d3b..11fe649 100644
--- a/src/analysis/scan/items/datasize.c
+++ b/src/analysis/scan/items/datasize.c
@@ -66,7 +66,7 @@ static bool g_scan_datasize_function_run_call(GScanDatasizeFunction *, GScanExpr
 
 
 /* Indique le type défini pour une mesure de quantité de données scannées. */
-G_DEFINE_TYPE(GScanDatasizeFunction, g_scan_datasize_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanDatasizeFunction, g_scan_datasize_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanDatasizeFunction, g_scan_datasize_function, G_TYPE_REGISTERED
 static void g_scan_datasize_function_class_init(GScanDatasizeFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_datasize_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_datasize_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_datasize_function_get_name;
     registered->reduce = (reduce_registered_item_fc)g_scan_datasize_function_reduce;
@@ -168,9 +168,9 @@ static void g_scan_datasize_function_finalize(GScanDatasizeFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_datasize_function_new(void)
+GScanRegisteredItem *g_scan_datasize_function_new(void)
 {
-    GScanDatasizeFunction *result;              /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_DATASIZE_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/datasize.h b/src/analysis/scan/items/datasize.h
index 476df2d..daa71d1 100644
--- a/src/analysis/scan/items/datasize.h
+++ b/src/analysis/scan/items/datasize.h
@@ -41,17 +41,17 @@
 
 
 /* Mesure de la quantité de données scannées (instance) */
-typedef GRegisteredItem GScanDatasizeFunction;
+typedef GScanRegisteredItem GScanDatasizeFunction;
 
 /* Mesure de la quantité de données scannées (classe) */
-typedef GRegisteredItemClass GScanDatasizeFunctionClass;
+typedef GScanRegisteredItemClass GScanDatasizeFunctionClass;
 
 
 /* Indique le type défini pour une mesure de quantité de données scannées. */
 GType g_scan_datasize_function_get_type(void);
 
 /* Constitue une fonction de récupération de taille de données. */
-GRegisteredItem *g_scan_datasize_function_new(void);
+GScanRegisteredItem *g_scan_datasize_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/magic/mime-encoding.c b/src/analysis/scan/items/magic/mime-encoding.c
index 935515d..aee23ff 100644
--- a/src/analysis/scan/items/magic/mime-encoding.c
+++ b/src/analysis/scan/items/magic/mime-encoding.c
@@ -64,7 +64,7 @@ static bool g_scan_mime_encoding_function_run_call(GScanMimeEncodingFunction *,
 
 
 /* Indique le type défini pour une reconnaissance d'encodages de contenus. */
-G_DEFINE_TYPE(GScanMimeEncodingFunction, g_scan_mime_encoding_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanMimeEncodingFunction, g_scan_mime_encoding_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -82,14 +82,14 @@ G_DEFINE_TYPE(GScanMimeEncodingFunction, g_scan_mime_encoding_function, G_TYPE_R
 static void g_scan_mime_encoding_function_class_init(GScanMimeEncodingFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_mime_encoding_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_mime_encoding_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_mime_encoding_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_mime_encoding_function_run_call;
@@ -165,9 +165,9 @@ static void g_scan_mime_encoding_function_finalize(GScanMimeEncodingFunction *fu
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_mime_encoding_function_new(void)
+GScanRegisteredItem *g_scan_mime_encoding_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_MIME_ENCODING_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/magic/mime-encoding.h b/src/analysis/scan/items/magic/mime-encoding.h
index 9349d55..45ac241 100644
--- a/src/analysis/scan/items/magic/mime-encoding.h
+++ b/src/analysis/scan/items/magic/mime-encoding.h
@@ -41,17 +41,17 @@
 
 
 /* Reconnaissance d'encodages de contenus (instance) */
-typedef GRegisteredItem GScanMimeEncodingFunction;
+typedef GScanRegisteredItem GScanMimeEncodingFunction;
 
 /* Reconnaissance d'encodages de contenus (classe) */
-typedef GRegisteredItemClass GScanMimeEncodingFunctionClass;
+typedef GScanRegisteredItemClass GScanMimeEncodingFunctionClass;
 
 
 /* Indique le type défini pour une reconnaissance d'encodages de contenus. */
 GType g_scan_mime_encoding_function_get_type(void);
 
 /* Constitue une fonction de cernement d'encodages de contenus. */
-GRegisteredItem *g_scan_mime_encoding_function_new(void);
+GScanRegisteredItem *g_scan_mime_encoding_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/magic/mime-type.c b/src/analysis/scan/items/magic/mime-type.c
index 95e441d..0635a33 100644
--- a/src/analysis/scan/items/magic/mime-type.c
+++ b/src/analysis/scan/items/magic/mime-type.c
@@ -64,7 +64,7 @@ static bool g_scan_mime_type_function_run_call(GScanMimeTypeFunction *, GScanExp
 
 
 /* Indique le type défini pour une reconnaissance de types de contenus. */
-G_DEFINE_TYPE(GScanMimeTypeFunction, g_scan_mime_type_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanMimeTypeFunction, g_scan_mime_type_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -82,14 +82,14 @@ G_DEFINE_TYPE(GScanMimeTypeFunction, g_scan_mime_type_function, G_TYPE_REGISTERE
 static void g_scan_mime_type_function_class_init(GScanMimeTypeFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_mime_type_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_mime_type_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_mime_type_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_mime_type_function_run_call;
@@ -165,9 +165,9 @@ static void g_scan_mime_type_function_finalize(GScanMimeTypeFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_mime_type_function_new(void)
+GScanRegisteredItem *g_scan_mime_type_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_MIME_TYPE_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/magic/mime-type.h b/src/analysis/scan/items/magic/mime-type.h
index e02ce0f..f46cd15 100644
--- a/src/analysis/scan/items/magic/mime-type.h
+++ b/src/analysis/scan/items/magic/mime-type.h
@@ -41,17 +41,17 @@
 
 
 /* Reconnaissance de types de contenus (instance) */
-typedef GRegisteredItem GScanMimeTypeFunction;
+typedef GScanRegisteredItem GScanMimeTypeFunction;
 
 /* Reconnaissance de types de contenus (classe) */
-typedef GRegisteredItemClass GScanMimeTypeFunctionClass;
+typedef GScanRegisteredItemClass GScanMimeTypeFunctionClass;
 
 
 /* Indique le type défini pour une reconnaissance de types de contenus. */
 GType g_scan_mime_type_function_get_type(void);
 
 /* Constitue une fonction d'identification de types de contenus. */
-GRegisteredItem *g_scan_mime_type_function_new(void);
+GScanRegisteredItem *g_scan_mime_type_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/magic/type.c b/src/analysis/scan/items/magic/type.c
index f87c34a..43b16ff 100644
--- a/src/analysis/scan/items/magic/type.c
+++ b/src/analysis/scan/items/magic/type.c
@@ -64,7 +64,7 @@ static bool g_scan_magic_type_function_run_call(GScanMagicTypeFunction *, GScanE
 
 
 /* Indique le type défini pour une reconnaissance de types de contenus. */
-G_DEFINE_TYPE(GScanMagicTypeFunction, g_scan_magic_type_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanMagicTypeFunction, g_scan_magic_type_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -82,14 +82,14 @@ G_DEFINE_TYPE(GScanMagicTypeFunction, g_scan_magic_type_function, G_TYPE_REGISTE
 static void g_scan_magic_type_function_class_init(GScanMagicTypeFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_magic_type_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_magic_type_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_magic_type_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_magic_type_function_run_call;
@@ -165,9 +165,9 @@ static void g_scan_magic_type_function_finalize(GScanMagicTypeFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_magic_type_function_new(void)
+GScanRegisteredItem *g_scan_magic_type_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_MAGIC_TYPE_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/magic/type.h b/src/analysis/scan/items/magic/type.h
index bfad213..7a26da3 100644
--- a/src/analysis/scan/items/magic/type.h
+++ b/src/analysis/scan/items/magic/type.h
@@ -41,17 +41,17 @@
 
 
 /* Reconnaissance de types de contenus (instance) */
-typedef GRegisteredItem GScanMagicTypeFunction;
+typedef GScanRegisteredItem GScanMagicTypeFunction;
 
 /* Reconnaissance de types de contenus (classe) */
-typedef GRegisteredItemClass GScanMagicTypeFunctionClass;
+typedef GScanRegisteredItemClass GScanMagicTypeFunctionClass;
 
 
 /* Indique le type défini pour une reconnaissance de types de contenus. */
 GType g_scan_magic_type_function_get_type(void);
 
 /* Constitue une fonction d'identification de types de contenus. */
-GRegisteredItem *g_scan_magic_type_function_new(void);
+GScanRegisteredItem *g_scan_magic_type_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/math/to_string.c b/src/analysis/scan/items/math/to_string.c
index 4bb8363..5debb61 100644
--- a/src/analysis/scan/items/math/to_string.c
+++ b/src/analysis/scan/items/math/to_string.c
@@ -70,7 +70,7 @@ static bool g_scan_math_to_string_function_run_call(GScanMathToStringFunction *,
 
 
 /* Indique le type défini pour une conversion d'entier en texte. */
-G_DEFINE_TYPE(GScanMathToStringFunction, g_scan_math_to_string_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanMathToStringFunction, g_scan_math_to_string_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -88,14 +88,14 @@ G_DEFINE_TYPE(GScanMathToStringFunction, g_scan_math_to_string_function, G_TYPE_
 static void g_scan_math_to_string_function_class_init(GScanMathToStringFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_math_to_string_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_math_to_string_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_math_to_string_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_math_to_string_function_run_call;
@@ -171,9 +171,9 @@ static void g_scan_math_to_string_function_finalize(GScanMathToStringFunction *f
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_math_to_string_function_new(void)
+GScanRegisteredItem *g_scan_math_to_string_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_MATH_TO_STRING_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/math/to_string.h b/src/analysis/scan/items/math/to_string.h
index 19f0020..b9213a9 100644
--- a/src/analysis/scan/items/math/to_string.h
+++ b/src/analysis/scan/items/math/to_string.h
@@ -41,17 +41,17 @@
 
 
 /* Conversion d'une valeur entière en valeur textuelle (instance) */
-typedef GRegisteredItem GScanMathToStringFunction;
+typedef GScanRegisteredItem GScanMathToStringFunction;
 
 /* Conversion d'une valeur entière en valeur textuelle (classe) */
-typedef GRegisteredItemClass GScanMathToStringFunctionClass;
+typedef GScanRegisteredItemClass GScanMathToStringFunctionClass;
 
 
 /* Indique le type défini pour une conversion d'entier en texte. */
 GType g_scan_math_to_string_function_get_type(void);
 
 /* Crée une fonction de conversion de valeur entière en texte. */
-GRegisteredItem *g_scan_math_to_string_function_new(void);
+GScanRegisteredItem *g_scan_math_to_string_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/string/lower.c b/src/analysis/scan/items/string/lower.c
index be8b133..241d87a 100644
--- a/src/analysis/scan/items/string/lower.c
+++ b/src/analysis/scan/items/string/lower.c
@@ -66,7 +66,7 @@ static bool g_scan_string_lower_function_run_call(GScanStringLowerFunction *, GS
 
 
 /* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
-G_DEFINE_TYPE(GScanStringLowerFunction, g_scan_string_lower_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanStringLowerFunction, g_scan_string_lower_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanStringLowerFunction, g_scan_string_lower_function, G_TYPE_REG
 static void g_scan_string_lower_function_class_init(GScanStringLowerFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_lower_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_string_lower_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_string_lower_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_string_lower_function_run_call;
@@ -167,9 +167,9 @@ static void g_scan_string_lower_function_finalize(GScanStringLowerFunction *func
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_string_lower_function_new(void)
+GScanRegisteredItem *g_scan_string_lower_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_STRING_LOWER_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/string/lower.h b/src/analysis/scan/items/string/lower.h
index f844a65..b9eb00a 100644
--- a/src/analysis/scan/items/string/lower.h
+++ b/src/analysis/scan/items/string/lower.h
@@ -41,17 +41,17 @@
 
 
 /* Bascule d'une suite de caractères en minuscules (instance) */
-typedef GRegisteredItem GScanStringLowerFunction;
+typedef GScanRegisteredItem GScanStringLowerFunction;
 
 /* Bascule d'une suite de caractères en minuscules (classe) */
-typedef GRegisteredItemClass GScanStringLowerFunctionClass;
+typedef GScanRegisteredItemClass GScanStringLowerFunctionClass;
 
 
 /* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
 GType g_scan_string_lower_function_get_type(void);
 
 /* Constitue une fonction de bascule de lettres en minuscules. */
-GRegisteredItem *g_scan_string_lower_function_new(void);
+GScanRegisteredItem *g_scan_string_lower_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/string/to_int.c b/src/analysis/scan/items/string/to_int.c
index 8031d4d..150fd06 100644
--- a/src/analysis/scan/items/string/to_int.c
+++ b/src/analysis/scan/items/string/to_int.c
@@ -66,7 +66,7 @@ static bool g_scan_string_to_int_function_run_call(GScanStringToIntFunction *, G
 
 
 /* Indique le type défini pour une conversion de texte en entier. */
-G_DEFINE_TYPE(GScanStringToIntFunction, g_scan_string_to_int_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanStringToIntFunction, g_scan_string_to_int_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanStringToIntFunction, g_scan_string_to_int_function, G_TYPE_RE
 static void g_scan_string_to_int_function_class_init(GScanStringToIntFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_to_int_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_string_to_int_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_string_to_int_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_string_to_int_function_run_call;
@@ -167,9 +167,9 @@ static void g_scan_string_to_int_function_finalize(GScanStringToIntFunction *fun
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_string_to_int_function_new(void)
+GScanRegisteredItem *g_scan_string_to_int_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_STRING_TO_INT_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/string/to_int.h b/src/analysis/scan/items/string/to_int.h
index 143da44..ffd971b 100644
--- a/src/analysis/scan/items/string/to_int.h
+++ b/src/analysis/scan/items/string/to_int.h
@@ -41,17 +41,17 @@
 
 
 /* Conversion d'une valeur textuelle en valeur entière (instance) */
-typedef GRegisteredItem GScanStringToIntFunction;
+typedef GScanRegisteredItem GScanStringToIntFunction;
 
 /* Conversion d'une valeur textuelle en valeur entière (classe) */
-typedef GRegisteredItemClass GScanStringToIntFunctionClass;
+typedef GScanRegisteredItemClass GScanStringToIntFunctionClass;
 
 
 /* Indique le type défini pour une conversion de texte en entier. */
 GType g_scan_string_to_int_function_get_type(void);
 
 /* Crée une fonction de conversion de texte en valeur entière. */
-GRegisteredItem *g_scan_string_to_int_function_new(void);
+GScanRegisteredItem *g_scan_string_to_int_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/string/upper.c b/src/analysis/scan/items/string/upper.c
index 2ddd0dc..d09ae00 100644
--- a/src/analysis/scan/items/string/upper.c
+++ b/src/analysis/scan/items/string/upper.c
@@ -66,7 +66,7 @@ static bool g_scan_string_upper_function_run_call(GScanStringUpperFunction *, GS
 
 
 /* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
-G_DEFINE_TYPE(GScanStringUpperFunction, g_scan_string_upper_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanStringUpperFunction, g_scan_string_upper_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanStringUpperFunction, g_scan_string_upper_function, G_TYPE_REG
 static void g_scan_string_upper_function_class_init(GScanStringUpperFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_upper_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_string_upper_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_string_upper_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_string_upper_function_run_call;
@@ -167,9 +167,9 @@ static void g_scan_string_upper_function_finalize(GScanStringUpperFunction *func
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_string_upper_function_new(void)
+GScanRegisteredItem *g_scan_string_upper_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_STRING_UPPER_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/string/upper.h b/src/analysis/scan/items/string/upper.h
index 4f6e4bc..4fdeb09 100644
--- a/src/analysis/scan/items/string/upper.h
+++ b/src/analysis/scan/items/string/upper.h
@@ -41,17 +41,17 @@
 
 
 /* Bascule d'une suite de caractères en majuscules (instance) */
-typedef GRegisteredItem GScanStringUpperFunction;
+typedef GScanRegisteredItem GScanStringUpperFunction;
 
 /* Bascule d'une suite de caractères en majuscules (classe) */
-typedef GRegisteredItemClass GScanStringUpperFunctionClass;
+typedef GScanRegisteredItemClass GScanStringUpperFunctionClass;
 
 
 /* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
 GType g_scan_string_upper_function_get_type(void);
 
 /* Constitue une fonction de bascule de lettres en majuscules. */
-GRegisteredItem *g_scan_string_upper_function_new(void);
+GScanRegisteredItem *g_scan_string_upper_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/time/make.c b/src/analysis/scan/items/time/make.c
index 477a77c..e7330a3 100644
--- a/src/analysis/scan/items/time/make.c
+++ b/src/analysis/scan/items/time/make.c
@@ -67,7 +67,7 @@ static bool g_scan_time_make_function_run_call(GScanTimeMakeFunction *, GScanExp
 
 
 /* Indique le type défini pour une conversion de date en nombre de secondes. */
-G_DEFINE_TYPE(GScanTimeMakeFunction, g_scan_time_make_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanTimeMakeFunction, g_scan_time_make_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -85,14 +85,14 @@ G_DEFINE_TYPE(GScanTimeMakeFunction, g_scan_time_make_function, G_TYPE_REGISTERE
 static void g_scan_time_make_function_class_init(GScanTimeMakeFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_time_make_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_time_make_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_time_make_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_time_make_function_run_call;
@@ -168,9 +168,9 @@ static void g_scan_time_make_function_finalize(GScanTimeMakeFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_time_make_function_new(void)
+GScanRegisteredItem *g_scan_time_make_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_TIME_MAKE_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/time/make.h b/src/analysis/scan/items/time/make.h
index 958a392..f4be276 100644
--- a/src/analysis/scan/items/time/make.h
+++ b/src/analysis/scan/items/time/make.h
@@ -41,17 +41,17 @@
 
 
 /* Convertisseur de date en nombre de secondes depuis le 01/01/1970 (instance) */
-typedef GRegisteredItem GScanTimeMakeFunction;
+typedef GScanRegisteredItem GScanTimeMakeFunction;
 
 /* Convertisseur de date en nombre de secondes depuis le 01/01/1970 (classe) */
-typedef GRegisteredItemClass GScanTimeMakeFunctionClass;
+typedef GScanRegisteredItemClass GScanTimeMakeFunctionClass;
 
 
 /* Indique le type défini pour une conversion de date en nombre de secondes. */
 GType g_scan_time_make_function_get_type(void);
 
 /* Constitue une fonction de décompte du temps écoulé. */
-GRegisteredItem *g_scan_time_make_function_new(void);
+GScanRegisteredItem *g_scan_time_make_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/time/now.c b/src/analysis/scan/items/time/now.c
index 16c4aef..7f8b627 100644
--- a/src/analysis/scan/items/time/now.c
+++ b/src/analysis/scan/items/time/now.c
@@ -66,7 +66,7 @@ static bool g_scan_time_now_function_run_call(GScanTimeNowFunction *, GScanExpre
 
 
 /* Indique le type défini pour un décompte de secondes écoulées depuis le 01/01/1970. */
-G_DEFINE_TYPE(GScanTimeNowFunction, g_scan_time_now_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanTimeNowFunction, g_scan_time_now_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanTimeNowFunction, g_scan_time_now_function, G_TYPE_REGISTERED_
 static void g_scan_time_now_function_class_init(GScanTimeNowFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_time_now_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_time_now_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_time_now_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_time_now_function_run_call;
@@ -167,9 +167,9 @@ static void g_scan_time_now_function_finalize(GScanTimeNowFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_time_now_function_new(void)
+GScanRegisteredItem *g_scan_time_now_function_new(void)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_TIME_NOW_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/time/now.h b/src/analysis/scan/items/time/now.h
index 6b3faa2..73ed52a 100644
--- a/src/analysis/scan/items/time/now.h
+++ b/src/analysis/scan/items/time/now.h
@@ -41,17 +41,17 @@
 
 
 /* Décompte du nombre de seccondes écoulées depuis le 01/01/1970 (instance) */
-typedef GRegisteredItem GScanTimeNowFunction;
+typedef GScanRegisteredItem GScanTimeNowFunction;
 
 /* Décompte du nombre de seccondes écoulées depuis le 01/01/1970 (classe) */
-typedef GRegisteredItemClass GScanTimeNowFunctionClass;
+typedef GScanRegisteredItemClass GScanTimeNowFunctionClass;
 
 
 /* Indique le type défini pour un décompte de secondes écoulées depuis le 01/01/1970. */
 GType g_scan_time_now_function_get_type(void);
 
 /* Constitue une fonction de décompte du temps écoulé. */
-GRegisteredItem *g_scan_time_now_function_new(void);
+GScanRegisteredItem *g_scan_time_now_function_new(void);
 
 
 
diff --git a/src/analysis/scan/items/uint-int.h b/src/analysis/scan/items/uint-int.h
index 972d7a0..49050e6 100644
--- a/src/analysis/scan/items/uint-int.h
+++ b/src/analysis/scan/items/uint-int.h
@@ -35,7 +35,7 @@
 /* Fonction conduisant à la lecture d'un mot (instance) */
 struct _GScanUintFunction
 {
-    GRegisteredItem parent;                 /* A laisser en premier        */
+    GScanRegisteredItem parent;             /* A laisser en premier        */
 
     MemoryDataSize size;                    /* Taille du mot à lire        */
     SourceEndian endian;                    /* Boutisme à respecter        */
@@ -45,7 +45,7 @@ struct _GScanUintFunction
 /* Fonction conduisant à la lecture d'un mot (classe) */
 struct _GScanUintFunctionClass
 {
-    GRegisteredItemClass parent;            /* A laisser en premier        */
+    GScanRegisteredItemClass parent;        /* A laisser en premier        */
 
 };
 
diff --git a/src/analysis/scan/items/uint.c b/src/analysis/scan/items/uint.c
index 66c7fa9..8060aca 100644
--- a/src/analysis/scan/items/uint.c
+++ b/src/analysis/scan/items/uint.c
@@ -67,7 +67,7 @@ static bool g_scan_uint_function_run_call(GScanUintFunction *, GScanExpression *
 
 
 /* Indique le type défini pour une lecture de mot à partir de données binaires. */
-G_DEFINE_TYPE(GScanUintFunction, g_scan_uint_function, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanUintFunction, g_scan_uint_function, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -85,14 +85,14 @@ G_DEFINE_TYPE(GScanUintFunction, g_scan_uint_function, G_TYPE_REGISTERED_ITEM);
 static void g_scan_uint_function_class_init(GScanUintFunctionClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_uint_function_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_uint_function_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_uint_function_get_name;
     registered->run_call = (run_registered_item_call_fc)g_scan_uint_function_run_call;
@@ -170,9 +170,9 @@ static void g_scan_uint_function_finalize(GScanUintFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_uint_function_new(MemoryDataSize size, SourceEndian endian)
+GScanRegisteredItem *g_scan_uint_function_new(MemoryDataSize size, SourceEndian endian)
 {
-    GRegisteredItem *result;                /* Structure à retourner       */
+    GScanRegisteredItem *result;            /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_UINT_FUNCTION, NULL);
 
diff --git a/src/analysis/scan/items/uint.h b/src/analysis/scan/items/uint.h
index abc2231..d3dd3cb 100644
--- a/src/analysis/scan/items/uint.h
+++ b/src/analysis/scan/items/uint.h
@@ -52,7 +52,7 @@ typedef struct _GScanUintFunctionClass GScanUintFunctionClass;
 GType g_scan_uint_function_get_type(void);
 
 /* Constitue une fonction de lecture de valeur entière. */
-GRegisteredItem *g_scan_uint_function_new(MemoryDataSize, SourceEndian);
+GScanRegisteredItem *g_scan_uint_function_new(MemoryDataSize, SourceEndian);
 
 
 
diff --git a/src/analysis/scan/space-int.h b/src/analysis/scan/space-int.h
index 386785d..34c481c 100644
--- a/src/analysis/scan/space-int.h
+++ b/src/analysis/scan/space-int.h
@@ -35,11 +35,11 @@
 /* Espace de noms pour un groupe de fonctions (instance) */
 struct _GScanNamespace
 {
-    GRegisteredItem parent;                 /* A laisser en premier        */
+    GScanRegisteredItem parent;             /* A laisser en premier        */
 
     char *name;                             /* Désignation de l'espace     */
 
-    GRegisteredItem **children;             /* Sous-éléments inscrits      */
+    GScanRegisteredItem **children;         /* Sous-éléments inscrits      */
     char **names;                           /* Désignations correspondantes*/
     size_t count;                           /* Quantité de sous-éléments   */
 
@@ -48,7 +48,7 @@ struct _GScanNamespace
 /* Espace de noms pour un groupe de fonctions (classe) */
 struct _GScanNamespaceClass
 {
-    GRegisteredItemClass parent;            /* A laisser en premier        */
+    GScanRegisteredItemClass parent;            /* A laisser en premier        */
 
 };
 
diff --git a/src/analysis/scan/space.c b/src/analysis/scan/space.c
index 1e158cf..e4d5049 100644
--- a/src/analysis/scan/space.c
+++ b/src/analysis/scan/space.c
@@ -56,7 +56,7 @@ static void g_scan_namespace_finalize(GScanNamespace *);
 static char *g_scan_namespace_get_name(const GScanNamespace *);
 
 /* Lance une résolution d'élément à solliciter. */
-static bool g_scan_namespace_resolve(GScanNamespace *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
+static bool g_scan_namespace_resolve(GScanNamespace *, const char *, GScanContext *, GScanScope *, GScanRegisteredItem **);
 
 
 
@@ -66,7 +66,7 @@ static bool g_scan_namespace_resolve(GScanNamespace *, const char *, GScanContex
 
 
 /* Indique le type défini pour une définition d'espace de noms. */
-G_DEFINE_TYPE(GScanNamespace, g_scan_namespace, G_TYPE_REGISTERED_ITEM);
+G_DEFINE_TYPE(GScanNamespace, g_scan_namespace, G_TYPE_SCAN_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -84,14 +84,14 @@ G_DEFINE_TYPE(GScanNamespace, g_scan_namespace, G_TYPE_REGISTERED_ITEM);
 static void g_scan_namespace_class_init(GScanNamespaceClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GRegisteredItemClass *registered;       /* Version de classe parente   */
+    GScanRegisteredItemClass *registered;   /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_namespace_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_namespace_finalize;
 
-    registered = G_REGISTERED_ITEM_CLASS(klass);
+    registered = G_SCAN_REGISTERED_ITEM_CLASS(klass);
 
     registered->get_name = (get_registered_item_name_fc)g_scan_namespace_get_name;
     registered->resolve = (resolve_registered_item_fc)g_scan_namespace_resolve;
@@ -245,13 +245,13 @@ bool g_scan_namespace_create(GScanNamespace *space, const char *name)
 *                                                                             *
 ******************************************************************************/
 
-bool g_scan_namespace_register_item(GScanNamespace *space, GRegisteredItem *child)
+bool g_scan_namespace_register_item(GScanNamespace *space, GScanRegisteredItem *child)
 {
     bool result;                            /* Bilan à retourner           */
     char *name;                             /* Nom de l'élément à ajouter  */
     size_t i;                               /* Boucle de parcours          */
 
-    name = g_registered_item_get_name(child);
+    name = g_scan_registered_item_get_name(child);
 
     /* Validation de l'unicité du nom */
 
@@ -270,7 +270,7 @@ bool g_scan_namespace_register_item(GScanNamespace *space, GRegisteredItem *chil
     {
         space->count++;
 
-        space->children = realloc(space->children, space->count * sizeof(GRegisteredItem *));
+        space->children = realloc(space->children, space->count * sizeof(GScanRegisteredItem *));
         space->children[space->count - 1] = child;
         g_object_ref(G_OBJECT(child));
 
@@ -333,7 +333,7 @@ static char *g_scan_namespace_get_name(const GScanNamespace *space)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_namespace_resolve(GScanNamespace *item, const char *target, GScanContext *ctx, GScanScope *scope, GRegisteredItem **out)
+static bool g_scan_namespace_resolve(GScanNamespace *item, const char *target, GScanContext *ctx, GScanScope *scope, GScanRegisteredItem **out)
 {
     bool result;                            /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours          */
diff --git a/src/analysis/scan/space.h b/src/analysis/scan/space.h
index 7a99387..619b960 100644
--- a/src/analysis/scan/space.h
+++ b/src/analysis/scan/space.h
@@ -55,7 +55,7 @@ GType g_scan_namespace_get_type(void);
 GScanNamespace *g_scan_namespace_new(const char *);
 
 /* Intègre un nouvel élément dans l'esapce de noms. */
-bool g_scan_namespace_register_item(GScanNamespace *, GRegisteredItem *);
+bool g_scan_namespace_register_item(GScanNamespace *, GScanRegisteredItem *);