From 529ad0221d262a5f3cc85c5ebb7c714c94e47fb3 Mon Sep 17 00:00:00 2001
From: mdecimus <mauro@stalw.art>
Date: Tue, 26 Sep 2023 16:34:09 +0200
Subject: [PATCH] Allow passing a context object to external functions

---
 src/compiler/mod.rs                      |   2 +-
 src/lib.rs                               |  18 +-
 src/runtime/actions/action_convert.rs    |   2 +-
 src/runtime/actions/action_editheader.rs |   6 +-
 src/runtime/actions/action_fileinto.rs   |   2 +-
 src/runtime/actions/action_flags.rs      |   4 +-
 src/runtime/actions/action_include.rs    |   2 +-
 src/runtime/actions/action_mime.rs       |   8 +-
 src/runtime/actions/action_notify.rs     |   2 +-
 src/runtime/actions/action_redirect.rs   |   2 +-
 src/runtime/actions/action_set.rs        |   6 +-
 src/runtime/actions/action_vacation.rs   |   4 +-
 src/runtime/context.rs                   |  10 +-
 src/runtime/eval.rs                      |   2 +-
 src/runtime/expression.rs                |   2 +-
 src/runtime/mod.rs                       |  92 +++---
 src/runtime/tests/comparator.rs          |  15 +-
 src/runtime/tests/glob.rs                | 386 ++++++++++++-----------
 src/runtime/tests/mime.rs                |  10 +-
 src/runtime/tests/mod.rs                 |   2 +-
 src/runtime/tests/test_address.rs        |   4 +-
 src/runtime/tests/test_body.rs           |   2 +-
 src/runtime/tests/test_date.rs           |   6 +-
 src/runtime/tests/test_duplicate.rs      |   2 +-
 src/runtime/tests/test_envelope.rs       |   4 +-
 src/runtime/tests/test_exists.rs         |   2 +-
 src/runtime/tests/test_extlists.rs       |   2 +-
 src/runtime/tests/test_hasflag.rs        |   2 +-
 src/runtime/tests/test_header.rs         |   4 +-
 src/runtime/tests/test_metadata.rs       |   4 +-
 src/runtime/tests/test_notify.rs         |   4 +-
 src/runtime/tests/test_size.rs           |   2 +-
 src/runtime/tests/test_spamtest.rs       |   4 +-
 src/runtime/tests/test_string.rs         |   2 +-
 src/runtime/variables.rs                 |   2 +-
 35 files changed, 324 insertions(+), 299 deletions(-)

diff --git a/src/compiler/mod.rs b/src/compiler/mod.rs
index a0fc088..2da7d1a 100644
--- a/src/compiler/mod.rs
+++ b/src/compiler/mod.rs
@@ -343,7 +343,7 @@ impl Compiler {
             })
     }
 
-    pub fn register_functions(mut self, fnc_map: &mut FunctionMap) -> Self {
+    pub fn register_functions<C>(mut self, fnc_map: &mut FunctionMap<C>) -> Self {
         self.functions = std::mem::take(&mut fnc_map.map);
         self
     }
diff --git a/src/lib.rs b/src/lib.rs
index e125e97..6bed467 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -312,16 +312,16 @@ pub struct Compiler {
     pub(crate) functions: AHashMap<String, (u32, u32)>,
 }
 
-pub type Function = for<'x> fn(&'x Context<'x>, Vec<Variable<'x>>) -> Variable<'x>;
+pub type Function<C> = for<'x> fn(&'x Context<'x, C>, Vec<Variable<'x>>) -> Variable<'x>;
 
 #[derive(Default, Clone)]
