Save current state with some ROST extra features.

58 files changed, 6690 insertions, 972 deletions

diff --git a/src/analysis/scan/context.c b/src/analysis/scan/context.c
index 51fdd6b..9dd41cf 100644
--- a/src/analysis/scan/context.c
+++ b/src/analysis/scan/context.c
@@ -529,6 +529,8 @@ void g_scan_context_register_atom_match(GScanContext *context, patid_t id, phys_
         tracker->matches = realloc(tracker->matches, tracker->allocated * sizeof(phys_t));
     }
 
+    printf("++ register pat=%llu @ %llu\n", (unsigned long long)id, (unsigned long long)offset); // REMME
+
     tracker->matches[tracker->used++] = offset;
 
 }
@@ -585,6 +587,8 @@ void g_scan_context_register_full_match(GScanContext *context, GScanMatch *match
 
     pattern = g_scan_match_get_source(match);
 
+    printf("// register match=%p for pattern=%p\n", pattern, match); // REMME
+
     key.pattern = pattern;
 
     found = bsearch((full_match_tracker_t *[]) { &key }, context->full_trackers, context->full_count,
@@ -637,7 +641,7 @@ const GScanMatch **g_scan_context_get_full_matches(const GScanContext *context,
     if (found == NULL)
     {
         result = NULL;
-        count = 0;
+        *count = 0;
     }
 
     else
diff --git a/src/analysis/scan/core.c b/src/analysis/scan/core.c
index 3d4e529..0b2c1d5 100644
--- a/src/analysis/scan/core.c
+++ b/src/analysis/scan/core.c
@@ -37,6 +37,10 @@
 #   include "items/magic/mime-encoding.h"
 #   include "items/magic/mime-type.h"
 #endif
+#include "items/math/to_string.h"
+#include "items/string/lower.h"
+#include "items/string/to_int.h"
+#include "items/string/upper.h"
 #include "items/time/make.h"
 #include "items/time/now.h"
 #include "patterns/modifiers/hex.h"
@@ -280,6 +284,36 @@ bool populate_main_scan_namespace(GScanNamespace *space)
     }
 #endif
 
+    /* Math */
+
+    if (result)
+    {
+        ns = g_scan_namespace_new("math");
+        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+
+        if (result) result = REGISTER_FUNC(ns, g_scan_math_to_string_function_new());
+
+        g_object_unref(G_OBJECT(ns));
+
+    }
+
+    /* String */
+
+    if (result)
+    {
+        ns = g_scan_namespace_new("string");
+        result = g_scan_namespace_register_item(space, G_REGISTERED_ITEM(ns));
+
+        printf("g_scan_string_to_int_function_new(): %p\n", g_scan_string_to_int_function_new());
+
+        if (result) result = REGISTER_FUNC(ns, g_scan_string_lower_function_new());
+        if (result) result = REGISTER_FUNC(ns, g_scan_string_to_int_function_new());
+        if (result) result = REGISTER_FUNC(ns, g_scan_string_upper_function_new());
+
+        g_object_unref(G_OBJECT(ns));
+
+    }
+
     /* Time */
 
     if (result)
diff --git a/src/analysis/scan/exprs/call.c b/src/analysis/scan/exprs/call.c
index d9b2c13..f68159f 100644
--- a/src/analysis/scan/exprs/call.c
+++ b/src/analysis/scan/exprs/call.c
@@ -312,7 +312,7 @@ static ScanReductionState g_scan_pending_call_reduce(const GScanPendingCall *exp
 
                     for (k = 0; k < i; k++)
                     {
-                        new_args[k] = expr->args[i];
+                        new_args[k] = expr->args[k];
                         g_object_ref(G_OBJECT(new_args[k]));
                     }
 
diff --git a/src/analysis/scan/grammar.y b/src/analysis/scan/grammar.y
index c0aa52d..64bcd5b 100644
--- a/src/analysis/scan/grammar.y
+++ b/src/analysis/scan/grammar.y
@@ -16,6 +16,8 @@ static int yyerror(GContentScanner *, yyscan_t, GScanRule **, sized_string_t *,
 #define YY_TYPEDEF_YY_SCANNER_T
 typedef void *yyscan_t;
 
+#include <assert.h>
+
 #include "core.h"
 #include "scanner.h"
 #include "exprs/access.h"
@@ -34,7 +36,12 @@ typedef void *yyscan_t;
 #include "patterns/modifiers/list.h"
 #include "patterns/tokens/hex.h"
 #include "patterns/tokens/plain.h"
+#include "patterns/tokens/nodes/any.h"
+#include "patterns/tokens/nodes/choice.h"
+#include "patterns/tokens/nodes/masked.h"
+#include "patterns/tokens/nodes/not.h"
 #include "patterns/tokens/nodes/plain.h"
+#include "patterns/tokens/nodes/sequence.h"
 #include "../../core/logs.h"
 
 }
@@ -52,11 +59,11 @@ typedef void *yyscan_t;
 
     sized_string_t *tmp_cstring;            /* Série d'octets reconstituée */
 
-    struct {
-        bin_t byte;                         /* Valeur partielle recherchée */
-        uint8_t mask;                       /* Masque associé              */
-    } semi_mask;
-
+    struct
+    {
+        sized_string_t *tmp_values;         /* Série d'octets partiels     */
+        sized_string_t *tmp_masks;          /* Masques associés            */
+    } masked;
 
 
     GScanRule *rule;                        /* Nouvelle règle à intégrer   */
@@ -66,7 +73,8 @@ typedef void *yyscan_t;
     GScanTokenNode *node;                   /* Bribe de motif à intégrer   */
     GSearchPattern *pattern;                /* Nouveau motif à considérer  */
 
-    GScanTokenModifier *modifier;
+    GScanTokenModifier *modifier;           /* Modificateur pour texte     */
+    ScanPlainNodeFlags str_flags;           /* Fanions pour texte          */
 
 
     GScanExpression *expr;                  /* Expression de condition     */
@@ -114,6 +122,11 @@ YY_DECL;
 %token NAME
 
 
+%token NOCASE "nocase"
+%token FULLWORD "fullword"
+%token PRIVATE "private"
+
+
 %token HEX_BYTES
 %token FULL_MASK
 %token SEMI_MASK
@@ -128,8 +141,8 @@ YY_DECL;
 %token BRACE_IN BRACE_OUT ASSIGN COLON
 
 
-%token PLAIN_STRING
-%token MASKED_STRING
+%token PLAIN_TEXT
+%token ESCAPED_TEXT
 
 %token TRUE_            "true"
 %token FALSE_           "false"
@@ -204,25 +217,33 @@ YY_DECL;
 
 %type <rule> rule
 
-%type <sized_cstring> PLAIN_STRING
-%type <pattern> MASKED_STRING
+%type <sized_cstring> PLAIN_TEXT
+%type <tmp_cstring> ESCAPED_TEXT
 
 %type <tmp_cstring> HEX_BYTES
 %type <unsigned_integer> FULL_MASK
-%type <semi_mask> SEMI_MASK
+%type <masked> SEMI_MASK
 
 %type <tmp_cstring> REGEX_BYTES
 
 
+
+%type <pattern> str_pattern
+
 %type <modifier> modifiers
 %type <modifier> _modifiers
 %type <modifier> chained_modifiers
 %type <modifier> mod_stage
 %type <modifier> modifier
 
+%type <str_flags> str_flags
+
+
 %type <pattern> hex_pattern
 %type <node> hex_tokens
 %type <node> hex_token
+%type <node> hex_range
+%type <node> hex_choices
 
 
 
@@ -294,13 +315,21 @@ rules : /* empty */
         //rule : RAW_RULE RULE_NAME { printf("RULE %s\n", $2); } RAW_BLOCK { printf("BLOCK: %s\n", $4); }
 
 
-external : "include" STRING
-         {
-             bool __status;
-             __status = g_content_scanner_include_resource(scanner, $2.data);
-             if (!__status)
-                 YYERROR;
-         }
+          external : "include" PLAIN_TEXT
+                   {
+                       bool __status;
+                       __status = g_content_scanner_include_resource(scanner, $2.data);
+                       if (!__status)
+                           YYERROR;
+                   }
+                   | "include" ESCAPED_TEXT
+                   {
+                       bool __status;
+                       __status = g_content_scanner_include_resource(scanner, $2->data);
+                       if (!__status)
+                           YYERROR;
+                   }
+                   ;
 
 
 rule : RAW_RULE RULE_NAME
@@ -320,11 +349,16 @@ rule : RAW_RULE RULE_NAME
 
 
 strings : /* empty */
-        | STRINGS COLON string_decls
+        | STRINGS COLON bytes_decls
         ;
 
 
-      string_decls : string_decl
+       bytes_decls : str_pattern
+                   {
+                       if ($1 == NULL) YYERROR;
+                       g_scan_rule_add_local_variable(*built_rule, $1);
+                       g_object_unref(G_OBJECT($1));
+                   }
                    | hex_pattern
                    {
                        if ($1 == NULL) YYERROR;
@@ -332,55 +366,51 @@ strings : /* empty */
                        g_object_unref(G_OBJECT($1));
                    }
                    | regex_pattern
-                   | string_decls string_decl
-                   | string_decls hex_pattern
+                   | bytes_decls str_pattern
+                   {
+                       if ($2 == NULL) YYERROR;
+                       g_scan_rule_add_local_variable(*built_rule, $2);
+                       g_object_unref(G_OBJECT($2));
+                   }
+                   | bytes_decls hex_pattern
                    {
                        if ($2 == NULL) YYERROR;
                        g_scan_rule_add_local_variable(*built_rule, $2);
                        g_object_unref(G_OBJECT($2));
                    }
-                   | string_decls regex_pattern
+                   | bytes_decls regex_pattern
                    ;
 
-string_decl : BYTES_ID ASSIGN PLAIN_STRING modifiers
-            {
-                GSearchPattern *__pat;
-                __pat = g_scan_plain_bytes_new(&$3, NULL, SPBF_NONE);
-                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));
-
-                /*
-                string_token_t *__token;
-                //printf("built plain %s\n", $3.cstring);
-                GBytesPattern *__pat;
-                __token = create_plain_string_token($3.cstring, $3.len);
-                printf("token: %p\n", __token);
-                __pat = g_bytes_pattern_new();
-                g_bytes_pattern_append_string(__pat, $3.cstring, $3.len);
-                g_scan_rule_add_local_variable(*built_rule, $1, G_SEARCH_PATTERN(__pat));
-                g_object_unref(G_OBJECT(__pat));
-                */
-            }
-            | BYTES_ID ASSIGN MASKED_STRING
-            {
-                printf("built %p\n", $3);
-                /*
-                GBytesPattern *__pat;
-                __pat = g_bytes_pattern_new();
-                g_search_pattern_set_name(__pat, $1.cstring, $1.len);
-                g_bytes_pattern_append_string(__pat, "\xd9\x74\x24\xf4", 4);
-                g_scan_rule_add_local_variable(*built_rule, G_SEARCH_PATTERN(__pat));
-                */
-                /*
-                GSearchPattern *__pat;
-                __pat = G_SEARCH_PATTERN($3);
-                if (g_search_pattern_prepare(__pat))
-                    g_scan_rule_add_local_variable(*built_rule, $1, __pat);
-                g_clear_object(built_pattern);
-                */
-            }
-            ;
+
+/**
+ * Définition de motif en texte brut.
+ */
+
+       str_pattern : BYTES_ID ASSIGN PLAIN_TEXT modifiers str_flags
+                   {
+                       GScanTokenNode *node;
+
+                       node = g_scan_token_node_plain_new(&$3, $4, $5);
+
+                       $$ = g_scan_plain_bytes_new(node);
+                       g_search_pattern_set_name($$, $1.data, $1.len);
+
+                       g_object_unref(G_OBJECT(node));
+
+                   }
+                   | BYTES_ID ASSIGN ESCAPED_TEXT modifiers str_flags
+                   {
+                       GScanTokenNode *node;
+
+                       node = g_scan_token_node_plain_new($3, $4, $5);
+
+                       $$ = g_scan_plain_bytes_new(node);
+                       g_search_pattern_set_name($$, $1.data, $1.len);
+
+                       g_object_unref(G_OBJECT(node));
+
+                   }
+                   ;
 
 
 /**
@@ -450,23 +480,70 @@ string_decl : BYTES_ID ASSIGN PLAIN_STRING modifiers
                    }
                    ;
 
+
+/**
+ * Prise en charge des fanions pour texte.
+ */
+
+         str_flags : /* empty */
+                   {
+                       $$ = SPNF_NONE;
+                   }
+                   | str_flags "nocase"
+                   {
+                       $$ = $1 | SPNF_CASE_INSENSITIVE;
+                   }
+                   | str_flags "fullword"
+                   {
+                       $$ = $1 | SPNF_FULLWORD;
+                   }
+                   | str_flags "private"
+                   {
+                       $$ = $1 | SPNF_PRIVATE;
+                   }
+                   ;
+
+
 /**
  * Définition de motif en hexadécimal.
  */
 
        hex_pattern : BYTES_ID ASSIGN hex_tokens
                    {
-                       $$ = g_scan_hex_bytes_new($3);
+                       $$ = g_scan_hex_bytes_new($3, false);
+                       g_search_pattern_set_name($$, $1.data, $1.len);
+                   }
+                   | BYTES_ID ASSIGN hex_tokens "private"
+                   {
+                       $$ = g_scan_hex_bytes_new($3, true);
                        g_search_pattern_set_name($$, $1.data, $1.len);
                    }
                    ;
 
         hex_tokens : hex_token
                    {
+                       if ($1 == NULL) YYERROR;
+
                        $$ = $1;
+
                    }
                    | hex_tokens hex_token
                    {
+                       if ($2 == NULL) YYERROR;
+
+                       if (!G_IS_SCAN_TOKEN_NODE_SEQUENCE($1))
+                       {
+                           $$ = g_scan_token_node_sequence_new($1);
+                           g_object_unref(G_OBJECT($1));
+                           g_scan_token_node_sequence_add(G_SCAN_TOKEN_NODE_SEQUENCE($$), $2);
+                           g_object_unref(G_OBJECT($2));
+                       }
+                       else
+                       {
+                           $$ = $1;
+                           g_scan_token_node_sequence_add(G_SCAN_TOKEN_NODE_SEQUENCE($$), $2);
+                           g_object_unref(G_OBJECT($2));
+                       }
 
                    }
                    ;
@@ -477,62 +554,115 @@ string_decl : BYTES_ID ASSIGN PLAIN_STRING modifiers
                    }
                    | FULL_MASK
                    {
-                       printf("mask len: %llu\n", $1);
+                       phys_t min;
+                       phys_t max;
+
+                       min = $1;
+                       max = $1;
+
+                       $$ = g_scan_token_node_any_new(&min, &max);
+
                    }
                    | SEMI_MASK
                    {
-                       printf("semi mask: %hhx / %hhx \n", $1.byte, $1.mask);
+                       size_t i;
+                       masked_byte_t byte;
+
+                       assert($1.tmp_values->len == $1.tmp_masks->len);
+
+                       byte.value = $1.tmp_values->data[0];
+                       byte.mask = $1.tmp_masks->data[0];
+
+                       $$ = g_scan_token_node_masked_new(&byte);
+
+                       for (i = 1; i < $1.tmp_values->len; i++)
+                       {
+                           byte.value = $1.tmp_values->data[i];
+                           byte.mask = $1.tmp_masks->data[i];
+
+                           g_scan_token_node_masked_add(G_SCAN_TOKEN_NODE_MASKED($$), &byte);
+
+                       }
+
                    }
                    | hex_range
                    {
-                       printf("...range...\n");
+                       $$ = $1;
                    }
                    | "~" hex_token
                    {
-
-                       printf("hex -- NOT --\n");
+                       $$ = g_scan_token_node_not_new($2);
 
                    }
-                   | "(" hex_token "|" hex_token ")"
+                   | "(" hex_choices ")"
                    {
-
-                       printf("hex -- OR --\n");
-
+                       $$ = $2;
                    }
                    ;
 
          hex_range : "[" "-" "]"
                    {
-
-                       printf("got inf range\n");
-
+                       $$ = g_scan_token_node_any_new(NULL, NULL);
                    }
                    | "[" UNSIGNED_INTEGER "]"
                    {
+                       phys_t min;
+                       phys_t max;
+
+                       min = $2;
+                       max = $2;
 
-                       printf("got range [%llu]\n", $2);
+                       $$ = g_scan_token_node_any_new(&min, &max);
 
                    }
                    | "[" UNSIGNED_INTEGER "-" "]"
                    {
+                       phys_t min;
+
+                       min = $2;
 
-                       printf("got range [%llu -> ]\n", $2);
+                       $$ = g_scan_token_node_any_new(&min, NULL);
 
                    }
                    | "[" "-" UNSIGNED_INTEGER "]"
                    {
+                       phys_t max;
 
-                       printf("got range [ -> %llu]\n", $3);
+                       max = $3;
+
+                       $$ = g_scan_token_node_any_new(NULL, &max);
 
                    }
                    | "[" UNSIGNED_INTEGER "-" UNSIGNED_INTEGER "]"
                    {
+                       phys_t min;
+                       phys_t max;
+
+                       min = $2;
+                       max = $4;
 
-                       printf("got range [%llu -> %llu]\n", $2, $4);
+                       $$ = g_scan_token_node_any_new(&min, &max);
 
                    }
                    ;
 
+       hex_choices : hex_token "|" hex_token
+                   {
+                       $$ = g_scan_token_node_choice_new();
+                       g_scan_token_node_choice_add(G_SCAN_TOKEN_NODE_CHOICE($$), $1);
+                       g_object_unref(G_OBJECT($1));
+                       g_scan_token_node_choice_add(G_SCAN_TOKEN_NODE_CHOICE($$), $3);
+                       g_object_unref(G_OBJECT($3));
+                   }
+                   | hex_choices "|" hex_token
+                   {
+                       $$ = $1;
+                       g_scan_token_node_choice_add(G_SCAN_TOKEN_NODE_CHOICE($$), $3);
+                       g_object_unref(G_OBJECT($3));
+                   }
+                   ;
+
+
 /**
  * Définition de motif sous forme d'expression régulière
  */
diff --git a/src/analysis/scan/items/Makefile.am b/src/analysis/scan/items/Makefile.am
index ce39cad..89ae41e 100644
--- a/src/analysis/scan/items/Makefile.am
+++ b/src/analysis/scan/items/Makefile.am
@@ -20,6 +20,8 @@ libanalysisscanitems_la_SOURCES =			\
 libanalysisscanitems_la_LIBADD = 			\
 	console/libanalysisscanitemsconsole.la	\
 	$(MAGIC_LIBADD)							\
+	math/libanalysisscanitemsmath.la		\
+	string/libanalysisscanitemsstring.la	\
 	time/libanalysisscanitemstime.la
 
 libanalysisscanitems_la_CFLAGS = $(LIBGOBJ_CFLAGS)
@@ -30,4 +32,4 @@ devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
 dev_HEADERS = $(libanalysisscanitems_la_SOURCES:%c=)
 
 
