Rewrite core parts of the ROST API.

63 files changed, 2030 insertions, 1831 deletions

diff --git a/src/analysis/scan/Makefile.am b/src/analysis/scan/Makefile.am
index bcec986..d4d7aa4 100644
--- a/src/analysis/scan/Makefile.am
+++ b/src/analysis/scan/Makefile.am
@@ -24,8 +24,6 @@ libanalysisscan_la_SOURCES =				\
 	core.h core.c							\
 	expr-int.h								\
 	expr.h expr.c							\
-	func-int.h								\
-	func.h func.c							\
 	item-int.h								\
 	item.h item.c							\
 	match-int.h								\
@@ -45,7 +43,7 @@ libanalysisscan_la_SOURCES =				\
 
 libanalysisscan_la_LIBADD = 				\
 	exprs/libanalysisscanexprs.la			\
-	funcs/libanalysisscanfuncs.la			\
+	items/libanalysisscanitems.la			\
 	matches/libanalysisscanmatches.la		\
 	patterns/libanalysisscanpatterns.la
 
@@ -64,4 +62,4 @@ CLEANFILES = grammar.h grammar.c grammar.output tokens.c tokens.h
 EXTRA_DIST = tokens.h
 
 
-SUBDIRS = exprs funcs matches patterns
+SUBDIRS = exprs items matches patterns
diff --git a/src/analysis/scan/conds/Makefile.am b/src/analysis/scan/conds/Makefile.am
deleted file mode 100644
index 402deac..0000000
--- a/src/analysis/scan/conds/Makefile.am
+++ /dev/null
@@ -1,16 +0,0 @@
-
-noinst_LTLIBRARIES  = libanalysisscanconds.la
-
-
-libanalysisscanconds_la_SOURCES =			\
-	binop-int.h								\
-	binop.h binop.c							\
-	counter-int.h							\
-	counter.h counter.c
-
-libanalysisscanconds_la_CFLAGS = $(LIBGOBJ_CFLAGS)
-
-
-devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
-
-dev_HEADERS = $(libanalysisscanconds_la_SOURCES:%c=)
diff --git a/src/analysis/scan/conds/binop-int.h b/src/analysis/scan/conds/binop-int.h
deleted file mode 100644
index 0fc5940..0000000
--- a/src/analysis/scan/conds/binop-int.h
+++ /dev/null
@@ -1,54 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * binop-int.h - prototypes internes pour les opérations booléennes impliquant deux opérandes
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_CONDS_BINOP_INT_H
-#define _ANALYSIS_SCAN_CONDS_BINOP_INT_H
-
-
-#include "binop.h"
-
-
-#include "../cond-int.h"
-
-
-
-/* Opération booléenne impliquant deux opérandes (instance) */
-struct _GBinaryOperation
-{
-    GMatchCondition parent;                 /* A laisser en premier        */
-
-    GMatchCondition *conds[2];              /* Opérandes à manipuler       */
-    BinOpType type;                         /* Type de manipulation        */
-
-};
-
-/* Opération booléenne impliquant deux opérandes (classe) */
-struct _GBinaryOperationClass
-{
-    GMatchConditionClass parent;            /* A laisser en premier        */
-
-};
-
-
-
-#endif  /* _ANALYSIS_SCAN_CONDS_BINOP_INT_H */
diff --git a/src/analysis/scan/conds/binop.c b/src/analysis/scan/conds/binop.c
deleted file mode 100644
index 01e99d9..0000000
--- a/src/analysis/scan/conds/binop.c
+++ /dev/null
@@ -1,265 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * binop.c - opérations booléennes impliquant deux opérandes
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "binop.h"
-
-
-#include "binop-int.h"
-
-
-
-/* --------------------- INSTANCIATION D'UNE FORME DE CONDITION --------------------- */
-
-
-/* Initialise la classe des opérations booléennes. */
-static void g_binary_operation_class_init(GBinaryOperationClass *);
-
-/* Initialise une instance d'opération booléenne. */
-static void g_binary_operation_init(GBinaryOperation *);
-
-/* Supprime toutes les références externes. */
-static void g_binary_operation_dispose(GBinaryOperation *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_binary_operation_finalize(GBinaryOperation *);
-
-
-
-/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-
-
-/* Indique le statut d'une condition de validation. */
-static bool g_binary_operation_resolve(const GBinaryOperation *);
-
-/* Lance l'analyse de contenu binaire selon un motif donné. */
-static void g_binary_operation_analyze(const GBinaryOperation *, const bin_t *, phys_t, phys_t, bool);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       INSTANCIATION D'UNE FORME DE CONDITION                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour une opération booléenne de validation. */
-G_DEFINE_TYPE(GBinaryOperation, g_binary_operation, G_TYPE_MATCH_CONDITION);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des opérations booléennes.              *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_operation_class_init(GBinaryOperationClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GMatchConditionClass *cond;             /* Classe parente directe      */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_operation_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_binary_operation_finalize;
-
-    cond = G_MATCH_CONDITION_CLASS(klass);
-
-    cond->resolve = (resolve_cond_fc)g_binary_operation_resolve;
-    cond->analyze = (analyze_cond_fc)g_binary_operation_analyze;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance à initialiser.                                 *
-*                                                                             *
-*  Description : Initialise une instance d'opération booléenne.               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_operation_init(GBinaryOperation *op)
-{
-    op->conds[0] = NULL;
-    op->conds[1] = NULL;
-
-    op->type = BOT_AND;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance d'objet GLib à traiter.                        *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_operation_dispose(GBinaryOperation *op)
-{
-    g_clear_object(&op->conds[0]);
-    g_clear_object(&op->conds[1]);
-
-    G_OBJECT_CLASS(g_binary_operation_parent_class)->dispose(G_OBJECT(op));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance d'objet GLib à traiter.                        *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_operation_finalize(GBinaryOperation *op)
-{
-    G_OBJECT_CLASS(g_binary_operation_parent_class)->finalize(G_OBJECT(op));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op1  = premier opérande à intégrer.                          *
-*                op2  = second opérande à intégrer.                           *
-*                type = type d'opération à prendre en compte.                 *
-*                                                                             *
-*  Description : Met en place une représentation d'opération booléenne.       *
-*                                                                             *
-*  Retour      : Condition mise en place.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBinaryOperation *g_binary_operation_new(GMatchCondition *op1, GMatchCondition *op2, BinOpType type)
-{
-    GBinaryOperation *result;                  /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_BINARY_OPERATION, NULL);
-
-    result->conds[0] = op1;
-    g_object_ref(G_OBJECT(op1));
-
-    result->conds[1] = op2;
-    g_object_ref(G_OBJECT(op2));
-
-    result->type = type;
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = condition à consulter.                                  *
-*                                                                             *
-*  Description : Indique le statut d'une condition de validation.             *
-*                                                                             *
-*  Retour      : Validation de la condition considérée.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_binary_operation_resolve(const GBinaryOperation *op)
-{
-    bool result;                            /* Bilan à retourner           */
-
-    result = g_match_condition_resolve(op->conds[0]);
-
-    switch (op->type)
-    {
-        case BOT_AND:
-        default:
-            if (result)
-                result = g_match_condition_resolve(op->conds[1]);
-            break;
-
-        case BOT_OR:
-            if (!result)
-                result = g_match_condition_resolve(op->conds[1]);
-            break;
-
-        case BOT_XOR:
-            result ^= g_match_condition_resolve(op->conds[1]);
-            break;
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op   = condition à considérer.                               *
-*                data = données binaires brutes à considérer.                 *
-*                size = quantité de ces données.                              *
-*                pos  = position du point d'étude courant.                    *
-*                full = force une recherche pleine et entière.                *
-*                                                                             *
-*  Description : Lance l'analyse de contenu binaire selon un motif donné.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_operation_analyze(const GBinaryOperation *op, const bin_t *data, phys_t size, phys_t pos, bool full)
-{
-    g_match_condition_analyze(op->conds[0], data, size, pos, full);
-
-    if (full || !g_binary_operation_resolve(op))
-        g_match_condition_analyze(op->conds[1], data, size, pos, full);
-
-}
diff --git a/src/analysis/scan/conds/binop.h b/src/analysis/scan/conds/binop.h
deleted file mode 100644
index 55cb515..0000000
--- a/src/analysis/scan/conds/binop.h
+++ /dev/null
@@ -1,68 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * binop.h - prototypes pour les opérations booléennes impliquant deux opérandes
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_CONDS_BINOP_H
-#define _ANALYSIS_SCAN_CONDS_BINOP_H
-
-
-#include <glib-object.h>
-
-
-#include "../cond.h"
-
-
-
-#define G_TYPE_BINARY_OPERATION            g_binary_operation_get_type()
-#define G_BINARY_OPERATION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BINARY_OPERATION, GBinaryOperation))
-#define G_IS_BINARY_OPERATION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BINARY_OPERATION))
-#define G_BINARY_OPERATION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_OPERATION, GBinaryOperationClass))
-#define G_IS_BINARY_OPERATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BINARY_OPERATION))
-#define G_BINARY_OPERATION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BINARY_OPERATION, GBinaryOperationClass))
-
-
-/* Opération booléenne impliquant deux opérandes (instance) */
-typedef struct _GBinaryOperation GBinaryOperation;
-
-/* Opération booléenne impliquant deux opérandes (classe) */
-typedef struct _GBinaryOperationClass GBinaryOperationClass;
-
-
-/* Types d'opérations booléennes disponibles */
-typedef enum _BinOpType
-{
-    BOT_AND,
-    BOT_OR,
-    BOT_XOR,
-
-} BinOpType;
-
-
-/* Indique le type défini pour une opération booléenne de validation. */
-GType g_binary_operation_get_type(void);
-
-/* Met en place une représentation d'opération booléenne. */
-GBinaryOperation *g_binary_operation_new(GMatchCondition *, GMatchCondition *, BinOpType);
-
-
-
-#endif  /* _ANALYSIS_SCAN_CONDS_BINOP_H */
diff --git a/src/analysis/scan/conds/counter-int.h b/src/analysis/scan/conds/counter-int.h
deleted file mode 100644
index a706fca..0000000
--- a/src/analysis/scan/conds/counter-int.h
+++ /dev/null
@@ -1,53 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * counter-int.h - prototypes internes pour le décompte de correspondances identifiées dans du contenu binaire
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_CONDS_COUNTER_INT_H
-#define _ANALYSIS_SCAN_CONDS_COUNTER_INT_H
-
-
-#include "counter.h"
-
-
-#include "../cond-int.h"
-
-
-
-/* Décompte des identifications de motifs (instance) */
-struct _GMatchCounter
-{
-    GMatchCondition parent;                 /* A laisser en premier        */
-
-    GSearchPattern *pattern;                /* Motif associé               */
-
-};
-
-/* Décompte des identifications de motifs (classe) */
-struct _GMatchCounterClass
-{
-    GMatchConditionClass parent;            /* A laisser en premier        */
-
-};
-
-
-
-#endif  /* _ANALYSIS_SCAN_CONDS_COUNTER_INT_H */
diff --git a/src/analysis/scan/conds/counter.c b/src/analysis/scan/conds/counter.c
deleted file mode 100644
index 7cf36b8..0000000
--- a/src/analysis/scan/conds/counter.c
+++ /dev/null
@@ -1,232 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * counter.c - décompte de correspondances identifiées dans du contenu binaire
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "counter.h"
-
-
-#include "counter-int.h"
-
-
-
-/* --------------------- INSTANCIATION D'UNE FORME DE CONDITION --------------------- */
-
-
-/* Initialise la classe des opérations booléennes. */
-static void g_match_counter_class_init(GMatchCounterClass *);
-
-/* Initialise une instance d'opération booléenne. */
-static void g_match_counter_init(GMatchCounter *);
-
-/* Supprime toutes les références externes. */
-static void g_match_counter_dispose(GMatchCounter *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_match_counter_finalize(GMatchCounter *);
-
-
-
-/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-
-
-/* Indique le statut d'une condition de validation. */
-static unsigned long long g_match_counter_resolve_as_number(const GMatchCounter *);
-
-/* Lance l'analyse de contenu binaire selon un motif donné. */
-static void g_match_counter_analyze(const GMatchCounter *, const bin_t *, phys_t, phys_t, bool);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       INSTANCIATION D'UNE FORME DE CONDITION                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour un décompte de résultats lors d'une recherche de motifs. */
-G_DEFINE_TYPE(GMatchCounter, g_match_counter, G_TYPE_MATCH_CONDITION);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des opérations booléennes.              *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_match_counter_class_init(GMatchCounterClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GMatchConditionClass *cond;             /* Classe parente directe      */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_match_counter_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_match_counter_finalize;
-
-    cond = G_MATCH_CONDITION_CLASS(klass);
-
-    cond->resolve_as_num = (resolve_cond_as_number_fc)g_match_counter_resolve_as_number;
-    cond->analyze = (analyze_cond_fc)g_match_counter_analyze;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance à initialiser.                                 *
-*                                                                             *
-*  Description : Initialise une instance d'opération booléenne.               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_match_counter_init(GMatchCounter *counter)
-{
-    counter->pattern = NULL;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance d'objet GLib à traiter.                        *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_match_counter_dispose(GMatchCounter *counter)
-{
-    g_clear_object(&counter->pattern);
-
-    G_OBJECT_CLASS(g_match_counter_parent_class)->dispose(G_OBJECT(counter));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = instance d'objet GLib à traiter.                        *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_match_counter_finalize(GMatchCounter *counter)
-{
-    G_OBJECT_CLASS(g_match_counter_parent_class)->finalize(G_OBJECT(counter));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : pattern = motif à impliquer.                                 *
-*                                                                             *
-*  Description : Met en place un décompte de correspondances obtenues.        *
-*                                                                             *
-*  Retour      : Condition mise en place.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GMatchCounter *g_match_counter_new(GSearchPattern *pattern)
-{
-    GMatchCounter *result;                  /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_MATCH_COUNTER, NULL);
-
-    result->pattern = pattern;
-    g_object_ref(G_OBJECT(pattern));
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : op = condition à consulter.                                  *
-*                                                                             *
-*  Description : Indique le statut d'une condition de validation.             *
-*                                                                             *
-*  Retour      : Forme numérique de la condition considérée pour validation.  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static unsigned long long g_match_counter_resolve_as_number(const GMatchCounter *counter)
-{
-    unsigned long long result;              /* Valeur à retourner          */
-
-    result = g_search_pattern_count_matchs(counter->pattern);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : counter = condition à considérer.                            *
-*                data    = données binaires brutes à considérer.              *
-*                size    = quantité de ces données.                           *
-*                pos     = position du point d'étude courant.                 *
-*                full    = force une recherche pleine et entière.             *
-*                                                                             *
-*  Description : Lance l'analyse de contenu binaire selon un motif donné.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_match_counter_analyze(const GMatchCounter *counter, const bin_t *data, phys_t size, phys_t pos, bool full)
-{
-    //g_search_pattern_analyze(counter->pattern, data, size, pos);
-
-}
diff --git a/src/analysis/scan/conds/counter.h b/src/analysis/scan/conds/counter.h
deleted file mode 100644
index 033ac99..0000000
--- a/src/analysis/scan/conds/counter.h
+++ /dev/null
@@ -1,58 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * counter.h - prototypes pour le décompte de correspondances identifiées dans du contenu binaire
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_CONDS_COUNTER_H
-#define _ANALYSIS_SCAN_CONDS_COUNTER_H
-
-
-#include <glib-object.h>
-
-
-#include "../pattern.h"
-
-
-
-#define G_TYPE_MATCH_COUNTER            g_match_counter_get_type()
-#define G_MATCH_COUNTER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_MATCH_COUNTER, GMatchCounter))
-#define G_IS_MATCH_COUNTER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_MATCH_COUNTER))
-#define G_MATCH_COUNTER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_MATCH_COUNTER, GMatchCounterClass))
-#define G_IS_MATCH_COUNTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_MATCH_COUNTER))
-#define G_MATCH_COUNTER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_MATCH_COUNTER, GMatchCounterClass))
-
-
-/* Décompte des identifications de motifs (instance) */
-typedef struct _GMatchCounter GMatchCounter;
-
-/* Décompte des identifications de motifs (classe) */
-typedef struct _GMatchCounterClass GMatchCounterClass;
-
-
-/* Indique le type défini pour un décompte de résultats lors d'une recherche de motifs. */
-GType g_match_counter_get_type(void);
-
-/* Met en place une représentation d'opération booléenne. */
-GMatchCounter *g_match_counter_new(GSearchPattern *);
-
-
-
-#endif  /* _ANALYSIS_SCAN_CONDS_COUNTER_H */
diff --git a/src/analysis/scan/context.c b/src/analysis/scan/context.c
index aec654a..c19b76c 100644
--- a/src/analysis/scan/context.c
+++ b/src/analysis/scan/context.c
@@ -499,7 +499,7 @@ bool g_scan_context_has_match_for_rule(GScanContext *context, const char *name)
 
     cond = NULL;
 
-    for (i = 0; context->cond_count; i++)
+    for (i = 0; i < context->cond_count; i++)
         if (strcmp(name, context->conditions[i].name) == 0)
         {
             cond = &context->conditions[i];
@@ -513,16 +513,14 @@ bool g_scan_context_has_match_for_rule(GScanContext *context, const char *name)
 
     if (!cond->final_reduced)
     {
-        new = g_scan_expression_reduce(cond->expr, context, false);
+        cond->final_reduced = g_scan_expression_reduce(cond->expr, context, NULL, &new);
 
-        if (new != NULL)
+        if (cond->final_reduced && new != NULL)
         {
             g_object_unref(G_OBJECT(cond->expr));
             cond->expr = new;
         }
 
-        cond->final_reduced = true;
-
     }
 
     /* Tentative de récupération d'un bilan final */
diff --git a/src/analysis/scan/core.c b/src/analysis/scan/core.c
index 3b6c2c9..aef9abd 100644
--- a/src/analysis/scan/core.c
+++ b/src/analysis/scan/core.c
@@ -24,8 +24,8 @@
 #include "core.h"
 
 
-#include "funcs/datasize.h"
-#include "funcs/uint.h"
+#include "items/datasize.h"
+#include "items/uint.h"
 
 
 
@@ -47,20 +47,21 @@ bool populate_main_scan_namespace(GScanNamespace *space)
 
     result = true;
 
-#define REGISTER_FUNC(s, f, n)                                              \
+#define REGISTER_FUNC(s, f)                                                 \
     ({                                                                      \
         bool __result;                                                      \
-        __result = g_scan_namespace_register(s, G_REGISTERED_ITEM(f), n);   \
+        __result = g_scan_namespace_register_item(s, G_REGISTERED_ITEM(f)); \
+        g_object_unref(G_OBJECT(f));                                        \
         __result;                                                           \
     })
 
-    if (result) result = REGISTER_FUNC(space, g_datasize_function_new(), "datasize");
-    if (result) result = REGISTER_FUNC(space, g_datasize_function_new(), "filesize"); /* Alias */
+    if (result) result = REGISTER_FUNC(space, g_datasize_function_new());
+    //if (result) result = REGISTER_FUNC(space, g_datasize_function_new(), "filesize"); /* Alias */
 
-    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_8_BITS_UNSIGNED), "uint8");
-    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_16_BITS_UNSIGNED), "uint16");
-    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_32_BITS_UNSIGNED), "uint32");
-    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_64_BITS_UNSIGNED), "uint64");
+    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_8_BITS_UNSIGNED));
+    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_16_BITS_UNSIGNED));
+    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_32_BITS_UNSIGNED));
+    if (result) result = REGISTER_FUNC(space, g_uint_function_new(MDS_64_BITS_UNSIGNED));
 
     return result;
 
diff --git a/src/analysis/scan/expr-int.h b/src/analysis/scan/expr-int.h
index 4323693..dbfea6e 100644
--- a/src/analysis/scan/expr-int.h
+++ b/src/analysis/scan/expr-int.h
@@ -44,8 +44,11 @@ typedef bool (* check_expr_validity_fc) (const GScanExpression *);
 /* Reproduit une expression en place dans une nouvelle instance. */
 typedef GScanExpression * (* dup_expr_fc) (const GScanExpression *);
 
+/* Reproduit une expression en place dans une nouvelle instance. */
+typedef void (* copy_expr_fc) (GScanExpression *, const GScanExpression *);
+
 /* Réduit une expression à une forme plus simple. */