-pub struct FunctionMap {
+pub struct FunctionMap<C> {
     pub(crate) map: AHashMap<String, (u32, u32)>,
-    pub(crate) functions: Vec<Function>,
+    pub(crate) functions: Vec<Function<C>>,
 }
 
 #[derive(Debug, Clone)]
-pub struct Runtime {
+pub struct Runtime<C> {
     pub(crate) allowed_capabilities: AHashSet<Capability>,
     pub(crate) valid_notification_uris: AHashSet<Cow<'static, str>>,
     pub(crate) valid_ext_lists: AHashSet<Cow<'static, str>>,
@@ -330,7 +330,7 @@ pub struct Runtime {
     pub(crate) metadata: Vec<(Metadata<String>, Cow<'static, str>)>,
     pub(crate) include_scripts: AHashMap<String, Arc<Sieve>>,
     pub(crate) local_hostname: Cow<'static, str>,
-    pub(crate) functions: Vec<Function>,
+    pub(crate) functions: Vec<Function<C>>,
 
     pub(crate) max_nested_includes: usize,
     pub(crate) cpu_limit: usize,
@@ -346,14 +346,16 @@ pub struct Runtime {
     pub(crate) vacation_use_orig_rcpt: bool,
     pub(crate) vacation_default_subject: Cow<'static, str>,
     pub(crate) vacation_subject_prefix: Cow<'static, str>,
+
+    pub(crate) context: C,
 }
 
 #[derive(Clone, Debug)]
-pub struct Context<'x> {
+pub struct Context<'x, C> {
     #[cfg(test)]
-    pub(crate) runtime: Runtime,
+    pub(crate) runtime: Runtime<C>,
     #[cfg(not(test))]
-    pub(crate) runtime: &'x Runtime,
+    pub(crate) runtime: &'x Runtime<C>,
     pub(crate) user_address: Cow<'x, str>,
     pub(crate) user_full_name: Cow<'x, str>,
     pub(crate) current_time: i64,
diff --git a/src/runtime/actions/action_convert.rs b/src/runtime/actions/action_convert.rs
index 8de8254..eda4af3 100644
--- a/src/runtime/actions/action_convert.rs
+++ b/src/runtime/actions/action_convert.rs
@@ -38,7 +38,7 @@ enum Conversion {
 }
 
 impl Convert {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let from_media_type = ctx.eval_value(&self.from_media_type).into_cow();
         let to_media_type = ctx.eval_value(&self.to_media_type).into_cow();
 
diff --git a/src/runtime/actions/action_editheader.rs b/src/runtime/actions/action_editheader.rs
index ea6a980..55ba6d2 100644
--- a/src/runtime/actions/action_editheader.rs
+++ b/src/runtime/actions/action_editheader.rs
@@ -38,7 +38,7 @@ use crate::{
 };
 
 impl AddHeader {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let header_name_ = ctx.eval_value(&self.field_name).into_cow();
         let mut header_name = String::with_capacity(header_name_.len());
 
@@ -68,7 +68,7 @@ impl AddHeader {
 }
 
 impl DeleteHeader {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let header_name = if let Some(header_name) =
             HeaderName::parse(ctx.eval_value(&self.field_name).into_cow())
         {
@@ -175,7 +175,7 @@ impl RemoveCrLf for &str {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn insert_header(
         &mut self,
         part_id: usize,
diff --git a/src/runtime/actions/action_fileinto.rs b/src/runtime/actions/action_fileinto.rs
index a87c3cb..07b1bd6 100644
--- a/src/runtime/actions/action_fileinto.rs
+++ b/src/runtime/actions/action_fileinto.rs
@@ -24,7 +24,7 @@
 use crate::{compiler::grammar::actions::action_fileinto::FileInto, Context, Event};
 
 impl FileInto {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let folder = ctx.eval_value(&self.folder).into_string();
         let mut events = Vec::with_capacity(2);
         if let Some(event) = ctx.build_message_id() {
diff --git a/src/runtime/actions/action_flags.rs b/src/runtime/actions/action_flags.rs
index 763166c..bd75be0 100644
--- a/src/runtime/actions/action_flags.rs
+++ b/src/runtime/actions/action_flags.rs
@@ -30,7 +30,7 @@ use crate::{
 };
 
 impl EditFlags {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let mut var_name_ = None;
         let var_name = self.name.as_ref().unwrap_or_else(|| {
             var_name_.get_or_insert_with(|| VariableType::Global("__flags".to_string()))
@@ -103,7 +103,7 @@ impl EditFlags {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn tokenize_flags(
         &self,
         strings: &[Value],
diff --git a/src/runtime/actions/action_include.rs b/src/runtime/actions/action_include.rs
index 5a93248..dc0dc39 100644
--- a/src/runtime/actions/action_include.rs
+++ b/src/runtime/actions/action_include.rs
@@ -37,7 +37,7 @@ pub(crate) enum IncludeResult {
 }
 
 impl Include {
-    pub(crate) fn exec(&self, ctx: &Context) -> IncludeResult {
+    pub(crate) fn exec<C>(&self, ctx: &Context<C>) -> IncludeResult {
         let script_name = ctx.eval_value(&self.value);
         if !script_name.is_empty() {
             let script_name = if self.location == Location::Global {
diff --git a/src/runtime/actions/action_mime.rs b/src/runtime/actions/action_mime.rs
index d7392aa..605e3c1 100644
--- a/src/runtime/actions/action_mime.rs
+++ b/src/runtime/actions/action_mime.rs
@@ -41,7 +41,7 @@ use super::action_editheader::RemoveCrLf;
 use mail_builder::headers::message_id::generate_message_id_header;
 
 impl Replace {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         // Delete children parts
         let mut part_ids = ctx.find_nested_parts_ids(false);
         part_ids.sort_unstable_by_key(|a| Reverse(*a));
@@ -182,7 +182,7 @@ impl Replace {
 }
 
 impl Enclose {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let body = ctx.eval_value(&self.value).into_string();
         let subject = self
             .subject
@@ -341,7 +341,7 @@ impl Enclose {
 }
 
 impl ExtractText {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let mut value = String::new();
 
         if !ctx.part_iter_stack.is_empty() {
@@ -400,7 +400,7 @@ enum StackItem<'x> {
     None,
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn build_message_id(&mut self) -> Option<Event> {
         if self.has_changes {
             self.last_message_id += 1;
diff --git a/src/runtime/actions/action_notify.rs b/src/runtime/actions/action_notify.rs
index fcdba1b..4a8008a 100644
--- a/src/runtime/actions/action_notify.rs
+++ b/src/runtime/actions/action_notify.rs
@@ -35,7 +35,7 @@ use crate::{
 use super::action_vacation::MAX_SUBJECT_LEN;
 
 impl Notify {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         // Do not notify on Auto-Submitted messages
         for header in &ctx.message.parts[0].headers {
             if matches!(&header.name, HeaderName::Other(name) if name.eq_ignore_ascii_case("Auto-Submitted"))
diff --git a/src/runtime/actions/action_redirect.rs b/src/runtime/actions/action_redirect.rs
index 0946f09..583ef49 100644
--- a/src/runtime/actions/action_redirect.rs
+++ b/src/runtime/actions/action_redirect.rs
@@ -29,7 +29,7 @@ use crate::{
 };
 
 impl Redirect {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         if let Some(address) = sanitize_address(ctx.eval_value(&self.address).into_cow().as_ref()) {
             if ctx.num_redirects < ctx.runtime.max_redirects
                 && ctx.num_out_messages < ctx.runtime.max_out_messages
diff --git a/src/runtime/actions/action_set.rs b/src/runtime/actions/action_set.rs
index f855c70..a1881e6 100644
--- a/src/runtime/actions/action_set.rs
+++ b/src/runtime/actions/action_set.rs
@@ -32,7 +32,7 @@ use crate::{
 use std::fmt::Write;
 
 impl Set {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let mut value = ctx.eval_value(&self.value).into_owned();
         for modifier in &self.modifiers {
             value = modifier.apply(value.into_cow().as_ref(), ctx).into();
@@ -42,7 +42,7 @@ impl Set {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn set_variable(&mut self, var_name: &VariableType, mut variable: Variable<'x>) {
         if variable.len() > self.runtime.max_variable_size {
             let mut new_variable = String::with_capacity(self.runtime.max_variable_size);
@@ -100,7 +100,7 @@ impl<'x> Context<'x> {
 }
 
 impl Modifier {
-    pub(crate) fn apply(&self, input: &str, ctx: &Context) -> String {
+    pub(crate) fn apply<C>(&self, input: &str, ctx: &Context<C>) -> String {
         let max_len = ctx.runtime.max_variable_size;
         match self {
             Modifier::Lower => input.to_lowercase(),
diff --git a/src/runtime/actions/action_vacation.rs b/src/runtime/actions/action_vacation.rs
index 8fbd25a..726be1d 100644
--- a/src/runtime/actions/action_vacation.rs
+++ b/src/runtime/actions/action_vacation.rs
@@ -41,7 +41,7 @@ use crate::{
 pub(crate) const MAX_SUBJECT_LEN: usize = 256;
 
 impl TestVacation {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let mut from = String::new();
         let mut user_addresses = Vec::new();
 
@@ -177,7 +177,7 @@ impl TestVacation {
 }
 
 impl Vacation {
-    pub(crate) fn exec(&self, ctx: &mut Context) {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) {
         let mut vacation_to = Cow::from("");
 
         for (name, value) in &ctx.envelope {
diff --git a/src/runtime/context.rs b/src/runtime/context.rs
index 5464b66..345db36 100644
--- a/src/runtime/context.rs
+++ b/src/runtime/context.rs
@@ -46,8 +46,8 @@ pub(crate) struct ScriptStack {
     pub(crate) prev_vars_match: Vec<Variable<'static>>,
 }
 
-impl<'x> Context<'x> {
-    pub(crate) fn new(runtime: &'x Runtime, message: Message<'x>) -> Self {
+impl<'x, C: Clone> Context<'x, C> {
+    pub(crate) fn new(runtime: &'x Runtime<C>, message: Message<'x>) -> Self {
         Context {
             #[cfg(test)]
             runtime: runtime.clone(),
@@ -90,7 +90,9 @@ impl<'x> Context<'x> {
             spam_status: SpamStatus::Unknown,
         }
     }
+}
 
+impl<'x, C> Context<'x, C> {
     #[allow(clippy::while_let_on_iterator)]
     pub fn run(&mut self, input: Input) -> Option<Result<Event, RuntimeError>> {
         match input {
@@ -632,4 +634,8 @@ impl<'x> Context<'x> {
     pub fn part(&self) -> usize {
         self.part
     }
+
+    pub fn context(&self) -> &C {
+        &self.runtime.context
+    }
 }
diff --git a/src/runtime/eval.rs b/src/runtime/eval.rs
index 5ddb325..1d11771 100644
--- a/src/runtime/eval.rs
+++ b/src/runtime/eval.rs
@@ -39,7 +39,7 @@ use crate::{
 
 use super::Variable;
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn variable<'y: 'x>(&'y self, var: &VariableType) -> Option<Variable<'x>> {
         match var {
             VariableType::Local(var_num) => self.vars_local.get(*var_num).map(|v| v.as_ref()),
diff --git a/src/runtime/expression.rs b/src/runtime/expression.rs
index 002f64c..4f033f4 100644
--- a/src/runtime/expression.rs
+++ b/src/runtime/expression.rs
@@ -27,7 +27,7 @@ use crate::{compiler::Number, runtime::Variable, Context};
 
 use crate::compiler::grammar::expr::{BinaryOperator, Constant, Expression, UnaryOperator};
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn eval_expression<'y: 'x>(
         &'y self,
         expr: &'x [Expression],
diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs
index b1ae0c0..b46804a 100644
--- a/src/runtime/mod.rs
+++ b/src/runtime/mod.rs
@@ -426,8 +426,47 @@ impl PluginArgument<String, Number> {
     }
 }
 
-impl Runtime {
-    pub fn new() -> Self {
+impl<C: Clone> Runtime<C> {
+    pub fn filter<'z: 'x, 'x>(&'z self, raw_message: &'x [u8]) -> Context<'x, C> {
+        Context::new(
+            self,
+            MessageParser::new()
+                .parse(raw_message)
+                .unwrap_or_else(|| Message {
+                    parts: vec![MessagePart {
+                        headers: vec![],
+                        is_encoding_problem: false,
+                        body: PartType::Text("".into()),
+                        encoding: Encoding::None,
+                        offset_header: 0,
+                        offset_body: 0,
+                        offset_end: 0,
+                    }],
+                    raw_message: b""[..].into(),
+                    ..Default::default()
+                }),
+        )
+    }
+
+    pub fn filter_parsed<'z: 'x, 'x>(&'z self, message: Message<'x>) -> Context<'x, C> {
+        Context::new(self, message)
+    }
+}
+
+impl Runtime<()> {
+    pub fn new() -> Runtime<()> {
+        Self::new_with_context(())
+    }
+}
+
+impl Default for Runtime<()> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<C> Runtime<C> {
+    pub fn new_with_context(context: C) -> Self {
         #[allow(unused_mut)]
         let mut allowed_capabilities = AHashSet::from_iter(Capability::all().iter().cloned());
 
@@ -462,6 +501,7 @@ impl Runtime {
             default_duplicate_expiry: 7 * 86400,
             local_hostname: "localhost".into(),
             functions: Vec::new(),
+            context,
         }
     }
 
@@ -700,58 +740,36 @@ impl Runtime {
         self
     }
 
-    pub fn with_functions(mut self, fnc_map: &mut FunctionMap) -> Self {
+    pub fn with_functions(mut self, fnc_map: &mut FunctionMap<C>) -> Self {
         self.functions = std::mem::take(&mut fnc_map.functions);
         self
     }
 
-    pub fn set_functions(&mut self, fnc_map: &mut FunctionMap) {
+    pub fn set_functions(&mut self, fnc_map: &mut FunctionMap<C>) {
         self.functions = std::mem::take(&mut fnc_map.functions);
     }
-
-    pub fn filter<'z: 'x, 'x>(&'z self, raw_message: &'x [u8]) -> Context<'x> {
-        Context::new(
-            self,
-            MessageParser::new()
-                .parse(raw_message)
-                .unwrap_or_else(|| Message {
-                    parts: vec![MessagePart {
-                        headers: vec![],
-                        is_encoding_problem: false,
-                        body: PartType::Text("".into()),
-                        encoding: Encoding::None,
-                        offset_header: 0,
-                        offset_body: 0,
-                        offset_end: 0,
-                    }],
-                    raw_message: b""[..].into(),
-                    ..Default::default()
-                }),
-        )
-    }
-
-    pub fn filter_parsed<'z: 'x, 'x>(&'z self, message: Message<'x>) -> Context<'x> {
-        Context::new(self, message)
-    }
 }
 
-impl FunctionMap {
+impl<C> FunctionMap<C> {
     pub fn new() -> Self {
-        Self::default()
+        FunctionMap {
+            map: Default::default(),
+            functions: Default::default(),
+        }
     }
 
-    pub fn with_function(self, name: impl Into<String>, fnc: Function) -> Self {
+    pub fn with_function(self, name: impl Into<String>, fnc: Function<C>) -> Self {
         self.with_function_args(name, fnc, 1)
     }
 
-    pub fn with_function_no_args(self, name: impl Into<String>, fnc: Function) -> Self {
+    pub fn with_function_no_args(self, name: impl Into<String>, fnc: Function<C>) -> Self {
         self.with_function_args(name, fnc, 0)
     }
 
     pub fn with_function_args(
         mut self,
         name: impl Into<String>,
-        fnc: Function,
+        fnc: Function<C>,
         num_args: u32,
     ) -> Self {
         self.map
@@ -761,12 +779,6 @@ impl FunctionMap {
     }
 }
 
-impl Default for Runtime {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Input {
     pub fn script(name: impl Into<Script>, script: impl Into<Arc<Sieve>>) -> Self {
         Input::Script {
diff --git a/src/runtime/tests/comparator.rs b/src/runtime/tests/comparator.rs
index 56a9f3f..db8c5ea 100644
--- a/src/runtime/tests/comparator.rs
+++ b/src/runtime/tests/comparator.rs
@@ -32,7 +32,7 @@ use crate::{
     MatchAs,
 };
 
-use super::glob::{glob_match, glob_match_capture};
+use super::glob::GlobPattern;
 
 impl Comparator {
     pub(crate) fn is(&self, a: &Variable<'_>, b: &Variable<'_>) -> bool {
@@ -71,15 +71,12 @@ impl Comparator {
         capture_positions: u64,
         captured_values: &mut Vec<(usize, String)>,
     ) -> bool {
+        let pattern = GlobPattern::compile(pattern, matches!(self, Comparator::AsciiCaseMap));
         match self {
-            Comparator::AsciiCaseMap if capture_positions == 0 => {
-                glob_match(&value.to_lowercase(), pattern, true)
-            }
-            Comparator::AsciiCaseMap => {
-                glob_match_capture(value, pattern, true, capture_positions, captured_values)
-            }
-            _ if capture_positions == 0 => glob_match(value, pattern, false),
-            _ => glob_match_capture(value, pattern, false, capture_positions, captured_values),
+            Comparator::AsciiCaseMap if capture_positions == 0 => pattern.matches(value),
+            Comparator::AsciiCaseMap => pattern.capture(value, capture_positions, captured_values),
+            _ if capture_positions == 0 => pattern.matches(value),
+            _ => pattern.capture(value, capture_positions, captured_values),
         }
     }
 
diff --git a/src/runtime/tests/glob.rs b/src/runtime/tests/glob.rs
index a83bff0..88b882e 100644
--- a/src/runtime/tests/glob.rs
+++ b/src/runtime/tests/glob.rs
@@ -25,246 +25,256 @@ use std::char::REPLACEMENT_CHARACTER;
 
 use crate::MAX_MATCH_VARIABLES;
 
-#[derive(Debug)]
-enum PatternChar {
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GlobPattern {
+    pattern: Vec<PatternChar>,
+    to_lower: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PatternChar {
     WildcardMany { num: usize, match_pos: usize },
     WildcardSingle { match_pos: usize },
     Char { char: char, match_pos: usize },
 }
 
-fn compile(str: &str, to_lower: bool) -> Vec<PatternChar> {
-    let mut chars = Vec::new();
-    let mut is_escaped = false;
-    let mut str = str.chars().peekable();
+impl GlobPattern {
+    pub fn compile(pattern: &str, to_lower: bool) -> Self {
+        let mut chars = Vec::new();
+        let mut is_escaped = false;
+        let mut str = pattern.chars().peekable();
 
-    while let Some(char) = str.next() {
-        match char {
-            '*' if !is_escaped => {
-                let mut num = 1;
-                while let Some('*') = str.peek() {
-                    num += 1;
-                    str.next();
+        while let Some(char) = str.next() {
+            match char {
+                '*' if !is_escaped => {
+                    let mut num = 1;
+                    while let Some('*') = str.peek() {
+                        num += 1;
+                        str.next();
+                    }
+                    chars.push(PatternChar::WildcardMany { num, match_pos: 0 });
                 }
-                chars.push(PatternChar::WildcardMany { num, match_pos: 0 });
-            }
-            '?' if !is_escaped => {
-                chars.push(PatternChar::WildcardSingle { match_pos: 0 });
-            }
-            '\\' if !is_escaped => {
-                is_escaped = true;
-                continue;
-            }
-            _ => {
-                if is_escaped {
-                    is_escaped = false;
+                '?' if !is_escaped => {
+                    chars.push(PatternChar::WildcardSingle { match_pos: 0 });
                 }
-                if to_lower && char.is_uppercase() {
-                    for char in char.to_lowercase() {
+                '\\' if !is_escaped => {
+                    is_escaped = true;
+                    continue;
+                }
+                _ => {
+                    if is_escaped {
+                        is_escaped = false;
+                    }
+                    if to_lower && char.is_uppercase() {
+                        for char in char.to_lowercase() {
+                            chars.push(PatternChar::Char { char, match_pos: 0 });
+                        }
+                    } else {
                         chars.push(PatternChar::Char { char, match_pos: 0 });
                     }
-                } else {
-                    chars.push(PatternChar::Char { char, match_pos: 0 });
                 }
             }
         }
-    }
-    chars
-}
 
-// Credits: Algorithm ported from https://research.swtch.com/glob
+        GlobPattern {
+            pattern: chars,
+            to_lower,
+        }
+    }
 
-pub(crate) fn glob_match(value: &str, pattern: &str, to_lower: bool) -> bool {
-    let pattern = compile(pattern, to_lower);
-    let value = if to_lower {
-        value.to_lowercase().chars().collect::<Vec<_>>()
-    } else {
-        value.chars().collect::<Vec<_>>()
-    };
+    // Credits: Algorithm ported from https://research.swtch.com/glob
+    pub fn matches(&self, value: &str) -> bool {
+        let value = if self.to_lower {
+            value.to_lowercase().chars().collect::<Vec<_>>()
+        } else {
+            value.chars().collect::<Vec<_>>()
+        };
 
-    let mut px = 0;
-    let mut nx = 0;
-    let mut next_px = 0;
-    let mut next_nx = 0;
+        let mut px = 0;
+        let mut nx = 0;
+        let mut next_px = 0;
+        let mut next_nx = 0;
 
-    while px < pattern.len() || nx < value.len() {
-        match pattern.get(px) {
-            Some(PatternChar::Char { char, .. }) => {
-                if matches!(value.get(nx), Some(nc) if nc == char ) {
-                    px += 1;
-                    nx += 1;
-                    continue;
+        while px < self.pattern.len() || nx < value.len() {
+            match self.pattern.get(px) {
+                Some(PatternChar::Char { char, .. }) => {
+                    if matches!(value.get(nx), Some(nc) if nc == char ) {
+                        px += 1;
+                        nx += 1;
+                        continue;
+                    }
                 }
-            }
-            Some(PatternChar::WildcardSingle { .. }) => {
-                if nx < value.len() {
+                Some(PatternChar::WildcardSingle { .. }) => {
+                    if nx < value.len() {
+                        px += 1;
+                        nx += 1;
+                        continue;
+                    }
+                }
+                Some(PatternChar::WildcardMany { .. }) => {
+                    next_px = px;
+                    next_nx = nx + 1;
                     px += 1;
-                    nx += 1;
                     continue;
                 }
+                _ => (),
             }
-            Some(PatternChar::WildcardMany { .. }) => {
-                next_px = px;
-                next_nx = nx + 1;
-                px += 1;
+            if 0 < next_nx && next_nx <= value.len() {
+                px = next_px;
+                nx = next_nx;
                 continue;
             }
-            _ => (),
-        }
-        if 0 < next_nx && next_nx <= value.len() {
-            px = next_px;
-            nx = next_nx;
-            continue;
+            return false;
         }
-        return false;
+        true
     }
-    true
-}
 
-pub(crate) fn glob_match_capture(
-    value_: &str,
-    pattern: &str,
-    to_lower: bool,
-    capture_positions: u64,
-    captured_values: &mut Vec<(usize, String)>,
-) -> bool {
-    let mut pattern = compile(pattern, to_lower);
-    let value = if to_lower {
-        let mut value = Vec::with_capacity(value_.len());
-        for char in value_.chars() {
-            if char.is_uppercase() {
-                for (pos, lowerchar) in char.to_lowercase().enumerate() {
-                    value.push((
-                        lowerchar,
-                        if pos == 0 {
-                            char
-                        } else {
-                            REPLACEMENT_CHARACTER
-                        },
-                    ));
+    pub fn capture(
+        mut self,
+        value_: &str,
+        capture_positions: u64,
+        captured_values: &mut Vec<(usize, String)>,
+    ) -> bool {
+        let value = if self.to_lower {
+            let mut value = Vec::with_capacity(value_.len());
+            for char in value_.chars() {
+                if char.is_uppercase() {
+                    for (pos, lowerchar) in char.to_lowercase().enumerate() {
+                        value.push((
+                            lowerchar,
+                            if pos == 0 {
+                                char
+                            } else {
+                                REPLACEMENT_CHARACTER
+                            },
+                        ));
+                    }
+                } else {
+                    value.push((char, char));
                 }
-            } else {
-                value.push((char, char));
             }
-        }
-        value
-    } else {
-        value_.chars().map(|char| (char, char)).collect::<Vec<_>>()
-    };
+            value
+        } else {
+            value_.chars().map(|char| (char, char)).collect::<Vec<_>>()
+        };
 
-    let mut px = 0;
-    let mut nx = 0;
-    let mut next_px = 0;
-    let mut next_nx = 0;
+        let mut px = 0;
+        let mut nx = 0;
+        let mut next_px = 0;
+        let mut next_nx = 0;
 
-    while px < pattern.len() || nx < value.len() {
-        match pattern.get_mut(px) {
-            Some(PatternChar::Char { char, match_pos }) => {
-                if matches!(value.get(nx), Some(nc) if &nc.0 == char ) {
-                    *match_pos = nx;
-                    px += 1;
-                    nx += 1;
-                    continue;
+        while px < self.pattern.len() || nx < value.len() {
+            match self.pattern.get_mut(px) {
+                Some(PatternChar::Char { char, match_pos }) => {
+                    if matches!(value.get(nx), Some(nc) if &nc.0 == char ) {
+                        *match_pos = nx;
+                        px += 1;
+                        nx += 1;
+                        continue;
+                    }
                 }
-            }
-            Some(PatternChar::WildcardSingle { match_pos }) => {
-                if nx < value.len() {
+                Some(PatternChar::WildcardSingle { match_pos }) => {
+                    if nx < value.len() {
+                        *match_pos = nx;
+                        px += 1;
+                        nx += 1;
+                        continue;
+                    }
+                }
+                Some(PatternChar::WildcardMany { match_pos, .. }) => {
                     *match_pos = nx;
+                    next_px = px;
+                    next_nx = nx + 1;
                     px += 1;
-                    nx += 1;
                     continue;
                 }
+                _ => (),
             }
-            Some(PatternChar::WildcardMany { match_pos, .. }) => {
-                *match_pos = nx;
-                next_px = px;
-                next_nx = nx + 1;
-                px += 1;
+            if 0 < next_nx && next_nx <= value.len() {
+                px = next_px;
+                nx = next_nx;
                 continue;
             }
-            _ => (),
-        }
-        if 0 < next_nx && next_nx <= value.len() {
-            px = next_px;
-            nx = next_nx;
-            continue;
+            return false;
         }
-        return false;
-    }
 
-    let mut last_pos = 0;
+        let mut last_pos = 0;
 
-    captured_values.clear();
-    if capture_positions & 1 != 0 {
-        captured_values.push((0usize, value_.to_string()));
-    }
+        captured_values.clear();
+        if capture_positions & 1 != 0 {
+            captured_values.push((0usize, value_.to_string()));
+        }
+
+        let mut wildcard_pos = 1;
+        for item in &self.pattern {
+            if wildcard_pos <= MAX_MATCH_VARIABLES {
+                last_pos = match item {
+                    PatternChar::WildcardMany { mut num, match_pos } => {
+                        while num > 1 {
+                            if capture_positions & (1 << wildcard_pos) != 0 {
+                                captured_values.push((wildcard_pos, String::with_capacity(0)));
+                            }
+                            wildcard_pos += 1;
+                            num -= 1;
+                        }
 
-    let mut wildcard_pos = 1;
-    for item in pattern {
-        if wildcard_pos <= MAX_MATCH_VARIABLES {
-            last_pos = match item {
-                PatternChar::WildcardMany { mut num, match_pos } => {
-                    while num > 1 {
                         if capture_positions & (1 << wildcard_pos) != 0 {
-                            captured_values.push((wildcard_pos, String::with_capacity(0)));
+                            if let Some(range) = value.get(last_pos..*match_pos) {
+                                captured_values.push((
+                                    wildcard_pos,
+                                    range
+                                        .iter()
+                                        .filter_map(|(_, char)| {
+                                            if char != &REPLACEMENT_CHARACTER {
+                                                Some(char)
+                                            } else {
+                                                None
+                                            }
+                                        })
+                                        .collect::<String>(),
+                                ));
+                            } else {
+                                debug_assert!(false, "Glob pattern failure.");
+                                return false;
+                            }
                         }
                         wildcard_pos += 1;
-                        num -= 1;
+                        match_pos
                     }
-
-                    if capture_positions & (1 << wildcard_pos) != 0 {
-                        if let Some(range) = value.get(last_pos..match_pos) {
-                            captured_values.push((
-                                wildcard_pos,
-                                range
-                                    .iter()
-                                    .filter_map(|(_, char)| {
-                                        if char != &REPLACEMENT_CHARACTER {
-                                            Some(char)
-                                        } else {
-                                            None
-                                        }
+                    PatternChar::WildcardSingle { match_pos } => {
+                        if capture_positions & (1 << wildcard_pos) != 0 {
+                            if let Some((char, orig_char)) = value.get(*match_pos) {
+                                captured_values.push((
+                                    wildcard_pos,
+                                    (if orig_char != &REPLACEMENT_CHARACTER {
+                                        orig_char
+                                    } else {
+                                        char
                                     })
-                                    .collect::<String>(),
-                            ));
-                        } else {
-                            debug_assert!(false, "Glob pattern failure.");
-                            return false;
-                        }
-                    }
-                    wildcard_pos += 1;
-                    match_pos
-                }
-                PatternChar::WildcardSingle { match_pos } => {
-                    if capture_positions & (1 << wildcard_pos) != 0 {
-                        if let Some((char, orig_char)) = value.get(match_pos) {
-                            captured_values.push((
-                                wildcard_pos,
-                                (if orig_char != &REPLACEMENT_CHARACTER {
-                                    orig_char
-                                } else {
-                                    char
-                                })
-                                .to_string(),
-                            ));
-                        } else {
-                            debug_assert!(false, "Glob pattern failure.");
-                            return false;
+                                    .to_string(),
+                                ));
+                            } else {
+                                debug_assert!(false, "Glob pattern failure.");
+                                return false;
+                            }
                         }
+                        wildcard_pos += 1;
+                        match_pos
                     }
-                    wildcard_pos += 1;
-                    match_pos
-                }
-                PatternChar::Char { match_pos, .. } => match_pos,
-            } + 1;
-        } else {
-            break;
+                    PatternChar::Char { match_pos, .. } => match_pos,
+                } + 1;
+            } else {
+                break;
+            }
         }
+        true
     }
-    true
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::runtime::tests::glob::GlobPattern;
+
     #[test]
     fn glob_match() {
         for (value, pattern, expected_result) in [
@@ -293,9 +303,10 @@ mod tests {
                 vec!["Straße"],
             ),
         ] {
+            let p = GlobPattern::compile(pattern, true);
             let mut match_values = Vec::new();
             assert!(
-                super::glob_match_capture(value, pattern, true, u64::MAX ^ 1, &mut match_values),
+                p.clone().capture(value, u64::MAX ^ 1, &mut match_values),
                 "{value:?} {pattern:?}",
             );
 
@@ -304,10 +315,7 @@ mod tests {
                 expected_result,
                 "{value:?} {pattern:?}",
             );
-            assert!(
-                super::glob_match(value, pattern, true),
-                "{value:?} {pattern:?}",
-            );
+            assert!(p.matches(value), "{value:?} {pattern:?}",);
         }
     }
 }
diff --git a/src/runtime/tests/mime.rs b/src/runtime/tests/mime.rs
index 71c76d3..b06b011 100644
--- a/src/runtime/tests/mime.rs
+++ b/src/runtime/tests/mime.rs
@@ -33,15 +33,15 @@ pub(crate) enum ContentTypeFilter {
     TypeSubtype((String, String)),
 }
 
-pub(crate) struct SubpartIterator<'x> {
-    ctx: &'x Context<'x>,
+pub(crate) struct SubpartIterator<'x, C> {
+    ctx: &'x Context<'x, C>,
     iter: Iter<'x, usize>,
     iter_stack: Vec<Iter<'x, usize>>,
     anychild: bool,
 }
 
-impl<'x> SubpartIterator<'x> {
-    pub(crate) fn new(ctx: &'x Context<'x>, parts: &'x [usize], anychild: bool) -> Self {
+impl<'x, C> SubpartIterator<'x, C> {
+    pub(crate) fn new(ctx: &'x Context<'x, C>, parts: &'x [usize], anychild: bool) -> Self {
         SubpartIterator {
             ctx,
             iter: parts.iter(),
@@ -73,7 +73,7 @@ impl<'x> SubpartIterator<'x> {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn find_nested_parts<'z: 'x>(
         &'z self,
         mut message: &'x Message<'x>,
diff --git a/src/runtime/tests/mod.rs b/src/runtime/tests/mod.rs
index dd2d98e..ff5cb2c 100644
--- a/src/runtime/tests/mod.rs
+++ b/src/runtime/tests/mod.rs
@@ -53,7 +53,7 @@ pub(crate) enum TestResult {
 }
 
 impl Test {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         match &self {
             Test::Header(test) => test.exec(ctx),
             Test::Address(test) => test.exec(ctx),
diff --git a/src/runtime/tests/test_address.rs b/src/runtime/tests/test_address.rs
index 10306aa..b3389f3 100644
--- a/src/runtime/tests/test_address.rs
+++ b/src/runtime/tests/test_address.rs
@@ -44,7 +44,7 @@ use crate::{
 use super::TestResult;
 
 impl TestAddress {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let key_list = ctx.eval_values(&self.key_list);
         let header_list = ctx.parse_header_names(&self.header_list);
 
@@ -189,7 +189,7 @@ impl TestAddress {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     #[allow(unused_assignments)]
     pub(crate) fn find_addresses(
         &self,
diff --git a/src/runtime/tests/test_body.rs b/src/runtime/tests/test_body.rs
index d3e439a..a4aab1e 100644
--- a/src/runtime/tests/test_body.rs
+++ b/src/runtime/tests/test_body.rs
@@ -38,7 +38,7 @@ use crate::{
 use super::{mime::ContentTypeFilter, TestResult};
 
 impl TestBody {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         // Check Subject (not a Sieve standard)
         let key_list = ctx.eval_values(&self.key_list);
         if self.include_subject {
diff --git a/src/runtime/tests/test_date.rs b/src/runtime/tests/test_date.rs
index 4c2fc37..6a9e847 100644
--- a/src/runtime/tests/test_date.rs
+++ b/src/runtime/tests/test_date.rs
@@ -40,7 +40,7 @@ use crate::{
 use super::TestResult;
 
 impl TestDate {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let header_name = if let Some(header_name) = ctx.parse_header_name(&self.header_name) {
             header_name
         } else {
@@ -161,7 +161,7 @@ impl TestDate {
 }
 
 impl TestCurrentDate {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let mut result = false;
 
         match &self.match_type {
@@ -243,7 +243,7 @@ impl TestCurrentDate {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     #[allow(unused_assignments)]
     pub(crate) fn find_dates(&self, header: &'x Header) -> Option<Cow<'x, DateTime>> {
         if let HeaderValue::DateTime(dt) = &header.value {
diff --git a/src/runtime/tests/test_duplicate.rs b/src/runtime/tests/test_duplicate.rs
index d67fcc0..fe2b888 100644
--- a/src/runtime/tests/test_duplicate.rs
+++ b/src/runtime/tests/test_duplicate.rs
@@ -31,7 +31,7 @@ use crate::{
 use super::TestResult;
 
 impl TestDuplicate {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let id = match &self.dup_match {
             DupMatch::Header(header_name) => {
                 let mut value = String::new();
diff --git a/src/runtime/tests/test_envelope.rs b/src/runtime/tests/test_envelope.rs
index 9eb09cc..9ffd305 100644
--- a/src/runtime/tests/test_envelope.rs
+++ b/src/runtime/tests/test_envelope.rs
@@ -35,7 +35,7 @@ use crate::{
 use super::TestResult;
 
 impl TestEnvelope {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let key_list = ctx.eval_values(&self.key_list);
 
         let result = match &self.match_type {
@@ -153,7 +153,7 @@ impl TestEnvelope {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     fn find_envelopes(
         &self,
         test_envelope: &TestEnvelope,
diff --git a/src/runtime/tests/test_exists.rs b/src/runtime/tests/test_exists.rs
index afea66a..43e49b6 100644
--- a/src/runtime/tests/test_exists.rs
+++ b/src/runtime/tests/test_exists.rs
@@ -26,7 +26,7 @@ use crate::{compiler::grammar::tests::test_exists::TestExists, Context};
 use super::{mime::SubpartIterator, TestResult};
 
 impl TestExists {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let header_names = ctx.parse_header_names(&self.header_names);
         let mut header_exists = vec![false; header_names.len()];
         let parts = [ctx.part];
diff --git a/src/runtime/tests/test_extlists.rs b/src/runtime/tests/test_extlists.rs
index 969d701..9aec7c5 100644
--- a/src/runtime/tests/test_extlists.rs
+++ b/src/runtime/tests/test_extlists.rs
@@ -26,7 +26,7 @@ use crate::{compiler::grammar::tests::test_extlists::TestValidExtList, Context};
 use super::TestResult;
 
 impl TestValidExtList {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let mut num_valid = 0;
 
         for list in &self.list_names {
diff --git a/src/runtime/tests/test_hasflag.rs b/src/runtime/tests/test_hasflag.rs
index 59307dd..58e8a7a 100644
--- a/src/runtime/tests/test_hasflag.rs
+++ b/src/runtime/tests/test_hasflag.rs
@@ -33,7 +33,7 @@ use crate::{
 use super::TestResult;
 
 impl TestHasFlag {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let mut variable_list_ = None;
         let variable_list = if !self.variable_list.is_empty() {
             &self.variable_list
diff --git a/src/runtime/tests/test_header.rs b/src/runtime/tests/test_header.rs
index 7969014..e9a0873 100644
--- a/src/runtime/tests/test_header.rs
+++ b/src/runtime/tests/test_header.rs
@@ -35,7 +35,7 @@ use crate::{
 use super::{mime::SubpartIterator, TestResult};
 
 impl TestHeader {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let key_list = ctx.eval_values(&self.key_list);
         let header_list = ctx.parse_header_names(&self.header_list);
         let mime_opts = match &self.mime_opts {
@@ -206,7 +206,7 @@ impl TestHeader {
     }
 }
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn parse_header_names<'z: 'y, 'y>(
         &'z self,
         header_names: &'y [Value],
diff --git a/src/runtime/tests/test_metadata.rs b/src/runtime/tests/test_metadata.rs
index 80be8d5..5f99306 100644
--- a/src/runtime/tests/test_metadata.rs
+++ b/src/runtime/tests/test_metadata.rs
@@ -36,7 +36,7 @@ use crate::{
 use super::TestResult;
 
 impl TestMetadata {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let metadata = match &self.medatata {
             Metadata::Server { annotation } => Metadata::Server {
                 annotation: ctx.eval_value(annotation).into_cow(),
@@ -122,7 +122,7 @@ impl TestMetadata {
 }
 
 impl TestMetadataExists {
-    pub(crate) fn exec(&self, ctx: &Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &Context<C>) -> TestResult {
         let mailbox = self
             .mailbox
             .as_ref()
diff --git a/src/runtime/tests/test_notify.rs b/src/runtime/tests/test_notify.rs
index 8713f7e..07cab91 100644
--- a/src/runtime/tests/test_notify.rs
+++ b/src/runtime/tests/test_notify.rs
@@ -38,7 +38,7 @@ use crate::{
 use super::TestResult;
 
 impl TestValidNotifyMethod {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let mut num_valid = 0;
 
         for uri in &self.notification_uris {
@@ -60,7 +60,7 @@ impl TestValidNotifyMethod {
 }
 
 impl TestNotifyMethodCapability {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let uri = ctx.eval_value(&self.notification_uri).into_cow();
         if !ctx
             .eval_value(&self.notification_capability)
diff --git a/src/runtime/tests/test_size.rs b/src/runtime/tests/test_size.rs
index bf521b2..aff5068 100644
--- a/src/runtime/tests/test_size.rs
+++ b/src/runtime/tests/test_size.rs
@@ -26,7 +26,7 @@ use crate::{compiler::grammar::tests::test_size::TestSize, Context};
 use super::TestResult;
 
 impl TestSize {
-    pub(crate) fn exec(&self, ctx: &Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &Context<C>) -> TestResult {
         TestResult::Bool(
             (if self.over {
                 ctx.message_size > self.limit
diff --git a/src/runtime/tests/test_spamtest.rs b/src/runtime/tests/test_spamtest.rs
index 1222a94..91e0cb3 100644
--- a/src/runtime/tests/test_spamtest.rs
+++ b/src/runtime/tests/test_spamtest.rs
@@ -36,7 +36,7 @@ use crate::{
 use super::TestResult;
 
 impl TestSpamTest {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let status = if self.percent {
             ctx.spam_status.as_percentage()
         } else {
@@ -84,7 +84,7 @@ impl TestSpamTest {
 }
 
 impl TestVirusTest {
-    pub(crate) fn exec(&self, ctx: &mut Context) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>) -> TestResult {
         let status = ctx.virus_status.as_number();
         let value = ctx.eval_value(&self.value);
         let mut captured_values = Vec::new();
diff --git a/src/runtime/tests/test_string.rs b/src/runtime/tests/test_string.rs
index c65b4a5..8c09c83 100644
--- a/src/runtime/tests/test_string.rs
+++ b/src/runtime/tests/test_string.rs
@@ -32,7 +32,7 @@ use crate::{
 use super::TestResult;
 
 impl TestString {
-    pub(crate) fn exec(&self, ctx: &mut Context, empty_is_null: bool) -> TestResult {
+    pub(crate) fn exec<C>(&self, ctx: &mut Context<C>, empty_is_null: bool) -> TestResult {
         let mut result = false;
 
         match &self.match_type {
diff --git a/src/runtime/variables.rs b/src/runtime/variables.rs
index b2481df..d46134c 100644
--- a/src/runtime/variables.rs
+++ b/src/runtime/variables.rs
@@ -25,7 +25,7 @@ use crate::Context;
 
 use super::Variable;
 
-impl<'x> Context<'x> {
+impl<'x, C> Context<'x, C> {
     pub(crate) fn set_match_variables(&mut self, set_vars: Vec<(usize, String)>) {
         for (var_num, value) in set_vars {
             if let Some(var) = self.vars_match.get_mut(var_num) {