-SUBDIRS = console $(MAGIC_SUBDIRS) time
+SUBDIRS = console $(MAGIC_SUBDIRS) math string time
diff --git a/src/analysis/scan/items/console/log.c b/src/analysis/scan/items/console/log.c
index f4031c7..02b6207 100644
--- a/src/analysis/scan/items/console/log.c
+++ b/src/analysis/scan/items/console/log.c
@@ -228,8 +228,8 @@ static bool g_scan_console_log_function_run_call(GScanConsoleLogFunction *item,
 {
     bool result;                            /* Bilan à retourner           */
     size_t i;                               /* Boucle de parcours #1       */
-    LiteralValueType vtype;                 /* Type de valeur portée       */
     GScanLiteralExpression *literal;        /* Version plus accessible     */
+    LiteralValueType vtype;                 /* Type de valeur portée       */
     bool boolean;                           /* Valeur booléenne            */
     long long sinteger;                     /* Valeur entière signée   */
     unsigned long long uinteger;            /* Valeur entière non signée   */
@@ -275,13 +275,14 @@ static bool g_scan_console_log_function_run_call(GScanConsoleLogFunction *item,
 
             case LVT_STRING:
                 result = g_scan_literal_expression_get_string_value(literal, &string);
-                for (k = 0; k < string->len; k++)
-                {
-                    if (isprint(string->data[k]))
-                        fprintf(stderr, "%c", string->data[k]);
-                    else
-                        fprintf(stderr, "\\x%02hhx", string->data[k]);
-                }
+                if (result)
+                    for (k = 0; k < string->len; k++)
+                    {
+                        if (isprint(string->data[k]))
+                            fprintf(stderr, "%c", string->data[k]);
+                        else
+                            fprintf(stderr, "\\x%02hhx", string->data[k]);
+                    }
                 break;
 
             default:
diff --git a/src/analysis/scan/items/math/Makefile.am b/src/analysis/scan/items/math/Makefile.am
new file mode 100644
index 0000000..1f37c72
--- /dev/null
+++ b/src/analysis/scan/items/math/Makefile.am
@@ -0,0 +1,13 @@
+
+noinst_LTLIBRARIES  = libanalysisscanitemsmath.la
+
+
+libanalysisscanitemsmath_la_SOURCES =		\
+	to_string.h to_string.c
+
+libanalysisscanitemsmath_la_CFLAGS = $(LIBGOBJ_CFLAGS)
+
+
+devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
+
+dev_HEADERS = $(libanalysisscanitemsmath_la_SOURCES:%c=)
diff --git a/src/analysis/scan/items/math/to_string.c b/src/analysis/scan/items/math/to_string.c
new file mode 100644
index 0000000..4bb8363
--- /dev/null
+++ b/src/analysis/scan/items/math/to_string.c
@@ -0,0 +1,381 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * to_string.c - conversion d'une valeur entière en chaîne
+ *
+ * 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 "to_string.h"
+
+
+#include <assert.h>
+#include <stdlib.h>
+
+
+#include "../../item-int.h"
+#include "../../exprs/literal.h"
+
+
+
+/* ---------------------- INTRODUCTION D'UNE NOUVELLE FONCTION ---------------------- */
+
+
+/* Initialise la classe des conversions de texte en entier. */
+static void g_scan_math_to_string_function_class_init(GScanMathToStringFunctionClass *);
+
+/* Initialise une instance de conversion de texte en entier. */
+static void g_scan_math_to_string_function_init(GScanMathToStringFunction *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_math_to_string_function_dispose(GScanMathToStringFunction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_math_to_string_function_finalize(GScanMathToStringFunction *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_scan_math_to_string_function_get_name(const GScanMathToStringFunction *);
+
+/* Réalise la conversion d'une valeur en texte. */
+static void convert_integer_to_string(unsigned long long, unsigned long long, char **);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_scan_math_to_string_function_run_call(GScanMathToStringFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        INTRODUCTION D'UNE NOUVELLE FONCTION                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une conversion d'entier en texte. */
+G_DEFINE_TYPE(GScanMathToStringFunction, g_scan_math_to_string_function, G_TYPE_REGISTERED_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des conversions de texte en entier.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_math_to_string_function_class_init(GScanMathToStringFunctionClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GRegisteredItemClass *registered;       /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_math_to_string_function_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_math_to_string_function_finalize;
+
+    registered = G_REGISTERED_ITEM_CLASS(klass);
+
+    registered->get_name = (get_registered_item_name_fc)g_scan_math_to_string_function_get_name;
+    registered->run_call = (run_registered_item_call_fc)g_scan_math_to_string_function_run_call;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance de conversion de texte en entier.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_math_to_string_function_init(GScanMathToStringFunction *func)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_math_to_string_function_dispose(GScanMathToStringFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_math_to_string_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_math_to_string_function_finalize(GScanMathToStringFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_math_to_string_function_parent_class)->finalize(G_OBJECT(func));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée une fonction de conversion de valeur entière en texte.  *
+*                                                                             *
+*  Retour      : Fonction mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRegisteredItem *g_scan_math_to_string_function_new(void)
+{
+    GRegisteredItem *result;                /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_MATH_TO_STRING_FUNCTION, NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_scan_math_to_string_function_get_name(const GScanMathToStringFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("to_string");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : val  = valeur entière à traiter.                             *
+*                base = base à considérer.                                    *
+*                data = tête d'écriture à faire évoluer. [OUT]                *
+*                                                                             *
+*  Description : Réalise la conversion d'une valeur en texte.                 *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void convert_integer_to_string(unsigned long long val, unsigned long long base, char **data)
+{
+    static const char digits[16] = "0123456789abcdef";
+
+    if (val < base)
+        *((*data)++) = digits[val];
+
+    else
+    {
+        convert_integer_to_string(val / base, base, data);
+
+        *((*data)++) = digits[val % base];
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_scan_math_to_string_function_run_call(GScanMathToStringFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GScanLiteralExpression *literal;        /* Version plus accessible     */
+    LiteralValueType vtype;                 /* Type de valeur portée       */
+    long long sval;                         /* Valeur signée obtenue       */
+    unsigned long long uval;                /* Valeur non signée obtenue   */
+    bool negative;                          /* Besoin de signe en préfixe ?*/
+    unsigned long long base;                /* Base de conversion          */
+    char *data;                             /* Chaîne "C" à constituer     */
+    char *iter;                             /* Tête d'écriture             */
+    sized_string_t string;                  /* Chaîne finale complète      */
+
+    /* Validation des arguments */
+
+    result = (count == 1 || count == 2);
+    if (!result) goto exit;
+
+    result = G_IS_SCAN_LITERAL_EXPRESSION(args[0]);
+    if (!result) goto exit;
+
+    literal = G_SCAN_LITERAL_EXPRESSION(args[0]);
+
+    vtype = g_scan_literal_expression_get_value_type(literal);
+
+    result = (vtype == LVT_SIGNED_INTEGER || vtype == LVT_UNSIGNED_INTEGER);
+    if (!result) goto exit;
+
+    if (vtype == LVT_SIGNED_INTEGER)
+    {
+        result = g_scan_literal_expression_get_signed_integer_value(literal, &sval);
+        if (!result) goto exit;
+
+        assert(sval < 0);
+
+        negative = (sval < 0);
+
+        if (negative)
+            uval = -sval;
+
+    }
+    else
+    {
+        result = g_scan_literal_expression_get_unsigned_integer_value(literal, &uval);
+        if (!result) goto exit;
+    }
+
+    if (count == 1)
+        base = 10;
+
+    else
+    {
+        result = G_IS_SCAN_LITERAL_EXPRESSION(args[1]);
+        if (!result) goto exit;
+
+        literal = G_SCAN_LITERAL_EXPRESSION(args[1]);
+
+        vtype = g_scan_literal_expression_get_value_type(literal);
+
+        result = (vtype == LVT_UNSIGNED_INTEGER);
+        if (!result) goto exit;
+
+        result = g_scan_literal_expression_get_unsigned_integer_value(literal, &base);
+        if (!result) goto exit;
+
+        result = (base == 2 || base == 8 || base == 10 || base == 16);
+        if (!result) goto exit;
+
+    }
+
+    /* Réalisation de l'opération attendue */
+
+    data = malloc((1 + 2 + 64 * 8 + 1) * sizeof(char));
+    iter = data;
+
+    if (negative)
+        *(iter++) = '-';
+
+    switch (base)
+    {
+        case 2:
+            *(iter++) = '0';
+            *(iter++) = 'b';
+            break;
+
+        case 8:
+            *(iter++) = '0';
+            break;
+
+        case 10:
+            break;
+
+        case 16:
+            *(iter++) = '0';
+            *(iter++) = 'x';
+            break;
+
+        default:
+            assert(false);
+            break;
+
+    }
+
+    convert_integer_to_string(uval, base, &iter);
+
+    string.data = data;
+    string.len = iter - data;
+
+    *out = G_OBJECT(g_scan_literal_expression_new(LVT_STRING, &string));
+
+    free(data);
+
+    result = true;
+
+ exit:
+
+    return result;
+
+}
diff --git a/src/analysis/scan/items/math/to_string.h b/src/analysis/scan/items/math/to_string.h
new file mode 100644
index 0000000..19f0020
--- /dev/null
+++ b/src/analysis/scan/items/math/to_string.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * to_string.h - prototypes pour la conversion d'une valeur entière en chaîne
+ *
+ * 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_ITEMS_MATH_TO_STRING_H
+#define _ANALYSIS_SCAN_ITEMS_MATH_TO_STRING_H
+
+
+#include <glib-object.h>
+
+
+#include "../../item.h"
+
+
+
+#define G_TYPE_SCAN_MATH_TO_STRING_FUNCTION            g_scan_math_to_string_function_get_type()
+#define G_SCAN_MATH_TO_STRING_FUNCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_MATH_TO_STRING_FUNCTION, GScanMathToStringFunction))
+#define G_IS_SCAN_MATH_TO_STRING_FUNCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_MATH_TO_STRING_FUNCTION))
+#define G_SCAN_MATH_TO_STRING_FUNCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_MATH_TO_STRING_FUNCTION, GScanMathToStringFunctionClass))
+#define G_IS_SCAN_MATH_TO_STRING_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_MATH_TO_STRING_FUNCTION))
+#define G_SCAN_MATH_TO_STRING_FUNCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_MATH_TO_STRING_FUNCTION, GScanMathToStringFunctionClass))
+
+
+/* Conversion d'une valeur entière en valeur textuelle (instance) */
+typedef GRegisteredItem GScanMathToStringFunction;
+
+/* Conversion d'une valeur entière en valeur textuelle (classe) */
+typedef GRegisteredItemClass GScanMathToStringFunctionClass;
+
+
+/* Indique le type défini pour une conversion d'entier en texte. */
+GType g_scan_math_to_string_function_get_type(void);
+
+/* Crée une fonction de conversion de valeur entière en texte. */
+GRegisteredItem *g_scan_math_to_string_function_new(void);
+
+
+
+#endif  /* _ANALYSIS_SCAN_ITEMS_MATH_TO_STRING_H */
diff --git a/src/analysis/scan/items/string/Makefile.am b/src/analysis/scan/items/string/Makefile.am
new file mode 100644
index 0000000..c9ce6a3
--- /dev/null
+++ b/src/analysis/scan/items/string/Makefile.am
@@ -0,0 +1,15 @@
+
+noinst_LTLIBRARIES  = libanalysisscanitemsstring.la
+
+
+libanalysisscanitemsstring_la_SOURCES =		\
+	lower.h lower.c							\
+	to_int.h to_int.c						\
+	upper.h upper.c
+
+libanalysisscanitemsstring_la_CFLAGS = $(LIBGOBJ_CFLAGS)
+
+
+devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
+
+dev_HEADERS = $(libanalysisscanitemsstring_la_SOURCES:%c=)
diff --git a/src/analysis/scan/items/string/lower.c b/src/analysis/scan/items/string/lower.c
new file mode 100644
index 0000000..be8b133
--- /dev/null
+++ b/src/analysis/scan/items/string/lower.c
@@ -0,0 +1,270 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * lower.c - bascule de lettres en minuscules
+ *
+ * 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 "lower.h"
+
+
+#include <ctype.h>
+
+
+#include "../../item-int.h"
+#include "../../exprs/literal.h"
+
+
+
+/* ---------------------- INTRODUCTION D'UNE NOUVELLE FONCTION ---------------------- */
+
+
+/* Initialise la classe des bascules de lettres en minuscules. */
+static void g_scan_string_lower_function_class_init(GScanStringLowerFunctionClass *);
+
+/* Initialise une instance de bascule de lettres en minuscules. */
+static void g_scan_string_lower_function_init(GScanStringLowerFunction *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_string_lower_function_dispose(GScanStringLowerFunction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_string_lower_function_finalize(GScanStringLowerFunction *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_scan_string_lower_function_get_name(const GScanStringLowerFunction *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_scan_string_lower_function_run_call(GScanStringLowerFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        INTRODUCTION D'UNE NOUVELLE FONCTION                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
+G_DEFINE_TYPE(GScanStringLowerFunction, g_scan_string_lower_function, G_TYPE_REGISTERED_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des bascules de lettres en minuscules.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_lower_function_class_init(GScanStringLowerFunctionClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GRegisteredItemClass *registered;       /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_lower_function_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_string_lower_function_finalize;
+
+    registered = G_REGISTERED_ITEM_CLASS(klass);
+
+    registered->get_name = (get_registered_item_name_fc)g_scan_string_lower_function_get_name;
+    registered->run_call = (run_registered_item_call_fc)g_scan_string_lower_function_run_call;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance de bascule de lettres en minuscules. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_lower_function_init(GScanStringLowerFunction *func)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_lower_function_dispose(GScanStringLowerFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_lower_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_string_lower_function_finalize(GScanStringLowerFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_lower_function_parent_class)->finalize(G_OBJECT(func));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Constitue une fonction de bascule de lettres en minuscules.  *
+*                                                                             *
+*  Retour      : Fonction mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRegisteredItem *g_scan_string_lower_function_new(void)
+{
+    GRegisteredItem *result;                /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_STRING_LOWER_FUNCTION, NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_scan_string_lower_function_get_name(const GScanStringLowerFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("lower");
+
+    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_scan_string_lower_function_run_call(GScanStringLowerFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GScanLiteralExpression *literal;        /* Version plus accessible     */
+    LiteralValueType vtype;                 /* Type de valeur portée       */
+    const sized_string_t *string;           /* Description du chaîne       */
+    sized_string_t new;                     /* Description transformée     */
+    size_t i;                               /* Boucle de parcours          */
+
+    /* Validation des arguments */
+
+    result = (count == 1);
+    if (!result) goto exit;
+
+    result = G_IS_SCAN_LITERAL_EXPRESSION(args[0]);
+    if (!result) goto exit;
+
+    literal = G_SCAN_LITERAL_EXPRESSION(args[0]);
+
+    vtype = g_scan_literal_expression_get_value_type(literal);
+
+    result = (vtype == LVT_STRING);
+    if (!result) goto exit;
+
+    result = g_scan_literal_expression_get_string_value(literal, &string);
+    if (!result) goto exit;
+
+    /* Réalisation de l'opération attendue */
+
+    new.data = malloc(string->len);
+    new.len = string->len;
+
+    for (i = 0; i < string->len; i++)
+        new.data[i] = tolower(string->data[i]);
+
+    *out = G_OBJECT(g_scan_literal_expression_new(LVT_STRING, &new));
+
+    exit_szstr(&new);
+
+ exit:
+
+    return result;
+
+}
diff --git a/src/analysis/scan/items/string/lower.h b/src/analysis/scan/items/string/lower.h
new file mode 100644
index 0000000..f844a65
--- /dev/null
+++ b/src/analysis/scan/items/string/lower.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * lower.h - prototypes pour la bascule de lettres en minuscules
+ *
+ * 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_ITEMS_STRING_LOWER_H
+#define _ANALYSIS_SCAN_ITEMS_STRING_LOWER_H
+
+
+#include <glib-object.h>
+
+
+#include "../../item.h"
+
+
+
+#define G_TYPE_SCAN_STRING_LOWER_FUNCTION            g_scan_string_lower_function_get_type()
+#define G_SCAN_STRING_LOWER_FUNCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_STRING_LOWER_FUNCTION, GScanStringLowerFunction))
+#define G_IS_SCAN_STRING_LOWER_FUNCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_STRING_LOWER_FUNCTION))
+#define G_SCAN_STRING_LOWER_FUNCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_STRING_LOWER_FUNCTION, GScanStringLowerFunctionClass))
+#define G_IS_SCAN_STRING_LOWER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_STRING_LOWER_FUNCTION))
+#define G_SCAN_STRING_LOWER_FUNCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_STRING_LOWER_FUNCTION, GScanStringLowerFunctionClass))
+
+
+/* Bascule d'une suite de caractères en minuscules (instance) */
+typedef GRegisteredItem GScanStringLowerFunction;
+
+/* Bascule d'une suite de caractères en minuscules (classe) */
+typedef GRegisteredItemClass GScanStringLowerFunctionClass;
+
+
+/* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
+GType g_scan_string_lower_function_get_type(void);
+
+/* Constitue une fonction de bascule de lettres en minuscules. */
+GRegisteredItem *g_scan_string_lower_function_new(void);
+
+
+
+#endif  /* _ANALYSIS_SCAN_ITEMS_STRING_LOWER_H */
diff --git a/src/analysis/scan/items/string/to_int.c b/src/analysis/scan/items/string/to_int.c
new file mode 100644
index 0000000..8031d4d
--- /dev/null
+++ b/src/analysis/scan/items/string/to_int.c
@@ -0,0 +1,303 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * to_int.c - conversion d'une chaîne en valeur entière
+ *
+ * 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 "to_int.h"
+
+
+#include <stdlib.h>
+
+
+#include "../../item-int.h"
+#include "../../exprs/literal.h"
+
+
+
+/* ---------------------- INTRODUCTION D'UNE NOUVELLE FONCTION ---------------------- */
+
+
+/* Initialise la classe des conversions de texte en entier. */
+static void g_scan_string_to_int_function_class_init(GScanStringToIntFunctionClass *);
+
+/* Initialise une instance de conversion de texte en entier. */
+static void g_scan_string_to_int_function_init(GScanStringToIntFunction *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_string_to_int_function_dispose(GScanStringToIntFunction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_string_to_int_function_finalize(GScanStringToIntFunction *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_scan_string_to_int_function_get_name(const GScanStringToIntFunction *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_scan_string_to_int_function_run_call(GScanStringToIntFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        INTRODUCTION D'UNE NOUVELLE FONCTION                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une conversion de texte en entier. */
+G_DEFINE_TYPE(GScanStringToIntFunction, g_scan_string_to_int_function, G_TYPE_REGISTERED_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des conversions de texte en entier.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_to_int_function_class_init(GScanStringToIntFunctionClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GRegisteredItemClass *registered;       /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_to_int_function_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_string_to_int_function_finalize;
+
+    registered = G_REGISTERED_ITEM_CLASS(klass);
+
+    registered->get_name = (get_registered_item_name_fc)g_scan_string_to_int_function_get_name;
+    registered->run_call = (run_registered_item_call_fc)g_scan_string_to_int_function_run_call;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance de conversion de texte en entier.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_to_int_function_init(GScanStringToIntFunction *func)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_to_int_function_dispose(GScanStringToIntFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_to_int_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_string_to_int_function_finalize(GScanStringToIntFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_to_int_function_parent_class)->finalize(G_OBJECT(func));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée une fonction de conversion de texte en valeur entière.  *
+*                                                                             *
+*  Retour      : Fonction mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRegisteredItem *g_scan_string_to_int_function_new(void)
+{
+    GRegisteredItem *result;                /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_STRING_TO_INT_FUNCTION, NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_scan_string_to_int_function_get_name(const GScanStringToIntFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("to_int");
+
+    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_scan_string_to_int_function_run_call(GScanStringToIntFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GScanLiteralExpression *literal;        /* Version plus accessible     */
+    LiteralValueType vtype;                 /* Type de valeur portée       */
+    const sized_string_t *string;           /* Chaîne à convertir          */
+    unsigned long long base;                /* Base de conversion          */
+    char *data;                             /* Chaîne "C" à considérer     */
+    long long sval;                         /* Valeur signée obtenue       */
+    unsigned long long uval;                /* Valeur non signée obtenue   */
+
+    /* Validation des arguments */
+
+    result = (count == 1 || count == 2);
+    if (!result) goto exit;
+
+    result = G_IS_SCAN_LITERAL_EXPRESSION(args[0]);
+    if (!result) goto exit;
+
+    literal = G_SCAN_LITERAL_EXPRESSION(args[0]);
+
+    vtype = g_scan_literal_expression_get_value_type(literal);
+
+    result = (vtype == LVT_STRING);
+    if (!result) goto exit;
+
+    result = g_scan_literal_expression_get_string_value(literal, &string);
+    if (!result) goto exit;
+
+    if (string->len == 0) goto exit;
+
+    if (count == 1)
+        base = 0;
+
+    else
+    {
+        result = G_IS_SCAN_LITERAL_EXPRESSION(args[1]);
+        if (!result) goto exit;
+
+        literal = G_SCAN_LITERAL_EXPRESSION(args[1]);
+
+        vtype = g_scan_literal_expression_get_value_type(literal);
+
+        result = (vtype == LVT_UNSIGNED_INTEGER);
+        if (!result) goto exit;
+
+        result = g_scan_literal_expression_get_unsigned_integer_value(literal, &base);
+        if (!result) goto exit;
+
+    }
+
+    /* Réalisation de l'opération attendue */
+
+    data = strndup(string->data, string->len);
+
+    if (string->data[0] == '-')
+    {
+        sval = strtoll(data, NULL, base);
+
+        *out = G_OBJECT(g_scan_literal_expression_new(LVT_SIGNED_INTEGER, &sval));
+
+    }
+    else
+    {
+        uval = strtoll(data, NULL, base);
+
+        *out = G_OBJECT(g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, &uval));
+
+    }
+
+    free(data);
+
+ exit:
+
+    return result;
+
+}
diff --git a/src/analysis/scan/items/string/to_int.h b/src/analysis/scan/items/string/to_int.h
new file mode 100644
index 0000000..143da44
--- /dev/null
+++ b/src/analysis/scan/items/string/to_int.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * to_int.h - prototypes pour la conversion d'une chaîne en valeur entière
+ *
+ * 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_ITEMS_STRING_TO_INT_H
+#define _ANALYSIS_SCAN_ITEMS_STRING_TO_INT_H
+
+
+#include <glib-object.h>
+
+
+#include "../../item.h"
+
+
+
+#define G_TYPE_SCAN_STRING_TO_INT_FUNCTION            g_scan_string_to_int_function_get_type()
+#define G_SCAN_STRING_TO_INT_FUNCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_STRING_TO_INT_FUNCTION, GScanStringToIntFunction))
+#define G_IS_SCAN_STRING_TO_INT_FUNCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_STRING_TO_INT_FUNCTION))
+#define G_SCAN_STRING_TO_INT_FUNCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_STRING_TO_INT_FUNCTION, GScanStringToIntFunctionClass))
+#define G_IS_SCAN_STRING_TO_INT_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_STRING_TO_INT_FUNCTION))
+#define G_SCAN_STRING_TO_INT_FUNCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_STRING_TO_INT_FUNCTION, GScanStringToIntFunctionClass))
+
+
+/* Conversion d'une valeur textuelle en valeur entière (instance) */
+typedef GRegisteredItem GScanStringToIntFunction;
+
+/* Conversion d'une valeur textuelle en valeur entière (classe) */
+typedef GRegisteredItemClass GScanStringToIntFunctionClass;
+
+
+/* Indique le type défini pour une conversion de texte en entier. */
+GType g_scan_string_to_int_function_get_type(void);
+
+/* Crée une fonction de conversion de texte en valeur entière. */
+GRegisteredItem *g_scan_string_to_int_function_new(void);
+
+
+
+#endif  /* _ANALYSIS_SCAN_ITEMS_STRING_TO_INT_H */
diff --git a/src/analysis/scan/items/string/upper.c b/src/analysis/scan/items/string/upper.c
new file mode 100644
index 0000000..2ddd0dc
--- /dev/null
+++ b/src/analysis/scan/items/string/upper.c
@@ -0,0 +1,270 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * upper.c - bascule de lettres en majuscules
+ *
+ * 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 "upper.h"
+
+
+#include <ctype.h>
+
+
+#include "../../item-int.h"
+#include "../../exprs/literal.h"
+
+
+
+/* ---------------------- INTRODUCTION D'UNE NOUVELLE FONCTION ---------------------- */
+
+
+/* Initialise la classe des bascules de lettres en majuscules. */
+static void g_scan_string_upper_function_class_init(GScanStringUpperFunctionClass *);
+
+/* Initialise une instance de bascule de lettres en majuscules. */
+static void g_scan_string_upper_function_init(GScanStringUpperFunction *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_string_upper_function_dispose(GScanStringUpperFunction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_string_upper_function_finalize(GScanStringUpperFunction *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Indique le nom associé à une expression d'évaluation. */
+static char *g_scan_string_upper_function_get_name(const GScanStringUpperFunction *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_scan_string_upper_function_run_call(GScanStringUpperFunction *, GScanExpression **, size_t, GScanContext *, GScanScope *, GObject **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        INTRODUCTION D'UNE NOUVELLE FONCTION                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
+G_DEFINE_TYPE(GScanStringUpperFunction, g_scan_string_upper_function, G_TYPE_REGISTERED_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des bascules de lettres en majuscules.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_upper_function_class_init(GScanStringUpperFunctionClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GRegisteredItemClass *registered;       /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_string_upper_function_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_string_upper_function_finalize;
+
+    registered = G_REGISTERED_ITEM_CLASS(klass);
+
+    registered->get_name = (get_registered_item_name_fc)g_scan_string_upper_function_get_name;
+    registered->run_call = (run_registered_item_call_fc)g_scan_string_upper_function_run_call;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance de bascule de lettres en majuscules. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_upper_function_init(GScanStringUpperFunction *func)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : func = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_string_upper_function_dispose(GScanStringUpperFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_upper_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_string_upper_function_finalize(GScanStringUpperFunction *func)
+{
+    G_OBJECT_CLASS(g_scan_string_upper_function_parent_class)->finalize(G_OBJECT(func));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Constitue une fonction de bascule de lettres en majuscules.  *
+*                                                                             *
+*  Retour      : Fonction mise en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRegisteredItem *g_scan_string_upper_function_new(void)
+{
+    GRegisteredItem *result;                /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_STRING_UPPER_FUNCTION, NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_scan_string_upper_function_get_name(const GScanStringUpperFunction *item)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("upper");
+
+    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_scan_string_upper_function_run_call(GScanStringUpperFunction *item, GScanExpression **args, size_t count, GScanContext *ctx, GScanScope *scope, GObject **out)
+{
+    bool result;                            /* Bilan à retourner           */
+    GScanLiteralExpression *literal;        /* Version plus accessible     */
+    LiteralValueType vtype;                 /* Type de valeur portée       */
+    const sized_string_t *string;           /* Description du chaîne       */
+    sized_string_t new;                     /* Description transformée     */
+    size_t i;                               /* Boucle de parcours          */
+
+    /* Validation des arguments */
+
+    result = (count == 1);
+    if (!result) goto exit;
+
+    result = G_IS_SCAN_LITERAL_EXPRESSION(args[0]);
+    if (!result) goto exit;
+
+    literal = G_SCAN_LITERAL_EXPRESSION(args[0]);
+
+    vtype = g_scan_literal_expression_get_value_type(literal);
+
+    result = (vtype == LVT_STRING);
+    if (!result) goto exit;
+
+    result = g_scan_literal_expression_get_string_value(literal, &string);
+    if (!result) goto exit;
+
+    /* Réalisation de l'opération attendue */
+
+    new.data = malloc(string->len);
+    new.len = string->len;
+
+    for (i = 0; i < string->len; i++)
+        new.data[i] = toupper(string->data[i]);
+
+    *out = G_OBJECT(g_scan_literal_expression_new(LVT_STRING, &new));
+
+    exit_szstr(&new);
+
+ exit:
+
+    return result;
+
+}
diff --git a/src/analysis/scan/items/string/upper.h b/src/analysis/scan/items/string/upper.h
new file mode 100644
index 0000000..4f6e4bc
--- /dev/null
+++ b/src/analysis/scan/items/string/upper.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * upper.h - prototypes pour la bascule de lettres en majuscules
+ *
+ * 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_ITEMS_STRING_UPPER_H
+#define _ANALYSIS_SCAN_ITEMS_STRING_UPPER_H
+
+
+#include <glib-object.h>
+
+
+#include "../../item.h"
+
+
+
+#define G_TYPE_SCAN_STRING_UPPER_FUNCTION            g_scan_string_upper_function_get_type()
+#define G_SCAN_STRING_UPPER_FUNCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_STRING_UPPER_FUNCTION, GScanStringUpperFunction))
+#define G_IS_SCAN_STRING_UPPER_FUNCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_STRING_UPPER_FUNCTION))
+#define G_SCAN_STRING_UPPER_FUNCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_STRING_UPPER_FUNCTION, GScanStringUpperFunctionClass))
+#define G_IS_SCAN_STRING_UPPER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_STRING_UPPER_FUNCTION))
+#define G_SCAN_STRING_UPPER_FUNCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_STRING_UPPER_FUNCTION, GScanStringUpperFunctionClass))
+
+
+/* Bascule d'une suite de caractères en majuscules (instance) */
+typedef GRegisteredItem GScanStringUpperFunction;
+
+/* Bascule d'une suite de caractères en majuscules (classe) */
+typedef GRegisteredItemClass GScanStringUpperFunctionClass;
+
+
+/* Indique le type défini pour une bascule de la casse d'une suite de caractères. */
+GType g_scan_string_upper_function_get_type(void);
+
+/* Constitue une fonction de bascule de lettres en majuscules. */
+GRegisteredItem *g_scan_string_upper_function_new(void);
+
+
+
+#endif  /* _ANALYSIS_SCAN_ITEMS_STRING_UPPER_H */
diff --git a/src/analysis/scan/matches/pending.c b/src/analysis/scan/matches/pending.c
index 9d1037d..03cf3f2 100644
--- a/src/analysis/scan/matches/pending.c
+++ b/src/analysis/scan/matches/pending.c
@@ -24,18 +24,80 @@
 #include "pending.h"
 
 
-#include <assert.h>
 #include <malloc.h>
+#include <stdlib.h>
 #include <string.h>
 
 
+#include "../../../common/sort.h"
+
+
+
+/* ------------------------- MEMORISATION D'UNE ZONE BORNEE ------------------------- */
+
+
+/* Compare deux couvertures bornées de correspondances. */
+static int compare_match_area(const match_area_t *, const match_area_t *);
+
+
+
+/* -------------------- CONSERVATION DE CORRESPONDANCES ETABLIES -------------------- */
+
+
 #define PENDING_ALLOC_SIZE 10
 
 
 
+
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           MEMORISATION D'UNE ZONE BORNEE                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = pointeur vers la première zone à analyser.               *
+*                b = pointeur vers la seconde zone à analyser.                *
+*                                                                             *
+*  Description : Compare deux couvertures bornées de correspondances.         *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int compare_match_area(const match_area_t *a, const match_area_t *b)
+{
+    int result;                             /* Bilan à renvoyer            */
+
+    result = sort_unsigned_long_long(a->start, b->start);
+
+    if (result == 0)
+        result = sort_unsigned_long_long(a->end, b->end);
+
+    if (result == 0)
+        result = sort_unsigned_long_long(a->ttl, b->ttl);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                      CONSERVATION DE CORRESPONDANCES ETABLIES                      */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : matches = suivi de correspondances à initialiser.            *
+*                start   = première position du contenu (souvent 0).          *
+*                end     = position de fin du contenu.                        *
 *                                                                             *
 *  Description : Initialise une structure de consolidation de correspondances.*
 *                                                                             *
@@ -45,14 +107,84 @@
 *                                                                             *
 ******************************************************************************/
 
-void init_pending_matches(pending_matches_t *matches)
+void init_pending_matches(pending_matches_t *matches, const phys_t *start, const phys_t *end)
 {
+    matches->content_start = *start;
+    matches->content_end = *end;
+
     matches->areas = NULL;
     matches->allocated = 0;
     matches->used = 0;
 
     matches->initialized = false;
 
+    matches->abort = false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = suivi de correspondances à initialiser. [OUT]         *
+*                src  = suivi de correspondances à copier.                    *
+*                                                                             *
+*  Description : Copie une structure de consolidation de correspondances.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void copy_pending_matches(pending_matches_t *dest, const pending_matches_t *src)
+{
+    dest->content_start = src->content_start;
+    dest->content_end = src->content_end;
+
+    dest->areas = malloc(src->used * sizeof(match_area_t));
+    dest->allocated = src->used;
+    dest->used = src->used;
+
+    memcpy(dest->areas, src->areas, src->used * sizeof(match_area_t));
+
+    dest->initialized = src->initialized;
+
+    dest->abort = src->abort;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = suivi de correspondances à initialiser. [OUT]         *
+*                src  = suivi de correspondances à copier.                    *
+*                                                                             *
+*  Description : Fusionne une structure de consolidation avec une autre.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void merge_pending_matches(pending_matches_t *dest, const pending_matches_t *src)
+{
+    if ((dest->used + src->used) > dest->allocated)
+    {
+        dest->allocated += src->used;
+
+        dest->areas = realloc(dest->areas, dest->allocated * sizeof(match_area_t));
+
+    }
+
+    memcpy(&dest->areas[dest->used], src->areas, src->used * sizeof(match_area_t));
+
+    dest->used += src->used;
+
+    dest->initialized |= src->initialized;
+
+    dest->abort |= src->abort;
+
 }
 
 
@@ -112,11 +244,11 @@ size_t count_pending_matches(const pending_matches_t *matches)
 *                                                                             *
 ******************************************************************************/
 
-const match_area_t *get_all_pending_matches(const pending_matches_t *matches, size_t *count)
+match_area_t * const *get_all_pending_matches(const pending_matches_t *matches, size_t *count)
 {
-    match_area_t *result;                   /* Série à renvoyer            */
+    match_area_t * const *result;           /* Série à renvoyer            */
 
-    result = matches->areas;
+    result = &matches->areas;
 
     *count = matches->used;
 
@@ -156,8 +288,15 @@ void add_pending_match(pending_matches_t *matches, phys_t start, phys_t length)
     area->start = start;
     area->end = start + length;
 
+    assert(matches->content_start <= area->start);
+    assert(area->end <= matches->content_end);
+
     area->ttl = 1;
 
+    printf("[i] new match: from %llx to %llx\n",
+           (unsigned long long)area->start,
+           (unsigned long long)area->end);
+
 }
 
 
@@ -165,7 +304,7 @@ void add_pending_match(pending_matches_t *matches, phys_t start, phys_t length)
 *                                                                             *
 *  Paramètres  : matches = suivi de correspondances à compléter.              *
 *                target  = indice de la zone de correspondance concernée.     *
-*                length  = taille de la zone couverte supplémentaire.         *
+*                start   = nouvelle position initiale de la zone couverte.    *
 *                                                                             *
 *  Description : Etend une zone couverte dans le suivi des correspondances.   *
 *                                                                             *
@@ -175,17 +314,19 @@ void add_pending_match(pending_matches_t *matches, phys_t start, phys_t length)
 *                                                                             *
 ******************************************************************************/
 
-void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end)
+void extend_pending_match_beginning(pending_matches_t *matches, size_t target, phys_t start)
 {
     match_area_t *area;                     /* Zone à actualiser           */
 
     assert(target < matches->used);
 
-    area = &matches->areas[matches->used++];
+    area = &matches->areas[target];
 
     if (area->ttl == 0)
     {
-        area->end = end;
+        assert(matches->content_start <= start);
+
+        area->start = start;
 
         area->ttl = 1;
 
@@ -194,7 +335,7 @@ void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end)
     {
         assert(area->ttl == 1);
 
-        add_pending_match(matches, area->start, end - area->start);
+        add_pending_match(matches, start, area->end - start);
 
     }
 
@@ -203,11 +344,11 @@ void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : matches = suivi de correspondances à consulter.              *
+*  Paramètres  : matches = suivi de correspondances à compléter.              *
 *                target  = indice de la zone de correspondance concernée.     *
-*                pos     = position à tester.                                 *
+*                length  = taille de la zone couverte supplémentaire.         *
 *                                                                             *
-*  Description : Détermine si une correspondance se termine à une position.   *
+*  Description : Etend une zone couverte dans le suivi des correspondances.   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -215,50 +356,40 @@ void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end)
 *                                                                             *
 ******************************************************************************/
 
-bool has_pending_match_ending_at(const pending_matches_t *matches, size_t target, phys_t pos)
+void extend_pending_match_ending(pending_matches_t *matches, size_t target, phys_t end)
 {
-    bool result;                            /* Statut à retourner          */
-    match_area_t *area;                     /* Couverture visée            */
+    match_area_t *area;                     /* Zone à actualiser           */
 
     assert(target < matches->used);
 
     area = &matches->areas[target];
 
-    result = (area->end == pos);
-
-    return result;
-
-}
+    if (area->ttl == 0)
+    {
+        assert(end <= matches->content_end);
 
+        printf(" -- extend same (%llu - %llu) -> new end: %llu\n",
+               (unsigned long long)area->start,
+               (unsigned long long)area->end,
+               (unsigned long long)end);
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : matches = suivi de correspondances à consulter.              *
-*                target  = indice de la zone de correspondance concernée.     *
-*                pos     = position à tester.                                 *
-*                min     = borne inférieure de l'espace à considérer.         *
-*                max     = borne supérieure de l'espace à considérer.         *
-*                                                                             *
-*  Description : Détermine si une correspondance se situe dans une plage.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+        area->end = end;
 
-bool has_pending_match_ending_between(const pending_matches_t *matches, size_t target, phys_t pos, phys_t min, phys_t max)
-{
-    bool result;                            /* Statut à retourner          */
-    match_area_t *area;                     /* Couverture visée            */
+        area->ttl = 1;
 
-    assert(target < matches->used);
+    }
+    else
+    {
+        assert(area->ttl == 1);
 
-    area = &matches->areas[target];
+        printf(" -- extend (%llu - %llu) -> new end: %llu\n",
+               (unsigned long long)area->start,
+               (unsigned long long)area->end,
+               (unsigned long long)end);
 
-    result = ((area->end + min) <= pos && pos <= (area->end + max));
+        add_pending_match(matches, area->start, end - area->start);
 
-    return result;
+    }
 
 }
 
@@ -279,6 +410,8 @@ void reset_pending_matches_ttl(pending_matches_t *matches)
 {
     size_t i;                               /* Boucle de parcours          */
 
+    assert(matches->initialized);
+
     for (i = 0; i < matches->used; i++)
         matches->areas[i].ttl = 0;
 
@@ -305,6 +438,8 @@ void purge_pending_matches(pending_matches_t *matches)
     size_t del_count;                       /* Nombre d'éléments à effacer */
     size_t i;                               /* Boucle de parcours          */
 
+    assert(matches->initialized);
+
     /**
      * Note : le code original était le suivant :
      *
@@ -378,4 +513,60 @@ void purge_pending_matches(pending_matches_t *matches)
 
     }
 
+    /* Bilan */
+
+    matches->abort = (matches->used == 0);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à finaliser.              *
+*                                                                             *
+*  Description : Trie les correspondances et retire tous les doublons.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void sort_and_filter_pending_matches(pending_matches_t *matches)
+{
+    match_area_t *last;                     /* Dernière zone conservée     */
+    size_t i;                               /* Boucle de parcours          */
+    match_area_t *cur;                      /* Zone courante dans l'analyse*/
+
+    if (matches->used > 0)
+    {
+        qsort(matches->areas, matches->used, sizeof(match_area_t), (__compar_fn_t)compare_match_area);
+
+        last = &matches->areas[0];
+
+        for (i = 1; i < matches->used; i++)
+        {
+            cur = &matches->areas[i];
+
+            if (last->start != cur->start || last->end != cur->end)
+            {
+                if ((cur - last) > 1)
+                {
+                    memmove(last + 1, cur, (matches->used - i) * sizeof(match_area_t));
+                    matches->used -= (cur - last + 1);
+                }
+
+                last = cur;
+
+            }
+
+        }
+
+        cur = &matches->areas[matches->used - 1];
+
+        if (last != cur)
+            matches->used = last - matches->areas + 1;
+
+    }
+
 }
diff --git a/src/analysis/scan/matches/pending.h b/src/analysis/scan/matches/pending.h
index 0a1fe5c..6df01c9 100644
--- a/src/analysis/scan/matches/pending.h
+++ b/src/analysis/scan/matches/pending.h
@@ -25,6 +25,7 @@
 #define _ANALYSIS_SCAN_MATCHES_PENDING_H
 
 
+#include <assert.h>
 #include <stdbool.h>
 
 
@@ -45,17 +46,28 @@ typedef struct _match_area_t
 /* Suivi de correspondances */
 typedef struct _pending_matches_t
 {
+    phys_t content_start;                   /* Point de début du contenu   */
+    phys_t content_end;                     /* Point de fin du contenu     */
+
     match_area_t *areas;                    /* Zones couvertes             */
     size_t allocated;                       /* Nombre d'allocations        */
     size_t used;                            /* Nombre de zones             */
 
     bool initialized;                       /* Etat du suivi               */
 
+    bool abort;                             /* Inutilité d'une poursuite   */
+
 } pending_matches_t;
 
 
 /* Initialise une structure de consolidation de correspondances. */
-void init_pending_matches(pending_matches_t *);
+void init_pending_matches(pending_matches_t *, const phys_t *, const phys_t *);
+
+/* Copie une structure de consolidation de correspondances. */
+void copy_pending_matches(pending_matches_t *, const pending_matches_t *);
+
+/* Fusionner une structure de consolidation avec une autre. */
+void merge_pending_matches(pending_matches_t *, const pending_matches_t *);
 
 /* Libère la mémoire utilisée par une consolidation. */
 void exit_pending_matches(pending_matches_t *);
@@ -69,26 +81,34 @@ void exit_pending_matches(pending_matches_t *);
 size_t count_pending_matches(const pending_matches_t *);
 
 /* Fournit la liste des correspondances établies à présent. */
-const match_area_t *get_all_pending_matches(const pending_matches_t *, size_t *);
+match_area_t * const  *get_all_pending_matches(const pending_matches_t *, size_t *);
 
 /*  Ajoute au suivi la définition d'une nouvelle correspondance. */
 void add_pending_match(pending_matches_t *, phys_t, phys_t);
 
 /* Etend une zone couverte dans le suivi des correspondances. */
-void extend_pending_match(pending_matches_t *, size_t, phys_t);
+void extend_pending_match_beginning(pending_matches_t *, size_t, phys_t);
 
-/* Détermine si une correspondance se situe dans une plage. */
-bool has_pending_match_ending_between(const pending_matches_t *, size_t, phys_t, phys_t, phys_t);
-
-/* Détermine si une correspondance se termine à une position. */
-bool has_pending_match_ending_at(const pending_matches_t *, size_t, phys_t);
+/* Etend une zone couverte dans le suivi des correspondances. */
+void extend_pending_match_ending(pending_matches_t *, size_t, phys_t);
 
 /* Réinitialisation à 0 tous les TTL de correspondances. */
 void reset_pending_matches_ttl(pending_matches_t *);
 
+#define keep_pending_match(p)   \
+    do                          \
+    {                           \
+        assert(p->ttl == 0);    \
+        p->ttl = 1;             \
+    }                           \
+    while (0);
+
 /* Retire toutes les correspondances sans issue pour l'analyse. */
 void purge_pending_matches(pending_matches_t *);
 
+/* Trie les correspondances et retire tous les doublons. */
+void sort_and_filter_pending_matches(pending_matches_t *);
+
 
 
 #endif  /* _ANALYSIS_SCAN_MATCHES_PENDING_H */
diff --git a/src/analysis/scan/patterns/token-int.h b/src/analysis/scan/patterns/token-int.h
index 294a3b1..f1d63f0 100644
--- a/src/analysis/scan/patterns/token-int.h
+++ b/src/analysis/scan/patterns/token-int.h
@@ -32,19 +32,17 @@
 
 
 
-/* Inscrit la définition d'un motif dans un moteur de recherche. */
-typedef bool (* enroll_token_fc) (GStringToken *, GScanContext *, GEngineBackend *, size_t);
-
-/* Transforme les correspondances locales en trouvailles. */
-typedef void (* check_token_fc) (const GStringToken *, GScanContext *, GBinContent *, pending_matches_t *);
-
-
 /* Encadrement d'une bribe de recherche textuelle (instance) */
 struct _GStringToken
 {
     GSearchPattern parent;                  /* A laisser en premier        */
 
     GScanTokenNode *root;                   /* Motif à rechercher          */
+    size_t slow;                            /* Surcoût du motif            */
+    bool need_backward;                     /* Besoin d'une seconde passe  */
+
+    bool fullword;                          /* Cible de mots entiers ?     */
+    bool private;                           /* Vocation privée ?           */
 
 };
 
@@ -53,14 +51,11 @@ struct _GStringTokenClass
 {
     GSearchPatternClass parent;             /* A laisser en premier        */
 
-    enroll_token_fc enroll;                 /* Inscription d'un motif      */
-    check_token_fc check;                   /* Conversion en trouvailles   */
-
 };
 
 
 /* Met en place un gestionnaire de recherche de binaire. */
-bool g_string_token_create(GStringToken *, GScanTokenNode *);
+bool g_string_token_create(GStringToken *, GScanTokenNode *, bool, bool);
 
 
 
diff --git a/src/analysis/scan/patterns/token.c b/src/analysis/scan/patterns/token.c
index cc2d87a..1b2ee8a 100644
--- a/src/analysis/scan/patterns/token.c
+++ b/src/analysis/scan/patterns/token.c
@@ -25,6 +25,7 @@
 
 
 #include <assert.h>
+#include <ctype.h>
 #include <stdio.h>
 
 
@@ -116,6 +117,11 @@ static void g_string_token_class_init(GStringTokenClass *klass)
 static void g_string_token_init(GStringToken *token)
 {
     token->root = NULL;
+    token->slow = 0;
+    token->need_backward = false;
+
+    token->fullword = false;
+    token->private = false;
 
 }
 
@@ -160,8 +166,10 @@ static void g_string_token_finalize(GStringToken *token)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : token = encadrement de motif à initialiser pleinement.       *
-*                root  = représentation du motif à recherche.                 *
+*  Paramètres  : token    = encadrement de motif à initialiser pleinement.    *
+*                root     = représentation du motif à recherche.              *
+*                fullword = limite les correspondances à des mots entiers.    *
+*                private  = donne une vocation privée au motif de recherche.  *
 *                                                                             *
 *  Description : Met en place un gestionnaire de recherche de binaire.        *
 *                                                                             *
@@ -171,7 +179,7 @@ static void g_string_token_finalize(GStringToken *token)
 *                                                                             *
 ******************************************************************************/
 
-bool g_string_token_create(GStringToken *token, GScanTokenNode *root)
+bool g_string_token_create(GStringToken *token, GScanTokenNode *root, bool fullword, bool private)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -180,6 +188,9 @@ bool g_string_token_create(GStringToken *token, GScanTokenNode *root)
     token->root = root;
     g_object_ref(G_OBJECT(root));
 
+    token->fullword = fullword;
+    token->private = private;
+
     return result;
 
 }
@@ -187,39 +198,74 @@ bool g_string_token_create(GStringToken *token, GScanTokenNode *root)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : token   = définition de la bribe à enregistrer.              *
-*                context = contexte de l'analyse à mener.                     *
-*                backend = moteur de recherche à préchauffer.                 *
-*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*  Paramètres  : token = encadrement de motif à consulter.                    *
 *                                                                             *
-*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*  Description : Indique si seuls des mots entiers sont retenus des analyses. *
 *                                                                             *
-*  Retour      : Bilan de l'opération à renvoyer.                             *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool g_string_token_enroll__old(GStringToken *token, GScanContext *context, GEngineBackend *backend, size_t maxsize)
+bool g_string_token_target_fullword(const GStringToken *token)
 {
-    bool result;                            /* Statut à retourner          */
-    GStringTokenClass *class;               /* Classe de l'instance        */
+    bool result;                            /* Statut à renvoyer           */
+
+    result = token->fullword;
 
-    assert(g_engine_backend_get_atom_max_size(backend) == maxsize);
+    return result;
 
-    class = G_STRING_TOKEN_GET_CLASS(token);
+}
 
-    result = class->enroll(token, context, backend, maxsize);
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : token = encadrement de motif à consulter.                    *
+*                                                                             *
+*  Description : Détermine si le gestionnaire est à vocation privée.          *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_string_token_is_private(const GStringToken *token)
+{
+    bool result;                            /* Statut à renvoyer           */
+
+    result = token->private;
 
     return result;
 
 }
 
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : token   = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
 bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBackend *backend, size_t maxsize)
 {
     bool result;                            /* Statut à retourner          */
 
-    result = g_scan_token_node_enroll(token->root, context, backend, maxsize);
+    token->need_backward = g_scan_token_node_setup_tree(token->root);
+
+    result = g_scan_token_node_enroll(token->root, context, backend, maxsize, &token->slow);
+
+    printf("need backward? %d\n", token->need_backward);
 
     return result;
 
@@ -241,19 +287,59 @@ bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBa
 *                                                                             *
 ******************************************************************************/
 
-void g_string_token_check__old(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches)
+void g_string_token_check(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches)
 {
-    GStringTokenClass *class;               /* Classe de l'instance        */
+    size_t p;                               /* Boucle de parcours #3       */
+    match_area_t *pending;                  /* Correspondance à traiter    */
+    vmpa2t pos;                             /* Tête de lecture             */
+    const bin_t *byte;                      /* Octet à valider             */
 
-    class = G_STRING_TOKEN_GET_CLASS(token);
+    g_scan_token_node_check_forward(token->root, context, content, matches);
 
-    class->check(token, context, content, matches);
+    if (token->need_backward)
+        g_scan_token_node_check_backward(token->root, context, content, matches);
 
-}
+    sort_and_filter_pending_matches(matches);
 
-void g_string_token_check(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches)
-{
-    g_scan_token_node_check(token->root, context, content, matches, NULL);
+    if (token->fullword)
+    {
+        reset_pending_matches_ttl(matches);
+
+        for (p = 0; p < matches->used; p++)
+        {
+            pending = &matches->areas[p];
+
+            /* Validation de l'octet précédent, s'il existe */
+            if (pending->start > matches->content_start)
+            {
+                init_vmpa(&pos, pending->start - 1, VMPA_NO_VIRTUAL);
+
+                byte = g_binary_content_get_raw_access(content, &pos, 1);
+
+                if (isalnum(*byte))
+                    continue;
+
+            }
+
+            /* Validation de l'octet suivant, s'il existe */
+            if (pending->end < matches->content_end)
+            {
+                init_vmpa(&pos, pending->end, VMPA_NO_VIRTUAL);
+
+                byte = g_binary_content_get_raw_access(content, &pos, 1);
+
+                if (isalnum(*byte))
+                    continue;
+
+            }
+
+            keep_pending_match(pending);
+
+        }
+
+        purge_pending_matches(matches);
+
+    }
 
 }
 
@@ -284,6 +370,9 @@ static void g_string_token_output_to_text(const GStringToken *pattern, GScanCont
     size_t count;                           /* Quantité de cette liste     */
     size_t i;                               /* Boucle de parcours          */
 
+    if (g_string_token_is_private(pattern))
+        return;
+
     matches = g_scan_context_get_full_matches(context, G_SEARCH_PATTERN(pattern), &count);
 
     for (i = 0; i < count; i++)
@@ -318,6 +407,9 @@ static void g_string_token_output_to_json(const GStringToken *pattern, GScanCont
     size_t k;                               /* Boucle de parcours #2       */
     bool trailing;                          /* Virgule finale              */
 
+    if (g_string_token_is_private(pattern))
+        return;
+
     matches = g_scan_context_get_full_matches(context, G_SEARCH_PATTERN(pattern), &count);
 
     /* Nombre de correspondances */
diff --git a/src/analysis/scan/patterns/token.h b/src/analysis/scan/patterns/token.h
index 879d912..b361ecc 100644
--- a/src/analysis/scan/patterns/token.h
+++ b/src/analysis/scan/patterns/token.h
@@ -52,6 +52,12 @@ typedef struct _GStringTokenClass GStringTokenClass;
 /* Indique le type défini pour une bribe de recherche textuelle. */
 GType g_string_token_get_type(void);
 
+/* Indique si seuls des mots entiers sont retenus des analyses. */
+bool g_string_token_target_fullword(const GStringToken *);
+
+/* Détermine si le gestionnaire est à vocation privée. */
+bool g_string_token_is_private(const GStringToken *);
+
 /* Inscrit la définition d'un motif dans un moteur de recherche. */
 bool g_string_token_enroll(GStringToken *, GScanContext *, GEngineBackend *, size_t);
 
diff --git a/src/analysis/scan/patterns/tokens/Makefile.am b/src/analysis/scan/patterns/tokens/Makefile.am
index 7fb515f..f0ab3d5 100644
--- a/src/analysis/scan/patterns/tokens/Makefile.am
+++ b/src/analysis/scan/patterns/tokens/Makefile.am
@@ -8,6 +8,7 @@ libanalysisscanpatternstokens_la_SOURCES =	\
 	hex.h hex.c								\
 	node-int.h								\
 	node.h node.c							\
+	offset.h offset.c						\
 	plain-int.h								\
 	plain.h plain.c
 
diff --git a/src/analysis/scan/patterns/tokens/atom.c b/src/analysis/scan/patterns/tokens/atom.c
index fcb585d..52f239c 100644
--- a/src/analysis/scan/patterns/tokens/atom.c
+++ b/src/analysis/scan/patterns/tokens/atom.c
@@ -251,6 +251,7 @@ void find_best_atom(const sized_binary_t *raw, size_t maxsize, tracked_scan_atom
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : src   = chaîne ed référence à dupliquer.                     *
+*                atom  = préselection opérée en amont.                        *
 *                count = nombre de lettres présentes.                         *
 *                                                                             *
 *  Description : Etablit la liste des cas de figures ignorant la casse.       *
@@ -261,7 +262,7 @@ void find_best_atom(const sized_binary_t *raw, size_t maxsize, tracked_scan_atom
 *                                                                             *
 ******************************************************************************/
 
-sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t count)
+sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, const tracked_scan_atom_t *atom, size_t count)
 {
     sized_binary_t *result;                 /* Liste à retourner           */
     size_t i;                               /* Boucle de parcours #1       */
@@ -274,16 +275,20 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
     size_t divisor;                         /* Taille de la découpe        */
     size_t quotient;                        /* Reste de la position        */
 
-    count *= 2;
-
     /* Création du réceptacle */
 
     result = malloc(count * sizeof(tracked_scan_atom_t));
 
+    assert(src->len == (atom->pos + atom->len + atom->rem));
+
     for (i = 0; i < count; i++)
     {
         result[i].data = malloc(src->len);
         result[i].len = src->len;
+
+        memcpy(result[i].data, src->data, atom->pos);
+        memcpy(&result[i].data[atom->pos + atom->len], &src->data[atom->pos + atom->len], atom->rem);
+
     }
 
     /* Remplissage */
@@ -294,7 +299,7 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
     check = 1;
 #endif
 
-    for (i = 0; i < src->len; i++)
+    for (i = atom->pos; i < (atom->pos + atom->len); i++)
     {
         ch = src->data[i];
 
@@ -315,8 +320,8 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
             replaced *= 2;
 
 #ifndef NDEBUG
-            check++;
-            assert((check - 1) <= count);
+            check *= 2;
+            assert(check <= count);
 #endif
 
         }
@@ -326,7 +331,51 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
 
     }
 
-    assert((check - 1) == count);
+    assert(check == count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : byte     = octet partiel à interpréter.                      *
+*                mask     = valeur du masque à appliquer.                     *
+*                produced = nombre de contenus générés. [OUT]                 *
+*                                                                             *
+*  Description : Etablit la liste des cas de figures avec un octet partiel.   *
+*                                                                             *
+*  Retour      : Liste de toutes les combinaisons possibles.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+sized_binary_t *make_atoms_from_masked_byte(bin_t value, bin_t mask, size_t *produced)
+{
+    sized_binary_t *result;                 /* Liste à retourner           */
+    size_t i;                               /* Boucle de parcours #1       */
+
+    *produced = 16;
+
+    /* Création du réceptacle */
+
+    result = malloc(16 * sizeof(tracked_scan_atom_t));
+
+    /* Remplissage */
+
+    for (i = 0; i < 16; i++)
+    {
+        result[i].data = malloc(1);
+        result[i].len = 1;
+
+        if (mask == 0x0f)
+            result[i].data[0] = value | (i << 4);
+        else
+            result[i].data[0] = value | i;
+
+    }
 
     return result;
 
diff --git a/src/analysis/scan/patterns/tokens/atom.h b/src/analysis/scan/patterns/tokens/atom.h
index daa1f16..2fbc19e 100644
--- a/src/analysis/scan/patterns/tokens/atom.h
+++ b/src/analysis/scan/patterns/tokens/atom.h
@@ -58,7 +58,10 @@ int finish_quality_rating(const bitfield_t *, size_t);
 void find_best_atom(const sized_binary_t *, size_t , tracked_scan_atom_t *, size_t *);
 
 /* Etablit la liste des cas de figures ignorant la casse. */
-sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *, size_t);
+sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *, const tracked_scan_atom_t *, size_t);
+
+/* Etablit la liste des cas de figures avec un octet partiel. */
+sized_binary_t *make_atoms_from_masked_byte(bin_t, bin_t, size_t *);
 
 /* Enregistre l'atome déterminé d'une série d'octets. */
 bool enroll_prepared_atom(const sized_binary_t *, GScanContext *, GEngineBackend *, tracked_scan_atom_t *);
diff --git a/src/analysis/scan/patterns/tokens/hex-int.h b/src/analysis/scan/patterns/tokens/hex-int.h
index f0460c8..440f693 100644
--- a/src/analysis/scan/patterns/tokens/hex-int.h
+++ b/src/analysis/scan/patterns/tokens/hex-int.h
@@ -49,7 +49,7 @@ struct _GScanHexBytesClass
 
 
 /* Met en place un gestionnaire de recherche de binaire. */
-bool g_scan_hex_bytes_create(GScanHexBytes *, GScanTokenNode *);
+bool g_scan_hex_bytes_create(GScanHexBytes *, GScanTokenNode *, bool);
 
 
 
diff --git a/src/analysis/scan/patterns/tokens/hex.c b/src/analysis/scan/patterns/tokens/hex.c
index c1cdbdf..1fda597 100644
--- a/src/analysis/scan/patterns/tokens/hex.c
+++ b/src/analysis/scan/patterns/tokens/hex.c
@@ -58,12 +58,6 @@ static void g_scan_hex_bytes_output_to_text(const GScanHexBytes *, GScanContext
 /* Affiche un motif de recherche au format JSON. */
 static void g_scan_hex_bytes_output_to_json(const GScanHexBytes *, GScanContext *, const sized_string_t *, unsigned int, int);
 
-/* Inscrit la définition d'un motif dans un moteur de recherche. */
-//static bool g_scan_hex_bytes_enroll(GScanHexBytes *, GScanContext *, GEngineBackend *, size_t);
-
-/* Transforme les correspondances locales en trouvailles. */
-//static void g_scan_hex_bytes_check(const GScanHexBytes *, GScanContext *, GBinContent *, pending_matches_t *);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -91,7 +85,6 @@ static void g_scan_hex_bytes_class_init(GScanHexBytesClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GSearchPatternClass *pattern;           /* Version de classe ancêtre   */
-    GStringTokenClass *token;               /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
@@ -103,11 +96,6 @@ static void g_scan_hex_bytes_class_init(GScanHexBytesClass *klass)
     pattern->to_text = (output_pattern_to_text_fc)g_scan_hex_bytes_output_to_text;
     pattern->to_json = (output_pattern_to_json_fc)g_scan_hex_bytes_output_to_json;
 
-    token = G_STRING_TOKEN_CLASS(klass);
-
-    //token->enroll = (enroll_token_fc)g_scan_hex_bytes_enroll;
-    //token->check = (check_token_fc)g_scan_hex_bytes_check;
-
 }
 
 
@@ -170,6 +158,7 @@ static void g_scan_hex_bytes_finalize(GScanHexBytes *bytes)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : root  = représentation du motif à recherche.                 *
+*                private  = donne une vocation privée au motif de recherche.  *
 *                                                                             *
 *  Description : Construit un gestionnaire de recherche de texte brut.        *
 *                                                                             *
@@ -179,13 +168,13 @@ static void g_scan_hex_bytes_finalize(GScanHexBytes *bytes)
 *                                                                             *
 ******************************************************************************/
 
-GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *root)
+GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *root, bool private)
 {
     GSearchPattern *result;                 /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_HEX_BYTES, NULL);
 
-    if (!g_scan_hex_bytes_create(G_SCAN_HEX_BYTES(result), root))
+    if (!g_scan_hex_bytes_create(G_SCAN_HEX_BYTES(result), root, private))
         g_clear_object(&result);
 
     return result;
@@ -197,6 +186,7 @@ GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *root)
 *                                                                             *
 *  Paramètres  : bytes = encadrement de motif à initialiser pleinement.       *
 *                root  = représentation du motif à recherche.                 *
+*                private  = donne une vocation privée au motif de recherche.  *
 *                                                                             *
 *  Description : Met en place un gestionnaire de recherche de binaire.        *
 *                                                                             *
@@ -206,11 +196,11 @@ GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *root)
 *                                                                             *
 ******************************************************************************/
 
-bool g_scan_hex_bytes_create(GScanHexBytes *bytes, GScanTokenNode *root)
+bool g_scan_hex_bytes_create(GScanHexBytes *bytes, GScanTokenNode *root, bool private)
 {
     bool result;                            /* Bilan à retourner           */
 
-    result = g_string_token_create(G_STRING_TOKEN(bytes), root);
+    result = g_string_token_create(G_STRING_TOKEN(bytes), root, false, private);
 
     return result;
 
@@ -267,191 +257,3 @@ static void g_scan_hex_bytes_output_to_json(const GScanHexBytes *pattern, GScanC
     /* TODO */
 
 }
-
-#if 0
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : bytes   = définition de la bribe à enregistrer.              *
-*                context = contexte de l'analyse à mener.                     *
-*                backend = moteur de recherche à préchauffer.                 *
-*                maxsize = taille max. des atomes (mise en commun optimisée). *
-*                                                                             *
-*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
-*                                                                             *
-*  Retour      : Bilan de l'opération à renvoyer.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_scan_hex_bytes_enroll(GScanHexBytes *bytes, GScanContext *context, GEngineBackend *backend, size_t maxsize)
-{
-    bool result;                            /* Statut à retourner          */
-    size_t i;                               /* Boucle de parcours #1       */
-    tracked_scan_atom_t atom;               /* Atome identifié             */
-    size_t letters;                         /* Nombre de lettres présentes */
-    size_t k;                               /* Boucle de parcours #2       */
-    size_t extra_count;                     /* Quantité pour l'exhaustivité*/
-    sized_binary_t *extra;                  /* Couverture supplémntaire    */
-    size_t remaining;                       /* Quantité restant à traiter  */
-
-    /* Génération d'une base de chaînes à couvrir */
-
-    if (bytes->modifier == NULL)
-    {
-        bytes->raw = malloc(sizeof(sized_binary_t));
-        bytes->count = 1;
-
-        szstrdup(&bytes[0].raw[0], &bytes->orig);
-
-        result = true;
-
-    }
-    else
-        result = g_scan_token_modifier_transform(bytes->modifier, &bytes->orig, &bytes->raw, &bytes->count);
-
-    if (!result)
-        goto exit;
-
-    /* Préparation pour la mémorisation des atomes */
-
-    bytes->atoms = malloc(bytes->count * sizeof(tracked_scan_atom_t));
-
-    /* Recherche des atomes */
-
-    for (i = 0; i < bytes->count; i++)
-    {
-        if (bytes->flags & SPBF_CASE_INSENSITIVE)
-        {
-            find_best_atom(&bytes->raw[i], maxsize, &atom, &letters);
-
-            if (letters == 0)
-                bytes->atoms[i] = atom;
-
-            /* Insertion des combinaisons pour couvrir toutes les casses */
-            else
-            {
-                for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2)
-                    ;
-
-                extra = make_atoms_case_insensitive(&bytes->raw[i], extra_count);
-
-                remaining = bytes->count - i - 1;
-
-                bytes->count += (extra_count - 1);
-
-                bytes->raw = realloc(bytes->raw, bytes->count * sizeof(sized_binary_t));
-
-                memmove(&bytes->raw[i + extra_count], &bytes->raw[i + 1], remaining * sizeof(sized_binary_t));
-
-                for (k = 0; k < extra_count; k++)
-                    bytes->raw[i + k] = extra[k];
-
-                free(extra);
-
-                bytes->atoms = realloc(bytes->raw, bytes->count * sizeof(tracked_scan_atom_t));
-
-                for (k = 0; k < extra_count; k++)
-                    bytes->atoms[i + k] = atom;
-
-                i += extra_count - 1;
-
-            }
-
-        }
-
-        else
-            find_best_atom(&bytes->raw[i], maxsize, &bytes->atoms[i], &letters);
-
-    }
-
-    /* Enregistrements en masse */
-
-
-    for (i = 0; i < bytes->count && result; i++)
-        result = enroll_prepared_atom(&bytes->raw[i], context, backend, &bytes->atoms[i]);
-
- exit:
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : bytes   = définition de la bribe à manipuler.                *
-*                context = contexte de l'analyse à mener.                     *
-*                content = accès au contenu brut pour vérifications (optim.)  *
-*                matches = suivi des correspondances à consolider.            *
-*                                                                             *
-*  Description : Transforme les correspondances locales en trouvailles.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_hex_bytes_check(const GScanHexBytes *bytes, GScanContext *context, GBinContent *content, pending_matches_t *matches)
-{
-    size_t i;                               /* Boucle de parcours #1       */
-    const sized_binary_t *raw;              /* Données brutes d'origine    */
-    const tracked_scan_atom_t *atom;        /* Atome correspondant         */
-    size_t count;                           /* Quantité de bribes trouvées */
-    const phys_t *found;                    /* Localisations des bribes    */
-    size_t k;                               /* Boucle de parcours #2       */
-    phys_t start;                           /* Point de départ             */
-    vmpa2t pos;                             /* Position dans les données   */
-    const bin_t *ptr;                       /* Accès aux données brutes    */
-    int ret;                                /* Bilan d'une comparaison     */
-
-    for (i = 0; i < bytes->count; i++)
-    {
-        raw = &bytes->raw[i];
-        atom = &bytes->atoms[i];
-
-        found = g_scan_context_get_atom_matches(context, atom->pid, &count);
-
-        for (k = 0; k < count; k++)
-        {
-            start = found[k] - atom->pos;
-
-            init_vmpa(&pos, start, VMPA_NO_VIRTUAL);
-
-            /* Validation du contenu avant l'atome */
-
-            if (atom->pos > 0)
-            {
-                ptr = g_binary_content_get_raw_access(content, &pos, atom->pos);
-
-                ret = memcmp(raw->data, ptr, atom->pos);
-                if (ret != 0) continue;
-
-            }
-
-            /* Validation du contenu après l'atome */
-
-            if (atom->rem > 0)
-            {
-                advance_vmpa(&pos, atom->len);
-
-                ptr = g_binary_content_get_raw_access(content, &pos, atom->rem);
-
-                ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem);
-                if (ret != 0) continue;
-
-            }
-
-            /* Mémorisation de la correspondance */
-
-            add_pending_matches(matches, start, raw->len);
-
-        }
-
-    }
-
-}
-
-#endif
diff --git a/src/analysis/scan/patterns/tokens/hex.h b/src/analysis/scan/patterns/tokens/hex.h
index 1db8eb6..fe5268c 100644
--- a/src/analysis/scan/patterns/tokens/hex.h
+++ b/src/analysis/scan/patterns/tokens/hex.h
@@ -52,7 +52,7 @@ typedef struct _GScanHexBytesClass GScanHexBytesClass;
 GType g_scan_hex_bytes_get_type(void);
 
 /* Construit un gestionnaire de recherche de texte brut. */
-GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *);
+GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *, bool);
 
 
 
diff --git a/src/analysis/scan/patterns/tokens/node-int.h b/src/analysis/scan/patterns/tokens/node-int.h
index c543cbf..091a5be 100644
--- a/src/analysis/scan/patterns/tokens/node-int.h
+++ b/src/analysis/scan/patterns/tokens/node-int.h
@@ -28,12 +28,33 @@
 #include "node.h"
 
 
+#include "offset.h"
+
+
+
+/* Prend acte d'une nouvelle propriété pour le noeud. */
+typedef void (* apply_scan_token_node_flags_fc) (GScanTokenNode *, ScanTokenNodeFlags);
+
+/* Noeuds clefs de l'arborescence mise en place */
+typedef struct _scan_tree_points_t
+{
+    GScanTokenNode *first_node;             /* Premier noeud de traitement */
+    GScanTokenNode *last_node;              /* Dernier noeud de traitement */
+
+    GScanTokenNode *first_plain;            /* Premier noeud textuel       */
+    GScanTokenNode *best_masked;            /* Noeud masqué le plus long   */
+
+} scan_tree_points_t;
+
+
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+typedef void (* visit_scan_token_node_fc) (GScanTokenNode *, scan_tree_points_t *);
 
 /* Inscrit la définition d'un motif dans un moteur de recherche. */
-typedef bool (* enroll_scan_token_node_fc) (GScanTokenNode *, GScanContext *, GEngineBackend *, size_t);
+typedef bool (* enroll_scan_token_node_fc) (GScanTokenNode *, GScanContext *, GEngineBackend *, size_t, size_t *);
 
 /* Transforme les correspondances locales en trouvailles. */
-typedef void (* check_scan_token_node_fc) (const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *);
+typedef void (* check_scan_token_node_fc) (const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
 
 
 /* Décomposition d'un motif de recherche en atomes (instance) */
@@ -41,6 +62,8 @@ struct _GScanTokenNode
 {
     GObject parent;                         /* A laisser en premier        */
 
+    ScanTokenNodeFlags flags;               /* Propriétés particulières    */
+
 };
 
 /* Décomposition d'un motif de recherche en atomes (classe) */
@@ -48,11 +71,29 @@ struct _GScanTokenNodeClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    apply_scan_token_node_flags_fc apply;   /* Prise en compte de fanions  */
+
+    visit_scan_token_node_fc visit;         /* Phase de répérage initial   */
     enroll_scan_token_node_fc enroll;       /* Inscription d'un motif      */
-    check_scan_token_node_fc check;         /* Conversion en trouvailles   */
+
+    check_scan_token_node_fc check_forward; /* Conversion en trouvailles   */
+    check_scan_token_node_fc check_backward;/* Conversion en trouvailles   */
 
 };
 
 
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+void g_scan_token_node_visit(GScanTokenNode *, scan_tree_points_t *);
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+bool _g_scan_token_node_enroll(GScanTokenNode *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Transforme les correspondances locales en trouvailles. */
+void _g_scan_token_node_check_forward(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+void _g_scan_token_node_check_backward(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
 
 #endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/node.c b/src/analysis/scan/patterns/tokens/node.c
index 224328a..1354fff 100644
--- a/src/analysis/scan/patterns/tokens/node.c
+++ b/src/analysis/scan/patterns/tokens/node.c
@@ -28,6 +28,7 @@
 
 
 #include "node-int.h"
+#include "nodes/any.h"
 
 
 
@@ -35,7 +36,7 @@
 
 
 /* Initialise la classe des éléments de décomposition. */
-static void g_scan_token_node_class_init(GScanTokenNodeClass *klass);
+static void g_scan_token_node_class_init(GScanTokenNodeClass *);
 
 /* Initialise une instance d'élément décomposant un motif. */
 static void g_scan_token_node_init(GScanTokenNode *);
@@ -95,6 +96,7 @@ static void g_scan_token_node_class_init(GScanTokenNodeClass *klass)
 
 static void g_scan_token_node_init(GScanTokenNode *node)
 {
+    node->flags = STNF_NONE;
 
 }
 
@@ -139,10 +141,148 @@ static void g_scan_token_node_finalize(GScanTokenNode *node)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : node = noeud de motif à consulter.                           *
+*                                                                             *
+*  Description : Indique les propriétés particulières d'un noeud d'analyse.   *
+*                                                                             *
+*  Retour      : Propriétés particulières associées au noeud.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+ScanTokenNodeFlags g_scan_token_node_get_flags(const GScanTokenNode *node)
+{
+    ScanTokenNodeFlags result;              /* Statut à retourner          */
+
+    result = node->flags;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node  = noeud de motif à mettre à jour.                      *
+*                flags = propriétés particulières à associer au noeud.        *
+*                                                                             *
+*  Description : Marque le noeud avec des propriétés particulières.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_set_flags(GScanTokenNode *node, ScanTokenNodeFlags flags)
+{
+    GScanTokenNodeClass *class;             /* Classe de l'instance        */
+
+    node->flags |= flags;
+
+    class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
+
+    if (class->apply != NULL)
+        class->apply(node, flags);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_visit(GScanTokenNode *node, scan_tree_points_t *points)
+{
+    GScanTokenNodeClass *class;             /* Classe de l'instance        */
+
+    if (node->flags & STNF_PROD)
+    {
+        if (points->first_node == NULL)
+            points->first_node = node;
+
+        points->last_node = node;
+
+    }
+
+    class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
+
+    if (class->visit != NULL)
+        class->visit(node, points);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à préparer.             *
+*                                                                             *
+*  Description : Détermine et prépare les éléments clefs d'une arborescence.  *
+*                                                                             *
+*  Retour      : true si une analyse à rebourd complémentaire est requise.    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_setup_tree(GScanTokenNode *node)
+{
+    bool result;                            /* Prévision à retourner       */
+    scan_tree_points_t points;              /* Repérage de points capitaux */
+    GScanTokenNode *main;                   /* Principal noeud d'opération */
+
+    /* Phase de localisation */
+
+    points.first_node = NULL;
+    points.last_node = NULL;
+
+    points.first_plain = NULL;
+    points.best_masked = NULL;
+
+    g_scan_token_node_visit(node, &points);
+
+    /* Phase d'application */
+
+    //g_scan_token_node_set_flags(points.first_node, STNF_FIRST);
+    //g_scan_token_node_set_flags(points.last_node, STNF_LAST);
+
+    if (points.first_plain != NULL)
+        main = points.first_plain;
+
+    else if (points.best_masked != NULL)
+        main = points.best_masked;
+
+    else
+        main = node;//points.first_node;
+
+    g_scan_token_node_set_flags(main, STNF_MAIN);
+
+    printf("main : %p (%s)\n", main, G_OBJECT_TYPE_NAME(main));
+
+    result = (main != node/*points.first_node*/);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : node    = définition de la bribe à enregistrer.              *
 *                context = contexte de l'analyse à mener.                     *
 *                backend = moteur de recherche à préchauffer.                 *
 *                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
 *                                                                             *
 *  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
 *                                                                             *
@@ -152,16 +292,45 @@ static void g_scan_token_node_finalize(GScanTokenNode *node)
 *                                                                             *
 ******************************************************************************/
 
-bool g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngineBackend *backend, size_t maxsize)
+bool _g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
 {
     bool result;                            /* Statut à retourner          */
     GScanTokenNodeClass *class;             /* Classe de l'instance        */
 
+    class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
+
+    result = class->enroll(node, context, backend, maxsize, slow);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+
     assert(g_engine_backend_get_atom_max_size(backend) == maxsize);
 
-    class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
+    *slow = 0;
 
-    result = class->enroll(node, context, backend, maxsize);
+    result = _g_scan_token_node_enroll(node, context, backend, maxsize, slow);
 
     return result;
 
@@ -175,6 +344,8 @@ bool g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngi
 *                content = accès au contenu brut pour vérifications (optim.)  *
 *                matches = suivi des correspondances à consolider.            *
 *                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
 *                                                                             *
 *  Description : Transforme les correspondances locales en trouvailles.       *
 *                                                                             *
@@ -184,12 +355,236 @@ bool g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngi
 *                                                                             *
 ******************************************************************************/
 
-void g_scan_token_node_check(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, const node_search_offset_t *offset)
+void _g_scan_token_node_check_forward(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
 {
     GScanTokenNodeClass *class;             /* Classe de l'instance        */
 
+    if (node->flags & STNF_MAIN)
+    {
+        //assert(*skip); //REMME
+        *skip = false;
+    }
+
+    printf("Checking forward... node=%p / %s skip=%d main=%u\n",
+           node, G_OBJECT_TYPE_NAME(node), *skip, (node->flags & STNF_MAIN) == STNF_MAIN);
+
     class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
 
-    class->check(node, context, content, matches, offset);
+    class->check_forward(node, context, content, matches, offset, not, skip);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_check_forward(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches)
+{
+    node_search_offset_t offset;            /* Espace des correspondances  */
+    bool skip;                              /* Mise en attente des analyses*/
+    size_t ocount;                          /* Quantité de bornes présentes*/
+    node_offset_range_t * const *ranges_ptr;/* Bornes d'espace à parcourir */
+    size_t pcount;                          /* Nombre de correspondances   */
+    match_area_t * const *pending_ptr;      /* Correspondances actuelles   */
+    size_t p;                               /* Boucle de parcours #2       */
+    match_area_t *pending;                  /* Correspondance à traiter    */
+    phys_t old_end;                         /* Ancien point d'arrivée      */
+    size_t o;                               /* Boucle de parcours #1       */
+    const node_offset_range_t *range;       /* Bornes d'espace à parcourir */
+    phys_t new_end;                         /* Nouveau point d'arrivée     */
+
+    init_node_search_offset(&offset);
+
+    skip = true;
+
+    _g_scan_token_node_check_forward(node, context, content, matches, &offset, false, &skip);
+
+    /**
+     * Si un décalage entre octets n'a pas été consommé,
+     * les résultats sont étendus à minima.
+     */
+
+    ranges_ptr = get_node_search_offset_ranges(&offset, &ocount);
+
+    if (ocount > 0)
+    {
+        reset_pending_matches_ttl(matches);
+
+        pending_ptr = get_all_pending_matches(matches, &pcount);
+
+        for (p = 0; p < pcount; p++)
+        {
+            pending = (*pending_ptr) + p;
+
+            old_end = pending->end;
+
+            for (o = 0; o < ocount; o++)
+            {
+                range = (*ranges_ptr) + o;
+
+                new_end = old_end + range->min;
+
+                if (new_end > matches->content_end)
+                    new_end = matches->content_end;
+
+                extend_pending_match_ending(matches, p, new_end);
+
+            }
+
+        }
+
+        /**
+         * Pas besoin de purge ici puisque tous les résultats ont été traités
+         * au moins une fois, sans condition.
+         */
+        /* purge_pending_matches(matches); */
+
+        disable_all_ranges_in_node_search_offset(&offset);
+
+    }
+
+    assert(offset.used == 0);
+
+    exit_node_search_offset(&offset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void _g_scan_token_node_check_backward(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    GScanTokenNodeClass *class;             /* Classe de l'instance        */
+
+    printf("Checking backward... node=%p / %s skip=%d main=%u\n",
+           node, G_OBJECT_TYPE_NAME(node), *skip, (node->flags & STNF_MAIN) == STNF_MAIN);
+
+    class = G_SCAN_TOKEN_NODE_GET_CLASS(node);
+
+    class->check_backward(node, context, content, matches, offset, not, skip);
+
+    if (node->flags & STNF_MAIN)
+    {
+        //assert(*skip); //REMME
+        *skip = false;
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_check_backward(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches)
+{
+    node_search_offset_t offset;            /* Espace des correspondances  */
+    bool skip;                              /* Mise en attente des analyses*/
+    size_t ocount;                          /* Quantité de bornes présentes*/
+    node_offset_range_t * const *ranges_ptr;/* Bornes d'espace à parcourir */
+    size_t pcount;                          /* Nombre de correspondances   */
+    match_area_t * const *pending_ptr;      /* Correspondances actuelles   */
+    size_t p;                               /* Boucle de parcours #2       */
+    match_area_t *pending;                  /* Correspondance à traiter    */
+    phys_t old_start;                       /* Ancien point d'arrivée      */
+    size_t o;                               /* Boucle de parcours #1       */
+    const node_offset_range_t *range;       /* Bornes d'espace à parcourir */
+    phys_t new_start;                       /* Nouveau point d'arrivée     */
+
+    init_node_search_offset(&offset);
+
+    skip = true;
+
+    _g_scan_token_node_check_backward(node, context, content, matches, &offset, false, &skip);
+
+    /**
+     * Si un décalage entre octets n'a pas été consommé,
+     * les résultats sont étendus à minima.
+     */
+
+    ranges_ptr = get_node_search_offset_ranges(&offset, &ocount);
+
+    if (ocount > 0)
+    {
+        reset_pending_matches_ttl(matches);
+
+        pending_ptr = get_all_pending_matches(matches, &pcount);
+
+        for (p = 0; p < pcount; p++)
+        {
+            pending = (*pending_ptr) + p;
+
+            old_start = pending->start;
+
+            for (o = 0; o < ocount; o++)
+            {
+                range = (*ranges_ptr) + o;
+
+                if (old_start < range->min)
+                    new_start = 0;
+                else
+                    new_start = old_start - range->min;
+
+                if (new_start < matches->content_start)
+                    new_start = matches->content_start;
+
+                extend_pending_match_beginning(matches, p, new_start);
+
+            }
+
+        }
+
+        /**
+         * Pas besoin de purge ici puisque tous les résultats ont été traités
+         * au moins une fois, sans condition.
+         */
+        /* purge_pending_matches(matches); */
+
+        disable_all_ranges_in_node_search_offset(&offset);
+
+    }
+
+    assert(offset.used == 0);
+
+    exit_node_search_offset(&offset);
 
 }
diff --git a/src/analysis/scan/patterns/tokens/node.h b/src/analysis/scan/patterns/tokens/node.h
index 4c9eb48..a2e3b0d 100644
--- a/src/analysis/scan/patterns/tokens/node.h
+++ b/src/analysis/scan/patterns/tokens/node.h
@@ -49,28 +49,38 @@ typedef struct _GScanTokenNode GScanTokenNode;
 typedef struct _GScanTokenNodeClass GScanTokenNodeClass;
 
 
+/* Propriétés particulières pour noeud d'analyse */
+typedef enum _ScanTokenNodeFlags
+{
+    STNF_NONE  = (0 << 0),                  /* Absence de singularité      */
+    STNF_PROD  = (1 << 0),                  /* Absence de singularité      */
+    STNF_FIRST = (1 << 1),                  /* Premier noeud de traitement */   /* REMME ? */
+    STNF_LAST  = (1 << 2),                  /* Dernier noeud de traitement */   /* REMME ? */
+    STNF_MAIN  = (1 << 3),                  /* Point de départ d'analyse   */
+
+} ScanTokenNodeFlags;
+
+
 /* Indique le type défini pour un élément décomposant un motif d'octets à rechercher. */
 GType g_scan_token_node_get_type(void);
 
+/* Indique les propriétés particulières d'un noeud d'analyse. */
+ScanTokenNodeFlags g_scan_token_node_get_flags(const GScanTokenNode *);
 
-// TODO
-// validate
-// force_plain_registration // set begin/end
+/* Marque le noeud avec des propriétés particulières. */
+void g_scan_token_node_set_flags(GScanTokenNode *, ScanTokenNodeFlags);
 
+/* Détermine et prépare les éléments clefs d'une arborescence. */
+bool g_scan_token_node_setup_tree(GScanTokenNode *);
 
 /* Inscrit la définition d'un motif dans un moteur de recherche. */
-bool g_scan_token_node_enroll(GScanTokenNode *, GScanContext *, GEngineBackend *, size_t);
+bool g_scan_token_node_enroll(GScanTokenNode *, GScanContext *, GEngineBackend *, size_t, size_t *);
 
-/* Mémorisation d'une souplesse dans les positions visées */
-typedef struct _node_search_offset_t
-{
-    phys_t min;                             /* Position minimale           */
-    phys_t max;                             /* Position maxnimale           */
-
-} node_search_offset_t;
+/* Transforme les correspondances locales en trouvailles. */
+void g_scan_token_node_check_forward(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *);
 
 /* Transforme les correspondances locales en trouvailles. */
-void g_scan_token_node_check(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *);
+void g_scan_token_node_check_backward(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *);
 
 
 
diff --git a/src/analysis/scan/patterns/tokens/nodes/Makefile.am b/src/analysis/scan/patterns/tokens/nodes/Makefile.am
index c20beaf..b5da1ee 100644
--- a/src/analysis/scan/patterns/tokens/nodes/Makefile.am
+++ b/src/analysis/scan/patterns/tokens/nodes/Makefile.am
@@ -3,10 +3,18 @@ noinst_LTLIBRARIES  = libanalysisscanpatternstokensnodes.la
 
 
 libanalysisscanpatternstokensnodes_la_SOURCES =	\
-	hub-int.h								\
-	hub.h hub.c								\
+	any-int.h								\
+	any.h any.c								\
+	choice-int.h							\
+	choice.h choice.c						\
+	masked-int.h							\
+	masked.h masked.c						\
+	not-int.h								\
+	not.h not.c								\
 	plain-int.h								\
-	plain.h plain.c
+	plain.h plain.c							\
+	sequence-int.h							\
+	sequence.h sequence.c
 
 libanalysisscanpatternstokensnodes_la_CFLAGS = $(LIBGOBJ_CFLAGS)
 
diff --git a/src/analysis/scan/patterns/tokens/nodes/any-int.h b/src/analysis/scan/patterns/tokens/nodes/any-int.h
new file mode 100644
index 0000000..705aab3
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/any-int.h
@@ -0,0 +1,60 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * any-int.h - prototypes internes pour une suite d'octets quelconques
+ *
+ * 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_PATTERNS_TOKENS_NODES_ANY_INT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_ANY_INT_H
+
+
+#include "any.h"
+
+
+#include "../atom.h"
+#include "../node-int.h"
+
+
+
+/* Espace constitué d'un ou plusieurs octets quelconques (instance) */
+struct _GScanTokenNodeAny
+{
+    GScanTokenNode parent;                  /* A laisser en premier        */
+
+    phys_t min;                             /* Quantité minimale           */
+    phys_t max;                             /* Quantité maximale           */
+    bool has_max;                           /* Quantité définie ?          */
+
+};
+
+/* Espace constitué d'un ou plusieurs octets quelconques (classe) */
+struct _GScanTokenNodeAnyClass
+{
+    GScanTokenNodeClass parent;             /* A laisser en premier        */
+
+};
+
+
+/* Met en place un un noeud pointant une série d'octets. */
+bool g_scan_token_node_any_create(GScanTokenNodeAny *, const phys_t *, const phys_t *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_ANY_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/any.c b/src/analysis/scan/patterns/tokens/nodes/any.c
new file mode 100644
index 0000000..af2ae29
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/any.c
@@ -0,0 +1,425 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * any.c - suite d'octets quelconques
+ *
+ * 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 "any.h"
+
+
+#include <assert.h>
+
+
+#include "any-int.h"
+
+
+
+/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
+
+
+/* Initialise la classe des séries d'octets quelconques. */
+static void g_scan_token_node_any_class_init(GScanTokenNodeAnyClass *);
+
+/* Initialise une instance de série d'octets quelconques. */
+static void g_scan_token_node_any_init(GScanTokenNodeAny *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_token_node_any_dispose(GScanTokenNodeAny *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_token_node_any_finalize(GScanTokenNodeAny *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+static bool g_scan_token_node_any_enroll(GScanTokenNodeAny *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_any_check_forward(const GScanTokenNodeAny *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_any_check_backward(const GScanTokenNodeAny *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une série d'octets quelconque, vide ou non. */
+G_DEFINE_TYPE(GScanTokenNodeAny, g_scan_token_node_any, G_TYPE_SCAN_TOKEN_NODE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des séries d'octets quelconques.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_class_init(GScanTokenNodeAnyClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenNodeClass *node;              /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_any_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_any_finalize;
+
+    node = G_SCAN_TOKEN_NODE_CLASS(klass);
+
+    node->visit = (visit_scan_token_node_fc)NULL;
+    node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_any_enroll;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_any_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_any_check_backward;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : any = instance à initialiser.                                *
+*                                                                             *
+*  Description : Initialise une instance de série d'octets quelconques.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_init(GScanTokenNodeAny *any)
+{
+    g_scan_token_node_set_flags(G_SCAN_TOKEN_NODE(any), STNF_PROD);
+
+    any->min = 0;
+    any->has_max = false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : any = instance d'objet GLib à traiter.                       *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_dispose(GScanTokenNodeAny *any)
+{
+    G_OBJECT_CLASS(g_scan_token_node_any_parent_class)->dispose(G_OBJECT(any));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : any = instance d'objet GLib à traiter.                       *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_finalize(GScanTokenNodeAny *any)
+{
+    G_OBJECT_CLASS(g_scan_token_node_any_parent_class)->finalize(G_OBJECT(any));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : min = éventuelle quantité minimale à retrouver.              *
+*                max = éventuelle quantité maximale à retrouver.              *
+*                                                                             *
+*  Description : Construit un noeud pointant une série d'octets quelconques.  *
+*                                                                             *
+*  Retour      : Mécanismes mis en place.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenNode *g_scan_token_node_any_new(const phys_t *min, const phys_t *max)
+{
+    GScanTokenNode *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_ANY, NULL);
+
+    if (!g_scan_token_node_any_create(G_SCAN_TOKEN_NODE_ANY(result), min, max))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : any = séquence d'octets quelconques à initialiser pleinement.*
+*                min = éventuelle quantité minimale à retrouver.              *
+*                max = éventuelle quantité maximale à retrouver.              *
+*                                                                             *
+*  Description : Met en place un un noeud pointant une série d'octets.        *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_any_create(GScanTokenNodeAny *any, const phys_t *min, const phys_t *max)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    if (min != NULL)
+        any->min = *min;
+    else
+        any->min = 0;
+
+    if (max != NULL)
+    {
+        any->max = *max;
+
+        result = (any->min <= any->max);
+
+    }
+
+    any->has_max = (max != NULL);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_token_node_any_enroll(GScanTokenNodeAny *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+    bool forced;                            /* Inclusion dans un scan ?    */
+
+    result = true;
+
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+
+    if (forced)
+        *slow += (maxsize * 4);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_check_forward(const GScanTokenNodeAny *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    bool initialized;                       /* Initialisation du suivi ?   */
+    bool forced;                            /* Inclusion dans un scan ?    */
+    phys_t size;                            /* Quantité d'octets considérés*/
+    const phys_t *datasize;                 /* Taille max. à communiquer   */
+
+    if (*skip)
+        return;
+
+
+    //         $a = { [1-3] 6f }
+    // pas d'initialisation, construction de résultats avec une taille nulle
+
+
+
+    initialized = are_pending_matches_initialized(matches);
+
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+
+    size = matches->content_end - matches->content_start;
+
+    datasize = (not ? &size : NULL);
+
+    if (forced)
+    {
+        assert(!initialized);
+
+        if (node->min > size)
+            /* TODO set abort in matches */;
+
+        else
+            add_range_to_node_search_offset(offset,
+                                            matches->content_start,
+                                            matches->content_end - matches->content_start,
+                                            datasize);
+
+    }
+    else
+    {
+        assert(initialized);
+
+
+        // TODO : compléter les intervales éventuels déjà en place
+
+
+        printf("[i] create hole: %llx <-> %llx\n",
+               (unsigned long long)node->min,
+               (unsigned long long)node->max);
+
+
+
+        if (node->has_max)
+            add_range_to_node_search_offset(offset, node->min, node->max, datasize);
+        else
+            add_range_to_node_search_offset(offset, node->min, matches->content_end - node->min, datasize);
+
+        // TODO : si dernier, virer les correspondances qui n'ont plus l'espace de fin requis
+        // -> au niveau du noeud, en fonction du flag _LAST
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_any_check_backward(const GScanTokenNodeAny *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+#ifndef NDEBUG
+    bool forced;                            /* Inclusion dans un scan ?    */
+#endif
+    phys_t size;                            /* Quantité d'octets considérés*/
+    const phys_t *datasize;                 /* Taille max. à communiquer   */
+
+    if (*skip)
+        return;
+
+    /**
+     * En lecture à rebourd, au moins un noeud a été solicité pour analyse (lors
+     * du sens de lecteur normal). Donc l'initialisation a déjà dû avoir lieu.
+     */
+    assert(are_pending_matches_initialized(matches));
+
+    /**
+     * Si les recherches associées au noeud ont été forcées, alors les traitements
+     * liés ont déjà été effectués, et l'appel de cette fonction aurait dû être sauté.
+     */
+#ifndef NDEBUG
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+    assert(!forced);
+#endif
+
+    size = matches->content_end - matches->content_start;
+
+    if (node->min > size)
+        /* TODO set abort in matches */;
+
+    else
+    {
+        datasize = (not ? &size : NULL);
+
+        /**
+         * Une tolérance basée sur des espaces (et non des positions) est déterminée
+         * ici.
+         *
+         * Charge au prochain noeud de traitement de filtrer les résultats courants
+         * avec, voire à la fonction _g_scan_token_node_check_backward() de
+         * réaliser une synthèse finale si le noeud courant est le dernier d'une
+         * lignée.
+         */
+
+        if (node->has_max)
+            add_range_to_node_search_offset(offset, node->min, node->max, datasize);
+        else
+            add_range_to_node_search_offset(offset, node->min, matches->content_end - node->min, datasize);
+
+    }
+
+}
diff --git a/src/analysis/scan/patterns/tokens/nodes/any.h b/src/analysis/scan/patterns/tokens/nodes/any.h
new file mode 100644
index 0000000..6a5628a
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/any.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * any.h - prototypes pour une suite d'octets quelconques
+ *
+ * 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_PATTERNS_TOKENS_NODES_ANY_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_ANY_H
+
+
+#include <glib-object.h>
+
+
+#include "../node.h"
+
+
+
+#define G_TYPE_SCAN_TOKEN_NODE_ANY            g_scan_token_node_any_get_type()
+#define G_SCAN_TOKEN_NODE_ANY(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_ANY, GScanTokenNodeAny))
+#define G_IS_SCAN_TOKEN_NODE_ANY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_ANY))
+#define G_SCAN_TOKEN_NODE_ANY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_ANY, GScanTokenNodeAnyClass))
+#define G_IS_SCAN_TOKEN_NODE_ANY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_ANY))
+#define G_SCAN_TOKEN_NODE_ANY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_ANY, GScanTokenNodeAnyClass))
+
+
+/* Espace constitué d'un ou plusieurs octets quelconques (instance) */
+typedef struct _GScanTokenNodeAny GScanTokenNodeAny;
+
+/* Espace constitué d'un ou plusieurs octets quelconques (classe) */
+typedef struct _GScanTokenNodeAnyClass GScanTokenNodeAnyClass;
+
+
+/* Indique le type défini pour une série d'octets quelconque, vide ou non. */
+GType g_scan_token_node_any_get_type(void);
+
+/* Construit un noeud pointant une série d'octets quelconques. */
+GScanTokenNode *g_scan_token_node_any_new(const phys_t *, const phys_t *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_ANY_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/hub-int.h b/src/analysis/scan/patterns/tokens/nodes/choice-int.h
index df05112..77a4058 100644
--- a/src/analysis/scan/patterns/tokens/nodes/hub-int.h
+++ b/src/analysis/scan/patterns/tokens/nodes/choice-int.h
@@ -1,6 +1,6 @@
 
 /* Chrysalide - Outil d'analyse de fichiers binaires
- * hub-int.h - prototypes internes pour un groupe de décompositions de motif de recherche en atomes assemblés
+ * choice-int.h - prototypes internes pour des décompositions alternatives de motif de recherche
  *
  * Copyright (C) 2023 Cyrille Bagard
  *
@@ -21,26 +21,29 @@
  */
 
 
-#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H
-#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H
+#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_CHOICE_INT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_CHOICE_INT_H
 
 
-#include "hub.h"
+#include "choice.h"
 
 
 #include "../node-int.h"
 
 
 
-/* Groupe de décompositions de motif de recherche en atomes (instance) */
-struct _GScanTokenNodeHub
+/* Décompositions alternatives de motif de recherche (instance) */
+struct _GScanTokenNodeChoice
 {
     GScanTokenNode parent;                  /* A laisser en premier        */
 
+    GScanTokenNode **children;              /* Sous-noeuds à représenter   */
+    size_t count;                           /* Taille de cette liste       */
+
 };
 
-/* Groupe de décompositions de motif de recherche en atomes (classe) */
-struct _GScanTokenNodeHubClass
+/* Décompositions alternatives de motif de recherche (classe) */
+struct _GScanTokenNodeChoiceClass
 {
     GScanTokenNodeClass parent;             /* A laisser en premier        */
 
@@ -48,4 +51,4 @@ struct _GScanTokenNodeHubClass
 
 
 
-#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H */
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_CHOICE_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/choice.c b/src/analysis/scan/patterns/tokens/nodes/choice.c
new file mode 100644
index 0000000..df6ae45
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/choice.c
@@ -0,0 +1,486 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * choice.c - décompositions alternatives de motif de recherche
+ *
+ * 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 "choice.h"
+
+
+#include "choice-int.h"
+
+
+
+/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
+
+
+/* Initialise la classe des décompositions alternatives. */
+static void g_scan_token_node_choice_class_init(GScanTokenNodeChoiceClass *);
+
+/* Initialise une instance de décompositions alternatives. */
+static void g_scan_token_node_choice_init(GScanTokenNodeChoice *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_token_node_choice_dispose(GScanTokenNodeChoice *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_token_node_choice_finalize(GScanTokenNodeChoice *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Prend acte d'une nouvelle propriété pour le noeud. */
+static void g_scan_token_node_choice_apply_flags(GScanTokenNodeChoice *, ScanTokenNodeFlags);
+
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+static void g_scan_token_node_choice_visit(GScanTokenNodeChoice *, scan_tree_points_t *);
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+static bool g_scan_token_node_choice_enroll(GScanTokenNodeChoice *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_choice_check_forward(const GScanTokenNodeChoice *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_choice_check_backward(const GScanTokenNodeChoice *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour des décompositions alternatives de motif de recherche. */
+G_DEFINE_TYPE(GScanTokenNodeChoice, g_scan_token_node_choice, G_TYPE_SCAN_TOKEN_NODE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des décompositions alternatives.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_class_init(GScanTokenNodeChoiceClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenNodeClass *node;              /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_choice_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_choice_finalize;
+
+    node = G_SCAN_TOKEN_NODE_CLASS(klass);
+
+    node->apply = (apply_scan_token_node_flags_fc)g_scan_token_node_choice_apply_flags;
+    node->visit = (visit_scan_token_node_fc)g_scan_token_node_choice_visit;
+    node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_choice_enroll;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_choice_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_choice_check_backward;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : choice = instance à initialiser.                             *
+*                                                                             *
+*  Description : Initialise une instance de décompositions alternatives.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_init(GScanTokenNodeChoice *choice)
+{
+    choice->children = NULL;
+    choice->count = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : choice = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_dispose(GScanTokenNodeChoice *choice)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < choice->count; i++)
+        g_clear_object(&choice->children[i]);
+
+    G_OBJECT_CLASS(g_scan_token_node_choice_parent_class)->dispose(G_OBJECT(choice));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : choice = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_finalize(GScanTokenNodeChoice *choice)
+{
+    if (choice->children != NULL)
+        free(choice->children);
+
+    G_OBJECT_CLASS(g_scan_token_node_choice_parent_class)->finalize(G_OBJECT(choice));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Construit une série de décompositions alternatives de motif. *
+*                                                                             *
+*  Retour      : Mécanismes mis en place.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenNode *g_scan_token_node_choice_new(void)
+{
+    GScanTokenNode *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_CHOICE, NULL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : choice = ensemble de noeuds à compléter.                     *
+*                node   = nouveau noeud à intégrer.                           *
+*                                                                             *
+*  Description : Ajoute un noeud à aux décompositions alternatives de motif.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_choice_add(GScanTokenNodeChoice *choice, GScanTokenNode *node)
+{
+    choice->children = realloc(choice->children, ++choice->count * sizeof(GScanTokenNode *));
+
+    choice->children[choice->count - 1] = node;
+    g_object_ref(G_OBJECT(node));
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node  = noeud de motif à mettre à jour.                      *
+*                flags = propriétés particulières à associer au noeud.        *
+*                                                                             *
+*  Description : Prend acte d'une nouvelle propriété pour le noeud.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_apply_flags(GScanTokenNodeChoice *node, ScanTokenNodeFlags flags)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < node->count; i++)
+        g_scan_token_node_set_flags(node->children[i], flags);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_visit(GScanTokenNodeChoice *node, scan_tree_points_t *points)
+{
+    size_t first_plain_count;               /* Décompte de noeuds textuels */
+    size_t i;                               /* Boucle de parcours          */
+    scan_tree_points_t tmp_points;          /* Synthèse d'analyse locale   */
+
+    if (points->first_plain != NULL)
+        return;
+
+    first_plain_count = 0;
+
+    for (i = 0; i < node->count; i++)
+    {
+        tmp_points.first_node = NULL;
+        tmp_points.last_node = NULL;
+
+        tmp_points.first_plain = NULL;
+        tmp_points.best_masked = NULL;
+
+        g_scan_token_node_visit(node->children[i], &tmp_points);
+
+        if (tmp_points.first_plain != NULL)
+            first_plain_count++;
+
+    }
+
+    if (first_plain_count == node->count)
+        points->first_plain = G_SCAN_TOKEN_NODE(node);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_token_node_choice_enroll(GScanTokenNodeChoice *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = true;
+
+    for (i = 0; i < node->count && result; i++)
+        result = _g_scan_token_node_enroll(node->children[i], context, backend, maxsize, slow);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_check_forward(const GScanTokenNodeChoice *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    pending_matches_t init_matches;         /* Correspondances initiales   */
+    node_search_offset_t init_offset;       /* Intervales initiaux         */ 
+    size_t new_offset;                      /* Décompte d'intervales       */
+    size_t i;                               /* Boucle de parcours          */
+    pending_matches_t tmp_matches;          /* Copie locale de travail #1  */
+    node_search_offset_t tmp_offset;        /* Copie locale de travail #2  */
+
+    if (*skip)
+        return;
+
+    /* Copie des contextes de départ */
+
+    copy_pending_matches(&init_matches, matches);
+
+    exit_pending_matches(matches);
+    init_pending_matches(matches, &init_matches.content_start, &init_matches.content_end);
+
+    copy_node_search_offset(&init_offset, offset);
+
+    exit_node_search_offset(offset);
+    init_node_search_offset(offset);
+
+    /* Lancement des sous-traitements */
+
+    new_offset = 0;
+
+    for (i = 0; i < node->count; i++)
+    {
+        copy_pending_matches(&tmp_matches, &init_matches);
+        copy_node_search_offset(&tmp_offset, &init_offset);
+
+        _g_scan_token_node_check_forward(node->children[i], context, content,
+                                         &tmp_matches, &tmp_offset, not, skip);
+
+        merge_pending_matches(matches, &tmp_matches);
+        merge_node_search_offset(offset, &tmp_offset);
+
+        if (tmp_offset.used > 0)
+            new_offset++;
+
+        exit_pending_matches(&tmp_matches);
+        exit_node_search_offset(&tmp_offset);
+
+    }
+
+    /* Sortie propre */
+
+    exit_pending_matches(&init_matches);
+    exit_node_search_offset(&init_offset);
+
+    /* "Alternative" directe en cas de motif(s) non terminé(s) par un intervale */
+
+    if (new_offset != node->count)
+    {
+        assert(node->count > 1);
+        add_range_to_node_search_offset(offset, 0, 0, NULL);
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offsets = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_choice_check_backward(const GScanTokenNodeChoice *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    pending_matches_t init_matches;         /* Correspondances initiales   */
+    node_search_offset_t init_offset;       /* Intervales initiaux         */ 
+    size_t new_offset;                      /* Décompte d'intervales       */
+    size_t i;                               /* Boucle de parcours          */
+    pending_matches_t tmp_matches;          /* Copie locale de travail #1  */
+    node_search_offset_t tmp_offset;        /* Copie locale de travail #2  */
+
+    if (*skip)
+        return;
+
+    /* Copie des contextes de départ */
+
+    copy_pending_matches(&init_matches, matches);
+
+    exit_pending_matches(matches);
+    init_pending_matches(matches, &init_matches.content_start, &init_matches.content_end);
+
+    copy_node_search_offset(&init_offset, offset);
+
+    exit_node_search_offset(offset);
+    init_node_search_offset(offset);
+
+    /* Lancement des sous-traitements */
+
+    new_offset = 0;
+
+    for (i = 0; i < node->count; i++)
+    {
+        copy_pending_matches(&tmp_matches, &init_matches);
+        copy_node_search_offset(&tmp_offset, &init_offset);
+
+        _g_scan_token_node_check_backward(node->children[i], context, content,
+                                          &tmp_matches, &tmp_offset, not, skip);
+
+        merge_pending_matches(matches, &tmp_matches);
+        merge_node_search_offset(offset, &tmp_offset);
+
+        if (tmp_offset.used > 0)
+            new_offset++;
+
+        exit_pending_matches(&tmp_matches);
+        exit_node_search_offset(&tmp_offset);
+
+    }
+
+    /* Sortie propre */
+
+    exit_pending_matches(&init_matches);
+    exit_node_search_offset(&init_offset);
+
+    /* "Alternative" directe en cas de motif(s) non terminé(s) par un intervale */
+
+    if (new_offset != node->count)
+    {
+        assert(node->count > 1);
+        add_range_to_node_search_offset(offset, 0, 0, NULL);
+    }
+
+}
diff --git a/src/analysis/scan/patterns/tokens/nodes/choice.h b/src/analysis/scan/patterns/tokens/nodes/choice.h
new file mode 100644
index 0000000..e793b1e
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/choice.h
@@ -0,0 +1,61 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * choice.h - prototypes pour des décompositions alternatives de motif de recherche
+ *
+ * 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_PATTERNS_TOKENS_NODES_CHOICE_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_CHOICE_H
+
+
+#include <glib-object.h>
+
+
+#include "../node.h"
+
+
+
+#define G_TYPE_SCAN_TOKEN_NODE_CHOICE            g_scan_token_node_choice_get_type()
+#define G_SCAN_TOKEN_NODE_CHOICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_CHOICE, GScanTokenNodeChoice))
+#define G_IS_SCAN_TOKEN_NODE_CHOICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_CHOICE))
+#define G_SCAN_TOKEN_NODE_CHOICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_CHOICE, GScanTokenNodeChoiceClass))
+#define G_IS_SCAN_TOKEN_NODE_CHOICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_CHOICE))
+#define G_SCAN_TOKEN_NODE_CHOICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_CHOICE, GScanTokenNodeChoiceClass))
+
+
+/* Décompositions alternatives de motif de recherche (instance) */
+typedef struct _GScanTokenNodeChoice GScanTokenNodeChoice;
+
+/* Décompositions alternatives de motif de recherche (classe) */
+typedef struct _GScanTokenNodeChoiceClass GScanTokenNodeChoiceClass;
+
+
+/* Indique le type défini pour des décompositions alternatives de motif de recherche. */
+GType g_scan_token_node_choice_get_type(void);
+
+/* Construit une série de décompositions alternatives de motif. */
+GScanTokenNode *g_scan_token_node_choice_new(void);
+
+/* Ajoute un noeud à aux décompositions alternatives de motif. */
+void g_scan_token_node_choice_add(GScanTokenNodeChoice *, GScanTokenNode *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_CHOICE_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/hub.c b/src/analysis/scan/patterns/tokens/nodes/hub.c
deleted file mode 100644
index a11531d..0000000
--- a/src/analysis/scan/patterns/tokens/nodes/hub.c
+++ /dev/null
@@ -1,150 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * hub.c - groupe de décompositions de motif de recherche en atomes assemblés
- *
- * 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 "hub.h"
-
-
-#include "hub-int.h"
-
-
-
-/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
-
-
-/* Initialise la classe des groupes de décompositions. */
-static void g_scan_token_node_hub_class_init(GScanTokenNodeHubClass *klass);
-
-/* Initialise une instance de groupe de décompositions. */
-static void g_scan_token_node_hub_init(GScanTokenNodeHub *);
-
-/* Supprime toutes les références externes. */
-static void g_scan_token_node_hub_dispose(GScanTokenNodeHub *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_scan_token_node_hub_finalize(GScanTokenNodeHub *);
-
-
-
-/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-
-
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour un groupe de décompositions de motif d'octets à rechercher. */
-G_DEFINE_TYPE(GScanTokenNodeHub, g_scan_token_node_hub, G_TYPE_SCAN_TOKEN_NODE);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des groupes de décompositions.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_token_node_hub_class_init(GScanTokenNodeHubClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_hub_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_hub_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : hub = instance à initialiser.                                *
-*                                                                             *
-*  Description : Initialise une instance de groupe de décompositions.         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_token_node_hub_init(GScanTokenNodeHub *hub)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : hub = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_token_node_hub_dispose(GScanTokenNodeHub *hub)
-{
-    G_OBJECT_CLASS(g_scan_token_node_hub_parent_class)->dispose(G_OBJECT(hub));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : hub = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_token_node_hub_finalize(GScanTokenNodeHub *hub)
-{
-    G_OBJECT_CLASS(g_scan_token_node_hub_parent_class)->finalize(G_OBJECT(hub));
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-
-
diff --git a/src/analysis/scan/patterns/tokens/nodes/hub.h b/src/analysis/scan/patterns/tokens/nodes/hub.h
deleted file mode 100644
index b2cb0fc..0000000
--- a/src/analysis/scan/patterns/tokens/nodes/hub.h
+++ /dev/null
@@ -1,55 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * hub.h - prototypes pour un groupe de décompositions de motif de recherche en atomes assemblés
- *
- * 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_PATTERNS_TOKENS_NODES_HUB_H
-#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_H
-
-
-#include <glib-object.h>
-
-
-#include "../node.h"
-
-
-
-#define G_TYPE_SCAN_TOKEN_NODE_HUB            g_scan_token_node_hub_get_type()
-#define G_SCAN_TOKEN_NODE_HUB(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHub))
-#define G_IS_SCAN_TOKEN_NODE_HUB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_HUB))
-#define G_SCAN_TOKEN_NODE_HUB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHubClass))
-#define G_IS_SCAN_TOKEN_NODE_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_HUB))
-#define G_SCAN_TOKEN_NODE_HUB_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHubClass))
-
-
-/* Groupe de décompositions de motif de recherche en atomes (instance) */
-typedef struct _GScanTokenNodeHub GScanTokenNodeHub;
-
-/* Groupe de décompositions de motif de recherche en atomes (classe) */
-typedef struct _GScanTokenNodeHubClass GScanTokenNodeHubClass;
-
-
-/* Indique le type défini pour un groupe de décompositions de motif d'octets à rechercher. */
-GType g_scan_token_node_hub_get_type(void);
-
-
-
-#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/masked-int.h b/src/analysis/scan/patterns/tokens/nodes/masked-int.h
new file mode 100644
index 0000000..9eb8712
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/masked-int.h
@@ -0,0 +1,63 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * masked-int.h - prototypes internes pour la gestion d'une recherche de motif partielle
+ *
+ * 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_PATTERNS_TOKENS_NODES_MASKED_INT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_MASKED_INT_H
+
+
+#include "masked.h"
+
+
+#include "../node-int.h"
+
+
+
+/* Bribe de motif partielle pour recherches (instance) */
+struct _GScanTokenNodeMasked
+{
+    GScanTokenNode parent;                  /* A laisser en premier        */
+
+    masked_byte_t *bytes;                   /* Série d'octets masqués      */
+    size_t len;                             /* Taille de cette série       */
+
+    sized_binary_t *raw;                    /* Liste de motifs à couvrir   */
+    tracked_scan_atom_t *atoms;             /* Atomes correspondants       */
+    size_t count;                           /* Taille de cette liste       */
+    size_t enrolled_count;                  /* Quantité avec identifiant   */
+
+};
+
+/* Bribe de motif partielle pour recherches (classe) */
+struct _GScanTokenNodeMaskedClass
+{
+    GScanTokenNodeClass parent;             /* A laisser en premier        */
+
+};
+
+
+/* Met en place une bribe de motif partielle. */
+bool g_scan_token_node_masked_create(GScanTokenNodeMasked *, const masked_byte_t *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_MASKED_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/masked.c b/src/analysis/scan/patterns/tokens/nodes/masked.c
new file mode 100644
index 0000000..25f0315
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/masked.c
@@ -0,0 +1,814 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * masked.c - gestion d'une recherche de motif partielle
+ *
+ * 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 "masked.h"
+
+
+#include <assert.h>
+
+
+#include "masked-int.h"
+#include "../../backends/bitap.h"
+
+
+
+/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
+
+
+/* Initialise la classe des bribes de motif partielles. */
+static void g_scan_token_node_masked_class_init(GScanTokenNodeMaskedClass *);
+
+/* Initialise une instance de bribe de motif partielle. */
+static void g_scan_token_node_masked_init(GScanTokenNodeMasked *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_token_node_masked_dispose(GScanTokenNodeMasked *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_token_node_masked_finalize(GScanTokenNodeMasked *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+static void g_scan_token_node_masked_visit(GScanTokenNodeMasked *, scan_tree_points_t *);
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+static bool g_scan_token_node_masked_enroll(GScanTokenNodeMasked *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Détermine si un contenu d'intérêt est présent à une position. */
+static bool check_scan_token_node_masked_content(const masked_byte_t *, size_t, phys_t, GBinContent *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_masked_check_forward(const GScanTokenNodeMasked *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_masked_check_backward(const GScanTokenNodeMasked *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un noeud représentant une bribe partielle à retrouver. */
+G_DEFINE_TYPE(GScanTokenNodeMasked, g_scan_token_node_masked, G_TYPE_SCAN_TOKEN_NODE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des bribes de motif partielles.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_class_init(GScanTokenNodeMaskedClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenNodeClass *node;              /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_masked_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_masked_finalize;
+
+    node = G_SCAN_TOKEN_NODE_CLASS(klass);
+
+    node->visit = (visit_scan_token_node_fc)g_scan_token_node_masked_visit;
+    node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_masked_enroll;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_masked_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_masked_check_backward;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : masked = instance à initialiser.                             *
+*                                                                             *
+*  Description : Initialise une instance de bribe de motif partielle.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_init(GScanTokenNodeMasked *masked)
+{
+    g_scan_token_node_set_flags(G_SCAN_TOKEN_NODE(masked), STNF_PROD);
+
+    masked->bytes = NULL;
+    masked->len = 0;
+
+    masked->raw = NULL;
+    masked->atoms = NULL;
+    masked->count = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : masked = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_dispose(GScanTokenNodeMasked *masked)
+{
+    G_OBJECT_CLASS(g_scan_token_node_masked_parent_class)->dispose(G_OBJECT(masked));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : masked = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_finalize(GScanTokenNodeMasked *masked)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    if (masked->bytes != NULL)
+        free(masked->bytes);
+
+    for (i = 0; i < masked->count; i++)
+        exit_szstr(&masked->raw[i]);
+
+    if (masked->raw != NULL)
+        free(masked->raw);
+
+    if (masked->atoms != NULL)
+        free(masked->atoms);
+
+    G_OBJECT_CLASS(g_scan_token_node_masked_parent_class)->finalize(G_OBJECT(masked));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : byte = valeur masquée à intégrer.                            *
+*                                                                             *
+*  Description : Construit une bribe de motif partielle.                      *
+*                                                                             *
+*  Retour      : Mécanismes mis en place.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenNode *g_scan_token_node_masked_new(const masked_byte_t *byte)
+{
+    GScanTokenNode *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_MASKED, NULL);
+
+    if (!g_scan_token_node_masked_create(G_SCAN_TOKEN_NODE_MASKED(result), byte))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : masked = bribe partielle à initialiser pleinement.           *
+*                byte   = valeur masquée à intégrer.                          *
+*                                                                             *
+*  Description : Met en place une bribe de motif partielle.                   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_masked_create(GScanTokenNodeMasked *masked, const masked_byte_t *byte)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    g_scan_token_node_masked_add(masked, byte);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : masked = ensemble de noeuds à compléter.                     *
+*                byte = valeur masquée à intégrer.                            *
+*                                                                             *
+*  Description : Enregistre la valeur d'octet à rechercher avec son masque.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_masked_add(GScanTokenNodeMasked *masked, const masked_byte_t *byte)
+{
+    assert((byte->value & 0x0f) == 0 || (byte->value & 0xf0) == 0);
+
+    masked->bytes = realloc(masked->bytes, ++masked->len * sizeof(masked_byte_t));
+
+    masked->bytes[masked->len - 1] = *byte;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_visit(GScanTokenNodeMasked *node, scan_tree_points_t *points)
+{
+    GScanTokenNodeMasked *other;            /* Concurrence à mesurer       */
+
+    if (points->best_masked == NULL)
+        points->best_masked = G_SCAN_TOKEN_NODE(node);
+
+    else
+    {
+        other = G_SCAN_TOKEN_NODE_MASKED(points->best_masked);
+
+        if (node->len > other->len)
+            points->best_masked = G_SCAN_TOKEN_NODE(node);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_token_node_masked_enroll(GScanTokenNodeMasked *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+    bool forced;                            /* Inclusion dans un scan ?    */
+    //size_t len_to_enroll;                   /* Taille à considérer         */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = true;
+
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+
+    if (forced)
+    {
+        *slow += (maxsize * 2);
+
+        /**
+         * Dans le cas bien précis de l'usage de l'algorithme Bitap pour les recherches
+         * dans le contenu binaire à analyser, on tire parti du coût nul des recherches
+         * multiples pour une même position.
+         */
+
+        if (G_IS_BITAP_BACKEND(backend))
+        {
+            //len_to_enroll = (node->len < maxsize ? node->len : maxsize);
+
+            /* TODO */
+            assert(false);
+
+
+            node->enrolled_count = 1;
+
+        }
+
+        else
+        {
+            node->raw = make_atoms_from_masked_byte(node->bytes[0].value, node->bytes[0].mask, &node->count);
+
+            node->atoms = malloc(node->count * sizeof(tracked_scan_atom_t));
+
+            for (i = 0; i < node->count && result; i++)
+            {
+                find_best_atom(&node->raw[i], maxsize, &node->atoms[i], NULL);
+
+                result = enroll_prepared_atom(&node->raw[i], context, backend, &node->atoms[i]);
+
+            }
+
+            node->enrolled_count = node->count;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : bytes   = octets partiels avec leur masque à interpréter.    *
+*                len     = quantité d'octets à interpréter.                   *
+*                start   = point d'analyse à respecter.                       *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                                                                             *
+*  Description : Détermine si un contenu d'intérêt est présent à une position.*
+*                                                                             *
+*  Retour      : Bilan de l'analyse : true pour une correspondance.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool check_scan_token_node_masked_content(const masked_byte_t *bytes, size_t len, phys_t start, GBinContent *content)
+{
+    bool result;                            /* Bilan à retourner           */
+    vmpa2t pos;                             /* Position dans les données   */
+    const bin_t *ptr;                       /* Accès aux données brutes    */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = false;
+
+    init_vmpa(&pos, start, VMPA_NO_VIRTUAL);
+
+    ptr = g_binary_content_get_raw_access(content, &pos, len);
+
+    for (i = 0; i < len; i++)
+    {
+        if ((ptr[i] & bytes[i].mask) != bytes[i].value)
+            break;
+    }
+
+    result = (i == len);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_check_forward(const GScanTokenNodeMasked *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    bool initialized;                       /* Initialisation du suivi ?   */
+#ifndef NDEBUG
+    bool forced;                            /* Inclusion dans un scan ?    */
+#endif
+    size_t ocount;                          /* Quantité de bornes présentes*/
+    node_offset_range_t * const *ranges_ptr;/* Bornes d'espace à parcourir */
+    size_t i;                               /* Boucle de parcours #1       */
+    const tracked_scan_atom_t *atom;        /* Atome correspondant         */
+    size_t count;                           /* Quantité de bribes trouvées */
+    const phys_t *found;                    /* Localisations des bribes    */
+    size_t k;                               /* Boucle de parcours #2       */
+    phys_t new_begin;                       /* Nouveau départ à tester     */
+    size_t o;                               /* Boucle de parcours #3       */
+    const node_offset_range_t *range;       /* Bornes d'espace à parcourir */
+    bool status;                            /* Bilan d'une correspondance  */
+    size_t pcount;                          /* Nombre de correspondances   */
+    match_area_t * const *pending_ptr;      /* Correspondances actuelles   */
+    size_t p;                               /* Boucle de parcours #4       */
+    match_area_t *pending;                  /* Correspondance à traiter    */
+    phys_t after;                           /* Espace disposible après     */
+    phys_t min;                             /* Borne minimale déterminée   */
+    phys_t max;                             /* Borne maximale déterminée   */
+    phys_t j;                               /* Boucle de parcours #5       */
+
+    if (*skip)
+        return;
+
+    initialized = are_pending_matches_initialized(matches);
+
+    /**
+     * Si l'analyse arrive à un ou plusieurs octets masqués, soit il s'agit du
+     * premier noeud, et la génération d'atomes a été forcée pour obtenir des
+     * points de départ, soit des correspondances ont été établies au préalable,
+     * et il ne doit alors pas y avoir d'atome mis en place (si l'initialisation
+     * ne provient pas d'une mise en place artificielle par une inversion NOT).
+     */
+#ifndef NDEBUG
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+    assert((!initialized && forced) || (initialized && (!forced || not)));
+#endif
+
+    ranges_ptr = get_node_search_offset_ranges(offset, &ocount);
+
+    /* Si aucune correspondance n'a été établie */
+    if (!initialized)
+    {
+        for (i = 0; i < node->enrolled_count; i++)
+        {
+            atom = &node->atoms[i];
+
+            found = g_scan_context_get_atom_matches(context, atom->pid, &count);
+
+            for (k = 0; k < count; k++)
+            {
+                assert(atom->pos == 0);
+
+                new_begin = found[k];
+
+                /**
+                 * Si des bornes sont spécifiées, la position de l'atome est testée.
+                 *
+                 * Dans la pratique, cette situation (non initialisée) ne peut provenir
+                 * que d'un espace situé dans le vide, donc couvrant un large périmètre.
+                 * La validation a ainsi de grandes chances de passer...
+                 *
+                 * Le motif pouvant amener à cette situation (pas d'initialisation,
+                 * mais à décalage à considérer) est par exemple :
+                 *
+                 *    ~( ?? ?1 )
+                 *
+                 */
+                if (ocount > 0)
+                {
+                    if (!does_node_search_offset_include_pos_forward(offset, 0, new_begin))
+                        continue;
+                }
+
+                /**
+                 * Existe-t-il assez de place pour faire tenir le motif masqué ?
+                 */
+                if ((new_begin + node->len) > matches->content_end)
+                    continue;
+
+                status = check_scan_token_node_masked_content(node->bytes, node->len, new_begin, content);
+
+                if ((status && !not) || (!status && not))
+                {
+                    /**
+                     * Il ne peut y avoir qu'une seule séquence d'octets à un même
+                     * emplacement, donc le couple (start, len) enregistré est
+                     * unique.
+                     */
+                    add_pending_match(matches, new_begin, node->len);
+
+                }
+
+            }
+
+        }
+
+    }
+
+    /* Si les correspondances en place sont à confirmer et compléter */
+    else
+    {
+        reset_pending_matches_ttl(matches);
+
+        pending_ptr = get_all_pending_matches(matches, &pcount);
+
+        for (p = 0; p < pcount; p++)
+        {
+            pending = (*pending_ptr) + p;
+
+            assert(pending->end <= matches->content_end);
+
+            after = matches->content_end - pending->end;
+
+            new_begin = pending->end;
+
+            if (ocount > 0)
+            {
+                for (o = 0; o < ocount; o++)
+                {
+                    range = (*ranges_ptr) + o;
+
+                    /**
+                     * Si bornes de tolérance il y a, l'espace restant est validé en
+                     * tenant compte de ces bornes.
+                     */
+                    if (!get_node_offset_range(range, node->len, after, &min, &max))
+                        continue;
+
+                    /**
+                     * Une recherche des différentes correspondances amont est lancée.
+                     */
+                    for (j = min; j <= max; j++)
+                    {
+                        status = check_scan_token_node_masked_content(node->bytes, node->len,
+                                                                      new_begin + j, content);
+
+                        if ((status && !not) || (!status && not))
+                        {
+                            /**
+                             * S'il s'avère qu'il existe de multiples correspondances dans l'espace
+                             * analysé, c'est la fonction extend_pending_match_ending() qui
+                             * duplique cette correspondance, en s'appuyant sur le TTL pour
+                             * repérer ce cas de figure.
+                             *
+                             * Par exemple, deux correspondances '?1 ?1 [1-3] ?2 ?2'
+                             * sont valides pour un même contenu :
+                             *
+                             *    aa.bbb -> correspondance 'aa.bb'
+                             *      ^
+                             *
+                             *    aa.bbb -> correspondance 'aa..bb'
+                             *      ^
+                             */
+                            extend_pending_match_ending(matches, p, new_begin + j + node->len);
+
+                            /**
+                             * Comme l'extension a pu conduire à un ajout et donc à une
+                             * réallocation de la liste, on recharge l'élément pour les
+                             * itérations suivantes.
+                             */
+                            pending = (*pending_ptr) + p;
+
+                        }
+
+                    }
+
+                }
+
+            }
+
+            else
+            {
+                /**
+                 * Si la fin d'une correspondance potentielle est trop près de
+                 * la fin du contenu binaire et ne peut contenir le motif
+                 * représenté, alors la corresponance est écartée.
+                 */
+                if (node->len > after)
+                    continue;
+
+                new_begin = pending->end;
+
+                status = check_scan_token_node_masked_content(node->bytes, node->len, new_begin, content);
+
+                if ((status && !not) || (!status && not))
+                {
+                    extend_pending_match_ending(matches, p, new_begin + node->len);
+
+                    /**
+                     * Comme il n'y a qu'une seule itération par correspondance,
+                     * nul besoin de recharcher l'élément.
+                     */
+
+                }
+
+            }
+
+        }
+
+        purge_pending_matches(matches);
+
+    }
+
+    set_pending_matches_initialized(matches);
+
+    disable_all_ranges_in_node_search_offset(offset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offsets = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_masked_check_backward(const GScanTokenNodeMasked *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+#ifndef NDEBUG
+    bool forced;                            /* Inclusion dans un scan ?    */
+#endif
+    size_t pcount;                          /* Nombre de correspondances   */
+    match_area_t * const *pending_ptr;      /* Correspondances actuelles   */
+    size_t ocount;                          /* Quantité de bornes présentes*/
+    node_offset_range_t * const *ranges_ptr;/* Bornes d'espace à parcourir */
+    size_t p;                               /* Boucle de parcours #1       */
+    const match_area_t *pending;            /* Correspondance à traiter    */
+    phys_t before;                          /* Espace disposible avant     */
+    phys_t new_begin;                       /* Nouveau départ à tester     */
+    size_t o;                               /* Boucle de parcours #2       */
+    const node_offset_range_t *range;       /* Bornes d'espace à parcourir */
+    phys_t min;                             /* Borne minimale déterminée   */
+    phys_t max;                             /* Borne maximale déterminée   */
+    phys_t j;                               /* Boucle de parcours #3       */
+    bool status;                            /* Bilan d'une correspondance  */
+
+    if (*skip)
+        return;
+
+    /**
+     * En lecture à rebourd, au moins un noeud a été solicité pour analyse (lors
+     * du sens de lecteur normal). Donc l'initialisation a déjà dû avoir lieu.
+     */
+    assert(are_pending_matches_initialized(matches));
+
+    /**
+     * Si les recherches associées au noeud ont été forcées, alors les traitements
+     * liés ont déjà été effectués, et l'appel de cette fonction aurait dû être sauté.
+     */
+#ifndef NDEBUG
+    forced = (g_scan_token_node_get_flags(G_SCAN_TOKEN_NODE(node)) & STNF_MAIN);
+    assert(!forced);
+#endif
+
+    reset_pending_matches_ttl(matches);
+
+    pending_ptr = get_all_pending_matches(matches, &pcount);
+
+    ranges_ptr = get_node_search_offset_ranges(offset, &ocount);
+
+    for (p = 0; p < pcount; p++)
+    {
+        pending = (*pending_ptr) + p;
+
+        assert(matches->content_start <= pending->start);
+
+        before = pending->start - matches->content_start;
+
+        printf(" (masked) pending: %u - len=%u\n",
+               (unsigned int)pending->start, (unsigned int)node->len);
+
+        new_begin = pending->start - node->len;
+
+        if (ocount > 0)
+        {
+            for (o = 0; o < ocount; o++)
+            {
+                range = (*ranges_ptr) + o;
+
+                /**
+                 * Si bornes de tolérance il y a, l'espace restant est validé en
+                 * tenant compte de ces bornes.
+                 */
+                if (!get_node_offset_range(range, node->len, before, &min, &max))
+                {
+                    if (not)
+                        extend_pending_match_beginning(matches, p, pending->start - node->len);
+
+                    continue;
+
+                }
+
+                /**
+                 * Une recherche des différentes correspondances amont est lancée.
+                 */
+                for (j = min; j <= max; j++)
+                {
+                    status = check_scan_token_node_masked_content(node->bytes, node->len,
+                                                                  new_begin - j, content);
+
+                    if ((status && !not) || (!status && not))
+                    {
+                        /**
+                         * S'il s'avère qu'il existe de multiples correspondances dans l'espace
+                         * analysé, c'est la fonction extend_pending_match_beginning() qui
+                         * duplique cette correspondance, en s'appuyant sur le TTL pour
+                         * repérer ce cas de figure.
+                         */
+                        extend_pending_match_beginning(matches, p, new_begin);
+
+                        /**
+                         * Comme l'extension a pu conduire à un ajout et donc à une
+                         * réallocation de la liste, on recharge l'élément pour les
+                         * itérations suivantes.
+                         */
+                        pending = (*pending_ptr) + p;
+
+                    }
+
+                }
+
+            }
+
+        }
+
+        else
+        {
+            /**
+             * Si le début d'une correspondance potentielle est trop près du début
+             * du contenu binaire et ne peut contenir le motif représenté, alors
+             * la corresponance est écartée.
+             */
+            if (node->len > before)
+            {
+                if (not)
+                    extend_pending_match_beginning(matches, p, new_begin);
+
+                continue;
+
+            }
+
+            status = check_scan_token_node_masked_content(node->bytes, node->len, new_begin, content);
+
+            printf(" (masked) found new @ %llx ? %d\n",
+                   (unsigned long long)new_begin, status);
+
+
+            if ((status && !not) || (!status && not))
+                extend_pending_match_beginning(matches, p, new_begin);
+
+        }
+
+    }
+
+    purge_pending_matches(matches);
+
+    disable_all_ranges_in_node_search_offset(offset);
+
+}
diff --git a/src/analysis/scan/patterns/tokens/nodes/masked.h b/src/analysis/scan/patterns/tokens/nodes/masked.h
new file mode 100644
index 0000000..d1765fa
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/masked.h
@@ -0,0 +1,72 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * masked.h - prototypes pour la gestion d'une recherche de motif partielle
+ *
+ * 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_PATTERNS_TOKENS_NODES_MASKED_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_MASKED_H
+
+
+#include <glib-object.h>
+
+
+#include "../atom.h"
+#include "../node.h"
+#include "../../../../../arch/archbase.h"
+
+
+
+#define G_TYPE_SCAN_TOKEN_NODE_MASKED            g_scan_token_node_masked_get_type()
+#define G_SCAN_TOKEN_NODE_MASKED(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_MASKED, GScanTokenNodeMasked))
+#define G_IS_SCAN_TOKEN_NODE_MASKED(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_MASKED))
+#define G_SCAN_TOKEN_NODE_MASKED_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_MASKED, GScanTokenNodeMaskedClass))
+#define G_IS_SCAN_TOKEN_NODE_MASKED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_MASKED))
+#define G_SCAN_TOKEN_NODE_MASKED_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_MASKED, GScanTokenNodeMaskedClass))
+
+
+/* Bribe de motif partielle pour recherches (instance) */
+typedef struct _GScanTokenNodeMasked GScanTokenNodeMasked;
+
+/* Bribe de motif partielle pour recherches (classe) */
+typedef struct _GScanTokenNodeMaskedClass GScanTokenNodeMaskedClass;
+
+
+/* Mémorisation d'un octet visé avec son masque */
+typedef struct _masked_byte_t
+{
+    bin_t value;                            /* Valeur de l'octet visé      */
+    bin_t mask;                             /* Masque à appliquer          */
+
+} masked_byte_t;
+
+
+/* Indique le type défini pour un noeud représentant une bribe partielle à retrouver. */
+GType g_scan_token_node_masked_get_type(void);
+
+/* Construit une bribe de motif partielle. */
+GScanTokenNode *g_scan_token_node_masked_new(const masked_byte_t *);
+
+/* Enregistre la valeur d'octet à rechercher avec son masque. */
+void g_scan_token_node_masked_add(GScanTokenNodeMasked *, const masked_byte_t *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_MASKED_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/not-int.h b/src/analysis/scan/patterns/tokens/nodes/not-int.h
new file mode 100644
index 0000000..5f92afd
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/not-int.h
@@ -0,0 +1,57 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * not-int.h - prototypes internes pour l'inversion de résultats de correspondances établis
+ *
+ * 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_PATTERNS_TOKENS_NODES_NOT_INT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_NOT_INT_H
+
+
+#include "not.h"
+
+
+#include "../node-int.h"
+
+
+
+/* Inversion de résultats de correspondances établis (instance) */
+struct _GScanTokenNodeNot
+{
+    GScanTokenNode parent;                  /* A laisser en premier        */
+
+    GScanTokenNode *child;                  /* Sous-noeud à considérer     */
+
+};
+
+/* Inversion de résultats de correspondances établis (classe) */
+struct _GScanTokenNodeNotClass
+{
+    GScanTokenNodeClass parent;             /* A laisser en premier        */
+
+};
+
+
+/* Met en place une inversion de résultats de correspondances. */
+bool g_scan_token_node_not_create(GScanTokenNodeNot *, GScanTokenNode *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_NOT_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/not.c b/src/analysis/scan/patterns/tokens/nodes/not.c
new file mode 100644
index 0000000..c54a66f
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/not.c
@@ -0,0 +1,364 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * not.c - inversion de résultats de correspondances établis
+ *
+ * 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 "not.h"
+
+
+#include "not-int.h"
+
+
+
+/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
+
+
+/* Initialise la classe des inversions de correspondances. */
+static void g_scan_token_node_not_class_init(GScanTokenNodeNotClass *);
+
+/* Initialise une instance d'inversion de correspondances. */
+static void g_scan_token_node_not_init(GScanTokenNodeNot *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_token_node_not_dispose(GScanTokenNodeNot *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_token_node_not_finalize(GScanTokenNodeNot *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+static void g_scan_token_node_not_visit(GScanTokenNodeNot *, scan_tree_points_t *);
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+static bool g_scan_token_node_not_enroll(GScanTokenNodeNot *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_not_check_forward(const GScanTokenNodeNot *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_not_check_backward(const GScanTokenNodeNot *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une inversion des résultats de correspondances. */
+G_DEFINE_TYPE(GScanTokenNodeNot, g_scan_token_node_not, G_TYPE_SCAN_TOKEN_NODE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des inversions de correspondances.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_class_init(GScanTokenNodeNotClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenNodeClass *node;              /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_not_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_not_finalize;
+
+    node = G_SCAN_TOKEN_NODE_CLASS(klass);
+
+    node->visit = (visit_scan_token_node_fc)g_scan_token_node_not_visit;
+    node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_not_enroll;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_not_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_not_check_backward;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : not = instance à initialiser.                                *
+*                                                                             *
+*  Description : Initialise une instance d'inversion de correspondances.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_init(GScanTokenNodeNot *not)
+{
+    not->child = NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : not = instance d'objet GLib à traiter.                       *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_dispose(GScanTokenNodeNot *not)
+{
+    g_clear_object(&not->child);
+
+    G_OBJECT_CLASS(g_scan_token_node_not_parent_class)->dispose(G_OBJECT(not));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : not = instance d'objet GLib à traiter.                       *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_finalize(GScanTokenNodeNot *not)
+{
+    G_OBJECT_CLASS(g_scan_token_node_not_parent_class)->finalize(G_OBJECT(not));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : child = noeud dont les résultats sont à écarter.             *
+*                                                                             *
+*  Description : Construit une inversion de résultats de correspondances.     *
+*                                                                             *
+*  Retour      : Mécanismes mis en place.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenNode *g_scan_token_node_not_new(GScanTokenNode *child)
+{
+    GScanTokenNode *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_NOT, NULL);
+
+    if (!g_scan_token_node_not_create(G_SCAN_TOKEN_NODE_NOT(result), child))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : not   = encadrement d'inversion à initialiser pleinement.    *
+*                child = noeud dont les résultats sont à écarter.             *
+*                                                                             *
+*  Description : Met en place une inversion de résultats de correspondances.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_not_create(GScanTokenNodeNot *not, GScanTokenNode *child)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    not->child = child;
+    g_object_ref(G_OBJECT(child));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_visit(GScanTokenNodeNot *node, scan_tree_points_t *points)
+{
+    g_scan_token_node_visit(node->child, points);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_token_node_not_enroll(GScanTokenNodeNot *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+
+    result = _g_scan_token_node_enroll(node->child, context, backend, maxsize, slow);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_check_forward(const GScanTokenNodeNot *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    bool initialized;                       /* Initialisation du suivi ?   */
+    phys_t i;                               /* Boucle de parcours          */
+
+
+    /*
+
+      ?????????????????????????
+
+
+    if (*skip)
+        return;
+    */
+
+
+
+    initialized = are_pending_matches_initialized(matches);
+
+
+    printf("TOTO......(init done? %d)\n", initialized);
+
+
+
+    if (!initialized)
+    {
+        for (i = matches->content_start; i < matches->content_end; i++)
+            add_pending_match(matches, i, 0);
+
+        set_pending_matches_initialized(matches);
+
+    }
+
+    _g_scan_token_node_check_forward(node->child, context, content, matches, offset, !not, skip);
+
+
+
+
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_not_check_backward(const GScanTokenNodeNot *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+
+
+
+    if (*skip)
+        return;
+
+
+
+    printf("TODO\n");
+    assert(0);
+
+
+
+}
diff --git a/src/analysis/scan/patterns/tokens/nodes/not.h b/src/analysis/scan/patterns/tokens/nodes/not.h
new file mode 100644
index 0000000..58630e8
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/not.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * not.h - prototypes pour l'inversion de résultats de correspondances établis
+ *
+ * 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_PATTERNS_TOKENS_NODES_NOT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_NOT_H
+
+
+#include <glib-object.h>
+
+
+#include "../node.h"
+#include "../../../../../arch/archbase.h"
+
+
+
+#define G_TYPE_SCAN_TOKEN_NODE_NOT            g_scan_token_node_not_get_type()
+#define G_SCAN_TOKEN_NODE_NOT(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_NOT, GScanTokenNodeNot))
+#define G_IS_SCAN_TOKEN_NODE_NOT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_NOT))
+#define G_SCAN_TOKEN_NODE_NOT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_NOT, GScanTokenNodeNotClass))
+#define G_IS_SCAN_TOKEN_NODE_NOT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_NOT))
+#define G_SCAN_TOKEN_NODE_NOT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_NOT, GScanTokenNodeNotClass))
+
+
+/* Inversion de résultats de correspondances établis (instance) */
+typedef struct _GScanTokenNodeNot GScanTokenNodeNot;
+
+/* Inversion de résultats de correspondances établis (classe) */
+typedef struct _GScanTokenNodeNotClass GScanTokenNodeNotClass;
+
+
+/* Indique le type défini pour une inversion des résultats de correspondances. */
+GType g_scan_token_node_not_get_type(void);
+
+/* Construit une inversion de résultats de correspondances. */
+GScanTokenNode *g_scan_token_node_not_new(GScanTokenNode *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_NOT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/plain-int.h b/src/analysis/scan/patterns/tokens/nodes/plain-int.h
index a38359d..2077c6f 100644
--- a/src/analysis/scan/patterns/tokens/nodes/plain-int.h
+++ b/src/analysis/scan/patterns/tokens/nodes/plain-int.h
@@ -28,8 +28,8 @@
 #include "plain.h"
 
 
-#include "../node-int.h"
 #include "../atom.h"
+#include "../node-int.h"
 
 
 
@@ -56,7 +56,7 @@ struct _GScanTokenNodePlainClass
 };
 
 
-/* Met en place un un noeud représentant un motif textuel. */
+/* Met en place un noeud représentant un motif textuel. */
 bool g_scan_token_node_plain_create(GScanTokenNodePlain *, const sized_binary_t *, GScanTokenModifier *, ScanPlainNodeFlags);
 
 
diff --git a/src/analysis/scan/patterns/tokens/nodes/plain.c b/src/analysis/scan/patterns/tokens/nodes/plain.c
index ee87c73..5a7f976 100644
--- a/src/analysis/scan/patterns/tokens/nodes/plain.c
+++ b/src/analysis/scan/patterns/tokens/nodes/plain.c
@@ -24,7 +24,11 @@
 #include "plain.h"
 
 
+#include <assert.h>
+
+
 #include "plain-int.h"
+#include "../../../../../common/extstr.h"
 
 
 
@@ -32,7 +36,7 @@
 
 
 /* Initialise la classe des noeuds pour motif textuel. */
-static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *klass);
+static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *);
 
 /* Initialise une instance de noeud pour motif textuel. */
 static void g_scan_token_node_plain_init(GScanTokenNodePlain *);
@@ -48,14 +52,20 @@ static void g_scan_token_node_plain_finalize(GScanTokenNodePlain *);
 /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+static void g_scan_token_node_plain_visit(GScanTokenNodePlain *, scan_tree_points_t *);
+
 /* Inscrit la définition d'un motif dans un moteur de recherche. */
-static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *, GScanContext *, GEngineBackend *, size_t );
+static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *, GScanContext *, GEngineBackend *, size_t, size_t *);
 
 /* Détermine si un contenu d'intérêt est présent à une position. */
-static bool check_scan_token_node_plain_content(const sized_binary_t *, const tracked_scan_atom_t *, phys_t, GBinContent *);
+static bool check_scan_token_node_plain_content(const sized_binary_t *, const tracked_scan_atom_t *, bool, phys_t, GBinContent *);
 
 /* Transforme les correspondances locales en trouvailles. */
-static void g_scan_plain_bytes_check(const GScanTokenNodePlain *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *);
+static void g_scan_token_node_plain_check_forward(const GScanTokenNodePlain *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_plain_check_backward(const GScanTokenNodePlain *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
 
 
 
@@ -92,8 +102,10 @@ static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *klass)
 
     node = G_SCAN_TOKEN_NODE_CLASS(klass);
 
+    node->visit = (visit_scan_token_node_fc)g_scan_token_node_plain_visit;
     node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_plain_enroll;
-    node->check = (check_scan_token_node_fc)g_scan_plain_bytes_check;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_plain_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_plain_check_backward;
 
 }
 
@@ -112,6 +124,8 @@ static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *klass)
 
 static void g_scan_token_node_plain_init(GScanTokenNodePlain *plain)
 {
+    g_scan_token_node_set_flags(G_SCAN_TOKEN_NODE(plain), STNF_PROD);
+
     init_szstr(&plain->orig);
     plain->modifier = NULL;
     plain->flags = SPNF_NONE;
@@ -203,6 +217,7 @@ GScanTokenNode *g_scan_token_node_plain_new(const sized_binary_t *text, GScanTok
 
 }
 
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : plain    = encadrement de motif à initialiser pleinement.    *
@@ -210,7 +225,7 @@ GScanTokenNode *g_scan_token_node_plain_new(const sized_binary_t *text, GScanTok
 *                modifier = transformateur éventuel à solliciter.             *
 *                flags    = particularités à prendre en considération.        *
 *                                                                             *
-*  Description : Met en place un un noeud représentant un motif textuel.      *
+*  Description : Met en place un noeud représentant un motif textuel.         *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -239,6 +254,29 @@ bool g_scan_token_node_plain_create(GScanTokenNodePlain *plain, const sized_bina
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : plain = noeud de motif textuel à consulter.                  *
+*                                                                             *
+*  Description : Indique les propriétés particulières d'un noeud de texte.    *
+*                                                                             *
+*  Retour      : Propriétés particulières associées au noeud.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+ScanPlainNodeFlags g_scan_token_node_plain_get_flags(const GScanTokenNodePlain *plain)
+{
+    ScanPlainNodeFlags result;              /* Statut à retourner          */
+
+    result = plain->flags;
+
+    return result;
+
+}
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
@@ -247,10 +285,32 @@ bool g_scan_token_node_plain_create(GScanTokenNodePlain *plain, const sized_bina
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_plain_visit(GScanTokenNodePlain *node, scan_tree_points_t *points)
+{
+    if (points->first_plain == NULL)
+        points->first_plain = G_SCAN_TOKEN_NODE(node);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : node    = définition de la bribe à enregistrer.              *
 *                context = contexte de l'analyse à mener.                     *
 *                backend = moteur de recherche à préchauffer.                 *
 *                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
 *                                                                             *
 *  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
 *                                                                             *
@@ -260,7 +320,7 @@ bool g_scan_token_node_plain_create(GScanTokenNodePlain *plain, const sized_bina
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanContext *context, GEngineBackend *backend, size_t maxsize)
+static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
 {
     bool result;                            /* Statut à retourner          */
     size_t i;                               /* Boucle de parcours #1       */
@@ -312,13 +372,14 @@ static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanConte
             if (letters == 0)
                 node->atoms[i] = atom;
 
-            /* Insertion des combinaisons pour couvrir toutes les casses */
+            /* Insertion des nouvelles combinaisons pour couvrir toutes les casses */
             else
             {
-                for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2)
+                /* extra_count = 2^letters */
+                for (k = 1, extra_count = 2; k < letters; k++, extra_count *= 2)
                     ;
 
-                extra = make_atoms_case_insensitive(&node->raw[i], extra_count);
+                extra = make_atoms_case_insensitive(&node->raw[i], &atom, extra_count);
 
                 remaining = node->count - i - 1;
 
@@ -333,7 +394,7 @@ static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanConte
 
                 free(extra);
 
-                node->atoms = realloc(node->raw, node->count * sizeof(tracked_scan_atom_t));
+                node->atoms = realloc(node->atoms, node->count * sizeof(tracked_scan_atom_t));
 
                 for (k = 0; k < extra_count; k++)
                     node->atoms[i + k] = atom;
@@ -365,6 +426,7 @@ static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanConte
 *                                                                             *
 *  Paramètres  : raw     = contneu brut à retrouver idéalement.               *
 *                atom    = contenu brut représentatif ciblé.                  *
+*                nocase  = marque un éventuel désintérêt pour la casse.       *
 *                start   = point d'analyse à respecter.                       *
 *                content = accès au contenu brut pour vérifications (optim.)  *
 *                                                                             *
@@ -376,7 +438,7 @@ static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanConte
 *                                                                             *
 ******************************************************************************/
 
-static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const tracked_scan_atom_t *atom, phys_t start, GBinContent *content)
+static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const tracked_scan_atom_t *atom, bool nocase, phys_t start, GBinContent *content)
 {
     bool result;                            /* Bilan à retourner           */
     vmpa2t pos;                             /* Position dans les données   */
@@ -393,7 +455,11 @@ static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const
     {
         ptr = g_binary_content_get_raw_access(content, &pos, atom->pos);
 
-        ret = memcmp(raw->data, ptr, atom->pos);
+        if (nocase)
+            ret = memcasecmp(raw->data, ptr, atom->pos);
+        else
+            ret = memcmp(raw->data, ptr, atom->pos);
+
         if (ret != 0) goto done;
 
     }
@@ -406,7 +472,11 @@ static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const
 
         ptr = g_binary_content_get_raw_access(content, &pos, atom->rem);
 
-        ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem);
+        if (nocase)
+            ret = memcasecmp(raw->data + atom->pos + atom->len, ptr, atom->rem);
+        else
+            ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem);
+
         if (ret != 0) goto done;
 
     }
@@ -427,6 +497,8 @@ static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const
 *                content = accès au contenu brut pour vérifications (optim.)  *
 *                matches = suivi des correspondances à consolider.            *
 *                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
 *                                                                             *
 *  Description : Transforme les correspondances locales en trouvailles.       *
 *                                                                             *
@@ -436,22 +508,33 @@ static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const
 *                                                                             *
 ******************************************************************************/
 
-static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, const node_search_offset_t *offset)
+static void g_scan_token_node_plain_check_forward(const GScanTokenNodePlain *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
 {
     bool initialized;                       /* Initialisation du suivi ?   */
+    bool nocase;                            /* Pas d'intérêt pour la casse */
+    size_t ocount;                          /* Quantité de bornes présentes*/
     size_t i;                               /* Boucle de parcours #1       */
     const sized_binary_t *raw;              /* Données brutes d'origine    */
     const tracked_scan_atom_t *atom;        /* Atome correspondant         */
     size_t count;                           /* Quantité de bribes trouvées */
     const phys_t *found;                    /* Localisations des bribes    */
     size_t k;                               /* Boucle de parcours #2       */
-    phys_t start;                           /* Point de départ             */
+    phys_t new_begin;                       /* Nouveau départ à tester     */
     bool status;                            /* Bilan d'une correspondance  */
     size_t pcount;                          /* Nombre de correspondances   */
+    match_area_t * const *pending_ptr;      /* Correspondances actuelles   */
     size_t p;                               /* Boucle de parcours #3       */
+    const match_area_t *pending;            /* Correspondance à traiter    */
+
+    if (*skip)
+        return;
 
     initialized = are_pending_matches_initialized(matches);
 
+    nocase = (node->flags & SPNF_CASE_INSENSITIVE);
+
+    get_node_search_offset_ranges(offset, &ocount);
+
     for (i = 0; i < node->count; i++)
     {
         raw = &node->raw[i];
@@ -463,28 +546,34 @@ static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanConte
         {
             for (k = 0; k < count; k++)
             {
-                start = found[k] - atom->pos;
+                new_begin = found[k] - atom->pos;
 
                 /**
                  * Si personne n'a manipulé les pré-résultats, mais qu'un décallage
                  * est spécifié par un noeud précédent, une validation sur la base
                  * d'une position 0 est menée.
                  */
-                if (offset != NULL)
+                if (ocount > 0)
                 {
-                    if (start < offset->min || start > offset->max)
+                    if (!does_node_search_offset_include_pos_forward(offset, 0, new_begin))
+                    {
+                        if (not)
+                            add_pending_match(matches, new_begin, raw->len);
+
                         continue;
+
+                    }
                 }
 
-                status = check_scan_token_node_plain_content(raw, atom, start, content);
+                status = check_scan_token_node_plain_content(raw, atom, nocase, new_begin, content);
 
-                if (status)
+                if ((status && !not) || (!status && not))
                     /**
                      * Il ne peut y avoir qu'une seule séquence d'octets à un même
-                     * emplacement, donc le couple (start, len) enregistré est
+                     * emplacement, donc le couple (new_begin, len) enregistré est
                      * unique.
                      */
-                    add_pending_match(matches, start, raw->len);
+                    add_pending_match(matches, new_begin, raw->len);
 
             }
 
@@ -494,12 +583,17 @@ static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanConte
         {
             reset_pending_matches_ttl(matches);
 
-            pcount = count_pending_matches(matches);
+            pending_ptr = get_all_pending_matches(matches, &pcount);
 
             for (p = 0; p < pcount; p++)
+            {
+                pending = (*pending_ptr) + p;
+
+                assert(matches->content_start <= pending->start);
+
                 for (k = 0; k < count; k++)
                 {
-                    start = found[k] - atom->pos;
+                    new_begin = found[k] - atom->pos;
 
                     /**
                      * Si bornes de tolérance il y a, on valide la position.
@@ -507,20 +601,52 @@ static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanConte
                      * Sinon les correspondances passées et actuelle doivent
                      * être jointes.
                      */
-                    if (offset != NULL)
+                    if (ocount > 0)
                     {
-                        if (!has_pending_match_ending_between(matches, p, start, offset->min, offset->max))
+                        if (!does_node_search_offset_include_pos_forward(offset, pending->end, new_begin))
+                        {
+                            if (not)
+                            {
+                                extend_pending_match_ending(matches, p, pending->end + raw->len);
+
+                                /**
+                                 * Comme l'extension a pu conduire à un ajout et donc à une
+                                 * réallocation de la liste, on recharge l'élément pour les
+                                 * itérations suivantes.
+                                 */
+                                pending = (*pending_ptr) + p;
+
+                            }
+
                             continue;
+
+                        }
                     }
                     else
                     {
-                        if (!has_pending_match_ending_at(matches, p, start))
+                        if (pending->end != new_begin)
+                        {
+                            if (not)
+                            {
+                                extend_pending_match_ending(matches, p, pending->end + raw->len);
+
+                                /**
+                                 * Comme l'extension a pu conduire à un ajout et donc à une
+                                 * réallocation de la liste, on recharge l'élément pour les
+                                 * itérations suivantes.
+                                 */
+                                pending = (*pending_ptr) + p;
+
+                            }
+
                             continue;
+
+                        }
                     }
 
-                    status = check_scan_token_node_plain_content(raw, atom, start, content);
+                    status = check_scan_token_node_plain_content(raw, atom, nocase, new_begin, content);
 
-                    if (status)
+                    if ((status && !not) || (!status && not))
                     {
                         /**
                          * Même si une base de couples uniques est assurée,
@@ -559,18 +685,28 @@ static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanConte
 
                         /**
                          * La seconde situation est prise en compte par la fonction
-                         * extend_pending_match() qui s'appuie sur le TTL pour dupliquer
-                         * la correspondance pending[x] initiale. Le nouvel élément est
-                         * placé en fin de liste, ce qui ne boulverse pas le parcours
-                         * de liste courant, la valeur de pcount n'étant pas actualisée.
+                         * extend_pending_match_ending() qui s'appuie sur le TTL pour
+                         * dupliquer la correspondance pending[x] initiale. Le nouvel
+                         * élément est placé en fin de liste, ce qui ne boulverse pas
+                         * le parcours de liste courant, la valeur de pcount n'étant
+                         * pas actualisée.
                          */
 
-                        extend_pending_match(matches, p, start + raw->len);
+                        extend_pending_match_ending(matches, p, new_begin + raw->len);
+
+                        /**
+                         * Comme l'extension a pu conduire à un ajout et donc à une
+                         * réallocation de la liste, on recharge l'élément pour les
+                         * itérations suivantes.
+                         */
+                        pending = (*pending_ptr) + p;
 
                     }
 
                 }
 
+            }
+
             purge_pending_matches(matches);
 
         }
@@ -579,4 +715,42 @@ static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanConte
 
     set_pending_matches_initialized(matches);
 
+    disable_all_ranges_in_node_search_offset(offset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_plain_check_backward(const GScanTokenNodePlain *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+
+
+
+    if (*skip)
+        return;
+
+
+
+    printf("TODO\n");
+    assert(0);
+
+
+
 }
diff --git a/src/analysis/scan/patterns/tokens/nodes/plain.h b/src/analysis/scan/patterns/tokens/nodes/plain.h
index 33e7feb..c8f3920 100644
--- a/src/analysis/scan/patterns/tokens/nodes/plain.h
+++ b/src/analysis/scan/patterns/tokens/nodes/plain.h
@@ -52,9 +52,16 @@ typedef struct _GScanTokenNodePlainClass GScanTokenNodePlainClass;
 /* Propriétés d'un élément textuel à rechercher */
 typedef enum _ScanPlainNodeFlags
 {
-    SPNF_NONE             = 0x0,            /* Aucune particularité        */
-    SPNF_CASE_INSENSITIVE = 0x1,            /* Ignorance de la casse       */
-    SPNF_FULL_WORD        = 0x2,            /* Recherche de mot entier     */
+    SPNF_NONE             = (0 << 0),       /* Aucune particularité        */
+    SPNF_CASE_INSENSITIVE = (1 << 0),       /* Ignorance de la casse       */
+
+    /**
+     * Les deux propriétés suivantes sont récupérées et traitées
+     * au niveau du Token propriétaire.
+     */
+
+    SPNF_FULLWORD         = (1 << 1),       /* Recherche de mot entier     */
+    SPNF_PRIVATE          = (1 << 2),       /* Marque privative            */
 
 } ScanPlainNodeFlags;
 
@@ -65,6 +72,9 @@ GType g_scan_token_node_plain_get_type(void);
 /* Construit un noeud représentant un motif textuel. */
 GScanTokenNode *g_scan_token_node_plain_new(const sized_binary_t *, GScanTokenModifier *, ScanPlainNodeFlags);
 
+/* Indique les propriétés particulières d'un noeud de texte. */
+ScanPlainNodeFlags g_scan_token_node_plain_get_flags(const GScanTokenNodePlain *);
+
 
 
 #endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/sequence-int.h b/src/analysis/scan/patterns/tokens/nodes/sequence-int.h
new file mode 100644
index 0000000..f0ea6ae
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/sequence-int.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * sequence-int.h - prototypes internes pour des décompositions séquentielles de motif de recherche
+ *
+ * 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_PATTERNS_TOKENS_NODES_SEQUENCE_INT_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_SEQUENCE_INT_H
+
+
+#include "sequence.h"
+
+
+#include "../node-int.h"
+
+
+
+/* Décompositions séquentielles de motif de recherche (instance) */
+struct _GScanTokenNodeSequence
+{
+    GScanTokenNode parent;                  /* A laisser en premier        */
+
+    GScanTokenNode **children;              /* Sous-noeuds à représenter   */
+    size_t count;                           /* Taille de cette liste       */
+
+};
+
+/* Décompositions séquentielles de motif de recherche (classe) */
+struct _GScanTokenNodeSequenceClass
+{
+    GScanTokenNodeClass parent;             /* A laisser en premier        */
+
+};
+
+
+/* Met en place une série de décompositions séquentielles. */
+bool g_scan_token_node_sequence_create(GScanTokenNodeSequence *, GScanTokenNode *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_SEQUENCE_INT_H */
diff --git a/src/analysis/scan/patterns/tokens/nodes/sequence.c b/src/analysis/scan/patterns/tokens/nodes/sequence.c
new file mode 100644
index 0000000..ad332fc
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/sequence.c
@@ -0,0 +1,360 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * sequence.c - décompositions séquentielles de motif de recherche
+ *
+ * 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 "sequence.h"
+
+
+#include "sequence-int.h"
+
+
+
+/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */
+
+
+/* Initialise la classe des décompositions séquentielles. */
+static void g_scan_token_node_sequence_class_init(GScanTokenNodeSequenceClass *);
+
+/* Initialise une instance de décompositions séquentielles. */
+static void g_scan_token_node_sequence_init(GScanTokenNodeSequence *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_token_node_sequence_dispose(GScanTokenNodeSequence *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_token_node_sequence_finalize(GScanTokenNodeSequence *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Parcourt une arborescence de noeuds et y relève des éléments. */
+static void g_scan_token_node_sequence_visit(GScanTokenNodeSequence *node, scan_tree_points_t *);
+
+/* Inscrit la définition d'un motif dans un moteur de recherche. */
+static bool g_scan_token_node_sequence_enroll(GScanTokenNodeSequence *, GScanContext *, GEngineBackend *, size_t, size_t *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_sequence_check_forward(const GScanTokenNodeSequence *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+/* Transforme les correspondances locales en trouvailles. */
+static void g_scan_token_node_sequence_check_backward(const GScanTokenNodeSequence *, GScanContext *, GBinContent *, pending_matches_t *, node_search_offset_t *, bool, bool *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DECOMPOSITION DE MOTIF RECHERCHE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour des décompositions séquentielles de motif de recherche. */
+G_DEFINE_TYPE(GScanTokenNodeSequence, g_scan_token_node_sequence, G_TYPE_SCAN_TOKEN_NODE);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des décompositions séquentielles.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_class_init(GScanTokenNodeSequenceClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenNodeClass *node;              /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_sequence_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_token_node_sequence_finalize;
+
+    node = G_SCAN_TOKEN_NODE_CLASS(klass);
+
+    node->visit = (visit_scan_token_node_fc)g_scan_token_node_sequence_visit;
+    node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_sequence_enroll;
+    node->check_forward = (check_scan_token_node_fc)g_scan_token_node_sequence_check_forward;
+    node->check_backward = (check_scan_token_node_fc)g_scan_token_node_sequence_check_backward;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : sequence = instance à initialiser.                           *
+*                                                                             *
+*  Description : Initialise une instance de décompositions séquentielles.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_init(GScanTokenNodeSequence *sequence)
+{
+    sequence->children = NULL;
+    sequence->count = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : sequence = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_dispose(GScanTokenNodeSequence *sequence)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < sequence->count; i++)
+        g_clear_object(&sequence->children[i]);
+
+    G_OBJECT_CLASS(g_scan_token_node_sequence_parent_class)->dispose(G_OBJECT(sequence));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : sequence = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_finalize(GScanTokenNodeSequence *sequence)
+{
+    if (sequence->children != NULL)
+        free(sequence->children);
+
+    G_OBJECT_CLASS(g_scan_token_node_sequence_parent_class)->finalize(G_OBJECT(sequence));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : child    = noeud dont les résultats sont à écarter.          *
+*                                                                             *
+*  Description : Construit une série de décompositions séquentielles de motif.*
+*                                                                             *
+*  Retour      : Mécanismes mis en place.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenNode *g_scan_token_node_sequence_new(GScanTokenNode *child)
+{
+    GScanTokenNode *result;                 /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_SEQUENCE, NULL);
+
+    if (!g_scan_token_node_sequence_create(G_SCAN_TOKEN_NODE_SEQUENCE(result), child))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : sequence = décompositions à initialiser pleinement.          *
+*                child    = noeud dont les résultats sont à écarter.          *
+*                                                                             *
+*  Description : Met en place une série de décompositions séquentielles.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_scan_token_node_sequence_create(GScanTokenNodeSequence *sequence, GScanTokenNode *child)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    g_scan_token_node_sequence_add(sequence, child);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : sequence = ensemble de noeuds à compléter.                   *
+*                child  = nouveau noeud à intégrer.                           *
+*                                                                             *
+*  Description : Ajoute un noeud à aux décompositions séquentielles de motif. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_scan_token_node_sequence_add(GScanTokenNodeSequence *sequence, GScanTokenNode *child)
+{
+    sequence->children = realloc(sequence->children, ++sequence->count * sizeof(GScanTokenNode *));
+
+    sequence->children[sequence->count - 1] = child;
+    g_object_ref(G_OBJECT(child));
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node   = point de départ du parcours à effectuer.            *
+*                points = points capitaux de l'arborescence. [OUT]            *
+*                                                                             *
+*  Description : Parcourt une arborescence de noeuds et y relève des éléments.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_visit(GScanTokenNodeSequence *node, scan_tree_points_t *points)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < node->count; i++)
+        g_scan_token_node_visit(node->children[i], points);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à enregistrer.              *
+*                context = contexte de l'analyse à mener.                     *
+*                backend = moteur de recherche à préchauffer.                 *
+*                maxsize = taille max. des atomes (mise en commun optimisée). *
+*                slow    = niveau de ralentissement induit (0 = idéal). [OUT] *
+*                                                                             *
+*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
+*                                                                             *
+*  Retour      : Bilan de l'opération à renvoyer.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_token_node_sequence_enroll(GScanTokenNodeSequence *node, GScanContext *context, GEngineBackend *backend, size_t maxsize, size_t *slow)
+{
+    bool result;                            /* Statut à retourner          */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = true;
+
+    for (i = 0; i < node->count && result; i++)
+        result = _g_scan_token_node_enroll(node->children[i], context, backend, maxsize, slow);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_check_forward(const GScanTokenNodeSequence *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < node->count; i++)
+        _g_scan_token_node_check_forward(node->children[i], context, content, matches, offset, not, skip);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node    = définition de la bribe à manipuler.                *
+*                context = contexte de l'analyse à mener.                     *
+*                content = accès au contenu brut pour vérifications (optim.)  *
+*                matches = suivi des correspondances à consolider.            *
+*                offset  = tolérance dans les positions à appliquer.          *
+*                not     = indique si les résultats doivent être inversés.    *
+*                skip    = détermine si l'analyse est différée. [OUT]         *
+*                                                                             *
+*  Description : Transforme les correspondances locales en trouvailles.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_token_node_sequence_check_backward(const GScanTokenNodeSequence *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, node_search_offset_t *offset, bool not, bool *skip)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = node->count; i > 0 ; i--)
+        _g_scan_token_node_check_backward(node->children[i - 1], context, content, matches, offset, not, skip);
+
+}
diff --git a/src/analysis/scan/patterns/tokens/nodes/sequence.h b/src/analysis/scan/patterns/tokens/nodes/sequence.h
new file mode 100644
index 0000000..fc181c6
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/nodes/sequence.h
@@ -0,0 +1,61 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * sequence.h - prototypes pour des décompositions séquentielles de motif de recherche
+ *
+ * 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_PATTERNS_TOKENS_NODES_SEQUENCE_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_SEQUENCE_H
+
+
+#include <glib-object.h>
+
+
+#include "../node.h"
+
+
+
+#define G_TYPE_SCAN_TOKEN_NODE_SEQUENCE            g_scan_token_node_sequence_get_type()
+#define G_SCAN_TOKEN_NODE_SEQUENCE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_SEQUENCE, GScanTokenNodeSequence))
+#define G_IS_SCAN_TOKEN_NODE_SEQUENCE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_SEQUENCE))
+#define G_SCAN_TOKEN_NODE_SEQUENCE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_SEQUENCE, GScanTokenNodeSequenceClass))
+#define G_IS_SCAN_TOKEN_NODE_SEQUENCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_SEQUENCE))
+#define G_SCAN_TOKEN_NODE_SEQUENCE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_SEQUENCE, GScanTokenNodeSequenceClass))
+
+
+/* Décompositions séquentielles de motif de recherche (instance) */
+typedef struct _GScanTokenNodeSequence GScanTokenNodeSequence;
+
+/* Décompositions séquentielles de motif de recherche (classe) */
+typedef struct _GScanTokenNodeSequenceClass GScanTokenNodeSequenceClass;
+
+
+/* Indique le type défini pour des décompositions séquentielles de motif de recherche. */
+GType g_scan_token_node_sequence_get_type(void);
+
+/* Construit une série de décompositions séquentielles de motif. */
+GScanTokenNode *g_scan_token_node_sequence_new(GScanTokenNode *);
+
+/* Ajoute un noeud à aux décompositions séquentielles de motif. */
+void g_scan_token_node_sequence_add(GScanTokenNodeSequence *, GScanTokenNode *);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_SEQUENCE_H */
diff --git a/src/analysis/scan/patterns/tokens/offset.c b/src/analysis/scan/patterns/tokens/offset.c
new file mode 100644
index 0000000..010ec67
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/offset.c
@@ -0,0 +1,352 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * offset.c - décomposition d'un motif de recherche en atomes assemblés
+ *
+ * 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 "offset.h"
+
+
+#include <assert.h>
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : range     = bornes décrivant un espace quelconque.           *
+*                available = espace restant disponible.                       *
+*                min       = point de départ pour parcourir une zone. [OUT]   *
+*                max       = point d'arrivée pour parcourir une zone. [OUT]   *
+*                                                                             *
+*  Description : Fournit les bornes d'une zone à analyser.                    *
+*                                                                             *
+*  Retour      : true si assez d'espace est disponible, false sinon.          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool get_node_offset_range(const node_offset_range_t *range, phys_t len, phys_t available, phys_t *min, phys_t *max)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    if ((len + range->min) > available)
+        result = false;
+
+    else
+    {
+        result = true;
+
+        *min = range->min;
+        *max = range->max;
+
+        if ((len + *max) > available)
+        {
+            *max = available - len;
+            assert(*max >= *min);
+        }
+
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset = suivi de tolérances bornées à initialiser.          *
+*                                                                             *
+*  Description : Initialise une mémorisation d'intervales de tolérance.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void init_node_search_offset(node_search_offset_t *offset)
+{
+    offset->ranges = NULL;
+    offset->allocated = 0;
+
+    offset->gen_ptr = NULL;
+
+    offset->used = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = suivi de tolérances bornées à initialiser. [OUT]      *
+*                src  = suivi de tolérances bornées à copier.                 *
+*                                                                             *
+*  Description : Copie une mémorisation d'intervales entre positions.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void copy_node_search_offset(node_search_offset_t *dest, const node_search_offset_t *src)
+{
+    init_node_search_offset(dest);
+
+    switch (src->used)
+    {
+        case 0:
+            dest->gen_ptr = NULL;
+            break;
+
+        case 1:
+            dest->range = src->range;
+            dest->gen_ptr = &dest->range;
+            break;
+
+        default:
+            dest->ranges = malloc(src->used * sizeof(node_offset_range_t));
+            memcpy(dest->ranges, src->ranges, src->used * sizeof(node_offset_range_t));
+            dest->gen_ptr = dest->ranges;;
+            break;
+
+    }
+
+    dest->used = src->used;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = suivi de tolérances bornées à initialiser. [OUT]      *
+*                src  = suivi de tolérances bornées à copier.                 *
+*                                                                             *
+*  Description : Fusionne une mémorisation d'intervales entre positions.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void merge_node_search_offset(node_search_offset_t *dest, const node_search_offset_t *src)
+{
+    node_offset_range_t * const *list;      /* Liste d'intervales à copier */
+    size_t i;                               /* Boucle de parcours          */
+
+    if ((dest->used + src->used) > 1 && (dest->used + src->used) > dest->allocated)
+    {
+        dest->allocated += src->used;
+
+        dest->ranges = realloc(dest->ranges, dest->allocated * sizeof(node_offset_range_t));
+
+    }
+
+    list = get_node_search_offset_ranges(src, (size_t []){ 0 });
+
+    for (i = 0; i < src->used; i++)
+        add_range_to_node_search_offset(dest, (*list)[i].min, (*list)[i].max, NULL);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset = suivi de tolérances bornées à terminer.             *
+*                                                                             *
+*  Description : Met fin à une mémorisation d'intervales de tolérance.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_node_search_offset(node_search_offset_t *offset)
+{
+    if (offset->ranges != NULL)
+        free(offset->ranges);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset = suivi de tolérances bornées à consulter.            *
+*                count  = nombre de bornes enregistrées. [OUT]                *
+*                                                                             *
+*  Description : Fournit la liste des tolérances bornées établies à présent.  *
+*                                                                             *
+*  Retour      : Liste d'intervales en lecture seule.                         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+node_offset_range_t * const *get_node_search_offset_ranges(const node_search_offset_t *offset, size_t *count)
+{
+    node_offset_range_t * const *result;    /* Série à renvoyer            */
+
+    result = &offset->gen_ptr;
+
+    *count = offset->used;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset   = suivi de tolérances bornées à consulter.          *
+*                min      = point de départ pour parcourir une zone.          *
+*                max      = point d'arrivée pour parcourir une zone.          *
+*                datasize = taille maximale pour définir une inversion NOT.   *
+*                                                                             *
+*  Description : Ajoute un nouvel espace borné aux décalages tolérés.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void add_range_to_node_search_offset(node_search_offset_t *offset, phys_t min, phys_t max, const phys_t *datasize)
+{
+    bool not;                               /* Traduction de la taille     */
+    size_t needed;                          /* Nombre d'emplacements requis*/
+
+    not = (datasize != NULL);
+
+    /* Si le réceptacle unique peut être employé... */
+    if (offset->used == 0 && !not)
+    {
+        offset->range.min = min;
+        offset->range.max = max;
+
+        offset->used = 1;
+
+        offset->gen_ptr = &offset->range;
+
+    }
+
+    /* Sinon le groupe dynamique est sollicité */
+    else
+    {
+        needed = offset->used + (not ? 2 : 1);
+
+        if (needed > offset->allocated)
+        {
+            offset->ranges = realloc(offset->ranges, needed * sizeof(node_offset_range_t));
+            offset->allocated = needed;
+        }
+
+        /* Bascule d'un éventuel intervale courant */
+        if (offset->used == 1)
+        {
+            offset->ranges[0].min = offset->range.min;
+            offset->ranges[0].max = offset->range.max;
+        }
+
+        if (not)
+        {
+            if (min > 0)
+            {
+                offset->ranges[offset->used].min = 0;
+                offset->ranges[offset->used].max = min - 1;
+
+                offset->used++;
+
+            }
+
+            if ((max + 1) < *datasize)
+            {
+                offset->ranges[offset->used].min = max + 1;
+                offset->ranges[offset->used].max = *datasize - (max + 1);
+
+                offset->used++;
+
+            }
+
+        }
+        else
+        {
+            offset->ranges[offset->used].min = min;
+            offset->ranges[offset->used].max = max;
+
+            offset->used++;
+
+        }
+
+        offset->gen_ptr = offset->ranges;
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : offset = suivi de tolérances bornées à consulter.            *
+*                last   = dernière position validée.                          *
+*                pos    = nouvelle position potentielle.                      *
+*                                                                             *
+*  Description : Indique si une position est comprise dans un intervale.      *
+*                                                                             *
+*  Retour      : Bilan de la détermination.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool does_node_search_offset_include_pos_forward(const node_search_offset_t *offset, phys_t last, phys_t pos)
+{
+    bool result;                            /* Bilan à retourner           */
+    size_t i;                               /* Boucle de parcours          */
+    const node_offset_range_t *range;       /* Accès rapide aux infos.     */
+
+    result = false;
+
+    for (i = 0; i < offset->used; i++)
+    {
+        range = &offset->gen_ptr[i];
+
+        result = ((last + range->min) <= pos && pos <= (last + range->max));
+        if (result) break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/analysis/scan/patterns/tokens/offset.h b/src/analysis/scan/patterns/tokens/offset.h
new file mode 100644
index 0000000..b458717
--- /dev/null
+++ b/src/analysis/scan/patterns/tokens/offset.h
@@ -0,0 +1,101 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * offset.h - prototypes pour la prise en compte des espaces entre octets dans un motif de recherche
+ *
+ * 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_PATTERNS_TOKENS_OFFSET_H
+#define _ANALYSIS_SCAN_PATTERNS_TOKENS_OFFSET_H
+
+
+#include <stdbool.h>
+
+#include "../../../../arch/vmpa.h"
+
+
+
+/* Mémorisation d'une souplesse dans les positions visées */
+typedef struct _node_offset_range_t
+{
+    /**
+     * Les deux champs ci-après font bien référence à des positions absolues,
+     * et non à des bornes d'espace, lors que les résultats de correspondances
+     * sont encore non initialisés.
+     *
+     * Ensuite ces bornes représentent bien un espace séparant les résultats
+     * issus de deux noeuds.
+     */
+    phys_t min;                             /* Position minimale           */
+    phys_t max;                             /* Position maximale           */
+
+} node_offset_range_t;
+
+
+/* Fournit les bornes d'une zone à analyser. */
+bool get_node_offset_range(const node_offset_range_t *, phys_t, phys_t, phys_t *, phys_t *);
+
+
+
+
+
+
+/* Mémorisation d'une souplesse dans les positions visées */
+typedef struct _node_search_offset_t
+{
+    node_offset_range_t range;              /* Bornes de décalage uniques  */
+
+    node_offset_range_t *ranges;            /* Bornes de décalage multiples*/
+    size_t allocated;                       /* Nombre d'allocations        */
+
+    node_offset_range_t *gen_ptr;           /* Accès générique à la liste  */
+
+    size_t used;                            /* Nombre de bornes présentes  */
+
+} node_search_offset_t;
+
+
+/* Initialise une mémorisation d'intervales de tolérance. */
+void init_node_search_offset(node_search_offset_t *);
+
+/* Copie une mémorisation d'intervales entre positions. */
+void copy_node_search_offset(node_search_offset_t *, const node_search_offset_t *);
+
+/* Fusionne une mémorisation d'intervales entre positions. */
+void merge_node_search_offset(node_search_offset_t *, const node_search_offset_t *);
+
+/* Met fin à une mémorisation d'intervales de tolérance. */
+void exit_node_search_offset(node_search_offset_t *);
+
+/* Fournit la liste des tolérances bornées établies à présent. */
+/* TODO : supprimer un niveau d'indirection */
+node_offset_range_t * const *get_node_search_offset_ranges(const node_search_offset_t *, size_t *);
+
+/* Ajoute un nouvel espace borné aux décalages tolérés. */
+void add_range_to_node_search_offset(node_search_offset_t *, phys_t, phys_t, const phys_t *);
+
+#define disable_all_ranges_in_node_search_offset(off) \
+    (off)->used = 0
+
+/* Indique si une position est comprise dans un intervale. */
+bool does_node_search_offset_include_pos_forward(const node_search_offset_t *, phys_t, phys_t);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_TOKENS_OFFSET_H */
diff --git a/src/analysis/scan/patterns/tokens/plain-int.h b/src/analysis/scan/patterns/tokens/plain-int.h
index 40a71b5..5748160 100644
--- a/src/analysis/scan/patterns/tokens/plain-int.h
+++ b/src/analysis/scan/patterns/tokens/plain-int.h
@@ -38,14 +38,6 @@ struct _GScanPlainBytes
 {
     GStringToken parent;                    /* A laisser en premier        */
 
-    sized_binary_t orig;                    /* Motif d'origine avant modifs*/
-    GScanTokenModifier *modifier;           /* Transformateur pour le motif*/
-    ScanPlainBytesFlags flags;              /* Fanions associés au motif   */
-
-    sized_binary_t *raw;                    /* Liste de motifs à couvrir   */
-    tracked_scan_atom_t *atoms;             /* Atomes correspondants       */
-    size_t count;                           /* Taille de cette liste       */
-
 };
 
 /* Encadrement d'une recherche de texte brut (classe) */
@@ -57,7 +49,7 @@ struct _GScanPlainBytesClass
 
 
 /* Met en place un gestionnaire de recherche de texte brut. */
-bool g_scan_plain_bytes_create(GScanPlainBytes *, const sized_binary_t *, GScanTokenModifier *, ScanPlainBytesFlags);
+bool g_scan_plain_bytes_create(GScanPlainBytes *, GScanTokenNode *);
 
 
 
diff --git a/src/analysis/scan/patterns/tokens/plain.c b/src/analysis/scan/patterns/tokens/plain.c
index 26e7dfa..2eb6bbc 100644
--- a/src/analysis/scan/patterns/tokens/plain.c
+++ b/src/analysis/scan/patterns/tokens/plain.c
@@ -29,6 +29,7 @@
 
 
 #include "plain-int.h"
+#include "nodes/plain.h"
 
 
 
@@ -58,12 +59,6 @@ static void g_scan_plain_bytes_output_to_text(const GScanPlainBytes *, GScanCont
 /* Affiche un motif de recherche au format JSON. */
 static void g_scan_plain_bytes_output_to_json(const GScanPlainBytes *, GScanContext *, const sized_string_t *, unsigned int, int);
 
-/* Inscrit la définition d'un motif dans un moteur de recherche. */
-static bool g_scan_plain_bytes_enroll(GScanPlainBytes *, GScanContext *, GEngineBackend *, size_t);
-
-/* Transforme les correspondances locales en trouvailles. */
-static void g_scan_plain_bytes_check(const GScanPlainBytes *, GScanContext *, GBinContent *, pending_matches_t *);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -91,7 +86,6 @@ static void g_scan_plain_bytes_class_init(GScanPlainBytesClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GSearchPatternClass *pattern;           /* Version de classe ancêtre   */
-    GStringTokenClass *token;               /* Version de classe parente   */
 
     object = G_OBJECT_CLASS(klass);
 
@@ -103,11 +97,6 @@ static void g_scan_plain_bytes_class_init(GScanPlainBytesClass *klass)
     pattern->to_text = (output_pattern_to_text_fc)g_scan_plain_bytes_output_to_text;
     pattern->to_json = (output_pattern_to_json_fc)g_scan_plain_bytes_output_to_json;
 
-    token = G_STRING_TOKEN_CLASS(klass);
-
-    token->enroll = (enroll_token_fc)g_scan_plain_bytes_enroll;
-    token->check = (check_token_fc)g_scan_plain_bytes_check;
-
 }
 
 
@@ -125,13 +114,6 @@ static void g_scan_plain_bytes_class_init(GScanPlainBytesClass *klass)
 
 static void g_scan_plain_bytes_init(GScanPlainBytes *bytes)
 {
-    init_szstr(&bytes->orig);
-    bytes->modifier = NULL;
-    bytes->flags = SPBF_NONE;
-
-    bytes->raw = NULL;
-    bytes->atoms = NULL;
-    bytes->count = 0;
 
 }
 
@@ -150,8 +132,6 @@ static void g_scan_plain_bytes_init(GScanPlainBytes *bytes)
 
 static void g_scan_plain_bytes_dispose(GScanPlainBytes *bytes)
 {
-    g_clear_object(&bytes->modifier);
-
     G_OBJECT_CLASS(g_scan_plain_bytes_parent_class)->dispose(G_OBJECT(bytes));
 
 }
@@ -171,19 +151,6 @@ static void g_scan_plain_bytes_dispose(GScanPlainBytes *bytes)
 
 static void g_scan_plain_bytes_finalize(GScanPlainBytes *bytes)
 {
-    size_t i;                               /* Boucle de parcours          */
-
-    exit_szstr(&bytes->orig);
-
-    for (i = 0; i < bytes->count; i++)
-        exit_szstr(&bytes->raw[i]);
-
-    if (bytes->raw != NULL)
-        free(bytes->raw);
-
-    if (bytes->atoms != NULL)
-        free(bytes->atoms);
-
     G_OBJECT_CLASS(g_scan_plain_bytes_parent_class)->finalize(G_OBJECT(bytes));
 
 }
@@ -191,9 +158,7 @@ static void g_scan_plain_bytes_finalize(GScanPlainBytes *bytes)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : text     = texte brut à rechercher.                          *
-*                modifier = transformateur éventuel à solliciter.             *
-*                flags    = particularités à prendre en considération.        *
+*  Paramètres  : root  = représentation du motif à recherche.                 *
 *                                                                             *
 *  Description : Construit un gestionnaire de recherche de texte brut.        *
 *                                                                             *
@@ -203,25 +168,24 @@ static void g_scan_plain_bytes_finalize(GScanPlainBytes *bytes)
 *                                                                             *
 ******************************************************************************/
 
-GSearchPattern *g_scan_plain_bytes_new(const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainBytesFlags flags)
+GSearchPattern *g_scan_plain_bytes_new(GScanTokenNode *root)
 {
     GSearchPattern *result;                 /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_SCAN_PLAIN_BYTES, NULL);
 
-    if (!g_scan_plain_bytes_create(G_SCAN_PLAIN_BYTES(result), text, modifier, flags))
+    if (!g_scan_plain_bytes_create(G_SCAN_PLAIN_BYTES(result), root))
         g_clear_object(&result);
 
     return result;
 
 }
 
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : bytes    = encadrement de motif à initialiser pleinement.    *
-*                text     = texte brut à rechercher.                          *
-*                modifier = transformateur éventuel à solliciter.             *
-*                flags    = particularités à prendre en considération.        *
+*  Paramètres  : bytes = encadrement de motif à initialiser pleinement.       *
+*                root  = représentation du motif à recherche.                 *
 *                                                                             *
 *  Description : Met en place un gestionnaire de recherche de texte brut.     *
 *                                                                             *
@@ -231,21 +195,19 @@ GSearchPattern *g_scan_plain_bytes_new(const sized_binary_t *text, GScanTokenMod
 *                                                                             *
 ******************************************************************************/
 
-bool g_scan_plain_bytes_create(GScanPlainBytes *bytes, const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainBytesFlags flags)
+bool g_scan_plain_bytes_create(GScanPlainBytes *bytes, GScanTokenNode *root)
 {
     bool result;                            /* Bilan à retourner           */
+    ScanPlainNodeFlags flags;               /* Propriétés à interpréter    */
+    bool fullword;                          /* Cible de mots entiers ?     */
+    bool private;                           /* Vocation privée ?           */
 
-    result = true;
+    flags = g_scan_token_node_plain_get_flags(G_SCAN_TOKEN_NODE_PLAIN(root));
 
-    szstrdup(&bytes->orig, text);
+    fullword = (flags & SPNF_FULLWORD);
+    private = (flags & SPNF_PRIVATE);
 
-    if (modifier != NULL)
-    {
-        bytes->modifier = modifier;
-        g_object_ref(G_OBJECT(modifier));
-    }
-
-    bytes->flags = flags;
+    result = g_string_token_create(G_STRING_TOKEN(bytes), root, fullword, private);
 
     return result;
 
@@ -302,192 +264,3 @@ static void g_scan_plain_bytes_output_to_json(const GScanPlainBytes *pattern, GS
     /* TODO */
 
 }
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : bytes   = définition de la bribe à enregistrer.              *
-*                context = contexte de l'analyse à mener.                     *
-*                backend = moteur de recherche à préchauffer.                 *
-*                maxsize = taille max. des atomes (mise en commun optimisée). *
-*                                                                             *
-*  Description : Inscrit la définition d'un motif dans un moteur de recherche.*
-*                                                                             *
-*  Retour      : Bilan de l'opération à renvoyer.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_scan_plain_bytes_enroll(GScanPlainBytes *bytes, GScanContext *context, GEngineBackend *backend, size_t maxsize)
-{
-    return false;
-#if 0
-    bool result;                            /* Statut à retourner          */
-    size_t i;                               /* Boucle de parcours #1       */
-    tracked_scan_atom_t atom;               /* Atome identifié             */
-    size_t letters;                         /* Nombre de lettres présentes */
-    size_t k;                               /* Boucle de parcours #2       */
-    size_t extra_count;                     /* Quantité pour l'exhaustivité*/
-    sized_binary_t *extra;                  /* Couverture supplémntaire    */
-    size_t remaining;                       /* Quantité restant à traiter  */
-
-    /* Génération d'une base de chaînes à couvrir */
-
-    if (bytes->modifier == NULL)
-    {
-        bytes->raw = malloc(sizeof(sized_binary_t));
-        bytes->count = 1;
-
-        szstrdup(&bytes[0].raw[0], &bytes->orig);
-
-        result = true;
-
-    }
-    else
-        result = g_scan_token_modifier_transform(bytes->modifier, &bytes->orig, &bytes->raw, &bytes->count);
-
-    if (!result)
-        goto exit;
-
-    /* Préparation pour la mémorisation des atomes */
-
-    bytes->atoms = malloc(bytes->count * sizeof(tracked_scan_atom_t));
-
-    /* Recherche des atomes */
-
-    for (i = 0; i < bytes->count; i++)
-    {
-        if (bytes->flags & SPBF_CASE_INSENSITIVE)
-        {
-            find_best_atom(&bytes->raw[i], maxsize, &atom, &letters);
-
-            if (letters == 0)
-                bytes->atoms[i] = atom;
-
-            /* Insertion des combinaisons pour couvrir toutes les casses */
-            else
-            {
-                for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2)
-                    ;
-
-                extra = make_atoms_case_insensitive(&bytes->raw[i], extra_count);
-
-                remaining = bytes->count - i - 1;
-
-                bytes->count += (extra_count - 1);
-
-                bytes->raw = realloc(bytes->raw, bytes->count * sizeof(sized_binary_t));
-
-                memmove(&bytes->raw[i + extra_count], &bytes->raw[i + 1], remaining * sizeof(sized_binary_t));
-
-                for (k = 0; k < extra_count; k++)
-                    bytes->raw[i + k] = extra[k];
-
-                free(extra);
-
-                bytes->atoms = realloc(bytes->raw, bytes->count * sizeof(tracked_scan_atom_t));
-
-                for (k = 0; k < extra_count; k++)
-                    bytes->atoms[i + k] = atom;
-
-                i += extra_count - 1;
-
-            }
-
-        }
-
-        else
-            find_best_atom(&bytes->raw[i], maxsize, &bytes->atoms[i], &letters);
-
-    }
-
-    /* Enregistrements en masse */
-
-
-    for (i = 0; i < bytes->count && result; i++)
-        result = enroll_prepared_atom(&bytes->raw[i], context, backend, &bytes->atoms[i]);
-
- exit:
-
-    return result;
-#endif
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : bytes   = définition de la bribe à manipuler.                *
-*                context = contexte de l'analyse à mener.                     *
-*                content = accès au contenu brut pour vérifications (optim.)  *
-*                matches = suivi des correspondances à consolider.            *
-*                                                                             *
-*  Description : Transforme les correspondances locales en trouvailles.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_scan_plain_bytes_check(const GScanPlainBytes *bytes, GScanContext *context, GBinContent *content, pending_matches_t *matches)
-{
-#if 0
-
-    size_t i;                               /* Boucle de parcours #1       */
-    const sized_binary_t *raw;              /* Données brutes d'origine    */
-    const tracked_scan_atom_t *atom;        /* Atome correspondant         */
-    size_t count;                           /* Quantité de bribes trouvées */
-    const phys_t *found;                    /* Localisations des bribes    */
-    size_t k;                               /* Boucle de parcours #2       */
-    phys_t start;                           /* Point de départ             */
-    vmpa2t pos;                             /* Position dans les données   */
-    const bin_t *ptr;                       /* Accès aux données brutes    */
-    int ret;                                /* Bilan d'une comparaison     */
-
-    for (i = 0; i < bytes->count; i++)
-    {
-        raw = &bytes->raw[i];
-        atom = &bytes->atoms[i];
-
-        found = g_scan_context_get_atom_matches(context, atom->pid, &count);
-
-        for (k = 0; k < count; k++)
-        {
-            start = found[k] - atom->pos;
-
-            init_vmpa(&pos, start, VMPA_NO_VIRTUAL);
-
-            /* Validation du contenu avant l'atome */
-
-            if (atom->pos > 0)
-            {
-                ptr = g_binary_content_get_raw_access(content, &pos, atom->pos);
-
-                ret = memcmp(raw->data, ptr, atom->pos);
-                if (ret != 0) continue;
-
-            }
-
-            /* Validation du contenu après l'atome */
-
-            if (atom->rem > 0)
-            {
-                advance_vmpa(&pos, atom->len);
-
-                ptr = g_binary_content_get_raw_access(content, &pos, atom->rem);
-
-                ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem);
-                if (ret != 0) continue;
-
-            }
-
-            /* Mémorisation de la correspondance */
-
-            add_pending_matches(matches, start, raw->len);
-
-        }
-
-    }
-#endif
-}
diff --git a/src/analysis/scan/patterns/tokens/plain.h b/src/analysis/scan/patterns/tokens/plain.h
index 80a0b4d..6ff48d7 100644
--- a/src/analysis/scan/patterns/tokens/plain.h
+++ b/src/analysis/scan/patterns/tokens/plain.h
@@ -28,9 +28,8 @@
 #include <glib-object.h>
 
 
-#include "../modifier.h"
+#include "node.h"
 #include "../../pattern.h"
-#include "../../../../common/szstr.h"
 
 
 
@@ -49,21 +48,11 @@ typedef struct _GScanPlainBytes GScanPlainBytes;
 typedef struct _GScanPlainBytesClass GScanPlainBytesClass;
 
 
-/* Propriétés d'un élément textuel à rechercher */
-typedef enum _ScanPlainBytesFlags
-{
-    SPBF_NONE             = 0x0,            /* Aucune particularité        */
-    SPBF_CASE_INSENSITIVE = 0x1,            /* Ignorance de la casse       */
-    SPBF_FULL_WORD        = 0x2,            /* Recherche de mot entier     */
-
-} ScanPlainBytesFlags;
-
-
 /* Indique le type défini pour une suite d'octets à retrouver dans un binaire. */
 GType g_scan_plain_bytes_get_type(void);
 
 /* Construit un gestionnaire de recherche de texte brut. */
-GSearchPattern *g_scan_plain_bytes_new(const sized_binary_t *, GScanTokenModifier *, ScanPlainBytesFlags);
+GSearchPattern *g_scan_plain_bytes_new(GScanTokenNode *);
 
 
 
diff --git a/src/analysis/scan/rule.c b/src/analysis/scan/rule.c
index 4727c9d..1d68b80 100644
--- a/src/analysis/scan/rule.c
+++ b/src/analysis/scan/rule.c
@@ -369,6 +369,8 @@ bool g_scan_rule_setup_backend(GScanRule *rule, GEngineBackend *backend, GScanCo
 void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *context)
 {
     GBinContent *content;                   /* Contenu à manipuler         */
+    vmpa2t start;                           /* Point de début du contenu   */
+    vmpa2t end;                             /* Point de fin du contenu     */
     pending_matches_t matches;              /* Suivi de correspondances    */
     size_t i;                               /* Boucle de parcours #1       */
     GSearchPattern *pattern;                /* Motif à intégrer            */
@@ -378,11 +380,14 @@ void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *c
 
     content = g_scan_context_get_content(context);
 
+    g_binary_content_compute_start_pos(content, &start);
+    g_binary_content_compute_end_pos(content, &end);
+
     /* Consolidation des résultats */
 
     for (i = 0; i < rule->bytes_used; i++)
     {
-        init_pending_matches(&matches);
+        init_pending_matches(&matches, &start.physical, &end.physical);
 
         pattern = rule->bytes_locals[i];
 
diff --git a/src/analysis/scan/tokens.l b/src/analysis/scan/tokens.l
index 18594c4..594d4d9 100644
--- a/src/analysis/scan/tokens.l
+++ b/src/analysis/scan/tokens.l
@@ -32,7 +32,7 @@
 *                                                                             *
 ******************************************************************************/
 
-static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out)
+static void rost_unescape_string_bytes(const char *src, size_t len, sized_string_t *out)
 {
     size_t i;                               /* Boucle de parcours          */
     bin_t byte;                             /* Octet à analyser            */
@@ -52,30 +52,177 @@ static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out
 
                 switch (next)
                 {
-                    case '\a':
+                    case 'a':
+                        out->data[out->len++] = '\a';
+                        break;
+
+                    case 'b':
+                        out->data[out->len++] = '\b';
+                        break;
+
+                    case 't':
+                        out->data[out->len++] = '\t';
+                        break;
+
+                    case 'n':
+                        out->data[out->len++] = '\n';
+                        break;
+
+                    case 'v':
+                        out->data[out->len++] = '\v';
+                        break;
+
+                    case 'f':
+                        out->data[out->len++] = '\f';
+                        break;
+
+                    case 'r':
+                        out->data[out->len++] = '\r';
+                        break;
+
+                    case 'e':
+                        out->data[out->len++] = '\e';
+                        break;
+
+                    case '"':
+                        out->data[out->len++] = '\"';
+                        break;
+
+                    case '\\':
                         out->data[out->len++] = '\\';
                         break;
 
-                    case '\t':
+                    case 'x':
+
+                        next = src[i + 2];
+
+                        switch (next)
+                        {
+                            case '0' ... '9':
+                                out->data[out->len] = (next - '0');
+                                break;
+
+                            case 'A' ... 'F':
+                                out->data[out->len] = 0xa + (next - 'A');
+                                break;
+
+                            case 'a' ... 'f':
+                                out->data[out->len] = 0xa + (next - 'a');
+                                break;
+
+                        }
+
+                        out->data[out->len] <<= 4;
+
+                        next = src[i + 3];
+
+                        switch (next)
+                        {
+                            case '0' ... '9':
+                                out->data[out->len] |= (next - '0');
+                                break;
+
+                            case 'A' ... 'F':
+                                out->data[out->len] |= 0xa + (next - 'A');
+                                break;
+
+                            case 'a' ... 'f':
+                                out->data[out->len] |= 0xa + (next - 'a');
+                                break;
+
+                        }
+
+                        out->len++;
+
+                        i += 2;
+                        break;
+
+                }
+
+                i++;
+                break;
+
+            default:
+                out->data[out->len++] = byte;
+                break;
+
+        }
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : src = liste d'octets à traiter.                              *
+*                len = taille de cette liste.                                 *
+*                out = série d'octets bruts obtenue. [OUT]                    *
+*                                                                             *
+*  Description : Transcrit une série d'octets en en remplaçant certains.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out)
+{
+    size_t i;                               /* Boucle de parcours          */
+    bin_t byte;                             /* Octet à analyser            */
+    bin_t next;                             /* Octet suivant               */
+
+    out->len = 0;
+
+    for (i = 0; i < len; i++)
+    {
+        byte = src[i];
+
+        switch (byte)
+        {
+            case '\\':
+
+                next = src[i + 1];
+
+                switch (next)
+                {
+                    case 'a':
+                        out->data[out->len++] = '\a';
+                        break;
+
+                    case 'b':
+                        out->data[out->len++] = '\b';
+                        break;
+
+                    case 't':
                         out->data[out->len++] = '\t';
                         break;
 
-                    case '\n':
+                    case 'n':
                         out->data[out->len++] = '\n';
                         break;
 
-                    case '\v':
+                    case 'v':
                         out->data[out->len++] = '\v';
                         break;
 
-                    case '\f':
+                    case 'f':
                         out->data[out->len++] = '\f';
                         break;
 
-                    case '\r':
+                    case 'r':
                         out->data[out->len++] = '\r';
                         break;
 
+                    case 'e':
+                        out->data[out->len++] = '\e';
+                        break;
+
+                    case '"':
+                        out->data[out->len++] = '\"';
+                        break;
+
                     case '\\':
                         out->data[out->len++] = '\\';
                         break;
@@ -91,11 +238,11 @@ static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out
                                 break;
 
                             case 'A' ... 'F':
-                                out->data[out->len] = 0x10 + (next - 'A');
+                                out->data[out->len] = 0xa + (next - 'A');
                                 break;
 
                             case 'a' ... 'f':
-                                out->data[out->len] = 0x10 + (next - 'a');
+                                out->data[out->len] = 0xa + (next - 'a');
                                 break;
 
                         }
@@ -111,11 +258,11 @@ static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out
                                 break;
 
                             case 'A' ... 'F':
-                                out->data[out->len] |= 0x10 + (next - 'A');
+                                out->data[out->len] |= 0xa + (next - 'A');
                                 break;
 
                             case 'a' ... 'f':
-                                out->data[out->len] |= 0x10 + (next - 'a');
+                                out->data[out->len] |= 0xa + (next - 'a');
                                 break;
 
                         }
@@ -175,7 +322,7 @@ static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out
 %option yylineno
 %option never-interactive
 
-%x include_path
+%x inc_path
 
 %x rule_intro
 %x raw_block
@@ -200,8 +347,12 @@ static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out
 %x comment
 
 
+str_not_escaped [^\"\\]
+str_escaped \\a|\\b|\\t|\\n|\\v|\\f|\\r|\\e|\\\"|\\\\|\\x{hbyte}
+str_mixed ({str_not_escaped}|{str_escaped})
 
 hbyte [0-9a-fA-F]{2}
+mbyte (\?[0-9a-fA-F]|[0-9a-fA-F]\?)
 
 reg_allowed [^^$.|/{}()\[\]*+?\\]
 reg_allowed_escaped \\^|\\$|\\\.|\\\||\\\/|\\\{|\\\}|\\\(|\\\)|\\\[|\\\]|\\\*|\\\+|\\\?|\\\\
@@ -219,15 +370,35 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
 %%
 
 
+"include"                           { PUSH_STATE(inc_path); return INCLUDE; }
 
+<inc_path>\"{str_not_escaped}+\"    {
+                                        POP_STATE;
 
-"include"                       { PUSH_STATE(include_path); return INCLUDE; }
+                                        yylval->sized_cstring.data = yytext + 1;
+                                        yylval->sized_cstring.len = yyleng - 2;
+
+                                        return PLAIN_TEXT;
+                                    }
+
+<inc_path>\"{str_mixed}+\"          {
+                                        POP_STATE;
+
+                                        rost_unescape_string_bytes(yytext + 1, yyleng - 2, tmp_0);
+
+#ifndef NDEBUG
+                                        /* Pour rendre plus lisibles les impressions de débogage */
+                                        tmp_0->data[tmp_0->len] = '\0';
+#endif
+
+                                        yylval->tmp_cstring = tmp_0;
+
+                                        return ESCAPED_TEXT;
+                                    }
+
+
+%{ /* Définition locale d'une règle */ %}
 
-<include_path>"\""              {
-                                    POP_STATE;
-                                    *used = 0;
-                                    PUSH_STATE(strlit);
-                                }
 
 "rule"                          { PUSH_STATE(rule_intro); return RAW_RULE; }
 
@@ -295,6 +466,41 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
                                 }
 
 
+%{ /* Définitions communes pour la section "bytes:" */ %}
+
+<strings>"fullword"                 { return FULLWORD; }
+<strings>"nocase"                   { return NOCASE; }
+<strings>"private"                  { return PRIVATE; }
+
+<strings>"="                        { PUSH_STATE(bytes_value); return ASSIGN; }
+
+
+%{ /* Définition de motif en texte brut */ %}
+
+<bytes_value>\"{str_not_escaped}+\" {
+                                        POP_STATE;
+
+                                        yylval->sized_cstring.data = yytext + 1;
+                                        yylval->sized_cstring.len = yyleng - 2;
+
+                                        return PLAIN_TEXT;
+                                    }
+
+<bytes_value>\"{str_mixed}+\"       {
+                                        POP_STATE;
+
+                                        rost_unescape_string_bytes(yytext + 1, yyleng - 2, tmp_0);
+
+#ifndef NDEBUG
+                                        /* Pour rendre plus lisibles les impressions de débogage */
+                                        tmp_0->data[tmp_0->len] = '\0';
+#endif
+
+                                        yylval->tmp_cstring = tmp_0;
+
+                                        return ESCAPED_TEXT;
+                                    }
+
 
 %{ /* Définition de motif en hexadécimal */ %}
 
@@ -350,26 +556,21 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
                                                     break;
 
                                                 case 'A' ... 'F':
-                                                    value = 0x10 + (byte - 'A');
+                                                    value = 0xa + (byte - 'A');
                                                     break;
 
                                                 case 'a' ... 'f':
-                                                    value = 0x10 + (byte - 'a');
+                                                    value = 0xa + (byte - 'a');
                                                     break;
 
                                             }
 
                                             if (even)
-                                            {
                                                 tmp_0->data[tmp_0->len] = (value << 4);
-                                                even = false;
-                                            }
-
                                             else
-                                            {
                                                 tmp_0->data[tmp_0->len++] |= value;
-                                                even = true;
-                                            }
+
+                                            even = !even;
 
                                         }
 
@@ -402,6 +603,73 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
 
                                     }
 
+   <bytes_hex>{mbyte}([ ]*{mbyte})* {
+                                        bool even;
+                                        size_t i;
+                                        bin_t byte;
+                                        bin_t value;
+
+                                        tmp_0->len = 0;
+                                        tmp_1->len = 0;
+
+                                        even = true;
+
+                                        for (i = 0; i < yyleng; i++)
+                                        {
+                                            byte = yytext[i];
+
+                                            switch (byte)
+                                            {
+                                                case ' ':
+                                                    continue;
+                                                    break;
+
+                                                case '?':
+                                                    even = !even;
+                                                    continue;
+                                                    break;
+
+                                                case '0' ... '9':
+                                                    value = (byte - '0');
+                                                    break;
+
+                                                case 'A' ... 'F':
+                                                    value = 0xa + (byte - 'A');
+                                                    break;
+
+                                                case 'a' ... 'f':
+                                                    value = 0xa + (byte - 'a');
+                                                    break;
+
+                                            }
+
+                                            if (even)
+                                            {
+                                                tmp_0->data[tmp_0->len++] = (value << 4);
+                                                tmp_1->data[tmp_1->len++] = 0xf0;
+                                            }
+                                            else
+                                            {
+                                                tmp_0->data[tmp_0->len++] = value;
+                                                tmp_1->data[tmp_1->len++] = 0x0f;
+                                            }
+
+                                            even = !even;
+
+                                        }
+
+#ifndef NDEBUG
+                                        /* Pour rendre plus lisibles les impressions de débogage */
+                                        tmp_0->data[tmp_0->len] = '\0';
+                                        tmp_1->data[tmp_1->len] = '\0';
+#endif
+
+                                        yylval->masked.tmp_values = tmp_0;
+                                        yylval->masked.tmp_masks = tmp_1;
+                                        return SEMI_MASK;
+
+                                    }
+
 
 %{ /* Définition d'expressions régulières */ %}
 
@@ -573,16 +841,6 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
                                     return NAME;
                                 }
 
-<strings>"="                    { PUSH_STATE(bytes_value); return ASSIGN; }
-
-
-<bytes_value>\"[^\"\\]+\"            {
-                                    POP_STATE;
-                                    yylval->sized_cstring.data = yytext + 1;
-                                    yylval->sized_cstring.len = yyleng - 2;
-                                    return PLAIN_STRING;
-                                }
-
 
 
 
@@ -592,7 +850,7 @@ bytes_id [A-Za-z_][A-Za-z0-9_]*
                                     PUSH_STATE(bytes_value_raw);
                                 }
 
-<bytes_value_raw>"\""                { POP_STATE; /*yylval->pattern = *built_pattern*/; return MASKED_STRING; }
+<bytes_value_raw>"\""                { POP_STATE; /*yylval->pattern = *built_pattern*/; return 11111/*MASKED_STRING*/; }
 
 <bytes_value_raw>"\\\""              { }//g_bytes_pattern_append_data(*built_pattern, '"', 0xff); }
 <bytes_value_raw>"\\t"               { }//g_bytes_pattern_append_data(*built_pattern, '\t', 0xff); }