-typedef GScanExpression * (* reduce_expr_fc) (GScanExpression *, GScanContext *, bool);
+typedef bool (* reduce_expr_fc) (GScanExpression *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 /* Expression d'évaluation généraliste (instance) */
@@ -64,6 +67,7 @@ struct _GScanExpressionClass
 
     compare_expr_rich_fc cmp_rich;          /* Comparaison de façon précise*/
     check_expr_validity_fc check;           /* Validation de la cohérence  */
+    copy_expr_fc copy;                      /* Reproduction d'expression   */
     dup_expr_fc dup;                        /* Reproduction d'expression   */
     reduce_expr_fc reduce;                  /* Simplification d'expression */
 
diff --git a/src/analysis/scan/expr.c b/src/analysis/scan/expr.c
index 0b81e01..52d2c42 100644
--- a/src/analysis/scan/expr.c
+++ b/src/analysis/scan/expr.c
@@ -24,6 +24,9 @@
 #include "expr.h"
 
 
+#include <assert.h>
+
+
 #include "expr-int.h"
 
 
@@ -46,6 +49,10 @@ static void g_scan_expression_dispose(GScanExpression *);
 /* Procède à la libération totale de la mémoire. */
 static void g_scan_expression_finalize(GScanExpression *);
 
+/* Reproduit une expression en place dans une nouvelle instance. */
+static void g_scan_expression_copy(GScanExpression *, const GScanExpression *);
+
+
 
 /* ----------------------- INTERFACE OFFRANT DES COMPARAISONS ----------------------- */
 
@@ -86,6 +93,8 @@ static void g_scan_expression_class_init(GScanExpressionClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_expression_dispose;
     object->finalize = (GObjectFinalizeFunc)g_scan_expression_finalize;
 
+    klass->copy = g_scan_expression_copy;
+
 }
 
 
@@ -241,6 +250,26 @@ bool g_scan_expression_check_validity(const GScanExpression *expr)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
+*                                                                             *
+*  Description : Reproduit une expression en place dans une nouvelle instance.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_expression_copy(GScanExpression *dest, const GScanExpression *src)
+{
+    dest->value_type = src->value_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : expr = expression à copier.                                  *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
@@ -254,11 +283,16 @@ bool g_scan_expression_check_validity(const GScanExpression *expr)
 GScanExpression *g_scan_expression_duplicate(const GScanExpression *expr)
 {
     GScanExpression *result;                /* Instance copiée à retourner */
+    GType type;                             /* Type d'objet à copier       */
     GScanExpressionClass *class;            /* Classe à activer            */
 
+    type = G_TYPE_FROM_INSTANCE(expr);
+
+    result = g_object_new(type, NULL);
+
     class = G_SCAN_EXPRESSION_GET_CLASS(expr);
 
-    result = class->dup(expr);
+    class->copy(result, expr);
 
     return result;
 
@@ -269,24 +303,32 @@ GScanExpression *g_scan_expression_duplicate(const GScanExpression *expr)
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_scan_expression_reduce(GScanExpression *expr, GScanContext *ctx, bool final)
+bool g_scan_expression_reduce(GScanExpression *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     GScanExpressionClass *class;            /* Classe à activer            */
 
+    *out = NULL;
+
     class = G_SCAN_EXPRESSION_GET_CLASS(expr);
 
-    result = class->reduce(expr, ctx, final);
+    result = class->reduce(expr, ctx, scope, out);
+
+#ifndef NDEBUG
+    if (*out != NULL)
+        assert(result);
+#endif
 
     return result;
 
diff --git a/src/analysis/scan/expr.h b/src/analysis/scan/expr.h
index 98e7f7d..d596222 100644
--- a/src/analysis/scan/expr.h
+++ b/src/analysis/scan/expr.h
@@ -30,6 +30,7 @@
 
 
 #include "context.h"
+#include "scope.h"
 
 
 
@@ -77,7 +78,7 @@ bool g_scan_expression_check_validity(const GScanExpression *);
 GScanExpression *g_scan_expression_duplicate(const GScanExpression *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_scan_expression_reduce(GScanExpression *, GScanContext *, bool);
+bool g_scan_expression_reduce(GScanExpression *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
diff --git a/src/analysis/scan/exprs/Makefile.am b/src/analysis/scan/exprs/Makefile.am
index f164864..efe25fc 100644
--- a/src/analysis/scan/exprs/Makefile.am
+++ b/src/analysis/scan/exprs/Makefile.am
@@ -3,6 +3,8 @@ noinst_LTLIBRARIES  = libanalysisscanexprs.la
 
 
 libanalysisscanexprs_la_SOURCES =			\
+	access-int.h							\
+	access.h access.c						\
 	arithmop-int.h							\
 	arithmop.h arithmop.c					\
 	boolop-int.h							\
@@ -13,8 +15,8 @@ libanalysisscanexprs_la_SOURCES =			\
 	literal.h literal.c						\
 	relop-int.h								\
 	relop.h relop.c							\
-	str-int.h								\
-	str.h str.c
+	strop-int.h								\
+	strop.h strop.c
 
 libanalysisscanexprs_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS)
 
diff --git a/src/analysis/scan/exprs/access-int.h b/src/analysis/scan/exprs/access-int.h
new file mode 100644
index 0000000..2212b48
--- /dev/null
+++ b/src/analysis/scan/exprs/access-int.h
@@ -0,0 +1,69 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * access-int.h - prototypes internes pour l'accès à un élément d'expression sous-jacent
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_SCAN_EXPRS_ACCESS_INT_H
+#define _ANALYSIS_SCAN_EXPRS_ACCESS_INT_H
+
+
+#include "access.h"
+
+
+#include "../expr-int.h"
+
+
+
+/* Accès à un élément d'expression sous-jacent (instance) */
+struct _GNamedAccess
+{
+    GScanExpression parent;                 /* A laisser en premier        */
+
+    union
+    {
+        GRegisteredItem *base;              /* Base de recherche           */
+        GRegisteredItem *resolved;          /* Elément ciblé au final      */
+        GObject *any;                       /* Accès indistinct            */
+    };
+
+    char *target;                           /* Cible dans l'espace         */
+
+    struct _GNamedAccess *next;            /* Evnetuel prochain élément   */
+
+};
+
+/* Accès à un élément d'expression sous-jacent (classe) */
+struct _GNamedAccessClass
+{
+    GScanExpressionClass parent;            /* A laisser en premier        */
+
+};
+
+
+/* Met en place une expression d'accès. */
+bool g_named_access_create(GNamedAccess *, const sized_string_t *);
+
+/* Réduit une expression à une forme plus simple. */
+bool _g_named_access_reduce(GNamedAccess *, GScanContext *, GScanScope *, GScanExpression **);
+
+
+
+#endif  /* _ANALYSIS_SCAN_EXPRS_ACCESS_INT_H */
diff --git a/src/analysis/scan/exprs/access.c b/src/analysis/scan/exprs/access.c
new file mode 100644
index 0000000..ad66f60
--- /dev/null
+++ b/src/analysis/scan/exprs/access.c
@@ -0,0 +1,471 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * access.c - accès à un élément d'expression sous-jacent
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "access.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include "access-int.h"
+#include "../../../core/global.h"
+
+
+
+/* --------------------- INTRODUCTION D'UNE NOUVELLE EXPRESSION --------------------- */
+
+
+/* Initialise la classe des appels de fonction avec arguments. */
+static void g_named_access_class_init(GNamedAccessClass *);
+
+/* Initialise une instance d'appel de fonction avec arguments. */
+static void g_named_access_init(GNamedAccess *);
+
+/* Supprime toutes les références externes. */
+static void g_named_access_dispose(GNamedAccess *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_named_access_finalize(GNamedAccess *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Reproduit une expression en place dans une nouvelle instance. */
+static void g_named_access_copy(GNamedAccess *, const GNamedAccess *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_named_access_reduce(GNamedAccess *, GScanContext *, GScanScope *, GScanExpression **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       INTRODUCTION D'UNE NOUVELLE EXPRESSION                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un appel de fonction enregistrée. */
+G_DEFINE_TYPE(GNamedAccess, g_named_access, G_TYPE_SCAN_EXPRESSION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des appels de fonction avec arguments.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_named_access_class_init(GNamedAccessClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanExpressionClass *expr;             /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_named_access_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_named_access_finalize;
+
+    expr = G_SCAN_EXPRESSION_CLASS(klass);
+
+    expr->cmp_rich = (compare_expr_rich_fc)NULL;
+    expr->copy = (copy_expr_fc)g_named_access_copy;
+    expr->reduce = (reduce_expr_fc)g_named_access_reduce;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = instance à initialiser.                             *
+*                                                                             *
+*  Description : Initialise une instance d'appel de fonction avec arguments.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_named_access_init(GNamedAccess *access)
+{
+    access->any = NULL;
+    access->target = NULL;
+
+    access->next = NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_named_access_dispose(GNamedAccess *access)
+{
+    g_clear_object(&access->any);
+
+    g_clear_object(&access->next);
+
+    G_OBJECT_CLASS(g_named_access_parent_class)->dispose(G_OBJECT(access));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_named_access_finalize(GNamedAccess *access)
+{
+    if (access->target != NULL)
+        free(access->target);
+
+    G_OBJECT_CLASS(g_named_access_parent_class)->finalize(G_OBJECT(access));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : target = désignation de l'objet d'appel à identifier.        *
+*                                                                             *
+*  Description : Organise un accès à un élément d'expression sous-jacent.     *
+*                                                                             *
+*  Retour      : Fonction mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanExpression *g_named_access_new(const sized_string_t *target)
+{
+    GScanExpression *result;                /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_NAMED_ACCESS, NULL);
+
+    if (!g_named_access_create(G_NAMED_ACCESS(result), target))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = instance à initialiser pleinement.                  *
+*                target = désignation de l'objet d'appel à identifier.        *
+*                                                                             *
+*  Description : Met en place une expression d'accès.                         *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_named_access_create(GNamedAccess *access, const sized_string_t *target)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = g_scan_expression_create(G_SCAN_EXPRESSION(access), EVT_PENDING);
+    if (!result) goto exit;
+
+    access->target = strndup(target->data, target->len);
+
+ exit:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = expression d'appel à actualiser.                    *
+*                base   = zone de recherche pour la résolution à venir.       *
+*                                                                             *
+*  Description : Définit une base de recherche pour la cible d'accès.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_named_access_set_base(GNamedAccess *access, GRegisteredItem *base)
+{
+    g_clear_object(&access->base);
+
+    access->base = base;
+    g_object_ref(G_OBJECT(base));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : access = expression d'appel à compléter.                     *
+*                next   = expression d'appel suivante dans la chaîne.         *
+*                                                                             *
+*  Description : Complète la chaine d'accès à des expressions.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_named_access_attach_next(GNamedAccess *access, GNamedAccess *next)
+{
+    if (access->next != NULL)
+        g_named_access_attach_next(access->next, next);
+
+    else
+    {
+        access->next = next;
+        g_object_ref(G_OBJECT(next));
+    }
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
+*                                                                             *
+*  Description : Reproduit une expression en place dans une nouvelle instance.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_named_access_copy(GNamedAccess *dest, const GNamedAccess *src)
+{
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
+
+    class = G_SCAN_EXPRESSION_CLASS(g_named_access_parent_class);
+
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    if (src->any != NULL)
+    {
+        dest->any = src->any;
+        g_object_ref(src->any);
+    }
+
+    if (src->target != NULL)
+        dest->target = strdup(src->target);
+
+    if (src->next != NULL)
+        dest->next = G_NAMED_ACCESS(g_scan_expression_duplicate(G_SCAN_EXPRESSION(src->next)));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr  = expression à consulter.                              *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
+*                                                                             *
+*  Description : Réduit une expression à une forme plus simple.               *
+*                                                                             *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool _g_named_access_reduce(GNamedAccess *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GRegisteredItem *base;                  /* Base de recherche courante  */
+    GRegisteredItem *resolved;              /* Cible concrète obtenue      */
+    GNamedAccess *new;                      /* Copie mise en place         */
+
+    result = true;
+
+    if (expr->target != NULL)
+    {
+        if (expr->base != NULL)
+        {
+            base = expr->base;
+            g_object_ref(G_OBJECT(base));
+        }
+        else
+            base = G_REGISTERED_ITEM(get_rost_root_namespace());
+
+        result = g_registered_item_resolve(base, expr->target, ctx, scope, &resolved);
+
+        g_object_unref(G_OBJECT(base));
+
+        if (result && resolved != NULL)
+        {
+            new = G_NAMED_ACCESS(g_scan_expression_duplicate(G_SCAN_EXPRESSION(expr)));
+
+            g_clear_object(&new->base);
+
+            free(new->target);
+            new->target = NULL;
+
+            new->resolved = resolved;
+
+            *out = G_SCAN_EXPRESSION(new);
+
+        }
+
+    }
+
+    /**
+     * Si plus aucune indication n'est diponible pour avancer dans les réductions,
+     * c'est que l'opération est déjà conclue.
+     */
+    else
+    {
+        assert(expr->resolved != NULL);
+
+        *out = G_SCAN_EXPRESSION(expr);
+        g_object_ref(G_OBJECT(*out));
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : expr  = expression à consulter.                              *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
+*                                                                             *
+*  Description : Réduit une expression à une forme plus simple.               *
+*                                                                             *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_named_access_reduce(GNamedAccess *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GNamedAccess *new;                      /* Eventuel étage suivant      */
+    GScanExpression *final;                 /* Expression d'évaluation     */
+    GScanExpression *new_next;              /* Nouvelle version du suivant */
+
+    result = _g_named_access_reduce(expr, ctx, scope, out);
+
+    if (result && *out != NULL)
+    {
+        assert(G_IS_NAMED_ACCESS(*out));
+
+        new = G_NAMED_ACCESS(*out);
+        *out = NULL;
+
+        assert(new->target == NULL);
+        assert(G_IS_NAMED_ACCESS(new));
+        assert(G_IS_REGISTERED_ITEM(new->resolved));
+
+        /**
+         * Si l'élément résolu se trouve en fin de chaîne, alors cet élément
+         * est sollicité pour obtenir une expression d'évaluation classique.
+         * Le produit de cette réduction finale bénéficie d'une promotion et
+         * représente à lui seul la réduction produite pour la chaîne.
+         */
+        if (new->next == NULL)
+        {
+            result = g_registered_item_reduce(new->resolved, ctx, scope, &final);
+
+            if (result && final != NULL)
+            {
+                g_clear_object(out);
+                *out = final;
+            }
+
+        }
+
+        /**
+         * Sinon, l'élément résolu constitue une base pour l'étage suivant de
+         * la chaîne de résolution.
+         */
+        else
+        {
+            new_next = g_scan_expression_duplicate(G_SCAN_EXPRESSION(new->next));
+            assert(G_IS_NAMED_ACCESS(new_next));
+
+            g_named_access_set_base(G_NAMED_ACCESS(new_next), new->resolved);
+
+            g_clear_object(out);
+
+            result = g_scan_expression_reduce(new_next, ctx, scope, out);
+
+            if (result && *out == NULL)
+                *out = new_next;
+
+        }
+
+        g_object_unref(G_OBJECT(new));
+
+    }
+
+    return result;
+
+}
diff --git a/src/analysis/scan/exprs/access.h b/src/analysis/scan/exprs/access.h
new file mode 100644
index 0000000..a04adc7
--- /dev/null
+++ b/src/analysis/scan/exprs/access.h
@@ -0,0 +1,63 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * access.h - prototypes pour l'accès à un élément d'expression sous-jacent
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_SCAN_EXPRS_ACCESS_H
+#define _ANALYSIS_SCAN_EXPRS_ACCESS_H
+
+
+#include "../expr.h"
+#include "../item.h"
+#include "../../../common/szstr.h"
+
+
+
+#define G_TYPE_NAMED_ACCESS            g_named_access_get_type()
+#define G_NAMED_ACCESS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_NAMED_ACCESS, GNamedAccess))
+#define G_IS_NAMED_ACCESS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_NAMED_ACCESS))
+#define G_NAMED_ACCESS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_NAMED_ACCESS, GNamedAccessClass))
+#define G_IS_NAMED_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_NAMED_ACCESS))
+#define G_NAMED_ACCESS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_NAMED_ACCESS, GNamedAccessClass))
+
+
+/* Accès à un élément d'expression sous-jacent (instance) */
+typedef struct _GNamedAccess GNamedAccess;
+
+/* Accès à un élément d'expression sous-jacent (classe) */
+typedef struct _GNamedAccessClass GNamedAccessClass;
+
+
+/* Indique le type défini pour un appel de fonction enregistrée. */
+GType g_named_access_get_type(void);
+
+/* Organise un accès à un élément d'expression sous-jacent. */
+GScanExpression *g_named_access_new(const sized_string_t *);
+
+/* Définit une base de recherche pour la cible d'accès. */
+void g_named_access_set_base(GNamedAccess *, GRegisteredItem *);
+
+/* Complète la chaine d'accès à des expressions. */
+void g_named_access_attach_next(GNamedAccess *, GNamedAccess *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_EXPRS_ACCESS_H */
diff --git a/src/analysis/scan/exprs/arithmop-int.h b/src/analysis/scan/exprs/arithmop-int.h
index 75f1dbb..031de84 100644
--- a/src/analysis/scan/exprs/arithmop-int.h
+++ b/src/analysis/scan/exprs/arithmop-int.h
@@ -39,8 +39,8 @@ struct _GArithmOperation
 
     ArithmeticExpressionOperator operator;  /* Type d'opération menée      */
 
-    GScanExpression *first;                 /* Expression impactée #1      */
-    GScanExpression *second;                /* Expression impactée #2      */
+    GScanExpression *left;                  /* Expression impactée #1      */
+    GScanExpression *right;                 /* Expression impactée #2      */
 
 };
 
diff --git a/src/analysis/scan/exprs/arithmop.c b/src/analysis/scan/exprs/arithmop.c
index f57e260..5f9e3f1 100644
--- a/src/analysis/scan/exprs/arithmop.c
+++ b/src/analysis/scan/exprs/arithmop.c
@@ -52,11 +52,11 @@ static void g_arithmetic_operation_finalize(GArithmOperation *);
 /* Réalise une comparaison entre objets selon un critère précis. */
 static bool g_arithmetic_operation_compare_rich(const GArithmOperation *, const GArithmOperation *, RichCmpOperation, bool *);
 
-/* Initialise une instance d'opération de relation. */
-static GScanExpression *g_arithmetic_operation_duplicate(const GArithmOperation *);
+/* Reproduit une expression en place dans une nouvelle instance. */
+static void g_arithmetic_operation_copy(GArithmOperation *, const GArithmOperation *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_arithmetic_operation_reduce(GArithmOperation *, GScanContext *, bool);
+static bool g_arithmetic_operation_reduce(GArithmOperation *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -94,7 +94,7 @@ static void g_arithmetic_operation_class_init(GArithmOperationClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)g_arithmetic_operation_compare_rich;
-    expr->dup = (dup_expr_fc)g_arithmetic_operation_duplicate;
+    expr->copy = (copy_expr_fc)g_arithmetic_operation_copy;
     expr->reduce = (reduce_expr_fc)g_arithmetic_operation_reduce;
 
 }
@@ -114,8 +114,8 @@ static void g_arithmetic_operation_class_init(GArithmOperationClass *klass)
 
 static void g_arithmetic_operation_init(GArithmOperation *op)
 {
-    op->first = NULL;
-    op->second = NULL;
+    op->left = NULL;
+    op->right = NULL;
 
 }
 
@@ -134,8 +134,8 @@ static void g_arithmetic_operation_init(GArithmOperation *op)
 
 static void g_arithmetic_operation_dispose(GArithmOperation *op)
 {
-    g_clear_object(&op->first);
-    g_clear_object(&op->second);
+    g_clear_object(&op->left);
+    g_clear_object(&op->right);
 
     G_OBJECT_CLASS(g_arithmetic_operation_parent_class)->dispose(G_OBJECT(op));
 
@@ -164,8 +164,8 @@ static void g_arithmetic_operation_finalize(GArithmOperation *op)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operator = type d'opération arithmétique à représenter.      *
-*                first    = premier opérande concerné.                        *
-*                second   = éventuel second opérande impliqué ou NULL.        *
+*                left     = premier opérande concerné.                        *
+*                right    = éventuel second opérande impliqué ou NULL.        *
 *                                                                             *
 *  Description : Organise une opération arithmétique entre expressions.       *
 *                                                                             *
@@ -175,13 +175,13 @@ static void g_arithmetic_operation_finalize(GArithmOperation *op)
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_arithmetic_operation_new(ArithmeticExpressionOperator operator, GScanExpression *first, GScanExpression *second)
+GScanExpression *g_arithmetic_operation_new(ArithmeticExpressionOperator operator, GScanExpression *left, GScanExpression *right)
 {
     GScanExpression *result;                /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_ARITHMETIC_OPERATION, NULL);
 
-    if (!g_arithmetic_operation_create(G_ARITHMETIC_OPERATION(result), operator, first, second))
+    if (!g_arithmetic_operation_create(G_ARITHMETIC_OPERATION(result), operator, left, right))
         g_clear_object(&result);
 
     return result;
@@ -193,8 +193,8 @@ GScanExpression *g_arithmetic_operation_new(ArithmeticExpressionOperator operato
 *                                                                             *
 *  Paramètres  : op       = instance à initialiser pleinement.                *
 *                operator = type d'opération booléenne à représenter.         *
-*                first    = premier opérande concerné.                        *
-*                second   = éventuel second opérande impliqué ou NULL.        *
+*                left     = premier opérande concerné.                        *
+*                right    = éventuel second opérande impliqué ou NULL.        *
 *                                                                             *
 *  Description : Met en place une opération arithmétique entre expressions.   *
 *                                                                             *
@@ -204,19 +204,19 @@ GScanExpression *g_arithmetic_operation_new(ArithmeticExpressionOperator operato
 *                                                                             *
 ******************************************************************************/
 
-bool g_arithmetic_operation_create(GArithmOperation *op, ArithmeticExpressionOperator operator, GScanExpression *first, GScanExpression *second)
+bool g_arithmetic_operation_create(GArithmOperation *op, ArithmeticExpressionOperator operator, GScanExpression *left, GScanExpression *right)
 {
     bool result;                            /* Bilan à retourner           */
     ExprValueType vtype;                    /* Type de valeur portée       */
 
     result = false;
 
-    vtype = g_scan_expression_get_value_type(first);
+    vtype = g_scan_expression_get_value_type(left);
 
     if (vtype != EVT_INTEGER && vtype != EVT_PENDING)
         goto exit;
 
-    vtype = g_scan_expression_get_value_type(second);
+    vtype = g_scan_expression_get_value_type(right);
 
     if (vtype != EVT_INTEGER && vtype != EVT_PENDING)
         goto exit;
@@ -226,11 +226,11 @@ bool g_arithmetic_operation_create(GArithmOperation *op, ArithmeticExpressionOpe
 
     op->operator = operator;
 
-    op->first = first;
-    g_object_ref(G_OBJECT(op->first));
+    op->left = left;
+    g_object_ref(G_OBJECT(op->left));
 
-    op->second = second;
-    g_object_ref(G_OBJECT(op->second));
+    op->right = right;
+    g_object_ref(G_OBJECT(op->right));
 
     result = true;
 
@@ -265,9 +265,9 @@ bool g_arithmetic_operation_create(GArithmOperation *op, ArithmeticExpressionOpe
 static bool g_arithmetic_operation_compare_rich(const GArithmOperation *item, const GArithmOperation *other, RichCmpOperation op, bool *status)
 {
     bool result;                            /* Etat à retourner            */
-    bool equal;                             /* Bilan intermédiaire         */
 
-    result = true; // TODO : cmp parent()->type
+    result = g_type_is_a(G_TYPE_FROM_INSTANCE(other), G_TYPE_ARITHMETIC_OPERATION);
+    if (!result) goto done;
 
     if (item->operator != other->operator)
     {
@@ -275,18 +275,16 @@ static bool g_arithmetic_operation_compare_rich(const GArithmOperation *item, co
         goto done;
     }
 
-    equal = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
-    if (!equal)
-    {
-        result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->first),
-                                                G_COMPARABLE_ITEM(other->first),
-                                                op, status);
-        goto done;
-    }
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->left),
+                                            G_COMPARABLE_ITEM(other->left),
+                                            op, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
-    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->second),
-                                            G_COMPARABLE_ITEM(other->second),
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->right),
+                                            G_COMPARABLE_ITEM(other->right),
                                             op, status);
 
  done:
@@ -298,23 +296,29 @@ static bool g_arithmetic_operation_compare_rich(const GArithmOperation *item, co
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : expr = expression à copier.                                  *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_arithmetic_operation_duplicate(const GArithmOperation *expr)
+static void g_arithmetic_operation_copy(GArithmOperation *dest, const GArithmOperation *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
 
-    result = g_arithmetic_operation_new(expr->operator, expr->first, expr->second);
+    class = G_SCAN_EXPRESSION_CLASS(g_arithmetic_operation_parent_class);
 
-    return result;
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    dest->operator = src->operator;
+
+    dest->left = g_scan_expression_duplicate(src->left);
+    dest->right = g_scan_expression_duplicate(src->right);
 
 }
 
@@ -323,92 +327,110 @@ static GScanExpression *g_arithmetic_operation_duplicate(const GArithmOperation
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = impose une conversion finale de dernier tour.        *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_arithmetic_operation_reduce(GArithmOperation *expr, GScanContext *ctx, bool final)
+static bool g_arithmetic_operation_reduce(GArithmOperation *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
-    GScanExpression *new;                   /* Nouvelle expression obtenue */
+    bool result;                            /* Bilan à retourner           */
+    GScanExpression *new_left;              /* Expression réduite (gauche) */
+    GScanExpression *new_right;             /* Expression réduite (droite) */
+    GLiteralExpression *op_left;            /* Opérande gauche final       */
+    GLiteralExpression *op_right;           /* Opérande droite final       */
     unsigned long long val_1;               /* Première valeur à traiter   */
-    unsigned long long val_2;               /* Second valeur à traiter     */
-    bool valid;                             /* Validité de ce bilan obtenu */
+    unsigned long long val_2;               /* Seconde valeur à traiter    */
     unsigned long long reduced;             /* Valeur réduite finale       */
 
-    result = NULL;
-
     /* Réduction des éléments considérés */
 
-    new = g_scan_expression_reduce(expr->first, ctx, final);
-
-    if (new != NULL)
-    {
-        g_object_unref(G_OBJECT(expr->first));
-        expr->first = new;
-    }
+    new_left = NULL;
+    new_right = NULL;
 
-    if (expr->second != NULL)
-    {
-        new = g_scan_expression_reduce(expr->second, ctx, final);
+    result = g_scan_expression_reduce(expr->left, ctx, scope, &new_left);
+    if (!result) goto exit;
 
-        if (new != NULL)
-        {
-            g_object_unref(G_OBJECT(expr->second));
-            expr->second = new;
-        }
-
-    }
+    result = g_scan_expression_reduce(expr->right, ctx, scope, &new_right);
+    if (!result) goto exit;
 
     /* Construction d'une réduction locale ? */
 
-    if (G_IS_LITERAL_EXPRESSION(expr->first) && G_IS_LITERAL_EXPRESSION(expr->second))
+    if (G_IS_LITERAL_EXPRESSION(new_left) && G_IS_LITERAL_EXPRESSION(new_right))
     {
-        valid = g_literal_expression_get_integer_value(G_LITERAL_EXPRESSION(expr->first), &val_1);
+        op_left = G_LITERAL_EXPRESSION(new_left);
+        op_right = G_LITERAL_EXPRESSION(new_right);
 
-        if (valid)
-            valid = g_literal_expression_get_integer_value(G_LITERAL_EXPRESSION(expr->second), &val_2);
+        result = g_literal_expression_get_integer_value(op_left, &val_1);
+        if (!result) goto exit;
 
-        if (valid)
-            switch (expr->operator)
-            {
-                case AEO_PLUS:
-                    reduced = val_1 + val_2;
-                    break;
+        result = g_literal_expression_get_integer_value(op_right, &val_2);
+        if (!result) goto exit;
 
-                case AEO_MINUS:
-                    reduced = val_1 - val_2;
-                    break;
+        switch (expr->operator)
+        {
+            case AEO_PLUS:
+                reduced = val_1 + val_2;
+                break;
+
+            case AEO_MINUS:
+                reduced = val_1 - val_2;
+                break;
+
+            case AEO_MUL:
+                reduced = val_1 * val_2;
+                break;
+
+            case AEO_DIV:
+                result = (val_2 != 0);
+                if (result)
+                    reduced = val_1 / val_2;
+                break;
+
+            case AEO_MOD:
+                result = (val_2 != 0);
+                if (result)
+                    reduced = val_1 % val_2;
+                break;
 
-                case AEO_MUL:
-                    reduced = val_1 * val_2;
-                    break;
+        }
 
-                case AEO_DIV:
-                    valid = (val_2 != 0);
-                    if (valid)
-                        reduced = val_1 / val_2;
-                    break;
+        if (result)
+            *out = g_literal_expression_new(EVT_INTEGER, &reduced);
 
-                case AEO_MOD:
-                    valid = (val_2 != 0);
-                    if (valid)
-                        reduced = val_1 % val_2;
-                    break;
+    }
 
-            }
+    /* Mise à jour de la progression ? */
 
-        if (valid)
-            result = g_literal_expression_new(EVT_INTEGER, &reduced);
+    else if ((new_left != NULL && new_left != expr->left) || (new_right != NULL && new_right != expr->right))
+    {
+        if (new_left == NULL)
+        {
+            new_left = expr->left;
+            g_object_ref(G_OBJECT(new_left));
+        }
+
+        if (new_right == NULL)
+        {
+            new_right = expr->right;
+            g_object_ref(G_OBJECT(new_right));
+        }
+
+        *out = g_arithmetic_operation_new(expr->operator, new_left, new_right);
 
     }
 
+ exit:
+
+    g_clear_object(&new_left);
+    g_clear_object(&new_right);
+
     return result;
 
 }
diff --git a/src/analysis/scan/exprs/boolop.c b/src/analysis/scan/exprs/boolop.c
index 2902fdd..f6a80dd 100644
--- a/src/analysis/scan/exprs/boolop.c
+++ b/src/analysis/scan/exprs/boolop.c
@@ -56,10 +56,10 @@ static void g_boolean_operation_finalize(GBoolOperation *);
 static bool g_boolean_operation_compare_rich(const GBoolOperation *, const GBoolOperation *, RichCmpOperation, bool *);
 
 /* Reproduit une expression en place dans une nouvelle instance. */
-static GScanExpression *g_boolean_operation_duplicate(const GBoolOperation *);
+static void g_boolean_operation_copy(GBoolOperation *, const GBoolOperation *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_boolean_operation_reduce(GBoolOperation *, GScanContext *, bool);
+static bool g_boolean_operation_reduce(GBoolOperation *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -97,7 +97,7 @@ static void g_boolean_operation_class_init(GBoolOperationClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)g_boolean_operation_compare_rich;
-    expr->dup = (dup_expr_fc)g_boolean_operation_duplicate;
+    expr->copy = (copy_expr_fc)g_boolean_operation_copy;
     expr->reduce = (reduce_expr_fc)g_boolean_operation_reduce;
 
 }
@@ -278,9 +278,9 @@ bool g_boolean_operation_create(GBoolOperation *op, BooleanOperationType type, G
 static bool g_boolean_operation_compare_rich(const GBoolOperation *item, const GBoolOperation *other, RichCmpOperation op, bool *status)
 {
     bool result;                            /* Etat à retourner            */
-    bool equal;                             /* Bilan intermédiaire         */
 
-    result = true;
+    result = g_type_is_a(G_TYPE_FROM_INSTANCE(other), G_TYPE_BOOLEAN_OPERATION);
+    if (!result) goto done;
 
     if (item->type != other->type)
     {
@@ -288,15 +288,13 @@ static bool g_boolean_operation_compare_rich(const GBoolOperation *item, const G
         goto done;
     }
 
-    equal = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
-    if (!equal)
-    {
-        *status = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->first),
-                                                 G_COMPARABLE_ITEM(other->first),
-                                                 op, status);
-        goto done;
-    }
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->first),
+                                            G_COMPARABLE_ITEM(other->first),
+                                            op, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
     if (item->second == NULL)
     {
@@ -321,9 +319,9 @@ static bool g_boolean_operation_compare_rich(const GBoolOperation *item, const G
     }
 
     else
-        *status = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->second),
-                                                 G_COMPARABLE_ITEM(other->second),
-                                                 op, status);
+        result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->second),
+                                                G_COMPARABLE_ITEM(other->second),
+                                                op, status);
 
  done:
 
@@ -334,23 +332,31 @@ static bool g_boolean_operation_compare_rich(const GBoolOperation *item, const G
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : expr = expression à copier.                                  *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_boolean_operation_duplicate(const GBoolOperation *expr)
+static void g_boolean_operation_copy(GBoolOperation *dest, const GBoolOperation *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
 
-    result = g_boolean_operation_new(expr->type, expr->first, expr->second);
+    class = G_SCAN_EXPRESSION_CLASS(g_boolean_operation_parent_class);
 
-    return result;
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    dest->type = src->type;
+
+    dest->first = g_scan_expression_duplicate(src->first);
+
+    if (src->second != NULL)
+        dest->second = g_scan_expression_duplicate(src->second);
 
 }
 
@@ -359,92 +365,115 @@ static GScanExpression *g_boolean_operation_duplicate(const GBoolOperation *expr
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = impose une conversion finale de dernier tour.        *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_boolean_operation_reduce(GBoolOperation *expr, GScanContext *ctx, bool final)
+static bool g_boolean_operation_reduce(GBoolOperation *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
-    GScanExpression *new;                   /* Nouvelle expression obtenue */
+    bool result;                            /* Bilan à retourner           */
+    GScanExpression *new_first;             /* Expression réduite (gauche) */
+    GScanExpression *new_second;            /* Expression réduite (droite) */
     bool values[2];                         /* Valeurs des éléments portés */
     bool valid[2];                          /* Validité de ces valeurs     */
 
-    result = NULL;
-
     /* Réduction des éléments considérés */
 
-    new = g_scan_expression_reduce(expr->first, ctx, final);
+    new_first = NULL;
+    new_second = NULL;
+
+    result = g_scan_expression_reduce(expr->first, ctx, scope, &new_first);
+    if (!result) goto exit;
 
-    if (new != NULL)
+    if (expr->second == NULL)
+        new_second = NULL;
+    else
     {
-        g_object_unref(G_OBJECT(expr->first));
-        expr->first = new;
+        result = g_scan_expression_reduce(expr->second, ctx, scope, &new_second);
+        if (!result) goto exit;
     }
 
-    if (expr->second != NULL)
-    {
-        new = g_scan_expression_reduce(expr->second, ctx, final);
+    /* Construction d'une réduction locale ? */
 
-        if (new != NULL)
-        {
-            g_object_unref(G_OBJECT(expr->second));
-            expr->second = new;
-        }
+    valid[0] = G_IS_LITERAL_EXPRESSION(new_first);
 
-    }
+    if (valid[0])
+        valid[0] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(new_first), &values[0]);
 
-    /* Construction d'une réduction locale ? */
+    valid[1] = G_IS_LITERAL_EXPRESSION(new_second);
+
+    if (valid[1])
+        valid[1] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(new_second), &values[1]);
 
     switch (expr->type)
     {
         case BOT_AND:
-            if (G_IS_LITERAL_EXPRESSION(expr->first) && G_IS_LITERAL_EXPRESSION(expr->second))
-            {
-                valid[0] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(expr->first), &values[0]);
-                valid[1] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(expr->second), &values[1]);
+            if (valid[0] && valid[1])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { values[0] && values[1] });
 
-                if (valid[0] && valid[1])
-                    result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { values[0] && values[1] });
+            else if (valid[0] && !values[0])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { false });
 
-                else
-                    /* Etre malin si 0 && x => bilan (si ctx->quick) */
-                    ;
+            else if (valid[1] && !values[1])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { false });
 
-            }
             break;
 
         case BOT_OR:
-            if (G_IS_LITERAL_EXPRESSION(expr->first) && G_IS_LITERAL_EXPRESSION(expr->second))
-            {
-                valid[0] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(expr->first), &values[0]);
-                valid[1] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(expr->second), &values[1]);
+            if (valid[0] && valid[1])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { values[0] || values[1] });
 
-                if (valid[0] && valid[1])
-                    result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { values[0] || values[1] });
+            else if (valid[0] && values[0])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { true });
+
+            else if (valid[1] && values[1])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { true });
 
-            }
             break;
 
         case BOT_NOT:
-            if (G_IS_LITERAL_EXPRESSION(expr->first))
-            {
-                valid[0] = g_literal_expression_get_boolean_value(G_LITERAL_EXPRESSION(expr->first), &values[0]);
+            if (valid[0])
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { !values[0] });
+            break;
 
-                if (valid[0])
-                    result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { !values[1] });
+    }
+
+    /* Mise à jour de la progression ? */
+
+    if (*out == NULL)
+    {
+        if ((new_first != NULL && new_first != expr->first) || (new_second != NULL && new_second != expr->second))
+        {
+            if (new_first == NULL)
+            {
+                new_first = expr->first;
+                g_object_ref(G_OBJECT(new_first));
+            }
 
+            if (new_second == NULL)
+            {
+                new_second = expr->second;
+                g_object_ref(G_OBJECT(new_second));
             }
-            break;
+
+            *out = g_boolean_operation_new(expr->type, new_first, new_second);
+
+        }
 
     }
 
+ exit:
+
+    g_clear_object(&new_first);
+    g_clear_object(&new_second);
+
     return result;
 
 }
diff --git a/src/analysis/scan/exprs/call-int.h b/src/analysis/scan/exprs/call-int.h
index d68977f..631a25b 100644
--- a/src/analysis/scan/exprs/call-int.h
+++ b/src/analysis/scan/exprs/call-int.h
@@ -28,35 +28,30 @@
 #include "call.h"
 
 
-#include "../expr-int.h"
+#include "access-int.h"
 
 
 
 /* Exécution d'une fonction auxiliaire d'analyse (instance) */
 struct _GPendingCall
 {
-    GScanExpression parent;                 /* A laisser en premier        */
-
-    GRegisteredItem *base;                  /* Base de recherche           */
-    char *target;                           /* Cible dans l'espace         */
+    GNamedAccess parent;                    /* A laisser en premier        */
 
     GScanExpression **args;                 /* Arguments d'appel fournis   */
     size_t count;                           /* Quantité de ces arguments   */
 
-    struct _GPendingCall *next;             /* Evnetuel prochain élément   */
-
 };
 
 /* Exécution d'une fonction auxiliaire d'analyse (classe) */
 struct _GPendingCallClass
 {
-    GScanExpressionClass parent;            /* A laisser en premier        */
+    GNamedAccessClass parent;               /* A laisser en premier        */
 
 };
 
 
 /* Met en place une expression d'appel. */
-bool g_pending_call_create(GPendingCall *, const char *, size_t, GScanExpression **, size_t);
+bool g_pending_call_create(GPendingCall *, const sized_string_t *, GScanExpression **, size_t);
 
 
 
diff --git a/src/analysis/scan/exprs/call.c b/src/analysis/scan/exprs/call.c
index 76f5fc3..dde627c 100644
--- a/src/analysis/scan/exprs/call.c
+++ b/src/analysis/scan/exprs/call.c
@@ -24,6 +24,7 @@
 #include "call.h"
 
 
+#include <assert.h>
 #include <malloc.h>
 #include <string.h>
 
@@ -48,19 +49,16 @@ static void g_pending_call_dispose(GPendingCall *);
 /* Procède à la libération totale de la mémoire. */
 static void g_pending_call_finalize(GPendingCall *);
 
-/* Définit une base de recherche pour la cible d'appel. */
-static void g_pending_call_set_base(GPendingCall *, GRegisteredItem *);
-
 
 
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
 /* Reproduit une expression en place dans une nouvelle instance. */
-static GScanExpression *g_pending_call_duplicate(const GPendingCall *);
+static void g_pending_call_copy(GPendingCall *, const GPendingCall *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_pending_call_reduce(GPendingCall *, GScanContext *, bool);
+static bool g_pending_call_reduce(GPendingCall *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -70,7 +68,7 @@ GScanExpression *g_pending_call_reduce(GPendingCall *, GScanContext *, bool);
 
 
 /* Indique le type défini pour un appel de fonction enregistrée. */
-G_DEFINE_TYPE(GPendingCall, g_pending_call, G_TYPE_SCAN_EXPRESSION);
+G_DEFINE_TYPE(GPendingCall, g_pending_call, G_TYPE_NAMED_ACCESS);
 
 
 /******************************************************************************
@@ -98,7 +96,7 @@ static void g_pending_call_class_init(GPendingCallClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)NULL;
-    expr->dup = (dup_expr_fc)g_pending_call_duplicate;
+    expr->copy = (copy_expr_fc)g_pending_call_copy;
     expr->reduce = (reduce_expr_fc)g_pending_call_reduce;
 
 }
@@ -118,14 +116,9 @@ static void g_pending_call_class_init(GPendingCallClass *klass)
 
 static void g_pending_call_init(GPendingCall *call)
 {
-    call->base = NULL;
-    call->target = NULL;
-
     call->args = NULL;
     call->count = 0;
 
-    call->next = NULL;
-
 }
 
 
@@ -145,13 +138,9 @@ static void g_pending_call_dispose(GPendingCall *call)
 {
     size_t i;                               /* Boucle de parcours          */
 
-    g_clear_object(&call->base);
-
     for (i = 0; i < call->count; i++)
         g_clear_object(&call->args[i]);
 
-    g_clear_object(&call->next);
-
     G_OBJECT_CLASS(g_pending_call_parent_class)->dispose(G_OBJECT(call));
 
 }
@@ -171,9 +160,6 @@ static void g_pending_call_dispose(GPendingCall *call)
 
 static void g_pending_call_finalize(GPendingCall *call)
 {
-    if (call->target != NULL)
-        free(call->target);
-
     if (call->args != NULL)
         free(call->args);
 
@@ -185,7 +171,6 @@ static void g_pending_call_finalize(GPendingCall *call)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : target = désignation de l'objet d'appel à identifier.        *
-*                len    = taille de cette désignation.                        *
 *                args   = éventuelle liste d'arguments à actionner.           *
 *                count  = quantité de ces arguments.                          *
 *                                                                             *
@@ -197,13 +182,13 @@ static void g_pending_call_finalize(GPendingCall *call)
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_pending_call_new(const char *target, size_t len, GScanExpression **args, size_t count)
+GScanExpression *g_pending_call_new(const sized_string_t *target, GScanExpression **args, size_t count)
 {
     GScanExpression *result;                /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_PENDING_CALL, NULL);
 
-    if (!g_pending_call_create(G_PENDING_CALL(result), target, len, args, count))
+    if (!g_pending_call_create(G_PENDING_CALL(result), target, args, count))
         g_clear_object(&result);
 
     return result;
@@ -215,7 +200,6 @@ GScanExpression *g_pending_call_new(const char *target, size_t len, GScanExpress
 *                                                                             *
 *  Paramètres  : call   = instance à initialiser pleinement.                  *
 *                target = désignation de l'objet d'appel à identifier.        *
-*                len    = taille de cette désignation.                        *
 *                args   = éventuelle liste d'arguments à actionner.           *
 *                count  = quantité de ces arguments.                          *
 *                                                                             *
@@ -227,16 +211,14 @@ GScanExpression *g_pending_call_new(const char *target, size_t len, GScanExpress
 *                                                                             *
 ******************************************************************************/
 
-bool g_pending_call_create(GPendingCall *call, const char *target, size_t len, GScanExpression **args, size_t count)
+bool g_pending_call_create(GPendingCall *call, const sized_string_t *target, GScanExpression **args, size_t count)
 {
     bool result;                            /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours          */
 
-    result = g_scan_expression_create(G_SCAN_EXPRESSION(call), EVT_PENDING);
+    result = g_named_access_create(G_NAMED_ACCESS(call), target);
     if (!result) goto exit;
 
-    call->target = strndup(target, len);
-
     call->args = malloc(count * sizeof(GScanExpression *));
     call->count = count;
 
@@ -253,48 +235,6 @@ bool g_pending_call_create(GPendingCall *call, const char *target, size_t len, G
 }
 
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : call = expression d'appel à actualiser.                      *
-*                base   = zone de recherche pour la résolution à venir.       *
-*                                                                             *
-*  Description : Définit une base de recherche pour la cible d'appel.         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_pending_call_set_base(GPendingCall *call, GRegisteredItem *base)
-{
-    call->base = base;
-    g_object_ref(G_OBJECT(base));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : call = expression d'appel à compléter.                       *
-*                next = expression d'appel suivante dans la chaîne.           *
-*                                                                             *
-*  Description : Complète la chaine d'expressions d'appel.                    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_pending_call_attach_next(GPendingCall *call, GPendingCall *next)
-{
-    call->next = next;
-    g_object_ref(G_OBJECT(next));
-
-}
-
-
 
 /* ---------------------------------------------------------------------------------- */
 /*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
@@ -303,23 +243,31 @@ void g_pending_call_attach_next(GPendingCall *call, GPendingCall *next)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : expr = expression à copier.                                  *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_pending_call_duplicate(const GPendingCall *expr)
+static void g_pending_call_copy(GPendingCall *dest, const GPendingCall *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
+    size_t i;                               /* Boucle de parcours          */
 
-    result = g_pending_call_new(expr->target, strlen(expr->target), expr->args, expr->count);
+    class = G_SCAN_EXPRESSION_CLASS(g_pending_call_parent_class);
 
-    return result;
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    dest->args = malloc(src->count * sizeof(GScanExpression *));
+    dest->count = src->count;
+
+    for (i = 0; i < src->count; i++)
+        dest->args[i] = g_scan_expression_duplicate(src->args[i]);
 
 }
 
@@ -328,99 +276,100 @@ static GScanExpression *g_pending_call_duplicate(const GPendingCall *expr)
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_pending_call_reduce(GPendingCall *expr, GScanContext *ctx, bool final)
+static bool g_pending_call_reduce(GPendingCall *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
+    GNamedAccess *new;                      /* Eventuel étage suivant      */
+    GPendingCall *new_call;                 /* Version en appel            */
     size_t i;                               /* Boucle de parcours          */
-    GScanExpression *new;                   /* Nouvelle expression obtenue */
-    bool last;                              /* Détection de fin de chaîne  */
-    GRegisteredItem *base;                  /* Base de recherche courante  */
-    GRegisteredItem *rebase;                /* Nouvelle base résolue       */
+    GScanExpression *arg;                   /* Argument réduit à échanger  */
+    GObject *final;                         /* Expression ou élément ?     */
     GScanExpression *new_next;              /* Nouvelle version du suivant */
 
-    for (i = 0; i < expr->count; i++)
+    result = _g_named_access_reduce(G_NAMED_ACCESS(expr), ctx, scope, out);
+
+    if (result && *out != NULL)
     {
-        new = g_scan_expression_reduce(expr->args[i], ctx, final);
+        assert(G_IS_NAMED_ACCESS(*out));
 
-        if (new != NULL)
-        {
-            g_object_unref(G_OBJECT(expr->args[i]));
-            expr->args[i] = new;
-        }
+        new = G_NAMED_ACCESS(*out);
+        *out = NULL;
 
-    }
+        assert(new->target == NULL);
+        assert(G_IS_PENDING_CALL(new));
+        assert(G_IS_REGISTERED_ITEM(new->resolved));
 
-    last = (expr->next == NULL);
+        new_call = G_PENDING_CALL(new);
 
-    if (!last)
-        new_next = g_scan_expression_duplicate(G_SCAN_EXPRESSION(expr->next));
-    else
-        new_next = NULL;
-
-    if (expr->target != NULL)
-    {
-        if (expr->base != NULL)
+        for (i = 0; i < new_call->count; i++)
         {
-            base = expr->base;
-            g_object_ref(G_OBJECT(base));
-        }
-        else
-            base = G_REGISTERED_ITEM(get_rost_root_namespace());
+            result = g_scan_expression_reduce(new_call->args[i], ctx, scope, &arg);
+            if (!result) goto exit;
 
-        rebase = g_registered_item_resolve(base, expr->target, ctx,
-                                           last ? NULL : expr->args, last ? 0 : expr->count,
-                                           last, final);
+            if (arg != NULL)
+            {
+                g_object_unref(G_OBJECT(new_call->args[i]));
+                new_call->args[i] = arg;
+            }
 
-        g_object_unref(G_OBJECT(base));
 
-        if (rebase == NULL)
-        {
-            result = NULL;
-            goto done;
         }
 
-        if (last)
-        {
-            g_pending_call_set_base(expr, rebase);
+        result = g_registered_item_run_call(new->resolved,
+                                            new_call->args,
+                                            new_call->count,
+                                            ctx, scope, &final);
 
-            free(expr->target);
-            expr->target = NULL;
+        if (result && final != NULL)
+        {
+            /**
+             * Si le produit de l'appel à la fonction est une expression d'évaluation
+             * classique, alors ce produit constitue la réduction finale de la chaîne.
+             *
+             * Ce cas de figure ne se rencontre normalement qu'en bout de chaîne.
+             */
+            if (!G_IS_REGISTERED_ITEM(final))
+            {
+                assert(new->next == NULL);
+                *out = G_SCAN_EXPRESSION(final);
+            }
+            else
+            {
+                assert(new->next != NULL);
+
+                new_next = g_scan_expression_duplicate(G_SCAN_EXPRESSION(new->next));
+                assert(G_IS_NAMED_ACCESS(new_next));
+
+                g_named_access_set_base(G_NAMED_ACCESS(new_next), G_REGISTERED_ITEM(final));
+
+                result = g_scan_expression_reduce(new_next, ctx, scope, out);
+
+                if (result && *out == NULL)
+                    *out = new_next;
+                else
+                    g_object_unref(G_OBJECT(new_next));
+
+            }
 
         }
-        else
-            g_pending_call_set_base(G_PENDING_CALL(new_next), rebase);
-
-    }
 
-    if (last)
-        result = g_registered_item_reduce(expr->base, ctx, expr->args, expr->count, final);
+ exit:
 
-    else
-    {
-        result = g_scan_expression_reduce(new_next, ctx, final);
-
-        if (result == NULL)
-        {
-            g_object_ref(G_OBJECT(new_next));
-            result = new_next;
-        }
+        g_object_unref(G_OBJECT(new));
 
     }
 
- done:
-
-    g_clear_object(&new_next);
-
     return result;
 
 }
diff --git a/src/analysis/scan/exprs/call.h b/src/analysis/scan/exprs/call.h
index b69ca85..c344036 100644
--- a/src/analysis/scan/exprs/call.h
+++ b/src/analysis/scan/exprs/call.h
@@ -26,7 +26,7 @@
 
 
 #include "../expr.h"
-#include "../item.h"
+#include "../../../common/szstr.h"
 
 
 
@@ -49,10 +49,7 @@ typedef struct _GPendingCallClass GPendingCallClass;
 GType g_pending_call_get_type(void);
 
 /* Organise un appel de fonction avec ses arguments. */
-GScanExpression *g_pending_call_new(const char *, size_t, GScanExpression **, size_t);
-
-/* Complète la chaine d'expressions d'appel. */
-void g_pending_call_attach_next(GPendingCall *, GPendingCall *);
+GScanExpression *g_pending_call_new(const sized_string_t *, GScanExpression **, size_t);
 
 
 
diff --git a/src/analysis/scan/exprs/literal-int.h b/src/analysis/scan/exprs/literal-int.h
index d803d30..875b3de 100644
--- a/src/analysis/scan/exprs/literal-int.h
+++ b/src/analysis/scan/exprs/literal-int.h
@@ -46,7 +46,7 @@ struct _GLiteralExpression
     {
         bool boolean;                       /* Valeur booléenne            */
         unsigned long long integer;         /* Valeur entière 64 bits      */
-        char *string;                       /* Chaîne de caractères        */
+        sized_string_t string;              /* Chaîne de caractères        */
         struct
         {
             char *regex;                    /* Formulation d'origine       */
diff --git a/src/analysis/scan/exprs/literal.c b/src/analysis/scan/exprs/literal.c
index f40747d..119b871 100644
--- a/src/analysis/scan/exprs/literal.c
+++ b/src/analysis/scan/exprs/literal.c
@@ -57,10 +57,10 @@ static void g_literal_expression_finalize(GLiteralExpression *);
 static bool g_literal_expression_compare_rich(const GLiteralExpression *, const GLiteralExpression *, RichCmpOperation, bool *);
 
 /* Reproduit une expression en place dans une nouvelle instance. */
-static GScanExpression *g_literal_expression_duplicate(const GLiteralExpression *);
+static void g_literal_expression_copy(GLiteralExpression *, const GLiteralExpression *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_literal_expression_reduce(GLiteralExpression *, GScanContext *, bool);
+static bool g_literal_expression_reduce(GLiteralExpression *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -98,7 +98,7 @@ static void g_literal_expression_class_init(GLiteralExpressionClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)g_literal_expression_compare_rich;
-    expr->dup = (dup_expr_fc)g_literal_expression_duplicate;
+    expr->copy = (copy_expr_fc)g_literal_expression_copy;
     expr->reduce = (reduce_expr_fc)g_literal_expression_reduce;
 
 }
@@ -215,7 +215,8 @@ bool g_literal_expression_create(GLiteralExpression *expr, ExprValueType vtype,
     va_list ap;                             /* Liste d'arguements          */
     const bool *boolean;                    /* Valeur booléenne            */
     const unsigned long long *integer;      /* Valeur entière 64 bits      */
-    const char *string;                     /* Chaîne de caractères        */
+    const sized_string_t *string;           /* Chaîne de caractères        */
+    const char *raw;                        /* Chaîne de caractères brute  */
     size_t len;                             /* Taille de la chaîne         */
     int cflags;                             /* Détails de compilation      */
     unsigned int i;                         /* Boucle de parcours          */
@@ -241,15 +242,15 @@ bool g_literal_expression_create(GLiteralExpression *expr, ExprValueType vtype,
                 break;
 
             case EVT_STRING:
-                string = va_arg(ap, const char *);
-                expr->value.string = strdup(string);
+                string = va_arg(ap, const sized_string_t *);
+                szstrdup(&expr->value.string, string);
                 break;
 
             case EVT_REG_EXPR:
-                string = va_arg(ap, const char *);
-                len = strlen(string);
+                raw = va_arg(ap, const char *);
+                len = strlen(raw);
 
-                result = (len > 2 && string[0] == '/');
+                result = (len > 2 && raw[0] == '/');
 
                 cflags = REG_EXTENDED | REG_NOSUB;
 
@@ -257,38 +258,38 @@ bool g_literal_expression_create(GLiteralExpression *expr, ExprValueType vtype,
                 {
                     result = (len > 2);
 
-                    if (string[len - 1] == 'i')
+                    if (raw[len - 1] == 'i')
                     {
                         cflags |= REG_ICASE;
                         len -= 1;
                     }
 
-                    else if (string[len - 1] == 's')
+                    else if (raw[len - 1] == 's')
                     {
                         cflags |= REG_NEWLINE;
                         len -= 1;
                     }
 
-                    else if (string[len - 1] == '/')
+                    else if (raw[len - 1] == '/')
                         break;
 
                 }
 
                 if (result)
-                    result = (string[len - 1] == '/');
+                    result = (raw[len - 1] == '/');
 
                 if (result)
                 {
                     assert(len > 2);
 
-                    tmp = strndup(&string[1], len - 2);
+                    tmp = strndup(&raw[1], len - 2);
                     ret = regcomp(&expr->value.preg, tmp, cflags);
                     free(tmp);
 
                     result = (ret == 0);
 
                     if (result)
-                        expr->value.regex = strdup(string);
+                        expr->value.regex = strdup(raw);
 
                 }
 
@@ -378,14 +379,14 @@ bool g_literal_expression_get_integer_value(const GLiteralExpression *item, unsi
 *                                                                             *
 ******************************************************************************/
 
-bool g_literal_expression_get_string_value(const GLiteralExpression *item, const char **value)
+bool g_literal_expression_get_string_value(const GLiteralExpression *item, const sized_string_t **value)
 {
     bool result;                            /* Etat à retourner            */
 
     result = (item->value_type == EVT_STRING);
 
     if (result)
-        *value = item->value.string;
+        *value = &item->value.string;
 
     return result;
 
@@ -445,10 +446,12 @@ static bool g_literal_expression_compare_rich(const GLiteralExpression *item, co
     bool result;                            /* Etat à retourner            */
     int cmp;                                /* Bilan intermédiaire         */
 
+    result = g_type_is_a(G_TYPE_FROM_INSTANCE(other), G_TYPE_LITERAL_EXPRESSION);
+    if (!result) goto done;
+
     if (item->value_type != other->value_type)
     {
         *status = compare_rich_integer_values(item->value_type, other->value_type, op);
-        result = true;
         goto done;
     }
 
@@ -480,7 +483,7 @@ static bool g_literal_expression_compare_rich(const GLiteralExpression *item, co
             break;
 
         case EVT_STRING:
-            cmp = strcmp(item->value.string, other->value.string);
+            cmp = szstrcmp(&item->value.string, &other->value.string);
             *status = compare_rich_integer_values(cmp, 0, op);
             result = true;
             break;
@@ -506,51 +509,51 @@ static bool g_literal_expression_compare_rich(const GLiteralExpression *item, co
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : expr = expression à copier.                                  *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_literal_expression_duplicate(const GLiteralExpression *expr)
+static void g_literal_expression_copy(GLiteralExpression *dest, const GLiteralExpression *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
-    const void *ptr;                        /* Pointeur vers des données   */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
+
+    class = G_SCAN_EXPRESSION_CLASS(g_literal_expression_parent_class);
+
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
 
-    switch (expr->value_type)
+    dest->value_type = src->value_type;
+
+    switch (src->value_type)
     {
         case EVT_BOOLEAN:
-            ptr = &expr->value.boolean;
+            dest->value.boolean = src->value.boolean;
             break;
 
         case EVT_INTEGER:
-            ptr = &expr->value.integer;
+            dest->value.integer = src->value.integer;
             break;
 
         case EVT_STRING:
-            ptr = &expr->value.string;
+            szstrdup(&dest->value.string, &src->value.string);
             break;
 
         case EVT_REG_EXPR:
-            ptr = &expr->value.regex;
+            /*ptr = &expr->value.regex*//* FIXME */;
             break;
 
         default:
-            ptr = NULL;
+            assert(false);
             break;
 
     }
 
-    assert(ptr != NULL);
-
-    result = g_literal_expression_new(expr->value_type, ptr);
-
-    return result;
-
 }
 
 
@@ -558,47 +561,25 @@ static GScanExpression *g_literal_expression_duplicate(const GLiteralExpression
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                force = impose une conversion en booléen si possible.        *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_literal_expression_reduce(GLiteralExpression *expr, GScanContext *ctx, bool force)
+static bool g_literal_expression_reduce(GLiteralExpression *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
-
-    if (!force)
-        result = NULL;
-
-    else
-        switch (expr->value_type)
-        {
-            case EVT_BOOLEAN:
-                result = NULL;
-                break;
-
-            case EVT_INTEGER:
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { expr->value.integer > 0 });
-                break;
-
-            case EVT_STRING:
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { strlen(expr->value.string) > 0 });
-                break;
-
-            case EVT_REG_EXPR:
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { strlen(expr->value.regex) > 0 });
-                break;
+    bool result;                            /* Bilan à retourner           */
 
-            default:
-                result = NULL;
-                break;
+    result = true;
 
-        }
+    *out = G_SCAN_EXPRESSION(expr);
+    g_object_ref(G_OBJECT(expr));
 
     return result;
 
diff --git a/src/analysis/scan/exprs/literal.h b/src/analysis/scan/exprs/literal.h
index ac5724f..7120c07 100644
--- a/src/analysis/scan/exprs/literal.h
+++ b/src/analysis/scan/exprs/literal.h
@@ -29,6 +29,7 @@
 
 
 #include "../expr.h"
+#include "../../../common/szstr.h"
 
 
 
@@ -60,7 +61,7 @@ bool g_literal_expression_get_boolean_value(const GLiteralExpression *, bool *);
 bool g_literal_expression_get_integer_value(const GLiteralExpression *, unsigned long long *);
 
 /* Indique la valeur portée par une expression de chaîne. */
-bool g_literal_expression_get_string_value(const GLiteralExpression *, const char **);
+bool g_literal_expression_get_string_value(const GLiteralExpression *, const sized_string_t **);
 
 /* Indique la valeur portée par une expression rationnelle. */
 bool g_literal_expression_get_regex_value(const GLiteralExpression *, const regex_t **);
diff --git a/src/analysis/scan/exprs/relop-int.h b/src/analysis/scan/exprs/relop-int.h
index 273b543..3adbcf0 100644
--- a/src/analysis/scan/exprs/relop-int.h
+++ b/src/analysis/scan/exprs/relop-int.h
@@ -39,8 +39,8 @@ struct _GRelOperation
 
     RichCmpOperation rel_type;              /* Type de relation étudiée    */
 
-    GScanExpression *first;                 /* Expression impactée #1      */
-    GScanExpression *second;                /* Expression impactée #2      */
+    GScanExpression *left;                  /* Expression impactée #1      */
+    GScanExpression *right;                 /* Expression impactée #2      */
 
 };
 
diff --git a/src/analysis/scan/exprs/relop.c b/src/analysis/scan/exprs/relop.c
index 94ce77d..7dc6864 100644
--- a/src/analysis/scan/exprs/relop.c
+++ b/src/analysis/scan/exprs/relop.c
@@ -52,11 +52,11 @@ static void g_relational_operation_finalize(GRelOperation *);
 /* Réalise une comparaison entre objets selon un critère précis. */
 static bool g_relational_operation_compare_rich(const GRelOperation *, const GRelOperation *, RichCmpOperation, bool *);
 
-/* Initialise une instance d'opération de relation. */
-static GScanExpression *g_relational_operation_duplicate(const GRelOperation *);
+/* Reproduit une expression en place dans une nouvelle instance. */
+static void g_relational_operation_copy(GRelOperation *, const GRelOperation *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_relational_operation_reduce(GRelOperation *, GScanContext *, bool);
+static bool g_relational_operation_reduce(GRelOperation *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -94,7 +94,7 @@ static void g_relational_operation_class_init(GRelOperationClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)g_relational_operation_compare_rich;
-    expr->dup = (dup_expr_fc)g_relational_operation_duplicate;
+    expr->copy = (copy_expr_fc)g_relational_operation_copy;
     expr->reduce = (reduce_expr_fc)g_relational_operation_reduce;
 
 }
@@ -114,8 +114,8 @@ static void g_relational_operation_class_init(GRelOperationClass *klass)
 
 static void g_relational_operation_init(GRelOperation *op)
 {
-    op->first = NULL;
-    op->second = NULL;
+    op->left = NULL;
+    op->right = NULL;
 
 }
 
@@ -134,8 +134,8 @@ static void g_relational_operation_init(GRelOperation *op)
 
 static void g_relational_operation_dispose(GRelOperation *op)
 {
-    g_clear_object(&op->first);
-    g_clear_object(&op->second);
+    g_clear_object(&op->left);
+    g_clear_object(&op->right);
 
     G_OBJECT_CLASS(g_relational_operation_parent_class)->dispose(G_OBJECT(op));
 
@@ -163,9 +163,9 @@ static void g_relational_operation_finalize(GRelOperation *op)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type   = type d'opération booléenne à représenter.           *
-*                first  = premier opérande concerné.                          *
-*                second = éventuel second opérande impliqué ou NULL.          *
+*  Paramètres  : type  = type d'opération booléenne à représenter.            *
+*                left  = premier opérande concerné.                           *
+*                right = éventuel second opérande impliqué ou NULL.           *
 *                                                                             *
 *  Description : Organise une opération relationnelle entre expressions.      *
 *                                                                             *
@@ -175,13 +175,13 @@ static void g_relational_operation_finalize(GRelOperation *op)
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_relational_operation_new(RichCmpOperation type, GScanExpression *first, GScanExpression *second)
+GScanExpression *g_relational_operation_new(RichCmpOperation type, GScanExpression *left, GScanExpression *right)
 {
     GScanExpression *result;                /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_RELATIONAL_OPERATION, NULL);
 
-    if (!g_relational_operation_create(G_RELATIONAL_OPERATION(result), type, first, second))
+    if (!g_relational_operation_create(G_RELATIONAL_OPERATION(result), type, left, right))
         g_clear_object(&result);
 
     return result;
@@ -191,10 +191,10 @@ GScanExpression *g_relational_operation_new(RichCmpOperation type, GScanExpressi
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : op     = instance à initialiser pleinement.                  *
-*                type   = type d'opération booléenne à représenter.           *
-*                first  = premier opérande concerné.                          *
-*                second = éventuel second opérande impliqué ou NULL.          *
+*  Paramètres  : op    = instance à initialiser pleinement.                   *
+*                type  = type d'opération booléenne à représenter.            *
+*                left  = premier opérande concerné.                           *
+*                right = éventuel second opérande impliqué ou NULL.           *
 *                                                                             *
 *  Description : Met en place une opération relationnelle entre expressions.  *
 *                                                                             *
@@ -204,13 +204,13 @@ GScanExpression *g_relational_operation_new(RichCmpOperation type, GScanExpressi
 *                                                                             *
 ******************************************************************************/
 
-bool g_relational_operation_create(GRelOperation *op, RichCmpOperation type, GScanExpression *first, GScanExpression *second)
+bool g_relational_operation_create(GRelOperation *op, RichCmpOperation type, GScanExpression *left, GScanExpression *right)
 {
     bool result;                            /* Bilan à retourner           */
 
     result = false;
 
-    if (g_scan_expression_get_value_type(first) != g_scan_expression_get_value_type(first))
+    if (g_scan_expression_get_value_type(left) != g_scan_expression_get_value_type(left))
         goto exit;
 
     if (!g_scan_expression_create(G_SCAN_EXPRESSION(op), EVT_BOOLEAN))
@@ -218,11 +218,11 @@ bool g_relational_operation_create(GRelOperation *op, RichCmpOperation type, GSc
 
     op->rel_type = type;
 
-    op->first = first;
-    g_object_ref(G_OBJECT(op->first));
+    op->left = left;
+    g_object_ref(G_OBJECT(op->left));
 
-    op->second = second;
-    g_object_ref(G_OBJECT(op->second));
+    op->right = right;
+    g_object_ref(G_OBJECT(op->right));
 
     result = true;
 
@@ -257,28 +257,26 @@ bool g_relational_operation_create(GRelOperation *op, RichCmpOperation type, GSc
 static bool g_relational_operation_compare_rich(const GRelOperation *item, const GRelOperation *other, RichCmpOperation op, bool *status)
 {
     bool result;                            /* Etat à retourner            */
-    bool equal;                             /* Bilan intermédiaire         */
 
-    result = true; // TODO : cmp parent()->type
+    result = g_type_is_a(G_TYPE_FROM_INSTANCE(other), G_TYPE_RELATIONAL_OPERATION);
+    if (!result) goto done;
 
     if (item->rel_type != other->rel_type)
     {
-        result = compare_rich_integer_values(item->rel_type, other->rel_type, op);
+        *status = compare_rich_integer_values(item->rel_type, other->rel_type, op);
         goto done;
     }
 
-    equal = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item), G_COMPARABLE_ITEM(other), RCO_EQ, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
-    if (!equal)
-    {
-        result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->first),
-                                                G_COMPARABLE_ITEM(other->first),
-                                                op, status);
-        goto done;
-    }
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->left),
+                                            G_COMPARABLE_ITEM(other->left),
+                                            op, status);
+    if (!result || STATUS_NOT_EQUAL(*status, op)) goto done;
 
-    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->second),
-                                            G_COMPARABLE_ITEM(other->second),
+    result = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(item->right),
+                                            G_COMPARABLE_ITEM(other->right),
                                             op, status);
 
  done:
@@ -290,23 +288,29 @@ static bool g_relational_operation_compare_rich(const GRelOperation *item, const
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : expr = expression à copier.                                  *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_relational_operation_duplicate(const GRelOperation *expr)
+static void g_relational_operation_copy(GRelOperation *dest, const GRelOperation *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
 
-    result = g_relational_operation_new(expr->rel_type, expr->first, expr->second);
+    class = G_SCAN_EXPRESSION_CLASS(g_relational_operation_parent_class);
 
-    return result;
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    dest->rel_type = src->rel_type;
+
+    dest->left = g_scan_expression_duplicate(src->left);
+    dest->right = g_scan_expression_duplicate(src->right);
 
 }
 
@@ -315,60 +319,74 @@ static GScanExpression *g_relational_operation_duplicate(const GRelOperation *ex
 *                                                                             *
 *  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = impose une conversion finale de dernier tour.        *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_relational_operation_reduce(GRelOperation *expr, GScanContext *ctx, bool final)
+static bool g_relational_operation_reduce(GRelOperation *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
-    GScanExpression *new;                   /* Nouvelle expression obtenue */
+    bool result;                            /* Bilan à retourner           */
+    GScanExpression *new_left;              /* Expression réduite (gauche) */
+    GScanExpression *new_right;             /* Expression réduite (droite) */
     bool status;                            /* Bilan d'une comparaison     */
     bool valid;                             /* Validité de ce bilan obtenu */
 
-    result = NULL;
-
     /* Réduction des éléments considérés */
 
-    new = g_scan_expression_reduce(expr->first, ctx, final);
+    new_left = NULL;
+    new_right = NULL;
 
-    if (new != NULL)
-    {
-        g_object_unref(G_OBJECT(expr->first));
-        expr->first = new;
-    }
+    result = g_scan_expression_reduce(expr->left, ctx, scope, &new_left);
+    if (!result) goto exit;
+
+    result = g_scan_expression_reduce(expr->right, ctx, scope, &new_right);
+    if (!result) goto exit;
+
+    /* Construction d'une réduction locale ? */
 
-    if (expr->second != NULL)
+    if (G_IS_LITERAL_EXPRESSION(new_left) && G_IS_LITERAL_EXPRESSION(new_right))
     {
-        new = g_scan_expression_reduce(expr->second, ctx, final);
+        valid = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(new_left),
+                                               G_COMPARABLE_ITEM(new_right),
+                                               expr->rel_type, &status);
 
-        if (new != NULL)
-        {
-            g_object_unref(G_OBJECT(expr->second));
-            expr->second = new;
-        }
+        if (valid)
+            *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { status });
 
     }
 
-    /* Construction d'une réduction locale ? */
+    /* Mise à jour de la progression ? */
 
-    if (G_IS_LITERAL_EXPRESSION(expr->first) && G_IS_LITERAL_EXPRESSION(expr->second))
+    else if ((new_left != NULL && new_left != expr->left) || (new_right != NULL && new_right != expr->right))
     {
-        valid = g_comparable_item_compare_rich(G_COMPARABLE_ITEM(expr->first),
-                                               G_COMPARABLE_ITEM(expr->second),
-                                               expr->rel_type, &status);
+        if (new_left == NULL)
+        {
+            new_left = expr->left;
+            g_object_ref(G_OBJECT(new_left));
+        }
 
-        if (valid)
-            result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { status });
+        if (new_right == NULL)
+        {
+            new_right = expr->right;
+            g_object_ref(G_OBJECT(new_right));
+        }
+
+        *out = g_relational_operation_new(expr->rel_type, new_left, new_right);
 
     }
 
+ exit:
+
+    g_clear_object(&new_left);
+    g_clear_object(&new_right);
+
     return result;
 
 }
diff --git a/src/analysis/scan/exprs/str-int.h b/src/analysis/scan/exprs/strop-int.h
index 9bed5cf..234ae8f 100644
--- a/src/analysis/scan/exprs/str-int.h
+++ b/src/analysis/scan/exprs/strop-int.h
@@ -1,6 +1,6 @@
 
 /* Chrysalide - Outil d'analyse de fichiers binaires
- * str-int.h - prototypes internes pour la gestion des opérations booléennes
+ * strop-int.h - prototypes internes pour la gestion des opérations booléennes
  *
  * Copyright (C) 2022 Cyrille Bagard
  *
@@ -21,14 +21,15 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_EXPRS_STR_INT_H
-#define _ANALYSIS_SCAN_EXPRS_STR_INT_H
+#ifndef _ANALYSIS_SCAN_EXPRS_STROP_INT_H
+#define _ANALYSIS_SCAN_EXPRS_STROP_INT_H
 
 
-#include "str.h"
+#include "strop.h"
 
 
 #include "../expr-int.h"
+#include "../../../common/extstr.h"
 
 
 
@@ -40,8 +41,8 @@ struct _GStringOperation
     StringOperationType type;               /* Type d'opération menée      */
     bool case_sensitive;                    /* Respect de la casse ?       */
 
-    GScanExpression *first;                 /* Expression impactée #1      */
-    GScanExpression *second;                /* Expression impactée #2      */
+    GScanExpression *left;                  /* Expression impactée #1      */
+    GScanExpression *right;                 /* Expression impactée #2      */
 
 };
 
@@ -58,4 +59,4 @@ bool g_string_operation_create(GStringOperation *, StringOperationType, GScanExp
 
 
 
-#endif  /* _ANALYSIS_SCAN_EXPRS_STR_INT_H */
+#endif  /* _ANALYSIS_SCAN_EXPRS_STROP_INT_H */
diff --git a/src/analysis/scan/exprs/str.c b/src/analysis/scan/exprs/strop.c
index 675b2f6..145e8da 100644
--- a/src/analysis/scan/exprs/str.c
+++ b/src/analysis/scan/exprs/strop.c
@@ -1,6 +1,6 @@
 
 /* Chrysalide - Outil d'analyse de fichiers binaires
- * str.c - gestion des opérations booléennes
+ * strop.c - gestion des opérations booléennes
  *
  * Copyright (C) 2022 Cyrille Bagard
  *
@@ -21,7 +21,7 @@
  */
 
 
-#include "str.h"
+#include "strop.h"
 
 
 #include <assert.h>
@@ -29,7 +29,7 @@
 #include <strings.h>
 
 
-#include "str-int.h"
+#include "strop-int.h"
 #include "literal.h"
 
 
@@ -55,10 +55,10 @@ static void g_string_operation_finalize(GStringOperation *);
 
 
 /* Reproduit une expression en place dans une nouvelle instance. */
-static GScanExpression *g_string_operation_duplicate(const GStringOperation *);
+static void g_string_operation_copy(GStringOperation *, const GStringOperation *);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_string_operation_reduce(GStringOperation *, GScanContext *, bool);
+static bool g_string_operation_reduce(GStringOperation *, GScanContext *, GScanScope *, GScanExpression **);
 
 
 
@@ -96,7 +96,7 @@ static void g_string_operation_class_init(GStringOperationClass *klass)
     expr = G_SCAN_EXPRESSION_CLASS(klass);
 
     expr->cmp_rich = (compare_expr_rich_fc)NULL;
-    expr->dup = (dup_expr_fc)g_string_operation_duplicate;
+    expr->copy = (copy_expr_fc)g_string_operation_copy;
     expr->reduce = (reduce_expr_fc)g_string_operation_reduce;
 
 }
@@ -116,8 +116,8 @@ static void g_string_operation_class_init(GStringOperationClass *klass)
 
 static void g_string_operation_init(GStringOperation *op)
 {
-    op->first = NULL;
-    op->second = NULL;
+    op->left = NULL;
+    op->right = NULL;
 
 }
 
@@ -136,8 +136,8 @@ static void g_string_operation_init(GStringOperation *op)
 
 static void g_string_operation_dispose(GStringOperation *op)
 {
-    g_clear_object(&op->first);
-    g_clear_object(&op->second);
+    g_clear_object(&op->left);
+    g_clear_object(&op->right);
 
     G_OBJECT_CLASS(g_string_operation_parent_class)->dispose(G_OBJECT(op));
 
@@ -196,9 +196,9 @@ GScanExpression *g_string_operation_new(StringOperationType type, GScanExpressio
 *                                                                             *
 *  Paramètres  : op        = instance à initialiser pleinement.               *
 *                type      = type d'opération booléenne à représenter.        *
-*                first     = premier opérande concerné.                       *
-*                second    = éventuel second opérande impliqué ou NULL.       *
-*                sensitive =  détermine la prise en compte de la casse.       *
+*                left      = premier opérande concerné.                       *
+*                right     = éventuel second opérande impliqué ou NULL.       *
+*                sensitive = détermine la prise en compte de la casse.       *
 *                                                                             *
 *  Description : Met en place une expression d'opération traite une chaîne.   *
 *                                                                             *
@@ -208,19 +208,19 @@ GScanExpression *g_string_operation_new(StringOperationType type, GScanExpressio
 *                                                                             *
 ******************************************************************************/
 
-bool g_string_operation_create(GStringOperation *op, StringOperationType type, GScanExpression *first, GScanExpression *second, bool sensitive)
+bool g_string_operation_create(GStringOperation *op, StringOperationType type, GScanExpression *left, GScanExpression *right, bool sensitive)
 {
     bool result;                            /* Bilan à retourner           */
     ExprValueType vtype;                    /* Type de valeur portée       */
 
     result = false;
 
-    vtype = g_scan_expression_get_value_type(first);
+    vtype = g_scan_expression_get_value_type(left);
 
     if (vtype != EVT_STRING && vtype != EVT_PENDING)
         goto exit;
 
-    vtype = g_scan_expression_get_value_type(second);
+    vtype = g_scan_expression_get_value_type(right);
 
     if (vtype != EVT_STRING && vtype != EVT_REG_EXPR && vtype != EVT_PENDING)
         goto exit;
@@ -245,11 +245,11 @@ bool g_string_operation_create(GStringOperation *op, StringOperationType type, G
 
     }
 
-    op->first = first;
-    g_object_ref(G_OBJECT(op->first));
+    op->left = left;
+    g_object_ref(G_OBJECT(op->left));
 
-    op->second = second;
-    g_object_ref(G_OBJECT(op->second));
+    op->right = right;
+    g_object_ref(G_OBJECT(op->right));
 
     result = true;
 
@@ -268,170 +268,202 @@ bool g_string_operation_create(GStringOperation *op, StringOperationType type, G
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : op = expression à copier.                                    *
+*  Paramètres  : dest = emplacement d'enregistrement à constituer. [OUT]      *
+*                src  = expression source à copier.                           *
 *                                                                             *
 *  Description : Reproduit une expression en place dans une nouvelle instance.*
 *                                                                             *
-*  Retour      : Nouvelle instance d'expression.                              *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_string_operation_duplicate(const GStringOperation *op)
+static void g_string_operation_copy(GStringOperation *dest, const GStringOperation *src)
 {
-    GScanExpression *result;                /* Instance copiée à retourner */
+    GScanExpressionClass *class;            /* Classe parente à solliciter */
 
-    result = g_string_operation_new(op->type, op->first, op->second, op->case_sensitive);
+    class = G_SCAN_EXPRESSION_CLASS(g_string_operation_parent_class);
 
-    return result;
+    class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+    dest->type = src->type;
+    dest->case_sensitive = src->case_sensitive;
+
+    dest->left = g_scan_expression_duplicate(src->left);
+    dest->right = g_scan_expression_duplicate(src->right);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : op    = expression à consulter.                              *
+*  Paramètres  : expr  = expression à consulter.                              *
 *                ctx   = contexte de suivi de l'analyse courante.             *
-*                final = impose une conversion finale de dernier tour.        *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_string_operation_reduce(GStringOperation *op, GScanContext *ctx, bool final)
+static bool g_string_operation_reduce(GStringOperation *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
-    GScanExpression *new;                   /* Nouvelle expression obtenue */
-    const char *strings[2];                 /* Chaînes en jeu              */
-    bool status;                            /* Bilan intermédiaire         */
-    char *found;                            /* Eventuelle portion trouvée  */
-    size_t len[2];                          /* Tailles max. de comparaison */
-    int ret;                                /* Bilan de comparaison        */
+    bool result;                            /* Bilan à retourner           */
+    GScanExpression *new_left;              /* Expression réduite (gauche) */
+    GScanExpression *new_right;             /* Expression réduite (droite) */
+    GLiteralExpression *op_left;            /* Opérande gauche final       */
+    GLiteralExpression *op_right;           /* Opérande droite final       */
+    const sized_string_t *strings[2];       /* Chaînes en jeu              */
+    const void *found;                      /* Présence d'une bribe ?      */
+    bool status;                            /* Bilan de comparaison #1     */
+    size_t offset;                          /* Point de départ d'analyse   */
     const regex_t *preg;                    /* Expression rationnelle      */
-
-    result = NULL;
+    int ret;                                /* Bilan de comparaison #2     */
 
     /* Réduction des éléments considérés */
 
-    new = g_scan_expression_reduce(op->first, ctx, final);
+    new_left = NULL;
+    new_right = NULL;
 
-    if (new != NULL)
-    {
-        g_object_unref(G_OBJECT(op->first));
-        op->first = new;
-    }
+    result = g_scan_expression_reduce(expr->left, ctx, scope, &new_left);
+    if (!result) goto exit;
 
-    new = g_scan_expression_reduce(op->second, ctx, final);
-
-    if (new != NULL)
-    {
-        g_object_unref(G_OBJECT(op->second));
-        op->second = new;
-    }
+    result = g_scan_expression_reduce(expr->right, ctx, scope, &new_right);
+    if (!result) goto exit;
 
     /* Construction d'une réduction locale ? */
 
-    if (!G_IS_LITERAL_EXPRESSION(op->first))
-        goto exit;
+    if (G_IS_LITERAL_EXPRESSION(new_left) && G_IS_LITERAL_EXPRESSION(new_right))
+    {
+        op_left = G_LITERAL_EXPRESSION(new_left);
+        op_right = G_LITERAL_EXPRESSION(new_right);
 
-    if (!G_IS_LITERAL_EXPRESSION(op->second))
-        goto exit;
+        result = g_literal_expression_get_string_value(op_left, &strings[0]);
+        if (!result) goto exit;
 
-    status = g_literal_expression_get_string_value(G_LITERAL_EXPRESSION(op->first), &strings[0]);
-    if (!status) goto exit;
+        switch (expr->type)
+        {
+            case SOT_CONTAINS:
 
-    switch (op->type)
-    {
-        case SOT_CONTAINS:
+                result = g_literal_expression_get_string_value(op_right, &strings[1]);
+                if (!result) goto exit;
 
-            status = g_literal_expression_get_string_value(G_LITERAL_EXPRESSION(op->second), &strings[1]);
-            if (!status) goto exit;
+                if (expr->case_sensitive)
+                    found = memmem(strings[0]->data, strings[0]->len, strings[1]->data, strings[1]->len);
 
-            if (op->case_sensitive)
-                found = strstr(strings[0], strings[1]);
-            else
-                found = strcasestr(strings[0], strings[1]);
+                else
+                    found = memcasemem(strings[0]->data, strings[0]->len, strings[1]->data, strings[1]->len);
 
-            result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { found != NULL });
-            break;
+                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { found != NULL });
+                break;
 
-        case SOT_STARTSWITH:
+            case SOT_STARTSWITH:
 
-            status = g_literal_expression_get_string_value(G_LITERAL_EXPRESSION(op->second), &strings[1]);
-            if (!status) goto exit;
+                result = g_literal_expression_get_string_value(op_right, &strings[1]);
+                if (!result) goto exit;
 
-            len[1] = strlen(strings[1]);
+                if (strings[0]->len < strings[1]->len)
+                    status = false;
 
-            if (op->case_sensitive)
-                ret = strncmp(strings[0], strings[1], len[1]);
-            else
-                ret = strncasecmp(strings[0], strings[1], len[1]);
+                else
+                {
+                    if (expr->case_sensitive)
+                        ret = memcmp(strings[0]->data, strings[1]->data, strings[1]->len);
+                    else
+                        ret = memcasecmp(strings[0]->data, strings[1]->data, strings[1]->len);
 
-            result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { ret == 0 });
-            break;
+                    status = (ret == 0);
 
-        case SOT_ENDSWITH:
+                }
 
-            len[0] = strlen(strings[0]);
+                result = g_literal_expression_new(EVT_BOOLEAN, &status);
+                break;
 
-            status = g_literal_expression_get_string_value(G_LITERAL_EXPRESSION(op->second), &strings[1]);
-            if (!status) goto exit;
+            case SOT_ENDSWITH:
 
-            len[1] = strlen(strings[1]);
+                result = g_literal_expression_get_string_value(op_right, &strings[1]);
+                if (!result) goto exit;
 
-            if (len[0] < len[1])
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { false });
+                if (strings[0]->len < strings[1]->len)
+                    status = false;
 
-            else
-            {
-                if (op->case_sensitive)
-                    ret = strncmp(strings[0] + (len[0] - len[1]), strings[1], len[1]);
                 else
-                    ret = strncasecmp(strings[0] + (len[0] - len[1]), strings[1], len[1]);
+                {
+                    offset = strings[0]->len - strings[1]->len;
 
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { ret == 0 });
+                    if (expr->case_sensitive)
+                        ret = memcmp(strings[0]->data + offset, strings[1]->data, strings[1]->len);
+                    else
+                        ret = memcasecmp(strings[0]->data + offset, strings[1]->data, strings[1]->len);
 
-            }
-            break;
+                    status = (ret == 0);
 
-        case SOT_MATCHES:
+                }
 
-            status = g_literal_expression_get_regex_value(G_LITERAL_EXPRESSION(op->second), &preg);
-            if (!status) goto exit;
+                result = g_literal_expression_new(EVT_BOOLEAN, &status);
+                break;
 
-            ret = regexec(preg, strings[0], 0, NULL, 0);
+            case SOT_MATCHES:
 
-            result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { ret != REG_NOMATCH });
-            break;
+                result = g_literal_expression_get_regex_value(op_right, &preg);
+                if (!result) goto exit;
 
-        case SOT_IEQUALS:
+                ret = regexec(preg, strings[0]->data, 0, NULL, 0);
 
-            len[0] = strlen(strings[0]);
+                *out = g_literal_expression_new(EVT_BOOLEAN, (bool []) { ret != REG_NOMATCH });
+                break;
 
-            status = g_literal_expression_get_string_value(G_LITERAL_EXPRESSION(op->second), &strings[1]);
-            if (!status) goto exit;
+            case SOT_IEQUALS:
 
-            len[1] = strlen(strings[1]);
+                result = g_literal_expression_get_string_value(op_right, &strings[1]);
+                if (!result) goto exit;
 
-            if (len[0] != len[1])
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { false });
+                if (strings[0]->len != strings[1]->len)
+                    status = false;
 
-            else
-            {
-                ret = strcasecmp(strings[0], strings[1]);
-                result = g_literal_expression_new(EVT_BOOLEAN, (bool []) { ret == 0 });
-            }
-            break;
+                else
+                {
+                    ret = memcasecmp(strings[0]->data, strings[1]->data, strings[1]->len);
+                    status = (ret == 0);
+                }
+
+                result = g_literal_expression_new(EVT_BOOLEAN, &status);
+                break;
+
+        }
+
+    }
+
+    /* Mise à jour de la progression ? */
+
+    else if ((new_left != NULL && new_left != expr->left) || (new_right != NULL && new_right != expr->right))
+    {
+        if (new_left == NULL)
+        {
+            new_left = expr->left;
+            g_object_ref(G_OBJECT(new_left));
+        }
+
+        if (new_right == NULL)
+        {
+            new_right = expr->right;
+            g_object_ref(G_OBJECT(new_right));
+        }
+
+        *out = g_string_operation_new(expr->type, new_left, new_right, expr->case_sensitive);
 
     }
 
  exit:
 
+    g_clear_object(&new_left);
+    g_clear_object(&new_right);
+
     return result;
 
 }
diff --git a/src/analysis/scan/exprs/str.h b/src/analysis/scan/exprs/strop.h
index 195f941..c7c0813 100644
--- a/src/analysis/scan/exprs/str.h
+++ b/src/analysis/scan/exprs/strop.h
@@ -1,6 +1,6 @@
 
 /* Chrysalide - Outil d'analyse de fichiers binaires
- * str.h - prototypes pour la gestion des opérations booléennes
+ * strop.h - prototypes pour la gestion des opérations booléennes
  *
  * Copyright (C) 2022 Cyrille Bagard
  *
@@ -21,8 +21,8 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_EXPRS_STR_H
-#define _ANALYSIS_SCAN_EXPRS_STR_H
+#ifndef _ANALYSIS_SCAN_EXPRS_STROP_H
+#define _ANALYSIS_SCAN_EXPRS_STROP_H
 
 
 #include "../expr.h"
@@ -64,4 +64,4 @@ GScanExpression *g_string_operation_new(StringOperationType, GScanExpression *,
 
 
 
-#endif  /* _ANALYSIS_SCAN_EXPRS_STR_H */
+#endif  /* _ANALYSIS_SCAN_EXPRS_STROP_H */
diff --git a/src/analysis/scan/func-int.h b/src/analysis/scan/func-int.h
deleted file mode 100644
index 6591ba4..0000000
--- a/src/analysis/scan/func-int.h
+++ /dev/null
@@ -1,51 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * func-int.h - prototypes internes pour la définition d'une fonction ciblant une propriété pendant un scan
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_FUNC_INT_H
-#define _ANALYSIS_SCAN_FUNC_INT_H
-
-
-#include "func.h"
-
-
-#include "item-int.h"
-
-
-
-/* Fonction apportant un support d'analyse pendant un scan (instance) */
-struct _GScanFunction
-{
-    GRegisteredItem parent;                 /* A laisser en premier        */
-
-};
-
-/* Fonction apportant un support d'analyse pendant un scan (classe) */
-struct _GScanFunctionClass
-{
-    GRegisteredItemClass parent;            /* A laisser en premier        */
-
-};
-
-
-
-#endif  /* _ANALYSIS_SCAN_FUNC_INT_H */
diff --git a/src/analysis/scan/func.c b/src/analysis/scan/func.c
deleted file mode 100644
index b839d1d..0000000
--- a/src/analysis/scan/func.c
+++ /dev/null
@@ -1,126 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * func.c - définition d'une fonction ciblant une propriété pendant un scan
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "func.h"
-
-
-#include "func-int.h"
-
-
-
-/* Initialise la classe des fonctions de support pour scan. */
-static void g_scan_function_class_init(GScanFunctionClass *);
-
-/* Initialise une instance de fonction de support pour scan. */
-static void g_scan_function_init(GScanFunction *);
-
-/* Supprime toutes les références externes. */
-static void g_scan_function_dispose(GScanFunction *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_scan_function_finalize(GScanFunction *);
-
-
-
-/* Indique le type défini pour une définition de fonction de scan. */
-G_DEFINE_TYPE(GScanFunction, g_scan_function, G_TYPE_REGISTERED_ITEM);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des fonctions de support pour scan.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_function_class_init(GScanFunctionClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_function_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_scan_function_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : func = instance à initialiser.                               *
-*                                                                             *
-*  Description : Initialise une instance de fonction de support pour scan.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_function_init(GScanFunction *func)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : func = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_function_dispose(GScanFunction *func)
-{
-    G_OBJECT_CLASS(g_scan_function_parent_class)->dispose(G_OBJECT(func));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : func = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_function_finalize(GScanFunction *func)
-{
-    G_OBJECT_CLASS(g_scan_function_parent_class)->finalize(G_OBJECT(func));
-
-}
diff --git a/src/analysis/scan/func.h b/src/analysis/scan/func.h
deleted file mode 100644
index bfc823a..0000000
--- a/src/analysis/scan/func.h
+++ /dev/null
@@ -1,52 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * func.h - prototypes pour la définition d'une fonction ciblant une propriété pendant un scan
- *
- * Copyright (C) 2022 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _ANALYSIS_SCAN_FUNC_H
-#define _ANALYSIS_SCAN_FUNC_H
-
-
-#include <glib-object.h>
-
-
-
-#define G_TYPE_SCAN_FUNCTION            g_scan_function_get_type()
-#define G_SCAN_FUNCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_FUNCTION, GScanFunction))
-#define G_IS_SCAN_FUNCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_FUNCTION))
-#define G_SCAN_FUNCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_FUNCTION, GScanFunctionClass))
-#define G_IS_SCAN_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_FUNCTION))
-#define G_SCAN_FUNCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_FUNCTION, GScanFunctionClass))
-
-
-/* Fonction apportant un support d'analyse pendant un scan (instance) */
-typedef struct _GScanFunction GScanFunction;
-
-/* Fonction apportant un support d'analyse pendant un scan (classe) */
-typedef struct _GScanFunctionClass GScanFunctionClass;
-
-
-/* Indique le type défini pour une définition de fonction de scan. */
-GType g_scan_function_get_type(void);
-
-
-
-#endif  /* _ANALYSIS_SCAN_FUNC_H */
diff --git a/src/analysis/scan/funcs/Makefile.am b/src/analysis/scan/funcs/Makefile.am
deleted file mode 100644
index be370ba..0000000
--- a/src/analysis/scan/funcs/Makefile.am
+++ /dev/null
@@ -1,15 +0,0 @@
-
-noinst_LTLIBRARIES  = libanalysisscanfuncs.la
-
-
-libanalysisscanfuncs_la_SOURCES =			\
-	datasize.h datasize.c					\
-	uint-int.h								\
-	uint.h uint.c
-
-libanalysisscanfuncs_la_CFLAGS = $(LIBGOBJ_CFLAGS)
-
-
-devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
-
-dev_HEADERS = $(libanalysisscanfuncs_la_SOURCES:%c=)
diff --git a/src/analysis/scan/grammar.y b/src/analysis/scan/grammar.y
index ab64ad8..525c5d1 100644
--- a/src/analysis/scan/grammar.y
+++ b/src/analysis/scan/grammar.y
@@ -17,12 +17,12 @@ static int yyerror(GContentScanner *, yyscan_t, GScanRule **, void/*GBytesPatter
 typedef void *yyscan_t;
 
 #include "scanner.h"
-#include "conds/counter.h"
+#include "exprs/access.h"
 #include "exprs/arithmop.h"
 #include "exprs/boolop.h"
 #include "exprs/call.h"
 #include "exprs/literal.h"
-#include "exprs/str.h"
+#include "exprs/strop.h"
 #include "exprs/relop.h"
 #include "patterns/tokens/plain.h"
 
@@ -46,14 +46,16 @@ typedef void *yyscan_t;
 
 %union {
 
-    //char *string;                           /* Chaîne de caractères #1     */
-    const char *cstring;                    /* Chaîne de caractères #2     */
+    unsigned long long unsigned_integer;    /* Valeur entière #1           */
+    signed long long signed_integer;        /* Valeur entière #2           */
+    double floating_number;                 /* Valeur à virgule flottante  */
+    sized_string_t sized_cstring;           /* Chaîne de caractères        */
+    char byte;                              /* Octet unique                */
+
+
+
     unsigned long long integer;             /* Valeur entière              */
 
-    struct {
-        const char *cstring;                /* Chaîne de caractères #3     */
-        size_t len;                         /* Taille correspondante       */
-    } sized_cstring;
 
     GScanRule *rule;                        /* Nouvelle règle à intégrer   */
     void/*GBytesPattern*/ *pattern;                 /* Nouveau motif à considérer  */
@@ -97,8 +99,6 @@ YY_DECL;
 %token BRACE_IN BRACE_OUT ASSIGN COLON
 
 
-%token RAW_BLOCK
-
 %token PLAIN_STRING
 %token MASKED_STRING
 
@@ -147,8 +147,7 @@ YY_DECL;
 %token THEM             "them"
 
 
-%type <cstring> RULE_NAME
-%type <cstring> RAW_BLOCK
+%type <sized_cstring> RULE_NAME
 
 
 %type <sized_cstring> IDENTIFIER
@@ -156,7 +155,7 @@ YY_DECL;
 
 
 %type <integer> INTEGER
-%type <cstring> STRING
+%type <sized_cstring> STRING
 
 %type <rule> rule
 
@@ -165,7 +164,7 @@ YY_DECL;
 
 %type <expr> cexpression
 %type <expr> literal
-%type <expr> callable
+%type <expr> item_chain
 %type <args_list> call_args
 %type <expr> bool_expr
 %type <expr> rel_expr
@@ -214,7 +213,7 @@ rules : /* empty */
 
 rule : RAW_RULE RULE_NAME
      {
-         *built_rule = g_scan_rule_new($2);
+         *built_rule = g_scan_rule_new($2.data);
          $<rule>$ = *built_rule;
      }
      BRACE_IN strings condition BRACE_OUT
@@ -238,8 +237,8 @@ string_decls : string_decl
 string_decl : IDENTIFIER ASSIGN PLAIN_STRING
             {
                 GSearchPattern *__pat;
-                __pat = g_plain_bytes_new((uint8_t *)$3.cstring, $3.len);
-                g_search_pattern_set_name(__pat, $1.cstring, $1.len);
+                __pat = g_plain_bytes_new((uint8_t *)$3.data, $3.len);
+                g_search_pattern_set_name(__pat, $1.data, $1.len);
                 g_scan_rule_add_local_variable(*built_rule, __pat);
                 g_object_unref(G_OBJECT(__pat));
 
@@ -300,7 +299,7 @@ cexpression : IDENTIFIER
                 */
             }
             | literal { $$ = $1; }
-            | callable { $$ = $1; }
+            | item_chain { $$ = $1; }
             | bool_expr { $$ = $1; }
             | rel_expr { $$ = $1; }
             | str_expr { $$ = $1; }
@@ -315,42 +314,42 @@ literal : "true" { $$ = g_literal_expression_new(EVT_BOOLEAN, (bool []){ true })
         | INTEGER KB { $$ = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ $1 * 1024 }); }
         | INTEGER MB { $$ = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ $1 * 1048576 }); }
         | INTEGER GB { $$ = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ $1 * 1073741824 }); }
-        | STRING { $$ = g_literal_expression_new(EVT_STRING, $1); }
+        | STRING { $$ = g_literal_expression_new(EVT_STRING, &$1); }
         ;
 
-callable : NAME { $$ = g_pending_call_new($1.cstring, $1.len, NULL, 0); }
-         | NAME "(" ")" { $$ = g_pending_call_new($1.cstring, $1.len, NULL, 0); }
+item_chain : NAME { $$ = g_named_access_new(&$1); }
+         | NAME "(" ")" { $$ = g_pending_call_new(&$1, NULL, 0); }
          | NAME "(" call_args ")"
          {
              size_t __i;
-             $$ = g_pending_call_new($1.cstring, $1.len, $3.args, $3.count);
+             $$ = g_pending_call_new(&$1, $3.args, $3.count);
              for (__i = 0; __i < $3.count; __i++)
                  g_object_unref(G_OBJECT($3.args[__i]));
              free($3.args);
          }
-         | callable "." NAME
+         | item_chain "." NAME
          {
              GScanExpression *__next;
-             __next = g_pending_call_new($3.cstring, $3.len, NULL, 0);
-             g_pending_call_attach_next(G_PENDING_CALL($1), G_PENDING_CALL(__next));
+             __next = g_named_access_new(&$3);
+             g_named_access_attach_next(G_NAMED_ACCESS($1), G_NAMED_ACCESS(__next));
              $$ = $1;
          }
-         | callable "." NAME "(" ")"
+         | item_chain "." NAME "(" ")"
          {
              GScanExpression *__next;
-             __next = g_pending_call_new($3.cstring, $3.len, NULL, 0);
-             g_pending_call_attach_next(G_PENDING_CALL($1), G_PENDING_CALL(__next));
+             __next = g_pending_call_new(&$3, NULL, 0);
+             g_named_access_attach_next(G_NAMED_ACCESS($1), G_NAMED_ACCESS(__next));
              $$ = $1;
          }
-         | callable "." NAME "(" call_args ")"
+         | item_chain "." NAME "(" call_args ")"
          {
              GScanExpression *__next;
              size_t __i;
-             __next = g_pending_call_new($3.cstring, $3.len, $5.args, $5.count);
+             __next = g_pending_call_new(&$3, $5.args, $5.count);
              for (__i = 0; __i < $5.count; __i++)
                  g_object_unref(G_OBJECT($5.args[__i]));
              free($5.args);
-             g_pending_call_attach_next(G_PENDING_CALL($1), G_PENDING_CALL(__next));
+             g_named_access_attach_next(G_NAMED_ACCESS($1), G_NAMED_ACCESS(__next));
              $$ = $1;
          }
          ;
diff --git a/src/analysis/scan/item-int.h b/src/analysis/scan/item-int.h
index d1151f2..0ec4e46 100644
--- a/src/analysis/scan/item-int.h
+++ b/src/analysis/scan/item-int.h
@@ -32,11 +32,17 @@
 
 
 
-/* Lance une résolution d'élément à appeler. */
-typedef GRegisteredItem * (* resolve_registered_item_fc) (GRegisteredItem *, const char *, GScanContext *, GScanExpression **, size_t, bool, bool);
+/* Indique le nom associé à une expression d'évaluation. */
+typedef char * (* get_registered_item_name_fc) (const GRegisteredItem *);
+
+/* Lance une résolution d'élément à solliciter. */
+typedef bool (* resolve_registered_item_fc) (GRegisteredItem *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
 
 /* Réduit une expression à une forme plus simple. */
-typedef GScanExpression * (* reduce_registered_item_fc) (GRegisteredItem *, GScanContext *, GScanExpression **, size_t, bool);
+typedef bool (* reduce_registered_item_fc) (GRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
+
+/* Effectue un appel à une fonction enregistrée. */
+typedef bool (* run_registered_item_call_fc) (GRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 /* Expression d'évaluation généraliste (instance) */
@@ -51,8 +57,10 @@ struct _GRegisteredItemClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    get_registered_item_name_fc get_name;   /* Obtention du nom associé    */
     resolve_registered_item_fc resolve;     /* Opération de résolution     */
     reduce_registered_item_fc reduce;       /* Opération de réduction      */
+    run_registered_item_call_fc run_call;   /* Appel à une fonction connue */
 
 };
 
diff --git a/src/analysis/scan/item.c b/src/analysis/scan/item.c
index c0b1532..d819f59 100644
--- a/src/analysis/scan/item.c
+++ b/src/analysis/scan/item.c
@@ -24,6 +24,9 @@
 #include "item.h"
 
 
+#include <assert.h>
+
+
 #include "item-int.h"
 
 
@@ -136,33 +139,67 @@ static void g_registered_item_finalize(GRegisteredItem *item)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : item = élément d'appel à consulter.                          *
+*                                                                             *
+*  Description : Indique le nom associé à une expression d'évaluation.        *
+*                                                                             *
+*  Retour      : Désignation humaine de l'expression d'évaluation.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_registered_item_get_name(const GRegisteredItem *item)
+{
+    char *result;                           /* Désignation à retourner     */
+    GRegisteredItemClass *class;            /* Classe à activer            */
+
+    class = G_REGISTERED_ITEM_GET_CLASS(item);
+
+    result = class->get_name(item);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : item   = élément d'appel à consulter.                        *
 *                target = désignation de l'objet d'appel à identifier.        *
 *                ctx    = contexte de suivi de l'analyse courante.            *
-*                args   = liste d'éventuels arguments fournis.                *
-*                count  = taille de cette liste.                              *
-*                last   = l'élément est-il le dernier d'une chaîne d'appels ? *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*                scope  = portée courante des variables locales.              *
+*                out    = zone d'enregistrement de la résolution opérée. [OUT]*
 *                                                                             *
-*  Description : Lance une résolution d'élément à appeler.                    *
+*  Description : Lance une résolution d'élément à solliciter.                 *
 *                                                                             *
-*  Retour      : Nouvel élément d'appel identifié ou NULL.                    *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_registered_item_resolve(GRegisteredItem *item, const char *target, GScanContext *ctx, GScanExpression **args, size_t count, bool last, bool final)
+bool g_registered_item_resolve(GRegisteredItem *item, const char *target, GScanContext *ctx, GScanScope *scope, GRegisteredItem **out)
 {
-    GRegisteredItem *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     GRegisteredItemClass *class;            /* Classe à activer            */
 
+    *out = NULL;
+
     class = G_REGISTERED_ITEM_GET_CLASS(item);
 
     if (class->resolve == NULL)
-        result = NULL;
+        result = false;
     else
-        result = class->resolve(item, target, ctx, args, count, last, final);
+    {
+        result = class->resolve(item, target, ctx, scope, out);
+
+#ifndef NDEBUG
+        if (*out != NULL)
+            assert(result);
+#endif
+
+    }
 
     return result;
 
@@ -171,28 +208,84 @@ GRegisteredItem *g_registered_item_resolve(GRegisteredItem *item, const char *ta
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item   = élément d'appel à consulter.                        *
-*                ctx    = contexte de suivi de l'analyse courante.            *
-*                args   = liste d'éventuels arguments fournis.                *
-*                count  = taille de cette liste.                              *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*  Paramètres  : item  = élément d'appel à consulter.                         *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_registered_item_reduce(GRegisteredItem *item, GScanContext *ctx, GScanExpression **args, size_t count, bool final)
+bool g_registered_item_reduce(GRegisteredItem *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     GRegisteredItemClass *class;            /* Classe à activer            */
 
+    *out = NULL;
+
     class = G_REGISTERED_ITEM_GET_CLASS(item);
 
-    result = class->reduce(item, ctx, args, count, final);
+    if (class->reduce == NULL)
+        result = false;
+    else
+    {
+        result = class->reduce(item, ctx, scope, out);
+
+#ifndef NDEBUG
+        if (*out != NULL)
+            assert(result);
+#endif
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item  = élément d'appel à consulter.                         *
+*                args  = liste d'éventuels arguments fournis.                 *
+*                count = taille de cette liste.                               *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la résolution opérée. [OUT] *
+*                                                                             *
+*  Description : Effectue un appel à une fonction enregistrée.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_registered_item_run_call(GRegisteredItem *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GRegisteredItemClass *class;            /* Classe à activer            */
+
+    *out = NULL;
+
+    class = G_REGISTERED_ITEM_GET_CLASS(item);
+
+    if (class->run_call == NULL)
+        result = false;
+    else
+    {
+        result = class->run_call(item, args, count, ctx, scope, out);
+
+#ifndef NDEBUG
+        if (*out != NULL)
+            assert(result);
+#endif
+
+    }
 
     return result;
 
diff --git a/src/analysis/scan/item.h b/src/analysis/scan/item.h
index e3e02e6..fee1e2c 100644
--- a/src/analysis/scan/item.h
+++ b/src/analysis/scan/item.h
@@ -52,11 +52,17 @@ typedef struct _GRegisteredItemClass GRegisteredItemClass;
 /* Indique le type défini pour un élément appelable et enregistré. */
 GType g_registered_item_get_type(void);
 
-/* Lance une résolution d'élément à appeler. */
-GRegisteredItem *g_registered_item_resolve(GRegisteredItem *, const char *, GScanContext *, GScanExpression **, size_t, bool, bool);
+/* Indique le nom associé à une expression d'évaluation. */
+char *g_registered_item_get_name(const GRegisteredItem *);
+
+/* Lance une résolution d'élément à solliciter. */
+bool g_registered_item_resolve(GRegisteredItem *, const char *, GScanContext *, GScanScope *, GRegisteredItem **);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_registered_item_reduce(GRegisteredItem *, GScanContext *, GScanExpression **, size_t, bool);
+bool g_registered_item_reduce(GRegisteredItem *, GScanContext *, GScanScope *, GScanExpression **);
+
+/* Effectue un appel à une fonction enregistrée. */
+bool g_registered_item_run_call(GRegisteredItem *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 
diff --git a/src/analysis/scan/items/Makefile.am b/src/analysis/scan/items/Makefile.am
new file mode 100644
index 0000000..3a6bb62
--- /dev/null
+++ b/src/analysis/scan/items/Makefile.am
@@ -0,0 +1,15 @@
+
+noinst_LTLIBRARIES  = libanalysisscanitems.la
+
+
+libanalysisscanitems_la_SOURCES =			\
+	datasize.h datasize.c					\
+	uint-int.h								\
+	uint.h uint.c
+
+libanalysisscanitems_la_CFLAGS = $(LIBGOBJ_CFLAGS)
+
+
+devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
+
+dev_HEADERS = $(libanalysisscanitems_la_SOURCES:%c=)
diff --git a/src/analysis/scan/funcs/datasize.c b/src/analysis/scan/items/datasize.c
index 7e63095..618d0c3 100644
--- a/src/analysis/scan/funcs/datasize.c
+++ b/src/analysis/scan/items/datasize.c
@@ -24,7 +24,7 @@
 #include "datasize.h"
 
 
-#include "../func-int.h"
+#include "../item-int.h"
 #include "../exprs/literal.h"
 
 
@@ -49,8 +49,14 @@ static void g_datasize_function_finalize(GDatasizeFunction *);
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_datasize_function_get_name(const GDatasizeFunction *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_datasize_function_reduce(GDatasizeFunction *, GScanContext *, GScanScope *, GScanExpression **);
+
 /* Réduit une expression à une forme plus simple. */
-static GScanExpression *g_datasize_function_reduce(GDatasizeFunction *, GScanContext *, GScanExpression **, size_t, bool);
+static bool g_datasize_function_run_call(GDatasizeFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 
@@ -60,7 +66,7 @@ static GScanExpression *g_datasize_function_reduce(GDatasizeFunction *, GScanCon
 
 
 /* Indique le type défini pour une mesure de quantité de données scannées. */
-G_DEFINE_TYPE(GDatasizeFunction, g_datasize_function, G_TYPE_SCAN_FUNCTION);
+G_DEFINE_TYPE(GDatasizeFunction, g_datasize_function, G_TYPE_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -87,7 +93,9 @@ static void g_datasize_function_class_init(GDatasizeFunctionClass *klass)
 
     registered = G_REGISTERED_ITEM_CLASS(klass);
 
+    registered->get_name = (get_registered_item_name_fc)g_datasize_function_get_name;
     registered->reduce = (reduce_registered_item_fc)g_datasize_function_reduce;
+    registered->run_call = (run_registered_item_call_fc)g_datasize_function_run_call;
 
 }
 
@@ -160,9 +168,9 @@ static void g_datasize_function_finalize(GDatasizeFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GScanFunction *g_datasize_function_new(void)
+GDatasizeFunction *g_datasize_function_new(void)
 {
-    GScanFunction *result;                  /* Structure à retourner       */
+    GDatasizeFunction *result;              /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_DATASIZE_FUNCTION, NULL);
 
@@ -179,36 +187,86 @@ GScanFunction *g_datasize_function_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : func   = élément d'appel à consulter.                        *
-*                target = désignation de l'objet d'appel à identifier.        *
-*                ctx    = contexte de suivi de l'analyse courante.            *
-*                args   = liste d'éventuels arguments fournis.                *
-*                count  = taille de cette liste.                              *
-*                last   = l'élément est-il le dernier d'une chaîne d'appels ? *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*  Paramètres  : item = élément d'appel à consulter.                          *
+*                                                                             *
+*  Description : Indique le nom associé à une expression d'évaluation.        *
+*                                                                             *
+*  Retour      : Désignation humaine de l'expression d'évaluation.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_datasize_function_get_name(const GDatasizeFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("datasize");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item  = élément d'appel à consulter.                         *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la réduction opérée. [OUT]  *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
-*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_datasize_function_reduce(GDatasizeFunction *func, GScanContext *ctx, GScanExpression **args, size_t count, bool final)
+static bool g_datasize_function_reduce(GDatasizeFunction *item, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     GBinContent *content;                   /* Contenu à manipuler         */
     phys_t size;                            /* Quantité de données liées   */
 
+    result = true;
+
     content = g_scan_context_get_content(ctx);
 
     size = g_binary_content_compute_size(content);
 
-    result = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ size });
+    *out = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ size });
 
     g_object_unref(G_OBJECT(content));
 
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item  = élément d'appel à consulter.                         *
+*                args  = liste d'éventuels arguments fournis.                 *
+*                count = taille de cette liste.                               *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la résolution opérée. [OUT] *
+*                                                                             *
+*  Description : Réduit une expression à une forme plus simple.               *
+*                                                                             *
+*  Retour      : Réduction correspondante, expression déjà réduite, ou NULL.  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_datasize_function_run_call(GDatasizeFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = g_datasize_function_reduce(item, ctx, scope, (GScanExpression **)out);
+
+    return result;
+
+}
diff --git a/src/analysis/scan/funcs/datasize.h b/src/analysis/scan/items/datasize.h
index bdd813d..bd8e185 100644
--- a/src/analysis/scan/funcs/datasize.h
+++ b/src/analysis/scan/items/datasize.h
@@ -21,11 +21,14 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_FUNCS_DATASIZE_H
-#define _ANALYSIS_SCAN_FUNCS_DATASIZE_H
+#ifndef _ANALYSIS_SCAN_ITEMS_DATASIZE_H
+#define _ANALYSIS_SCAN_ITEMS_DATASIZE_H
 
 
-#include "../func.h"
+#include <glib-object.h>
+
+
+#include "../item.h"
 
 
 
@@ -38,18 +41,18 @@
 
 
 /* Mesure de la quantité de données scannées (instance) */
-typedef GScanFunction GDatasizeFunction;
+typedef GRegisteredItem GDatasizeFunction;
 
 /* Mesure de la quantité de données scannées (classe) */
-typedef GScanFunctionClass GDatasizeFunctionClass;
+typedef GRegisteredItemClass GDatasizeFunctionClass;
 
 
 /* Indique le type défini pour une mesure de quantité de données scannées. */
 GType g_datasize_function_get_type(void);
 
 /* Constitue une fonction de récupération de taille de données. */
-GScanFunction *g_datasize_function_new(void);
+GDatasizeFunction *g_datasize_function_new(void);
 
 
 
-#endif  /* _ANALYSIS_SCAN_FUNCS_DATASIZE_H */
+#endif  /* _ANALYSIS_SCAN_ITEMS_DATASIZE_H */
diff --git a/src/analysis/scan/funcs/uint-int.h b/src/analysis/scan/items/uint-int.h
index 0817805..1fa83c5 100644
--- a/src/analysis/scan/funcs/uint-int.h
+++ b/src/analysis/scan/items/uint-int.h
@@ -21,21 +21,21 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_FUNCS_UINT_INT_H
-#define _ANALYSIS_SCAN_FUNCS_UINT_INT_H
+#ifndef _ANALYSIS_SCAN_ITEMS_UINT_INT_H
+#define _ANALYSIS_SCAN_ITEMS_UINT_INT_H
 
 
 #include "uint.h"
 
 
-#include "../func-int.h"
+#include "../item-int.h"
 
 
 
 /* Fonction conduisant à la lecture d'un mot (instance) */
 struct _GUintFunction
 {
-    GScanFunction parent;                   /* A laisser en premier        */
+    GRegisteredItem parent;                 /* A laisser en premier        */
 
     MemoryDataSize size;                    /* Taille du mot à lire        */
     SourceEndian endian;                    /* Boutisme à respecter        */
@@ -45,10 +45,14 @@ struct _GUintFunction
 /* Fonction conduisant à la lecture d'un mot (classe) */
 struct _GUintFunctionClass
 {
-    GScanFunctionClass parent;              /* A laisser en premier        */
+    GRegisteredItemClass parent;            /* A laisser en premier        */
 
 };
 
 
+/* Met en place un nouvelle fonction de lecture d'entiers. */
+bool g_uint_function_create(GUintFunction *, MemoryDataSize);
 
-#endif  /* _ANALYSIS_SCAN_FUNCS_UINT_INT_H */
+
+
+#endif  /* _ANALYSIS_SCAN_ITEMS_UINT_INT_H */
diff --git a/src/analysis/scan/funcs/uint.c b/src/analysis/scan/items/uint.c
index 6421f52..4fea494 100644
--- a/src/analysis/scan/funcs/uint.c
+++ b/src/analysis/scan/items/uint.c
@@ -24,6 +24,9 @@
 #include "uint.h"
 
 
+#include <assert.h>
+
+
 #include "uint-int.h"
 #include "../exprs/literal.h"
 
@@ -49,8 +52,11 @@ static void g_uint_function_finalize(GUintFunction *);
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_uint_function_get_name(const GUintFunction *);
+
 /* Réduit une expression à une forme plus simple. */
-static GScanExpression *g_uint_function_reduce(GUintFunction *, GScanContext *, GScanExpression **, size_t, bool);
+static bool g_uint_function_run_call(GUintFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
 
 
 
@@ -60,7 +66,7 @@ static GScanExpression *g_uint_function_reduce(GUintFunction *, GScanContext *,
 
 
 /* Indique le type défini pour une lecture de mot à partir de données binaires. */
-G_DEFINE_TYPE(GUintFunction, g_uint_function, G_TYPE_SCAN_FUNCTION);
+G_DEFINE_TYPE(GUintFunction, g_uint_function, G_TYPE_REGISTERED_ITEM);
 
 
 /******************************************************************************
@@ -87,7 +93,8 @@ static void g_uint_function_class_init(GUintFunctionClass *klass)
 
     registered = G_REGISTERED_ITEM_CLASS(klass);
 
-    registered->reduce = (reduce_registered_item_fc)g_uint_function_reduce;
+    registered->get_name = (get_registered_item_name_fc)g_uint_function_get_name;
+    registered->run_call = (run_registered_item_call_fc)g_uint_function_run_call;
 
 }
 
@@ -162,13 +169,40 @@ static void g_uint_function_finalize(GUintFunction *func)
 *                                                                             *
 ******************************************************************************/
 
-GScanFunction *g_uint_function_new(MemoryDataSize size)
+GUintFunction *g_uint_function_new(MemoryDataSize size)
 {
-    GScanFunction *result;                  /* Structure à retourner       */
+    GUintFunction *result;                  /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_UINT_FUNCTION, NULL);
 
-    G_UINT_FUNCTION(result)->size = size;
+    if (!g_uint_function_create(result, size))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = encadrement d'un parcours de correspondances.         *
+*                size = taille du mot à venir lire dans les données.          *
+*                                                                             *
+*  Description : Met en place un nouvelle fonction de lecture d'entiers.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_uint_function_create(GUintFunction *func, MemoryDataSize size)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    func->size = size;
 
     return result;
 
@@ -183,13 +217,58 @@ GScanFunction *g_uint_function_new(MemoryDataSize size)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : func   = élément d'appel à consulter.                        *
-*                target = désignation de l'objet d'appel à identifier.        *
-*                ctx    = contexte de suivi de l'analyse courante.            *
-*                args   = liste d'éventuels arguments fournis.                *
-*                count  = taille de cette liste.                              *
-*                last   = l'élément est-il le dernier d'une chaîne d'appels ? *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*  Paramètres  : item = élément d'appel à consulter.                          *
+*                                                                             *
+*  Description : Indique le nom associé à une expression d'évaluation.        *
+*                                                                             *
+*  Retour      : Désignation humaine de l'expression d'évaluation.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_uint_function_get_name(const GUintFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    switch (item->size)
+    {
+        case MDS_8_BITS_UNSIGNED:
+            result = strdup("uint8");
+            break;
+
+        case MDS_16_BITS_UNSIGNED:
+            result = strdup("uint16");
+            break;
+
+        case MDS_32_BITS_UNSIGNED:
+            result = strdup("uint32");
+            break;
+
+        case MDS_64_BITS_UNSIGNED:
+            result = strdup("uint64");
+            break;
+
+        default:
+            assert(false);
+            result = NULL;
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item  = élément d'appel à consulter.                         *
+*                args  = liste d'éventuels arguments fournis.                 *
+*                count = taille de cette liste.                               *
+*                ctx   = contexte de suivi de l'analyse courante.             *
+*                scope = portée courante des variables locales.               *
+*                out   = zone d'enregistrement de la résolution opérée. [OUT] *
 *                                                                             *
 *  Description : Réduit une expression à une forme plus simple.               *
 *                                                                             *
@@ -199,11 +278,10 @@ GScanFunction *g_uint_function_new(MemoryDataSize size)
 *                                                                             *
 ******************************************************************************/
 
-static GScanExpression *g_uint_function_reduce(GUintFunction *func, GScanContext *ctx, GScanExpression **args, size_t count, bool final)
+static bool g_uint_function_run_call(GUintFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
 {
-    GScanExpression *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     unsigned long long offset;              /* Position du mot ciblé       */
-    bool status;                            /* Bilan d'une opération       */
     GBinContent *content;                   /* Contenu à manipuler         */
     vmpa2t pos;                             /* Tête de lecture             */
     uint8_t val_8;                          /* Valeur entière sur 8 bits   */
@@ -211,54 +289,51 @@ static GScanExpression *g_uint_function_reduce(GUintFunction *func, GScanContext
     uint32_t val_32;                        /* Valeur entière sur 32 bits  */
     uint64_t val_64;                        /* Valeur entière sur 64 bits  */
 
-    result = NULL;
-
-    if (count == 1 && G_IS_LITERAL_EXPRESSION(args[0]))
-    {
-        status = g_literal_expression_get_integer_value(G_LITERAL_EXPRESSION(args[0]), &offset);
-        if (!status) goto exit;
-
-        content = g_scan_context_get_content(ctx);
-
-        g_binary_content_compute_start_pos(content, &pos);
-        advance_vmpa(&pos, offset);
+    result = (count == 1 && G_IS_LITERAL_EXPRESSION(args[0]));
+    if (!result) goto exit;
 
-        switch (func->size)
-        {
-            case MDS_8_BITS_UNSIGNED:
-                status = g_binary_content_read_u8(content, &pos, &val_8);
-                if (status)
-                    result = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_8 });
-                break;
+    result = g_literal_expression_get_integer_value(G_LITERAL_EXPRESSION(args[0]), &offset);
+    if (!result) goto exit;
 
-            case MDS_16_BITS_UNSIGNED:
-                status = g_binary_content_read_u16(content, &pos, func->endian, &val_16);
-                if (status)
-                    result = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_16 });
-                break;
+    content = g_scan_context_get_content(ctx);
 
-            case MDS_32_BITS_UNSIGNED:
-                status = g_binary_content_read_u32(content, &pos, func->endian, &val_32);
-                if (status)
-                    result = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_32 });
-                break;
+    g_binary_content_compute_start_pos(content, &pos);
+    advance_vmpa(&pos, offset);
 
-
-            case MDS_64_BITS_UNSIGNED:
-                status = g_binary_content_read_u64(content, &pos, func->endian, &val_64);
-                if (status)
-                    result = g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_64 });
-                break;
-
-            default:
-                break;
-
-        }
-
-        g_object_unref(G_OBJECT(content));
+    switch (item->size)
+    {
+        case MDS_8_BITS_UNSIGNED:
+            result = g_binary_content_read_u8(content, &pos, &val_8);
+            if (result)
+                *out = G_OBJECT(g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_8 }));
+            break;
+
+        case MDS_16_BITS_UNSIGNED:
+            result = g_binary_content_read_u16(content, &pos, item->endian, &val_16);
+            if (result)
+                *out = G_OBJECT(g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_16 }));
+            break;
+
+        case MDS_32_BITS_UNSIGNED:
+            result = g_binary_content_read_u32(content, &pos, item->endian, &val_32);
+            if (result)
+                *out = G_OBJECT(g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_32 }));
+            break;
+
+
+        case MDS_64_BITS_UNSIGNED:
+            result = g_binary_content_read_u64(content, &pos, item->endian, &val_64);
+            if (result)
+                *out = G_OBJECT(g_literal_expression_new(EVT_INTEGER, (unsigned long long []){ val_64 }));
+            break;
+
+        default:
+            break;
 
     }
 
+    g_object_unref(G_OBJECT(content));
+
  exit:
 
     return result;
diff --git a/src/analysis/scan/funcs/uint.h b/src/analysis/scan/items/uint.h
index fe6cb52..60f2975 100644
--- a/src/analysis/scan/funcs/uint.h
+++ b/src/analysis/scan/items/uint.h
@@ -21,11 +21,13 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_FUNCS_UINT_H
-#define _ANALYSIS_SCAN_FUNCS_UINT_H
+#ifndef _ANALYSIS_SCAN_ITEMS_UINT_H
+#define _ANALYSIS_SCAN_ITEMS_UINT_H
+
+
+#include <glib-object.h>
 
 
-#include "../func.h"
 #include "../../../arch/archbase.h"
 
 
@@ -49,8 +51,8 @@ typedef struct _GUintFunctionClass GUintFunctionClass;
 GType g_uint_function_get_type(void);
 
 /* Constitue une fonction de lecture de valeur entière. */
-GScanFunction *g_uint_function_new(MemoryDataSize);
+GUintFunction *g_uint_function_new(MemoryDataSize);
 
 
 
-#endif  /* _ANALYSIS_SCAN_FUNCS_UINT_H */
+#endif  /* _ANALYSIS_SCAN_ITEMS_UINT_H */
diff --git a/src/analysis/scan/patterns/backend-int.h b/src/analysis/scan/patterns/backend-int.h
index 698ba5f..b2587df 100644
--- a/src/analysis/scan/patterns/backend-int.h
+++ b/src/analysis/scan/patterns/backend-int.h
@@ -39,7 +39,7 @@ typedef patid_t (* enroll_plain_into_backend_fc) (GEngineBackend *, GScanContext
 typedef void (* warm_up_backend_fc) (GEngineBackend *);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-typedef void (* run_backend_scan_fc) (const GEngineBackend *, GScanContext *, GBinContent *);
+typedef void (* run_backend_scan_fc) (const GEngineBackend *, GScanContext *);
 
 /* Imprime quelques faits quant aux éléments mis en place. */
 typedef void (* output_backend_stats_fc) (const GEngineBackend *);
diff --git a/src/analysis/scan/patterns/backend.c b/src/analysis/scan/patterns/backend.c
index 800d0aa..0ecc7fe 100644
--- a/src/analysis/scan/patterns/backend.c
+++ b/src/analysis/scan/patterns/backend.c
@@ -209,7 +209,6 @@ void g_engine_backend_warm_up(GEngineBackend *backend)
 *                                                                             *
 *  Paramètres  : backend = moteur de recherche à manipuler.                   *
 *                context = lieu d'enregistrement des résultats.               *
-*                content = données binaires à analyser.                       *
 *                                                                             *
 *  Description : Parcours un contenu binaire à la recherche de motifs.        *
 *                                                                             *
@@ -219,13 +218,13 @@ void g_engine_backend_warm_up(GEngineBackend *backend)
 *                                                                             *
 ******************************************************************************/
 
-void g_engine_backend_run_scan(const GEngineBackend *backend, GScanContext *context, GBinContent *content)
+void g_engine_backend_run_scan(const GEngineBackend *backend, GScanContext *context)
 {
     GEngineBackendClass *class;             /* Classe à activer            */
 
     class = G_ENGINE_BACKEND_GET_CLASS(backend);
 
-    class->run_scan(backend, context, content);
+    class->run_scan(backend, context);
 
 }
 
diff --git a/src/analysis/scan/patterns/backend.h b/src/analysis/scan/patterns/backend.h
index 700366e..8f6b929 100644
--- a/src/analysis/scan/patterns/backend.h
+++ b/src/analysis/scan/patterns/backend.h
@@ -63,7 +63,7 @@ patid_t g_engine_backend_enroll_plain_pattern(GEngineBackend *, GScanContext *,
 void g_engine_backend_warm_up(GEngineBackend *);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-void g_engine_backend_run_scan(const GEngineBackend *, GScanContext *, GBinContent *);
+void g_engine_backend_run_scan(const GEngineBackend *, GScanContext *);
 
 /* Imprime quelques faits quant aux éléments mis en place. */
 void g_engine_backend_output_stats(const GEngineBackend *);
diff --git a/src/analysis/scan/patterns/backends/acism.c b/src/analysis/scan/patterns/backends/acism.c
index 12339f2..eef681a 100644
--- a/src/analysis/scan/patterns/backends/acism.c
+++ b/src/analysis/scan/patterns/backends/acism.c
@@ -96,7 +96,7 @@ static void g_acism_backend_build_interleave_array(GAcismBackend *);
 static void g_acism_backend_warm_up(GAcismBackend *);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-static void g_acism_backend_run_scan(const GAcismBackend *, GScanContext *, GBinContent *);
+static void g_acism_backend_run_scan(const GAcismBackend *, GScanContext *);
 
 /* Affiche les caractéristques d'un noeud et de ses enfants. */
 static void visit_and_output_node(const acism_trie_node_t *, unsigned int);
@@ -1125,7 +1125,6 @@ static void g_acism_backend_warm_up(GAcismBackend *backend)
 *                                                                             *
 *  Paramètres  : backend = moteur de recherche à manipuler.                   *
 *                context = lieu d'enregistrement des résultats.               *
-*                content = données binaires à analyser.                       *
 *                                                                             *
 *  Description : Parcours un contenu binaire à la recherche de motifs.        *
 *                                                                             *
@@ -1135,8 +1134,9 @@ static void g_acism_backend_warm_up(GAcismBackend *backend)
 *                                                                             *
 ******************************************************************************/
 
-static void g_acism_backend_run_scan(const GAcismBackend *backend, GScanContext *context, GBinContent *content)
+static void g_acism_backend_run_scan(const GAcismBackend *backend, GScanContext *context)
 {
+    GBinContent *content;                   /* Contenu binaire manipulé    */
     phys_t dlen;                            /* Quantité de données         */
     vmpa2t pos;                             /* Point de départ ciblé       */
     const bin_t *data;                      /* Données à analyser          */
@@ -1151,6 +1151,8 @@ static void g_acism_backend_run_scan(const GAcismBackend *backend, GScanContext
     acism_state_t *iter;                    /* Boucle de parcours #2       */
     acism_state_t *test;                    /* Test de validité alternative*/
 
+    content = g_scan_context_get_content(context);
+
     dlen = g_binary_content_compute_size(content);
 
     g_binary_content_compute_start_pos(content, &pos);
@@ -1238,6 +1240,8 @@ static void g_acism_backend_run_scan(const GAcismBackend *backend, GScanContext
 
     }
 
+    g_object_unref(G_OBJECT(content));
+
 }
 
 
diff --git a/src/analysis/scan/patterns/backends/bitap.c b/src/analysis/scan/patterns/backends/bitap.c
index bd80fb0..adf66d6 100644
--- a/src/analysis/scan/patterns/backends/bitap.c
+++ b/src/analysis/scan/patterns/backends/bitap.c
@@ -63,7 +63,7 @@ size_t g_bitap_backend_get_atom_max_size(const GBitapBackend *);
 static patid_t g_bitap_backend_enroll_plain_pattern(GBitapBackend *, GScanContext *, const uint8_t *, size_t);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-static void g_bitap_backend_run_scan(const GBitapBackend *, GScanContext *, GBinContent *);
+static void g_bitap_backend_run_scan(const GBitapBackend *, GScanContext *);
 
 /* Imprime quelques faits quant aux éléments mis en place. */
 static void g_bitap_backend_output_stats(const GBitapBackend *);
@@ -80,7 +80,7 @@ static void extend_grouped_strings_avx2(grouped_strings_avx2_t ***, size_t *);
 static patid_t enroll_plain_pattern_avx2(GBitapBackend *, GScanContext *, const bin_t *, size_t);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-static void run_scan_avx2(const GBitapBackend *, GScanContext *, GBinContent *);
+static void run_scan_avx2(const GBitapBackend *, GScanContext *, const bin_t *, phys_t);
 
 
 
@@ -96,7 +96,7 @@ static void extend_grouped_strings_avx512(grouped_strings_avx512_t ***, size_t *
 static patid_t enroll_plain_pattern_avx512(GBitapBackend *, GScanContext *, const bin_t *, size_t);
 
 /* Parcours un contenu binaire à la recherche de motifs. */
-static void run_scan_avx512(const GBitapBackend *, GScanContext *, GBinContent *);
+static void run_scan_avx512(const GBitapBackend *, GScanContext *, const bin_t *, phys_t);
 
 
 
@@ -295,7 +295,6 @@ static patid_t g_bitap_backend_enroll_plain_pattern(GBitapBackend *backend, GSca
 *                                                                             *
 *  Paramètres  : backend = moteur de recherche à manipuler.                   *
 *                context = lieu d'enregistrement des résultats.               *
-*                content = données binaires à analyser.                       *
 *                                                                             *
 *  Description : Parcours un contenu binaire à la recherche de motifs.        *
 *                                                                             *
@@ -305,12 +304,16 @@ static patid_t g_bitap_backend_enroll_plain_pattern(GBitapBackend *backend, GSca
 *                                                                             *
 ******************************************************************************/
 
-static void g_bitap_backend_run_scan(const GBitapBackend *backend, GScanContext *context, GBinContent *content)
+static void g_bitap_backend_run_scan(const GBitapBackend *backend, GScanContext *context)
 {
     cpu_set_t old_mask;                     /* Cartographie des CPU #1     */
     int ret;                                /* Bilan d'un appel            */
     unsigned int cpu;                       /* Processeur courant          */
     cpu_set_t new_mask;                     /* Cartographie des CPU #2     */
+    GBinContent *content;                   /* Contenu binaire manipulé    */
+    phys_t dlen;                            /* Quantité de données         */
+    vmpa2t pos;                             /* Point de départ ciblé       */
+    const bin_t *data;                      /* Données à analyser          */
 
     ret = sched_getaffinity(0, sizeof(cpu_set_t), &old_mask);
 
@@ -339,16 +342,24 @@ static void g_bitap_backend_run_scan(const GBitapBackend *backend, GScanContext
         goto exit;
     }
 
+    content = g_scan_context_get_content(context);
+
+    dlen = g_binary_content_compute_size(content);
+
+    g_binary_content_compute_start_pos(content, &pos);
+    data = g_binary_content_get_raw_access(content, &pos, dlen);
 
+    assert(data != NULL);
 
     if (0)
 
-        run_scan_avx2(backend, context, content);
+        run_scan_avx2(backend, context, data, dlen);
 
     else
 
-        run_scan_avx512(backend, context, content);
+        run_scan_avx512(backend, context, data, dlen);
 
+    g_object_unref(G_OBJECT(content));
 
  exit:
 
@@ -515,7 +526,8 @@ static patid_t enroll_plain_pattern_avx2(GBitapBackend *backend, GScanContext *c
 *                                                                             *
 *  Paramètres  : backend = moteur de recherche à manipuler.                   *
 *                context = lieu d'enregistrement des résultats.               *
-*                content = données binaires à analyser.                       *
+*                data    = données à analyser.                                *
+*                dlen    = quantité de ces données.                           *
 *                                                                             *
 *  Description : Parcours un contenu binaire à la recherche de motifs.        *
 *                                                                             *
@@ -525,12 +537,9 @@ static patid_t enroll_plain_pattern_avx2(GBitapBackend *backend, GScanContext *c
 *                                                                             *
 ******************************************************************************/
 
-static void run_scan_avx2(const GBitapBackend *backend, GScanContext *context, GBinContent *content)
+static void run_scan_avx2(const GBitapBackend *backend, GScanContext *context, const bin_t *data, phys_t dlen)
 {
     const group_manager_avx2_t *manager;    /* Accès simplifié             */
-    phys_t dlen;                            /* Quantité de données         */
-    vmpa2t pos;                             /* Point de départ ciblé       */
-    const bin_t *data;                      /* Données à analyser          */
 
     register __m256i zero asm("ymm11");                           /* Constante 0 sur 256 bits    */
     size_t k;                               /* Boucle de parcours #1       */
@@ -570,11 +579,6 @@ static void run_scan_avx2(const GBitapBackend *backend, GScanContext *context, G
 
     manager = &backend->manager_avx2;
 
-    dlen = g_binary_content_compute_size(content);
-
-    g_binary_content_compute_start_pos(content, &pos);
-    data = g_binary_content_get_raw_access(content, &pos, dlen);
-
     zero = _mm256_set1_epi16(0);
 
     asm volatile ("nop;nop;nop;nop;nop;nop;nop;nop;nop;");
@@ -1622,7 +1626,8 @@ static patid_t enroll_plain_pattern_avx512(GBitapBackend *backend, GScanContext
 *                                                                             *
 *  Paramètres  : backend = moteur de recherche à manipuler.                   *
 *                context = lieu d'enregistrement des résultats.               *
-*                content = données binaires à analyser.                       *
+*                data    = données à analyser.                                *
+*                dlen    = quantité de ces données.                           *
 *                                                                             *
 *  Description : Parcours un contenu binaire à la recherche de motifs.        *
 *                                                                             *
@@ -1632,12 +1637,9 @@ static patid_t enroll_plain_pattern_avx512(GBitapBackend *backend, GScanContext
 *                                                                             *
 ******************************************************************************/
 
-static void run_scan_avx512(const GBitapBackend *backend, GScanContext *context, GBinContent *content)
+static void run_scan_avx512(const GBitapBackend *backend, GScanContext *context, const bin_t *data, phys_t dlen)
 {
     const group_manager_avx512_t *manager;  /* Accès simplifié             */
-    phys_t dlen;                            /* Quantité de données         */
-    vmpa2t pos;                             /* Point de départ ciblé       */
-    const bin_t *data;                      /* Données à analyser          */
 
     //register __m512i zero asm("zmm19");                           /* Constante 0 sur 512 bits    */
 
@@ -1674,10 +1676,6 @@ static void run_scan_avx512(const GBitapBackend *backend, GScanContext *context,
 
     manager = &backend->manager_avx512;
 
-    dlen = g_binary_content_compute_size(content);
-
-    g_binary_content_compute_start_pos(content, &pos);
-    data = g_binary_content_get_raw_access(content, &pos, dlen);
 
 
 
diff --git a/src/analysis/scan/rule.c b/src/analysis/scan/rule.c
index 6c771fb..bf37585 100644
--- a/src/analysis/scan/rule.c
+++ b/src/analysis/scan/rule.c
@@ -338,7 +338,7 @@ bool g_scan_rule_setup_backend(GScanRule *rule, GEngineBackend *backend, GScanCo
 *                                                                             *
 ******************************************************************************/
 
-void g_scan_rule_analyze(GScanRule *rule, GEngineBackend *backend, GScanContext *context)
+void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *context)
 {
     GBinContent *content;                   /* Contenu à manipuler         */
     pending_matches_t matches;              /* Suivi de correspondances    */
@@ -350,8 +350,6 @@ void g_scan_rule_analyze(GScanRule *rule, GEngineBackend *backend, GScanContext
 
     content = g_scan_context_get_content(context);
 
-    g_engine_backend_run_scan(backend, context, content);
-
     /* Consolidation des résultats */
 
     for (i = 0; i < rule->data_used; i++)
diff --git a/src/analysis/scan/rule.h b/src/analysis/scan/rule.h
index edd57b3..e240da9 100644
--- a/src/analysis/scan/rule.h
+++ b/src/analysis/scan/rule.h
@@ -70,7 +70,7 @@ void g_scan_rule_set_match_condition(GScanRule *, GScanExpression *);
 bool g_scan_rule_setup_backend(GScanRule *, GEngineBackend *, GScanContext *);
 
 /* Lance une analyse d'un contenu binaire selon une règle. */
-void g_scan_rule_analyze(GScanRule *, GEngineBackend *, GScanContext *);
+void g_scan_rule_check(GScanRule *, GEngineBackend *, GScanContext *);
 
 
 
diff --git a/src/analysis/scan/scanner.c b/src/analysis/scan/scanner.c
index ae3cb9a..d52c0fc 100644
--- a/src/analysis/scan/scanner.c
+++ b/src/analysis/scan/scanner.c
@@ -332,8 +332,10 @@ GScanContext *g_content_scanner_analyze(GContentScanner *scanner, GScanOptions *
 
     g_scan_context_set_content(result, content);
 
+    g_engine_backend_run_scan(scanner->data_backend, result);
+
     for (i = 0; i < scanner->rule_count; i++)
-        g_scan_rule_analyze(scanner->rules[i], scanner->data_backend, result);
+        g_scan_rule_check(scanner->rules[i], scanner->data_backend, result);
 
  exit:
 
diff --git a/src/analysis/scan/scope.h b/src/analysis/scan/scope.h
new file mode 100644
index 0000000..1e5de2c
--- /dev/null
+++ b/src/analysis/scan/scope.h
@@ -0,0 +1,37 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * scope.h - prototypes pour la définition d'une portée locale de variables
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_SCAN_SCOPE_H
+#define _ANALYSIS_SCAN_SCOPE_H
+
+
+
+
+
+typedef void *GScanScope;
+
+
+
+
+
+#endif  /* _ANALYSIS_SCAN_SCOPE_H */
diff --git a/src/analysis/scan/space-int.h b/src/analysis/scan/space-int.h
index fa4437d..386785d 100644
--- a/src/analysis/scan/space-int.h
+++ b/src/analysis/scan/space-int.h
@@ -37,6 +37,8 @@ struct _GScanNamespace
 {
     GRegisteredItem parent;                 /* A laisser en premier        */
 
+    char *name;                             /* Désignation de l'espace     */
+
     GRegisteredItem **children;             /* Sous-éléments inscrits      */
     char **names;                           /* Désignations correspondantes*/
     size_t count;                           /* Quantité de sous-éléments   */
@@ -51,5 +53,9 @@ struct _GScanNamespaceClass
 };
 
 
+/* Met en place un nouvel espace de noms pour scan. */
+bool g_scan_namespace_create(GScanNamespace *, const char *);
+
+
 
 #endif  /* _ANALYSIS_SCAN_SPACE_INT_H */
diff --git a/src/analysis/scan/space.c b/src/analysis/scan/space.c
index 34b67fe..dc9a237 100644
--- a/src/analysis/scan/space.c
+++ b/src/analysis/scan/space.c
@@ -52,11 +52,14 @@ static void g_scan_namespace_finalize(GScanNamespace *);
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
-/* Lance une résolution d'élément à appeler. */
-GRegisteredItem *g_scan_namespace_resolve(GScanNamespace *, const char *, GScanContext *, GScanExpression **, size_t, bool, bool);
+/* Indique le nom associé à une expression d'évaluation. */
+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 **);
 
 /* Réduit une expression à une forme plus simple. */
-GScanExpression *g_scan_namespace_reduce(GScanNamespace *, GScanContext *, GScanExpression **, size_t, bool);
+static GScanExpression *g_scan_namespace_reduce(GScanNamespace *, GScanContext *, GScanExpression **, size_t, bool);
 
 
 
@@ -93,6 +96,7 @@ static void g_scan_namespace_class_init(GScanNamespaceClass *klass)
 
     registered = G_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;
     registered->reduce = (reduce_registered_item_fc)g_scan_namespace_reduce;
 
@@ -113,6 +117,8 @@ static void g_scan_namespace_class_init(GScanNamespaceClass *klass)
 
 static void g_scan_namespace_init(GScanNamespace *space)
 {
+    space->name = NULL;
+
     space->children = NULL;
     space->names = NULL;
     space->count = 0;
@@ -160,6 +166,9 @@ static void g_scan_namespace_finalize(GScanNamespace *space)
 {
     size_t i;                               /* Boucle de parcours          */
 
+    if (space->name != NULL)
+        free(space->name);
+
     if (space->children != NULL)
         free(space->children);
 
@@ -176,7 +185,7 @@ static void g_scan_namespace_finalize(GScanNamespace *space)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : name = désignation du futur espace de noms.                  *
 *                                                                             *
 *  Description : Construit un nouvel espace de noms pour scan.                *
 *                                                                             *
@@ -186,12 +195,42 @@ static void g_scan_namespace_finalize(GScanNamespace *space)
 *                                                                             *
 ******************************************************************************/
 
-GScanNamespace *g_scan_namespace_new(void)
+GScanNamespace *g_scan_namespace_new(const char *name)
 {
     GScanNamespace *result;                 /* Instance à retourner        */
 
     result = g_object_new(G_TYPE_SCAN_NAMESPACE, NULL);
 
+    if (!g_scan_namespace_create(result, name))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : space = instance d'espace de noms à initialiser.             *
+*                name  = désignation du futur espace de noms.                 *
+*                                                                             *
+*  Description : Met en place un nouvel espace de noms pour scan.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_namespace_create(GScanNamespace *space, const char *name)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    if (name != NULL)
+        space->name = strdup(name);
+
     return result;
 
 }
@@ -200,8 +239,7 @@ GScanNamespace *g_scan_namespace_new(void)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : space = espace de noms à compléter.                          *
-*                type  = type d'élément à intégrer.                           *
-*                name  = nom du futur espace ou NULL pour une racine.         *
+*                child = élément d'évaluation à intégrer.                     *
 *                                                                             *
 *  Description : Intègre un nouvel élément dans l'esapce de noms.             *
 *                                                                             *
@@ -211,19 +249,39 @@ GScanNamespace *g_scan_namespace_new(void)
 *                                                                             *
 ******************************************************************************/
 
-bool g_scan_namespace_register(GScanNamespace *space, GRegisteredItem *child, const char *name)
+bool g_scan_namespace_register_item(GScanNamespace *space, GRegisteredItem *child)
 {
     bool result;                            /* Bilan à retourner           */
+    char *name;                             /* Nom de l'élément à ajouter  */
+    size_t i;                               /* Boucle de parcours          */
 
-    result = true;
+    name = g_registered_item_get_name(child);
+
+    /* Validation de l'unicité du nom */
+
+    for (i = 0; i < space->count; i++)
+        if (strcmp(name, space->names[i]) == 0)
+            break;
 
-    space->count++;
+    result = (i == space->count);
 
-    space->children = realloc(space->children, space->count * sizeof(GRegisteredItem *));
-    space->children[space->count - 1] = child;
+    /* Inscription de l'élément ? */
 
-    space->names = realloc(space->names, space->count * sizeof(char *));
-    space->names[space->count - 1] = strdup(name);
+    if (!result)
+        free(name);
+
+    else
+    {
+        space->count++;
+
+        space->children = realloc(space->children, space->count * sizeof(GRegisteredItem *));
+        space->children[space->count - 1] = child;
+        g_object_ref(G_OBJECT(child));
+
+        space->names = realloc(space->names, space->count * sizeof(char *));
+        space->names[space->count - 1] = strdup(name);
+
+    }
 
     return result;
 
@@ -238,34 +296,59 @@ bool g_scan_namespace_register(GScanNamespace *space, GRegisteredItem *child, co
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : space  = élément d'appel à consulter.                        *
+*  Paramètres  : space = élément d'appel à consulter.                         *
+*                                                                             *
+*  Description : Indique le nom associé à une expression d'évaluation.        *
+*                                                                             *
+*  Retour      : Désignation humaine de l'expression d'évaluation.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_scan_namespace_get_name(const GScanNamespace *space)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    if (space->name != NULL)
+        result = strdup(space->name);
+
+    else
+        result = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item   = élément d'appel à consulter.                        *
 *                target = désignation de l'objet d'appel à identifier.        *
 *                ctx    = contexte de suivi de l'analyse courante.            *
-*                args   = liste d'éventuels arguments fournis.                *
-*                count  = taille de cette liste.                              *
-*                last   = l'élément est-il le dernier d'une chaîne d'appels ? *
-*                final = indique une ultime conversion dans le cycle en cours.*
+*                scope  = portée courante des variables locales.              *
+*                out    = zone d'enregistrement de la résolution opérée. [OUT]*
 *                                                                             *
-*  Description : Lance une résolution d'élément à appeler.                    *
+*  Description : Lance une résolution d'élément à solliciter.                 *
 *                                                                             *
-*  Retour      : Nouvel élément d'appel identifié ou NULL.                    *
+*  Retour      : Bilan de l'opération : false en cas d'erreur irrécupérable.  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GRegisteredItem *g_scan_namespace_resolve(GScanNamespace *space, const char *target, GScanContext *ctx, GScanExpression **args, size_t count, bool last, bool final)
+static bool g_scan_namespace_resolve(GScanNamespace *item, const char *target, GScanContext *ctx, GScanScope *scope, GRegisteredItem **out)
 {
-    GRegisteredItem *result;                /* Instance à renvoyer         */
+    bool result;                            /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours          */
 
-    result = NULL;
+    result = true;
 
-    for (i = 0; i < space->count; i++)
-        if (strcmp(target, space->names[i]) == 0)
+    for (i = 0; i < item->count; i++)
+        if (strcmp(target, item->names[i]) == 0)
         {
-            result = space->children[i];
-            g_object_ref(G_OBJECT(result));
+            *out = item->children[i];
+            g_object_ref(G_OBJECT(*out));
             break;
         }
 
@@ -290,11 +373,11 @@ GRegisteredItem *g_scan_namespace_resolve(GScanNamespace *space, const char *tar
 *                                                                             *
 ******************************************************************************/
 
-GScanExpression *g_scan_namespace_reduce(GScanNamespace *space, GScanContext *ctx, GScanExpression **args, size_t count, bool final)
+static GScanExpression *g_scan_namespace_reduce(GScanNamespace *space, GScanContext *ctx, GScanExpression **args, size_t count, bool final)
 {
     GScanExpression *result;                /* Instance à renvoyer         */
 
-    assert(false);
+    assert(false); /* REMME */
 
     result = NULL;
 
diff --git a/src/analysis/scan/space.h b/src/analysis/scan/space.h
index 9058959..7a99387 100644
--- a/src/analysis/scan/space.h
+++ b/src/analysis/scan/space.h
@@ -52,10 +52,10 @@ typedef struct _GScanNamespaceClass GScanNamespaceClass;
 GType g_scan_namespace_get_type(void);
 
 /* Construit un nouvel espace de noms pour scan. */
-GScanNamespace *g_scan_namespace_new(void);
+GScanNamespace *g_scan_namespace_new(const char *);
 
 /* Intègre un nouvel élément dans l'esapce de noms. */
-bool g_scan_namespace_register(GScanNamespace *, GRegisteredItem *, const char *);
+bool g_scan_namespace_register_item(GScanNamespace *, GRegisteredItem *);
 
 
 
diff --git a/src/analysis/scan/tokens.l b/src/analysis/scan/tokens.l
index 92a5340..b541786 100644
--- a/src/analysis/scan/tokens.l
+++ b/src/analysis/scan/tokens.l
@@ -107,7 +107,11 @@
 
 "rule"                          { PUSH_STATE(rule_intro); return RAW_RULE; }
 
-<rule_intro>[A-Za-z0-9_]+       {   yylval->cstring = yytext; return RULE_NAME; }
+<rule_intro>[A-Za-z0-9_]+       {
+                                    yylval->sized_cstring.data = yytext;
+                                    yylval->sized_cstring.len = yyleng;
+                                    return RULE_NAME;
+                                }
 
 <rule_intro>[ \t]*              {  }
 <rule_intro>"{"                 { POP_STATE; PUSH_STATE(raw_block); return BRACE_IN; }
@@ -139,7 +143,8 @@
                                     POP_STATE; 
                                     EXTEND_BUFFER_IF_NEEDED(1);
                                     (*buf)[(*used)++] = '\0';
-                                    yylval->cstring = *buf;
+                                    yylval->sized_cstring.data = *buf;
+                                    yylval->sized_cstring.len = *used;
                                     return STRING;
                                 }
 
@@ -206,12 +211,12 @@
 
 
 <strings,condition>$[A-Za-z0-9_]* {
-                                    yylval->sized_cstring.cstring = yytext + 1;
+                                    yylval->sized_cstring.data = yytext + 1;
                                     yylval->sized_cstring.len = yyleng - 1;
                                     return IDENTIFIER;
                                 }
 <condition>[A-Za-z_][A-Za-z0-9_]* {
-                                    yylval->sized_cstring.cstring = yytext;
+                                    yylval->sized_cstring.data = yytext;
                                     yylval->sized_cstring.len = yyleng;
                                     return NAME;
                                 }
@@ -221,7 +226,7 @@
 
 <strval>\"[^\"\\]+\"            {
                                     POP_STATE;
-                                    yylval->sized_cstring.cstring = yytext + 1;
+                                    yylval->sized_cstring.data = yytext + 1;
                                     yylval->sized_cstring.len = yyleng - 2;
                                     return PLAIN_STRING;
                                 }
diff --git a/src/common/extstr.c b/src/common/extstr.c
index 3041be0..ac93f5d 100644
--- a/src/common/extstr.c
+++ b/src/common/extstr.c
@@ -24,6 +24,7 @@
 #include "extstr.h"
 
 
+#include <ctype.h>
 #include <malloc.h>
 #include <regex.h>
 #include <stdio.h>
@@ -565,3 +566,106 @@ bool _endswith(const char *str, const char *suffix, const char **end)
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : haystack    = botte de foin composant l'espace de recherche. *
+*                haystacklen = taille de cet espace.                          *
+*                needle      = aiguille visée, cible des recherches.          *
+*                needlelen   = taille de l'aiguille à rechercher.             *
+*                                                                             *
+*  Description : Recherche une séquence d'octets dans un ensemble de données. *
+*                                                                             *
+*  Retour      : Adresse de l'éventuelle trouvaille ou NULL.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const void *memcasemem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
+{
+    const void *result;                     /* Trouvaille à renvoyer       */
+    const char *_haystack;                  /* Autre version de la botte   */
+    const char *_needle;                    /* Autre version de l'aiguille */
+    size_t i;                               /* Boucle de parcours #1       */
+    size_t k;                               /* Boucle de parcours #2       */
+    int c1;                                 /* Caractère de la chaîne #1   */
+    int c2;                                 /* Caractère de la chaîne #2   */
+
+    result = NULL;
+
+    if (needlelen > haystacklen)
+        goto done;
+
+    _haystack = (const char *)haystack;
+    _needle = (const char *)needle;
+
+    for (i = 0; i <= (haystacklen - needlelen); i++, _haystack++)
+    {
+        for (k = 0; k < needlelen; k++)
+        {
+            c1 = toupper(_haystack[k]);
+            c2 = toupper(_needle[k]);
+
+            if (c1 != c2)
+                break;
+
+        }
+
+        if (k == needlelen)
+        {
+            result = _haystack;
+            break;
+        }
+
+    }
+
+ done:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : s1 = première séquence d'octets à consulter.                 *
+*                s2 = second séquence d'octets à consulter.                   *
+*                n  = quantité d'octets à comparer.                           *
+*                                                                             *
+*  Description : Compare sans casse deux série d'octets entre elles.          *
+*                                                                             *
+*  Retour      : Status de la comparaison des séries d'octets.                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int memcasecmp(const void *s1, const void *s2, size_t n)
+{
+    int result;                             /* Statut à retourner          */
+    size_t i;                               /* Boucle de parcours          */
+    const char *_s1;                        /* Séquence avec taille #1     */
+    const char *_s2;                        /* Séquence avec taille #2     */
+    int c1;                                 /* Caractère de la chaîne #1   */
+    int c2;                                 /* Caractère de la chaîne #2   */
+
+    result = 0;
+
+    _s1 = (const char *)s1;
+    _s2 = (const char *)s2;
+
+    for (i = 0; i < n; i++)
+    {
+        c1 = toupper(_s1[i]);
+        c2 = toupper(_s2[i]);
+
+        result = c1 - c2;
+        if (result != 0) break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/common/extstr.h b/src/common/extstr.h
index c4e671e..a2293be 100644
--- a/src/common/extstr.h
+++ b/src/common/extstr.h
@@ -79,6 +79,12 @@ bool _endswith(const char *, const char *, const char **);
 #define startswith(str, prefix) _startswith(str, prefix, NULL)
 #define endswith(str, suffix) _endswith(str, suffix, NULL)
 
+/* Recherche une séquence d'octets dans un ensemble de données. */
+const void *memcasemem(const void *, size_t, const void *, size_t);
+
+/* Compare sans casse deux série d'octets entre elles. */
+int memcasecmp(const void *, const void *, size_t);
+
 
 
 #endif  /* _COMMON_EXTSTR_H */
diff --git a/src/common/szstr.h b/src/common/szstr.h
index aadbb28..54beb9a 100644
--- a/src/common/szstr.h
+++ b/src/common/szstr.h
@@ -47,6 +47,15 @@ typedef struct _sized_string_t
     }                       \
     while (0)
 
+#define szstrdup(dst, src)                              \
+    do                                                  \
+    {                                                   \
+        (dst)->data = malloc((src)->len);               \
+        memcpy((dst)->data, (src)->data, (src)->len);   \
+        (dst)->len = (src)->len;                        \
+    }                                                   \
+    while (0)
+
 #define exit_szstr(s)           \
     do                          \
     {                           \
@@ -59,18 +68,8 @@ typedef struct _sized_string_t
     while (0)
             
 #define szstrcmp(ss, rs) \
-    strncmp((ss)->data, rs, (ss)->len)
-
-#define szmemcmp(s1, s2)                                        \
-    ({                                                          \
-        int __result;                                           \
-        size_t __n;                                             \
-        __n = (s1)->len < (s2)->len ? (s1)->len : (s2)->len;    \
-        __result = memcmp((s1)->data, (s2)->data, __n);         \
-        if (__result == 0 && (s1)->len != (s2)->len)            \
-            __result = (s1)->len < (s2)->len ? -1 : 1;          \
-        __result;                                               \
-    })
+    strncmp((ss)->data, (rs)/*->data*/, (ss)->len)
+
 
 
 #endif  /* _COMMON_SZSTR_H */
diff --git a/src/core/core.c b/src/core/core.c
index 01ebbe1..8d4daa7 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -105,7 +105,7 @@ bool load_all_core_components(bool cs)
             resolver = g_content_resolver_new();
             set_current_content_resolver(resolver);
 
-            root_ns = g_scan_namespace_new();
+            root_ns = g_scan_namespace_new(NULL);
             set_rost_root_namespace(root_ns);
 
             if (result) result = populate_main_scan_namespace(root_ns);
diff --git a/src/glibext/comparison.h b/src/glibext/comparison.h
index 26e501c..8d43210 100644
--- a/src/glibext/comparison.h
+++ b/src/glibext/comparison.h
@@ -57,6 +57,17 @@ typedef enum _RichCmpOperation
 
 } RichCmpOperation;
 
+/* Détermination d'un besoin de comparaison supplémentaire */
+#define STATUS_NOT_EQUAL(_s, _o)                            \
+    ({                                                      \
+        bool __result;                                      \
+        if (_o == RCO_LE || _o == RCO_EQ || _o == RCO_GE)   \
+            __result = !_s;                                 \
+        else                                                \
+            __result = _s;                                  \
+        __result;                                           \
+    })
+
 
 /* Détermine le type d'une interface pour un objet comparable. */
 GType g_comparable_item_get_type(void) G_GNUC_CONST;