From edb4cc9c11c417d81b1948d93dfd171f0696217a Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Fri, 6 Oct 2023 13:41:46 +0200 Subject: Rename the registered items for ROST to make their name more expressive. --- plugins/pychrysalide/analysis/scan/item.c | 140 +++++++++++++------------- plugins/pychrysalide/analysis/scan/item.h | 8 +- plugins/pychrysalide/analysis/scan/module.c | 2 +- plugins/pychrysalide/analysis/scan/space.c | 4 +- src/analysis/scan/core.c | 12 +-- src/analysis/scan/exprs/access-int.h | 6 +- src/analysis/scan/exprs/access.c | 18 ++-- src/analysis/scan/exprs/access.h | 4 +- src/analysis/scan/exprs/call.c | 22 ++-- src/analysis/scan/item-int.h | 12 +-- src/analysis/scan/item.c | 50 ++++----- src/analysis/scan/item.h | 26 ++--- src/analysis/scan/items/console/log.c | 6 +- src/analysis/scan/items/console/log.h | 4 +- src/analysis/scan/items/count.c | 10 +- src/analysis/scan/items/count.h | 6 +- src/analysis/scan/items/datasize.c | 10 +- src/analysis/scan/items/datasize.h | 6 +- src/analysis/scan/items/magic/mime-encoding.c | 10 +- src/analysis/scan/items/magic/mime-encoding.h | 6 +- src/analysis/scan/items/magic/mime-type.c | 10 +- src/analysis/scan/items/magic/mime-type.h | 6 +- src/analysis/scan/items/magic/type.c | 10 +- src/analysis/scan/items/magic/type.h | 6 +- src/analysis/scan/items/math/to_string.c | 10 +- src/analysis/scan/items/math/to_string.h | 6 +- src/analysis/scan/items/string/lower.c | 10 +- src/analysis/scan/items/string/lower.h | 6 +- src/analysis/scan/items/string/to_int.c | 10 +- src/analysis/scan/items/string/to_int.h | 6 +- src/analysis/scan/items/string/upper.c | 10 +- src/analysis/scan/items/string/upper.h | 6 +- src/analysis/scan/items/time/make.c | 10 +- src/analysis/scan/items/time/make.h | 6 +- src/analysis/scan/items/time/now.c | 10 +- src/analysis/scan/items/time/now.h | 6 +- src/analysis/scan/items/uint-int.h | 4 +- src/analysis/scan/items/uint.c | 10 +- src/analysis/scan/items/uint.h | 2 +- src/analysis/scan/space-int.h | 6 +- src/analysis/scan/space.c | 16 +-- src/analysis/scan/space.h | 2 +- 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 *); -- cgit v0.11.2-87-g4458