diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp
index 80b2a8c6e36f66c54f84b0e58eb84e27e5d7ee7c..5e6706a436395ebb4f3e0295922c958af1f54d64 100644
--- a/src/language/ASTNode.hpp
+++ b/src/language/ASTNode.hpp
@@ -7,7 +7,7 @@
 #include <ASTNodeDataType.hpp>
 #include <ASTNodeDataVariant.hpp>
 
-#include <node_processor/ExecUntilBreakOrContinue.hpp>
+#include <node_processor/ExecutionPolicy.hpp>
 #include <node_processor/INodeProcessor.hpp>
 
 #include <pegtl/contrib/parse_tree.hpp>
@@ -22,7 +22,6 @@ struct ASTNode : public parse_tree::basic_node<ASTNode>
   std::unique_ptr<INodeProcessor> m_node_processor;
 
   ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t};
-  ASTNodeDataVariant m_value;
 
   PUGS_INLINE
   std::string
@@ -32,12 +31,14 @@ struct ASTNode : public parse_tree::basic_node<ASTNode>
   }
 
   PUGS_INLINE
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
     Assert(m_node_processor, "Undefined node processor");
     if (exec_policy.exec()) {
-      m_node_processor->execute(exec_policy);
+      return m_node_processor->execute(exec_policy);
+    } else {
+      return {};
     }
   }
 };
diff --git a/src/language/ASTNodeCFunctionExpressionBuilder.cpp b/src/language/ASTNodeCFunctionExpressionBuilder.cpp
index 0219ef3097acc20767e98eeac9a3105894b0296a..b958907ab7f9d2c1e5f1852cd27977ec404a7e5b 100644
--- a/src/language/ASTNodeCFunctionExpressionBuilder.cpp
+++ b/src/language/ASTNodeCFunctionExpressionBuilder.cpp
@@ -6,24 +6,22 @@
 #include <node_processor/CFunctionProcessor.hpp>
 
 PUGS_INLINE std::unique_ptr<INodeProcessor>
-ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(const ASTNodeDataType& parameter_type,
-                                                         ASTNode& argument_node,
-                                                         ASTNodeDataVariant& argument_value)
+ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(const ASTNodeDataType& parameter_type, ASTNode& argument_node)
 {
   auto get_function_argument_processor_for = [&](const auto& parameter_v) -> std::unique_ptr<INodeProcessor> {
     using ParameterT = std::decay_t<decltype(parameter_v)>;
     switch (argument_node.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ParameterT, bool>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, bool>>(argument_node);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ParameterT, uint64_t>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, uint64_t>>(argument_node);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ParameterT, int64_t>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, int64_t>>(argument_node);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ParameterT, double>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, double>>(argument_node);
     }
     default: {
       throw parse_error("invalid argument type for function", std::vector{argument_node.begin()});
@@ -61,10 +59,8 @@ ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const std::vector<AST
                                                            ASTNode& argument_node,
                                                            CFunctionProcessor& c_function_processor)
 {
-  auto& argument_values = c_function_processor.argumentValues();
-
   c_function_processor.addArgumentProcessor(
-    this->_getArgumentProcessor(parameter_type_list[argument_number], argument_node, argument_values[argument_number]));
+    this->_getArgumentProcessor(parameter_type_list[argument_number], argument_node));
 }
 
 PUGS_INLINE
@@ -78,8 +74,6 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(const std::vector<AS
   const size_t arguments_number =
     argument_nodes.is_type<language::function_argument_list>() ? argument_nodes.children.size() : 1;
 
-  c_function_processor.setNumberOfArguments(arguments_number);
-
   const size_t parameters_number = parameter_type_list.size();
 
   if (arguments_number != parameters_number) {
@@ -117,7 +111,7 @@ ASTNodeCFunctionExpressionBuilder::ASTNodeCFunctionExpressionBuilder(ASTNode& no
   this->_buildArgumentProcessors(c_function_parameter_type_list, node, *c_function_processor);
 
   c_function_processor->setFunctionExpressionProcessor(
-    std::make_unique<CFunctionExpressionProcessor>(node, c_function_embedder, c_function_processor->argumentValues()));
+    std::make_unique<CFunctionExpressionProcessor>(c_function_embedder));
 
   node.m_node_processor = std::move(c_function_processor);
 }
diff --git a/src/language/ASTNodeCFunctionExpressionBuilder.hpp b/src/language/ASTNodeCFunctionExpressionBuilder.hpp
index f2e2de4f372057780548064a330c05ecfb14210a..db4533bdb16dbe4ce332476ac1d768ccf43097eb 100644
--- a/src/language/ASTNodeCFunctionExpressionBuilder.hpp
+++ b/src/language/ASTNodeCFunctionExpressionBuilder.hpp
@@ -10,8 +10,7 @@ class ASTNodeCFunctionExpressionBuilder
 {
  private:
   PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(const ASTNodeDataType& parameter_type,
-                                                                    ASTNode& argument_node,
-                                                                    ASTNodeDataVariant& argument_value);
+                                                                    ASTNode& argument_node);
 
   PUGS_INLINE
   void _storeArgumentProcessor(const std::vector<ASTNodeDataType>& parameter_type_list,
diff --git a/src/language/ASTNodeDataTypeBuilder.cpp b/src/language/ASTNodeDataTypeBuilder.cpp
index 3e003392007b8ccc5250c14fed31a94e36d3be22..73be74fe8017f68c5bc596ca4d1a73ca099779f0 100644
--- a/src/language/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ASTNodeDataTypeBuilder.cpp
@@ -322,7 +322,6 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
         if (image_domain_node.children.size() > 0) {
           data_type = image_domain_node.m_data_type;
         } else {
-#warning check if it is really useful to compute exact types here?
           if (image_domain_node.is_type<language::B_set>()) {
             data_type = ASTNodeDataType::bool_t;
           } else if (image_domain_node.is_type<language::Z_set>()) {
diff --git a/src/language/ASTNodeDataVariant.hpp b/src/language/ASTNodeDataVariant.hpp
index 5dc17b57f17288564d00075e809ae0a0d3dcd6d5..b2e4cbb25607fbfa0cd3dd1a0f5c5f3fdf899a03 100644
--- a/src/language/ASTNodeDataVariant.hpp
+++ b/src/language/ASTNodeDataVariant.hpp
@@ -77,7 +77,7 @@ class AggregateDataVariant
   AggregateDataVariant& operator=(const AggregateDataVariant&) = default;
   AggregateDataVariant& operator=(AggregateDataVariant&&) = default;
 
-  AggregateDataVariant(size_t size) : m_data_vector(size) {}
+  AggregateDataVariant(std::vector<ASTNodeDataVariant>&& data_vector) : m_data_vector(data_vector) {}
 
   AggregateDataVariant(const AggregateDataVariant&) = default;
   AggregateDataVariant(AggregateDataVariant&&)      = default;
diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp
index c9378f165ab24dcb935c4bba661cbd6e2c6e5e57..e745d24f82ff2c22c609701dcab9a0431e551ee3 100644
--- a/src/language/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ASTNodeExpressionBuilder.cpp
@@ -8,6 +8,7 @@
 #include <ASTNodeIncDecExpressionBuilder.hpp>
 #include <ASTNodeUnaryOperatorExpressionBuilder.hpp>
 
+#include <node_processor/ASTNodeExpressionListProcessor.hpp>
 #include <node_processor/ASTNodeListProcessor.hpp>
 #include <node_processor/BreakProcessor.hpp>
 #include <node_processor/ContinueProcessor.hpp>
@@ -15,8 +16,10 @@
 #include <node_processor/FakeProcessor.hpp>
 #include <node_processor/ForProcessor.hpp>
 #include <node_processor/IfProcessor.hpp>
+#include <node_processor/LocalNameProcessor.hpp>
 #include <node_processor/NameProcessor.hpp>
 #include <node_processor/OStreamProcessor.hpp>
+#include <node_processor/ValueProcessor.hpp>
 #include <node_processor/WhileProcessor.hpp>
 
 #include <PEGGrammar.hpp>
@@ -42,28 +45,33 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
     ASTNodeFunctionEvaluationExpressionBuilder{n};
 
   } else if (n.is_type<language::real>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::integer>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::literal>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::true_kw>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::false_kw>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
 
   } else if (n.is_type<language::function_argument_list>()) {
     n.m_node_processor = std::make_unique<FakeProcessor>();
 
   } else if (n.is_type<language::expression_list>()) {
-    n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
+    n.m_node_processor = std::make_unique<ASTNodeExpressionListProcessor>(n);
 
   } else if (n.is_type<language::name_list>()) {
     n.m_node_processor = std::make_unique<FakeProcessor>();
 
   } else if (n.is_type<language::name>()) {
-    n.m_node_processor = std::make_unique<NameProcessor>(n);
-
+    // Dealing with contexts
+    auto [i_symbol, success] = n.m_symbol_table->find(n.string(), n.begin());
+    if (i_symbol->attributes().hasLocalContext()) {
+      n.m_node_processor = std::make_unique<LocalNameProcessor>(n);
+    } else {
+      n.m_node_processor = std::make_unique<NameProcessor>(n);
+    }
   } else if (n.is_type<language::unary_minus>() or n.is_type<language::unary_not>()) {
     ASTNodeUnaryOperatorExpressionBuilder{n};
 
@@ -102,7 +110,7 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
   } else if (n.is_type<language::for_post>()) {
     n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is_type<language::for_test>()) {
-    n.m_node_processor = std::make_unique<FakeProcessor>();
+    n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::break_kw>()) {
     n.m_node_processor = std::make_unique<BreakProcessor>();
   } else if (n.is_type<language::continue_kw>()) {
diff --git a/src/language/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ASTNodeFunctionExpressionBuilder.cpp
index 8833958c6009246f8fbb3a0745bf2912786929b1..3d8000370c28505b0ecfd8eb8918c5ddfebac357 100644
--- a/src/language/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ASTNodeFunctionExpressionBuilder.cpp
@@ -141,29 +141,26 @@ std::unique_ptr<INodeProcessor>
 ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType expression_value_type,
                                                         const ASTNodeDataType return_value_type,
                                                         ASTNode& node,
-                                                        ASTNode& function_component_expression,
-                                                        ASTNodeDataVariant& node_value)
+                                                        ASTNode& function_component_expression)
 {
   auto get_function_processor_for_expression_value = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> {
     using ReturnT = std::decay_t<decltype(return_v)>;
     switch (expression_value_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<FunctionExpressionProcessor<ReturnT, bool>>(function_component_expression, node_value);
+      return std::make_unique<FunctionExpressionProcessor<ReturnT, bool>>(function_component_expression);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<FunctionExpressionProcessor<ReturnT, uint64_t>>(function_component_expression,
-                                                                              node_value);
+      return std::make_unique<FunctionExpressionProcessor<ReturnT, uint64_t>>(function_component_expression);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<FunctionExpressionProcessor<ReturnT, int64_t>>(function_component_expression, node_value);
+      return std::make_unique<FunctionExpressionProcessor<ReturnT, int64_t>>(function_component_expression);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<FunctionExpressionProcessor<ReturnT, double>>(function_component_expression, node_value);
+      return std::make_unique<FunctionExpressionProcessor<ReturnT, double>>(function_component_expression);
     }
     case ASTNodeDataType::string_t: {
       if constexpr (std::is_same_v<ReturnT, std::string>) {
-        return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(function_component_expression,
-                                                                                   node_value);
+        return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(function_component_expression);
       } else {
         throw parse_error("invalid string conversion", std::vector{node.children[1]->begin()});
       }
@@ -215,14 +212,17 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
 
   FunctionDescriptor& function_descriptor = node.m_symbol_table->functionTable()[function_id];
 
-  std::unique_ptr function_processor = std::make_unique<FunctionProcessor>();
-
-  this->_buildArgumentProcessors(function_descriptor, node, *function_processor);
-
   ASTNode& function_image_domain = *function_descriptor.domainMappingNode().children[1];
   ASTNode& function_expression   = *function_descriptor.definitionNode().children[1];
 
-  auto add_component_expression = [&](ASTNode& expression_node, ASTNode& domain_node, ASTNodeDataVariant& value) {
+  Assert(function_expression.m_symbol_table->hasContext());
+  const SymbolTable::Context& context = function_expression.m_symbol_table->context();
+
+  std::unique_ptr function_processor = std::make_unique<FunctionProcessor>(context.size());
+
+  this->_buildArgumentProcessors(function_descriptor, node, *function_processor);
+
+  auto add_component_expression = [&](ASTNode& expression_node, ASTNode& domain_node) {
     ASTNodeDataType expression_value_type = expression_node.m_data_type;
     ASTNodeDataType return_value_type     = ASTNodeDataType::undefined_t;
 
@@ -243,23 +243,18 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
     Assert(return_value_type != ASTNodeDataType::undefined_t);
 
     function_processor->addFunctionExpressionProcessor(
-      this->_getFunctionProcessor(expression_value_type, return_value_type, node, expression_node, value));
+      this->_getFunctionProcessor(expression_value_type, return_value_type, node, expression_node));
   };
 
   if (function_expression.is_type<language::expression_list>()) {
     Assert(function_image_domain.is_type<language::type_expression>());
     ASTNode& image_domain_node = function_image_domain;
-    const size_t& nb_component = function_expression.children.size();
-
-    AggregateDataVariant aggregate_value(nb_component);
 
     for (size_t i = 0; i < function_expression.children.size(); ++i) {
-      add_component_expression(*function_expression.children[i], *image_domain_node.children[i], aggregate_value[i]);
+      add_component_expression(*function_expression.children[i], *image_domain_node.children[i]);
     }
-
-    node.m_value = std::move(aggregate_value);
   } else {
-    add_component_expression(function_expression, function_image_domain, node.m_value);
+    add_component_expression(function_expression, function_image_domain);
   }
 
   node.m_node_processor = std::move(function_processor);
diff --git a/src/language/ASTNodeFunctionExpressionBuilder.hpp b/src/language/ASTNodeFunctionExpressionBuilder.hpp
index f8f69e9c6c9f3363db9d9e3c57fdf0c8d6bbc521..193d60e27ad27e6c705676b1fcf3fdf2baf85330 100644
--- a/src/language/ASTNodeFunctionExpressionBuilder.hpp
+++ b/src/language/ASTNodeFunctionExpressionBuilder.hpp
@@ -28,8 +28,7 @@ class ASTNodeFunctionExpressionBuilder
   std::unique_ptr<INodeProcessor> _getFunctionProcessor(const ASTNodeDataType expression_value_type,
                                                         const ASTNodeDataType return_value_type,
                                                         ASTNode& node,
-                                                        ASTNode& function_component_expression,
-                                                        ASTNodeDataVariant& node_value);
+                                                        ASTNode& function_component_expression);
 
  public:
   ASTNodeFunctionExpressionBuilder(ASTNode& node);
diff --git a/src/language/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
index 7db25c42bb2a25971cbd99d29dd14508f833cd57..8b0005c90657f39d142d4507809e005ababf4cc2 100644
--- a/src/language/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
@@ -15,19 +15,19 @@ ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessorFromExpre
       using ValueT = std::decay_t<decltype(value)>;
       switch (data_type) {
       case ASTNodeDataType::bool_t: {
-        list_affectation_processor->template add<ValueT, bool>(value_node, data_node);
+        list_affectation_processor->template add<ValueT, bool>(value_node);
         break;
       }
       case ASTNodeDataType::unsigned_int_t: {
-        list_affectation_processor->template add<ValueT, uint64_t>(value_node, data_node);
+        list_affectation_processor->template add<ValueT, uint64_t>(value_node);
         break;
       }
       case ASTNodeDataType::int_t: {
-        list_affectation_processor->template add<ValueT, int64_t>(value_node, data_node);
+        list_affectation_processor->template add<ValueT, int64_t>(value_node);
         break;
       }
       case ASTNodeDataType::double_t: {
-        list_affectation_processor->template add<ValueT, double>(value_node, data_node);
+        list_affectation_processor->template add<ValueT, double>(value_node);
         break;
       }
       default: {
@@ -40,23 +40,23 @@ ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessorFromExpre
       if constexpr (std::is_same_v<OperatorT, language::eq_op> or std::is_same_v<OperatorT, language::pluseq_op>) {
         switch (data_type) {
         case ASTNodeDataType::bool_t: {
-          list_affectation_processor->template add<std::string, bool>(value_node, data_node);
+          list_affectation_processor->template add<std::string, bool>(value_node);
           break;
         }
         case ASTNodeDataType::unsigned_int_t: {
-          list_affectation_processor->template add<std::string, uint64_t>(value_node, data_node);
+          list_affectation_processor->template add<std::string, uint64_t>(value_node);
           break;
         }
         case ASTNodeDataType::int_t: {
-          list_affectation_processor->template add<std::string, int64_t>(value_node, data_node);
+          list_affectation_processor->template add<std::string, int64_t>(value_node);
           break;
         }
         case ASTNodeDataType::double_t: {
-          list_affectation_processor->template add<std::string, double>(value_node, data_node);
+          list_affectation_processor->template add<std::string, double>(value_node);
           break;
         }
         case ASTNodeDataType::string_t: {
-          list_affectation_processor->template add<std::string, std::string>(value_node, data_node);
+          list_affectation_processor->template add<std::string, std::string>(value_node);
           break;
         }
         default: {
diff --git a/src/language/ASTNodeValueBuilder.cpp b/src/language/ASTNodeValueBuilder.cpp
deleted file mode 100644
index d0320c4ea35f44e1435bf7b77031cc413258e355..0000000000000000000000000000000000000000
--- a/src/language/ASTNodeValueBuilder.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <ASTNodeValueBuilder.hpp>
-
-#include <PEGGrammar.hpp>
-#include <PugsAssert.hpp>
-
-#include <EscapedString.hpp>
-
-#include <FunctionTable.hpp>
-#include <SymbolTable.hpp>
-
-void
-ASTNodeValueBuilder::_buildNodeValue(ASTNode& n)
-{
-  if (n.is_type<language::block>()) {
-    if (!n.children.empty()) {
-      for (auto& child : n.children) {
-        this->_buildNodeValue(*child);
-      }
-    }
-    n.m_data_type = ASTNodeDataType::void_t;
-  } else {
-    for (auto& child : n.children) {
-      this->_buildNodeValue(*child);
-    }
-
-    if (n.has_content()) {
-      if (n.is_type<language::real>()) {
-        std::stringstream ss(n.string());
-        double v;
-        ss >> v;
-        n.m_value = v;
-      } else if (n.is_type<language::integer>()) {
-        std::stringstream ss(n.string());
-        int64_t v;
-        ss >> v;
-        n.m_value = v;
-      } else if (n.is_type<language::literal>()) {
-        n.m_value = unescapeString(n.string());
-      } else if (n.is_type<language::for_test>()) {
-        // if AST contains a for_test statement, it means that no test were
-        // given to the for-loop, so its value is always true
-        n.m_value = true;
-      } else if (n.is_type<language::true_kw>()) {
-        n.m_value = true;
-      } else if (n.is_type<language::false_kw>()) {
-        n.m_value = false;
-      }
-    }
-  }
-}
-
-ASTNodeValueBuilder::ASTNodeValueBuilder(ASTNode& node)
-{
-  Assert(node.is_root());
-  node.m_data_type = ASTNodeDataType::void_t;
-  this->_buildNodeValue(node);
-
-  FunctionTable& function_table = node.m_symbol_table->functionTable();
-  for (size_t function_id = 0; function_id < function_table.size(); ++function_id) {
-    FunctionDescriptor& function_descriptor = function_table[function_id];
-    ASTNode& function_expression            = function_descriptor.definitionNode();
-
-    this->_buildNodeValue(function_expression);
-  }
-
-  std::cout << " - build node values\n";
-}
diff --git a/src/language/ASTNodeValueBuilder.hpp b/src/language/ASTNodeValueBuilder.hpp
deleted file mode 100644
index 0e60ccc7141c011ccd26226024c433ce32c8fde7..0000000000000000000000000000000000000000
--- a/src/language/ASTNodeValueBuilder.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef AST_NODE_VALUE_BUILDER_HPP
-#define AST_NODE_VALUE_BUILDER_HPP
-
-#include <ASTNode.hpp>
-
-class ASTNodeValueBuilder
-{
- private:
-  void _buildNodeValue(ASTNode& node);
-
- public:
-  ASTNodeValueBuilder(ASTNode& root_node);
-};
-
-#endif   // AST_NODE_VALUE_BUILDER_HPP
diff --git a/src/language/ASTPrinter.cpp b/src/language/ASTPrinter.cpp
index ca09efc5f4c8a68508e1e7938a6a9548e5cef223..5b71a7094cc991bb075e51c65c8b682ca2d2682f 100644
--- a/src/language/ASTPrinter.cpp
+++ b/src/language/ASTPrinter.cpp
@@ -24,24 +24,6 @@ ASTPrinter::_print(std::ostream& os, const ASTNode& node) const
     os << dataTypeName(node.m_data_type) << rang::fg::reset;
   }
 
-  if (m_info & static_cast<InfoBaseType>(Info::data_value)) {
-    os << ':';
-    os << rang::fgB::cyan;
-    std::visit(   // LCOV_EXCL_LINE
-      [&](const auto& value) {
-        using T = std::decay_t<decltype(value)>;
-        if constexpr (std::is_same_v<T, std::monostate>) {
-          os << "--";
-        } else if constexpr (std::is_same_v<T, std::string>) {
-          os << '\"' << escapeString(value) << '\"';
-        } else {
-          os << value;
-        }
-      },
-      node.m_value);
-    os << rang::fg::reset;
-  }
-
   if (m_info & static_cast<InfoBaseType>(Info::exec_type)) {
     if (node.m_node_processor) {
       os << ':';
diff --git a/src/language/ASTPrinter.hpp b/src/language/ASTPrinter.hpp
index d8eb0802af8b4fdd61fd594583dbfa4f61800703..22566006ee5dda2eb0ec4c191dcde3a013cacfc4 100644
--- a/src/language/ASTPrinter.hpp
+++ b/src/language/ASTPrinter.hpp
@@ -16,11 +16,10 @@ class ASTPrinter
 
   enum class Info : InfoBaseType
   {
-    none       = 0,
-    data_type  = 1 << 0,
-    data_value = 1 << 1,
-    exec_type  = 1 << 2,
-    all        = std::numeric_limits<InfoBaseType>::max()
+    none      = 0,
+    data_type = 1 << 0,
+    exec_type = 1 << 1,
+    all       = std::numeric_limits<InfoBaseType>::max()
   };
 
  private:
diff --git a/src/language/ASTSymbolTableBuilder.cpp b/src/language/ASTSymbolTableBuilder.cpp
index d78100060862518d5f68934b9b99ca01444e6ae1..7db59aae4a89d1e4b3a17a7d52f8bd7c3c4909c4 100644
--- a/src/language/ASTSymbolTableBuilder.cpp
+++ b/src/language/ASTSymbolTableBuilder.cpp
@@ -16,10 +16,12 @@ ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>
       }
     }
   } else if (n.is_type<language::let_declaration>()) {
-    std::shared_ptr local_symbol_table = std::make_shared<SymbolTable>(symbol_table);
-    n.m_symbol_table                   = local_symbol_table;
-    const std::string& symbol          = n.children[0]->string();
-    auto [i_symbol, success]           = symbol_table->add(symbol, n.children[0]->begin());
+    std::shared_ptr local_symbol_table =
+      std::make_shared<SymbolTable>(symbol_table, std::make_shared<SymbolTable::Context>());
+
+    n.m_symbol_table          = local_symbol_table;
+    const std::string& symbol = n.children[0]->string();
+    auto [i_symbol, success]  = symbol_table->add(symbol, n.children[0]->begin());
     if (not success) {
       std::ostringstream error_message;
       error_message << "symbol '" << rang::fg::red << symbol << rang::fg::reset << "' was already defined!";
diff --git a/src/language/CFunctionEmbedder.hpp b/src/language/CFunctionEmbedder.hpp
index 1abbde7aabd416777b57f81fed2d7a2451f6cfea..5434d4fa0db00ac9a6b2f4e4140545ab31b942aa 100644
--- a/src/language/CFunctionEmbedder.hpp
+++ b/src/language/CFunctionEmbedder.hpp
@@ -24,7 +24,7 @@ class ICFunctionEmbedder
 
   virtual std::vector<ASTNodeDataType> getParameterDataTypes() const = 0;
 
-  virtual void apply(const std::vector<ASTNodeDataVariant>& x, ASTNodeDataVariant& f_x) const = 0;
+  virtual ASTNodeDataVariant apply(const std::vector<ASTNodeDataVariant>& x) const = 0;
 
   virtual ~ICFunctionEmbedder() = default;
 };
@@ -99,15 +99,15 @@ class CFunctionEmbedder : public ICFunctionEmbedder
   }
 
   PUGS_INLINE
-  void
-  apply(const std::vector<ASTNodeDataVariant>& x, ASTNodeDataVariant& f_x) const final
+  ASTNodeDataVariant
+  apply(const std::vector<ASTNodeDataVariant>& x) const final
   {
     constexpr size_t N = std::tuple_size_v<ArgsTuple>;
     ArgsTuple t;
     using IndexSequence = std::make_index_sequence<N>;
 
     this->_copy_from_vector(t, x, IndexSequence{});
-    f_x = std::apply(m_f, t);
+    return {std::apply(m_f, t)};
   }
 
   // @note This is written in a template fashion to ensure that function type
diff --git a/src/language/CMakeLists.txt b/src/language/CMakeLists.txt
index 21a0c78feeb929bba99cd30e349375fd19889560..d3783566626d14fca9b49c5a58e35e2e4c8798b5 100644
--- a/src/language/CMakeLists.txt
+++ b/src/language/CMakeLists.txt
@@ -25,7 +25,6 @@ add_library(
   ASTNodeJumpPlacementChecker.cpp
   ASTNodeListAffectationExpressionBuilder.cpp
   ASTNodeUnaryOperatorExpressionBuilder.cpp
-  ASTNodeValueBuilder.cpp
   ASTPrinter.cpp
   ASTSymbolTableBuilder.cpp
   ASTSymbolInitializationChecker.cpp
diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index 5603fa424012cf3ae4f23ac2b03b0c1e04aab5c1..ea4a37cd573c57ee7a1353301e78dd9ea4130f69 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -39,8 +39,6 @@
 #include <ASTDotPrinter.hpp>
 #include <ASTPrinter.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 void
 parser(const std::string& filename)
 {
@@ -75,8 +73,6 @@ parser(const std::string& filename)
 
     ASTNodeDataTypeChecker{*root_node};
 
-    ASTNodeValueBuilder{*root_node};
-
     ASTNodeJumpPlacementChecker{*root_node};
 
     // optimizations
@@ -91,7 +87,7 @@ parser(const std::string& filename)
 
     std::cout << ASTPrinter{*root_node} << '\n';
 
-    ExecUntilBreakOrContinue exec_all;
+    ExecutionPolicy exec_all;
     root_node->execute(exec_all);
     std::cout << *(root_node->m_symbol_table) << '\n';
   }
diff --git a/src/language/SymbolTable.hpp b/src/language/SymbolTable.hpp
index 328e200cb138ba6d4b149b9680648fef04f2c2bc..648f71c6e6554de888c4094976fc7b2c04ada900 100644
--- a/src/language/SymbolTable.hpp
+++ b/src/language/SymbolTable.hpp
@@ -19,13 +19,21 @@ class SymbolTable
   class Attributes
   {
    private:
+    TAO_PEGTL_NAMESPACE::position m_position;
+    bool m_has_local_context;
+
     bool m_is_initialized{false};
+
     ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t};
     ASTNodeDataVariant m_value;
 
-    TAO_PEGTL_NAMESPACE::position m_position;
-
    public:
+    bool
+    hasLocalContext() const
+    {
+      return m_has_local_context;
+    }
+
     auto&
     value()
     {
@@ -88,7 +96,9 @@ class SymbolTable
       return os;
     }
 
-    Attributes(const TAO_PEGTL_NAMESPACE::position& position) : m_position(position) {}
+    Attributes(const TAO_PEGTL_NAMESPACE::position& position, const bool& has_local_context)
+      : m_position{position}, m_has_local_context{has_local_context}
+    {}
 
     Attributes(const Attributes&) = default;
   };
@@ -131,13 +141,57 @@ class SymbolTable
     ~Symbol()             = default;
   };
 
+  class Context
+  {
+   private:
+    size_t m_size{0};
+
+   public:
+    size_t
+    size() const
+    {
+      return m_size;
+    }
+
+    size_t
+    getNextSymbolId()
+    {
+      return m_size++;
+    }
+
+    Context() = default;
+
+    Context& operator=(Context&&) = default;
+    Context& operator=(const Context&) = default;
+
+    Context(const Context&) = default;
+    Context(Context&&)      = default;
+    ~Context()              = default;
+  };
+
  private:
   std::vector<Symbol> m_symbol_list;
+
   std::shared_ptr<SymbolTable> m_parent_table;
+  std::shared_ptr<Context> m_context;
+
   std::shared_ptr<FunctionTable> m_function_table;
   std::shared_ptr<CFunctionEmbedderTable> m_c_function_embedder_table;
 
  public:
+  bool
+  hasContext() const
+  {
+    return bool{m_context};
+  }
+
+  const Context&
+  context() const
+  {
+    Assert(m_context);
+    return *m_context;
+  }
+
   const FunctionTable&
   functionTable() const
   {
@@ -210,22 +264,39 @@ class SymbolTable
         return std::make_pair(i_stored_symbol, false);
       }
     }
-    return std::make_pair(m_symbol_list.emplace(m_symbol_list.end(), Symbol{symbol_name, Attributes(symbol_position)}),
-                          true);
+    auto i_symbol =
+      m_symbol_list.emplace(m_symbol_list.end(), Symbol{symbol_name, Attributes{symbol_position, this->hasContext()}});
+
+    if (this->hasContext()) {
+      i_symbol->attributes().value() = m_context->getNextSymbolId();
+    }
+
+    return std::make_pair(i_symbol, true);
+  }
+
+  SymbolTable(const std::shared_ptr<SymbolTable>& parent_table, const std::shared_ptr<Context>& context)
+    : m_parent_table{parent_table},
+      m_context{context},
+      m_function_table{parent_table->m_function_table},
+      m_c_function_embedder_table{parent_table->m_c_function_embedder_table}
+  {
+    ;
   }
 
   SymbolTable(const std::shared_ptr<SymbolTable>& parent_table)
-    : m_parent_table(parent_table),
-      m_function_table(parent_table->m_function_table),
-      m_c_function_embedder_table(parent_table->m_c_function_embedder_table)
+    : m_parent_table{parent_table},
+      m_context{parent_table->m_context},
+      m_function_table{parent_table->m_function_table},
+      m_c_function_embedder_table{parent_table->m_c_function_embedder_table}
   {
     ;
   }
 
   SymbolTable()
-    : m_parent_table(nullptr),
-      m_function_table(std::make_shared<FunctionTable>()),
-      m_c_function_embedder_table(std::make_shared<CFunctionEmbedderTable>())
+    : m_parent_table{nullptr},
+      m_context{nullptr},
+      m_function_table{std::make_shared<FunctionTable>()},
+      m_c_function_embedder_table{std::make_shared<CFunctionEmbedderTable>()}
   {
     ;
   }
diff --git a/src/language/node_processor/ASTNodeExpressionListProcessor.hpp b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..88703b838d47750f5f46d4931b1f896236702a8b
--- /dev/null
+++ b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
@@ -0,0 +1,29 @@
+#ifndef AST_NODE_EXPRESSION_LIST_PROCESSOR_HPP
+#define AST_NODE_EXPRESSION_LIST_PROCESSOR_HPP
+
+#include <node_processor/INodeProcessor.hpp>
+
+#include <vector>
+
+class ASTNodeExpressionListProcessor final : public INodeProcessor
+{
+ private:
+  ASTNode& m_node;
+
+ public:
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
+  {
+    std::vector<ASTNodeDataVariant> list_values;
+    list_values.reserve(m_node.children.size());
+    for (auto& child : m_node.children) {
+      list_values.emplace_back(child->execute(exec_policy));
+    }
+
+    return ASTNodeDataVariant{std::move(list_values)};
+  }
+
+  ASTNodeExpressionListProcessor(ASTNode& node) : m_node{node} {}
+};
+
+#endif   // AST_NODE_EXPRESSION_LIST_PROCESSOR_HPP
diff --git a/src/language/node_processor/ASTNodeListProcessor.hpp b/src/language/node_processor/ASTNodeListProcessor.hpp
index b907b6fda5bc28909923581c565ada76abfe4e84..2303d3f2f14b4403f390fdf878648ce09f215655 100644
--- a/src/language/node_processor/ASTNodeListProcessor.hpp
+++ b/src/language/node_processor/ASTNodeListProcessor.hpp
@@ -9,12 +9,14 @@ class ASTNodeListProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
     for (auto& child : m_node.children) {
       child->execute(exec_policy);
     }
+
+    return {};
   }
 
   ASTNodeListProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index a538c351a14740d6d39e746649bf160e3cb5e990..cbb7c4e741aa25ddf5b024e0b195c93b4d52a56d 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -54,7 +54,8 @@ struct AffOp<language::minuseq_op>
 
 struct IAffectationExecutor
 {
-  virtual void execute()          = 0;
+  virtual void affect(ASTNodeDataVariant&& rhs) = 0;
+
   virtual ~IAffectationExecutor() = default;
 };
 
@@ -63,7 +64,6 @@ class AffectationExecutor final : public IAffectationExecutor
 {
  private:
   ASTNodeDataVariant* m_lhs{nullptr};
-  ASTNodeDataVariant* m_rhs{nullptr};
 
   static inline const bool _is_defined{[] {
     if constexpr (std::is_same_v<std::decay_t<ValueT>, bool>) {
@@ -75,7 +75,7 @@ class AffectationExecutor final : public IAffectationExecutor
   }()};
 
  public:
-  AffectationExecutor(ASTNode& node, ASTNodeDataVariant* lhs, ASTNodeDataVariant* rhs) : m_lhs(lhs), m_rhs(rhs)
+  AffectationExecutor(ASTNode& node, ASTNodeDataVariant* lhs) : m_lhs(lhs)
   {
     if constexpr (not _is_defined) {
       throw parse_error("invalid operands to affectation expression", std::vector{node.begin()});
@@ -83,33 +83,33 @@ class AffectationExecutor final : public IAffectationExecutor
   }
 
   PUGS_INLINE void
-  execute()
+  affect(ASTNodeDataVariant&& rhs)
   {
     if constexpr (_is_defined) {
       if constexpr (std::is_same_v<ValueT, std::string>) {
         if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
           if constexpr (std::is_same_v<std::string, DataT>) {
-            *m_lhs = *m_rhs;
+            *m_lhs = rhs;
           } else {
-            *m_lhs = std::to_string(std::get<DataT>(*m_rhs));
+            *m_lhs = std::to_string(std::get<DataT>(rhs));
           }
         } else {
           static_assert(std::is_same_v<OperatorT, language::pluseq_op>, "unexpected operator type");
           if constexpr (std::is_same_v<std::string, DataT>) {
-            std::get<std::string>(*m_lhs) += std::get<std::string>(*m_rhs);
+            std::get<std::string>(*m_lhs) += std::get<std::string>(rhs);
           } else {
-            std::get<std::string>(*m_lhs) += std::to_string(std::get<DataT>(*m_rhs));
+            std::get<std::string>(*m_lhs) += std::to_string(std::get<DataT>(rhs));
           }
         }
       } else {
         if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
           if constexpr (std::is_same_v<ValueT, DataT>) {
-            *m_lhs = *m_rhs;
+            *m_lhs = rhs;
           } else {
-            *m_lhs = static_cast<ValueT>(std::get<DataT>(*m_rhs));
+            *m_lhs = static_cast<ValueT>(std::get<DataT>(rhs));
           }
         } else {
-          AffOp<OperatorT>().eval(std::get<ValueT>(*m_lhs), std::get<DataT>(*m_rhs));
+          AffOp<OperatorT>().eval(std::get<ValueT>(*m_lhs), std::get<DataT>(rhs));
         }
       }
     }
@@ -126,11 +126,12 @@ class AffectationProcessor final : public INodeProcessor
   std::unique_ptr<AffectationExecutorT> m_affectation_executor;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_node.children[1]->execute(exec_policy);
-    m_affectation_executor->execute();
+    m_affectation_executor->affect(m_node.children[1]->execute(exec_policy));
+
+    return {};
   }
 
   AffectationProcessor(ASTNode& node) : m_node{node}
@@ -139,8 +140,7 @@ class AffectationProcessor final : public INodeProcessor
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
     Assert(found);
 
-    m_affectation_executor =
-      std::make_unique<AffectationExecutorT>(m_node, &i_symbol->attributes().value(), &m_node.children[1]->m_value);
+    m_affectation_executor = std::make_unique<AffectationExecutorT>(m_node, &i_symbol->attributes().value());
   }
 };
 
@@ -155,24 +155,27 @@ class ListAffectationProcessor final : public INodeProcessor
  public:
   template <typename ValueT, typename DataT>
   void
-  add(ASTNode& lhs_node, ASTNode& rhs_node)
+  add(ASTNode& lhs_node)
   {
     const std::string& symbol = lhs_node.string();
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->end());
     Assert(found);
 
     m_affectation_executor_list.emplace_back(
-      std::make_unique<AffectationExecutor<OperatorT, ValueT, DataT>>(m_node, &i_symbol->attributes().value(),
-                                                                      &rhs_node.m_value));
+      std::make_unique<AffectationExecutor<OperatorT, ValueT, DataT>>(m_node, &i_symbol->attributes().value()));
   }
 
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_node.children[1]->execute(exec_policy);
-    for (auto& affectation_executor : m_affectation_executor_list) {
-      affectation_executor->execute();
+    AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_node.children[1]->execute(exec_policy));
+    Assert(m_affectation_executor_list.size() == children_values.size());
+
+    for (size_t i = 0; i < m_affectation_executor_list.size(); ++i) {
+      m_affectation_executor_list[i]->affect(std::move(children_values[i]));
     }
+
+    return {};
   }
 
   ListAffectationProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/BinaryExpressionProcessor.hpp b/src/language/node_processor/BinaryExpressionProcessor.hpp
index da8fa59f7b23e2c33274fc3c73ff797ac6214084..c8561f61c338abda228616c39329a55123856d97 100644
--- a/src/language/node_processor/BinaryExpressionProcessor.hpp
+++ b/src/language/node_processor/BinaryExpressionProcessor.hpp
@@ -156,8 +156,8 @@ class BinaryExpressionProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
-  PUGS_INLINE auto
-  _eval(const ASTNodeDataVariant& a, const ASTNodeDataVariant& b, ASTNodeDataVariant& value)
+  PUGS_INLINE ASTNodeDataVariant
+  _eval(const ASTNodeDataVariant& a, const ASTNodeDataVariant& b)
   {
     // Add 'signed' when necessary to avoid signed/unsigned comparison warnings
     if constexpr ((not(std::is_same_v<A_DataT, bool> or std::is_same_v<B_DataT, bool>)) and
@@ -171,18 +171,18 @@ class BinaryExpressionProcessor final : public INodeProcessor
       if constexpr (std::is_unsigned_v<A_DataT>) {
         using signed_A_DataT          = std::make_signed_t<A_DataT>;
         const signed_A_DataT signed_a = static_cast<signed_A_DataT>(std::get<A_DataT>(a));
-        value                         = BinOp<BinaryOpT>().eval(signed_a, std::get<B_DataT>(b));
+        return BinOp<BinaryOpT>().eval(signed_a, std::get<B_DataT>(b));
       } else {
         using signed_B_DataT          = std::make_signed_t<B_DataT>;
         const signed_B_DataT signed_b = static_cast<signed_B_DataT>(std::get<B_DataT>(b));
-        value                         = BinOp<BinaryOpT>().eval(std::get<A_DataT>(a), signed_b);
+        return BinOp<BinaryOpT>().eval(std::get<A_DataT>(a), signed_b);
       }
     } else {
       auto result = BinOp<BinaryOpT>().eval(std::get<A_DataT>(a), std::get<B_DataT>(b));
       if constexpr (std::is_same_v<decltype(result), int>) {
-        value = static_cast<int64_t>(result);
+        return static_cast<int64_t>(result);
       } else {
-        value = result;
+        return result;
       }
     }
   }
@@ -195,14 +195,13 @@ class BinaryExpressionProcessor final : public INodeProcessor
   }()};
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
     if constexpr (_is_defined) {
-      m_node.children[0]->execute(exec_policy);
-      m_node.children[1]->execute(exec_policy);
-
-      this->_eval(m_node.children[0]->m_value, m_node.children[1]->m_value, m_node.m_value);
+      return this->_eval(m_node.children[0]->execute(exec_policy), m_node.children[1]->execute(exec_policy));
+    } else {
+      return {};
     }
   }
 
diff --git a/src/language/node_processor/BreakProcessor.hpp b/src/language/node_processor/BreakProcessor.hpp
index e00bf861fa71ef7279fd64176d4ae00bc0d0a5a3..292184271ef45e3a250e9879b2e65416f3f8dc79 100644
--- a/src/language/node_processor/BreakProcessor.hpp
+++ b/src/language/node_processor/BreakProcessor.hpp
@@ -6,10 +6,11 @@
 class BreakProcessor final : public INodeProcessor
 {
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    exec_policy = ExecUntilBreakOrContinue(ExecUntilBreakOrContinue::JumpType::break_jump);
+    exec_policy = ExecutionPolicy(ExecutionPolicy::JumpType::break_jump, exec_policy.sharedContext());
+    return {};
   }
 
   BreakProcessor() = default;
diff --git a/src/language/node_processor/CFunctionProcessor.hpp b/src/language/node_processor/CFunctionProcessor.hpp
index 2cefd9def75403d2921f6807197ba89e73f34a26..55354f78828f65531b27d1b5f8b1f94635ad2410 100644
--- a/src/language/node_processor/CFunctionProcessor.hpp
+++ b/src/language/node_processor/CFunctionProcessor.hpp
@@ -12,45 +12,35 @@ class CFunctionArgumentProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_provided_value_node;
-  ASTNodeDataVariant& m_argument_value;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_provided_value_node.execute(exec_policy);
-
     if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
-      m_argument_value = m_provided_value_node.m_value;
+      return m_provided_value_node.execute(exec_policy);
     } else {
-      m_argument_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value));
+      return static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.execute(exec_policy)));
     }
   }
 
-  CFunctionArgumentProcessor(ASTNode& provided_value_node, ASTNodeDataVariant& argument_value)
-    : m_provided_value_node{provided_value_node}, m_argument_value{argument_value}
-  {}
+  CFunctionArgumentProcessor(ASTNode& provided_value_node) : m_provided_value_node{provided_value_node} {}
 };
 
 class CFunctionExpressionProcessor final : public INodeProcessor
 {
  private:
-  ASTNode& m_node;
-
   std::shared_ptr<ICFunctionEmbedder> m_embedded_c_function;
-  std::vector<ASTNodeDataVariant>& m_argument_values;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue&)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_embedded_c_function->apply(m_argument_values, m_node.m_value);
+    return m_embedded_c_function->apply(exec_policy.context());
   }
 
-  CFunctionExpressionProcessor(ASTNode& node,
-                               std::shared_ptr<ICFunctionEmbedder> embedded_c_function,
-                               std::vector<ASTNodeDataVariant>& argument_values)
-    : m_node{node}, m_embedded_c_function(embedded_c_function), m_argument_values{argument_values}
+  CFunctionExpressionProcessor(std::shared_ptr<ICFunctionEmbedder> embedded_c_function)
+    : m_embedded_c_function(embedded_c_function)
   {}
 };
 
@@ -60,22 +50,8 @@ class CFunctionProcessor : public INodeProcessor
   std::unique_ptr<INodeProcessor> m_function_expression_processor;
 
   std::vector<std::unique_ptr<INodeProcessor>> m_argument_processors;
-  std::vector<ASTNodeDataVariant> m_argument_values;
 
  public:
-  void
-  setNumberOfArguments(const size_t& number_of_arguments)
-  {
-    Assert(m_argument_values.size() == 0, "argument number has already been provided");
-    m_argument_values.resize(number_of_arguments);
-  }
-
-  std::vector<ASTNodeDataVariant>&
-  argumentValues()
-  {
-    return m_argument_values;
-  }
-
   void
   addArgumentProcessor(std::unique_ptr<INodeProcessor>&& argument_processor)
   {
@@ -88,15 +64,18 @@ class CFunctionProcessor : public INodeProcessor
     m_function_expression_processor = std::move(function_processor);
   }
 
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    Assert(m_argument_processors.size() == m_argument_values.size());
-    for (auto& argument_processor : m_argument_processors) {
-      argument_processor->execute(exec_policy);
+    ExecutionPolicy context_exec_policy{exec_policy.jumpType(),
+                                        std::make_shared<ExecutionPolicy::Context>(m_argument_processors.size())};
+    auto& argument_values = context_exec_policy.context();
+
+    for (size_t i = 0; i < argument_values.size(); ++i) {
+      argument_values[i] = m_argument_processors[i]->execute(context_exec_policy);
     }
 
-    m_function_expression_processor->execute(exec_policy);
+    return m_function_expression_processor->execute(context_exec_policy);
   }
 
   CFunctionProcessor() = default;
diff --git a/src/language/node_processor/ConcatExpressionProcessor.hpp b/src/language/node_processor/ConcatExpressionProcessor.hpp
index a8249560791c2ff02423d46ba4456c87bb904bb8..5f493b8d664b1f4515bac1cfa069b5d99ea8a531 100644
--- a/src/language/node_processor/ConcatExpressionProcessor.hpp
+++ b/src/language/node_processor/ConcatExpressionProcessor.hpp
@@ -9,24 +9,23 @@ class ConcatExpressionProcessor final : public INodeProcessor
  private:
   ASTNode& m_node;
 
-  PUGS_INLINE void
-  _eval(const std::string& a, const ASTNodeDataVariant& b, ASTNodeDataVariant& value)
+  PUGS_INLINE
+  ASTNodeDataVariant
+  _eval(const std::string& a, const ASTNodeDataVariant& b)
   {
     if constexpr (std::is_same_v<B_DataT, std::string>) {
-      value = a + std::get<B_DataT>(b);
+      return a + std::get<B_DataT>(b);
     } else {
-      value = a + std::to_string(std::get<B_DataT>(b));
+      return a + std::to_string(std::get<B_DataT>(b));
     }
   }
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_node.children[0]->execute(exec_policy);
-    m_node.children[1]->execute(exec_policy);
-
-    this->_eval(std::get<std::string>(m_node.children[0]->m_value), m_node.children[1]->m_value, m_node.m_value);
+    return this->_eval(std::get<std::string>(m_node.children[0]->execute(exec_policy)),
+                       m_node.children[1]->execute(exec_policy));
   }
 
   ConcatExpressionProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/ContinueProcessor.hpp b/src/language/node_processor/ContinueProcessor.hpp
index a6d64d3d527f12a8c22b005c3e5dde4704c7bc67..29cd31a4770d6677180fa9f0a5ad7766f6fac910 100644
--- a/src/language/node_processor/ContinueProcessor.hpp
+++ b/src/language/node_processor/ContinueProcessor.hpp
@@ -6,10 +6,11 @@
 class ContinueProcessor final : public INodeProcessor
 {
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    exec_policy = ExecUntilBreakOrContinue(ExecUntilBreakOrContinue::JumpType::continue_jump);
+    exec_policy = ExecutionPolicy(ExecutionPolicy::JumpType::continue_jump, exec_policy.sharedContext());
+    return {};
   }
 
   ContinueProcessor() = default;
diff --git a/src/language/node_processor/DoWhileProcessor.hpp b/src/language/node_processor/DoWhileProcessor.hpp
index 3a1a9d59bd485973e52ac60eb076efc003e89f4e..a9c8a200569211fee293630a8dbf1def1385d472 100644
--- a/src/language/node_processor/DoWhileProcessor.hpp
+++ b/src/language/node_processor/DoWhileProcessor.hpp
@@ -9,23 +9,24 @@ class DoWhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
     bool continuation_test = true;
-    ExecUntilBreakOrContinue exec_until_jump;
+    ExecutionPolicy exec_until_jump;
     do {
       m_node.children[0]->execute(exec_until_jump);
       if (not exec_until_jump.exec()) {
-        if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::break_jump) {
+        if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::break_jump) {
           break;
-        } else if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::continue_jump) {
-          exec_until_jump = ExecUntilBreakOrContinue{};   // getting ready for next loop traversal
+        } else if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::continue_jump) {
+          exec_until_jump = ExecutionPolicy{};   // getting ready for next loop traversal
         }
       }
-      m_node.children[1]->execute(exec_policy);
+
+      ;
       continuation_test = static_cast<bool>(std::visit(
-        [](const auto& value) -> bool {
+        [](auto&& value) -> bool {
           using T = std::decay_t<decltype(value)>;
           if constexpr (std::is_arithmetic_v<T>) {
             return value;
@@ -33,8 +34,9 @@ class DoWhileProcessor final : public INodeProcessor
             return false;   // LCOV_EXCL_LINE (unreachable: only there for compilation purpose)
           }
         },
-        m_node.children[1]->m_value));
+        m_node.children[1]->execute(exec_policy)));
     } while (continuation_test);
+    return {};
   }
 
   DoWhileProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/ExecUntilBreakOrContinue.hpp b/src/language/node_processor/ExecUntilBreakOrContinue.hpp
deleted file mode 100644
index c9aea0bc5bf7cbf037750d8dc3811e7f6fedbc2a..0000000000000000000000000000000000000000
--- a/src/language/node_processor/ExecUntilBreakOrContinue.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef EXEC_UNTIL_BREAK_OR_CONTINUE_HPP
-#define EXEC_UNTIL_BREAK_OR_CONTINUE_HPP
-
-#include <PugsMacros.hpp>
-
-struct ExecUntilBreakOrContinue
-{
-  enum class JumpType
-  {
-    no_jump,
-    break_jump,
-    continue_jump
-  };
-
- private:
-  JumpType m_jump_type;
-  bool m_exec;
-
- public:
-  PUGS_INLINE
-  bool
-  exec() const
-  {
-    return m_exec;
-  }
-
-  PUGS_INLINE
-  JumpType
-  jumpType() const
-  {
-    return m_jump_type;
-  }
-
-  ExecUntilBreakOrContinue& operator=(const ExecUntilBreakOrContinue&) = delete;
-  ExecUntilBreakOrContinue& operator=(ExecUntilBreakOrContinue&&) = default;
-
-  ExecUntilBreakOrContinue() : m_jump_type{JumpType::no_jump}, m_exec{true} {}
-
-  ExecUntilBreakOrContinue(const JumpType& jump_type) : m_jump_type(jump_type), m_exec((jump_type == JumpType::no_jump))
-  {
-    ;
-  }
-};
-
-#endif   // EXEC_UNTIL_BREAK_OR_CONTINUE_HPP
diff --git a/src/language/node_processor/ExecutionPolicy.hpp b/src/language/node_processor/ExecutionPolicy.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3374a694c0d4051150583c5fd861137c24d5146f
--- /dev/null
+++ b/src/language/node_processor/ExecutionPolicy.hpp
@@ -0,0 +1,70 @@
+#ifndef EXECUTION_POLICY_HPP
+#define EXECUTION_POLICY_HPP
+
+#include <PugsMacros.hpp>
+
+#include <ASTNodeDataVariant.hpp>
+
+#include <memory>
+#include <vector>
+
+class ExecutionPolicy
+{
+ public:
+  enum class JumpType
+  {
+    no_jump,
+    break_jump,
+    continue_jump
+  };
+
+  using Context       = std::vector<ASTNodeDataVariant>;
+  using SharedContext = std::shared_ptr<Context>;
+
+ private:
+  JumpType m_jump_type;
+  bool m_exec;
+
+  SharedContext m_shared_context;
+
+ public:
+  PUGS_INLINE
+  bool
+  exec() const
+  {
+    return m_exec;
+  }
+
+  PUGS_INLINE
+  JumpType
+  jumpType() const
+  {
+    return m_jump_type;
+  }
+
+  Context&
+  context()
+  {
+    Assert(m_shared_context);
+    return *m_shared_context;
+  }
+
+  SharedContext
+  sharedContext() const
+  {
+    return m_shared_context;
+  }
+
+  ExecutionPolicy& operator=(const ExecutionPolicy&) = delete;
+  ExecutionPolicy& operator=(ExecutionPolicy&&) = default;
+
+  ExecutionPolicy() : m_jump_type{JumpType::no_jump}, m_exec{true} {}
+
+  ExecutionPolicy(const JumpType& jump_type, const SharedContext& shared_context)
+    : m_jump_type{jump_type}, m_exec{jump_type == JumpType::no_jump}, m_shared_context{shared_context}
+  {
+    ;
+  }
+};
+
+#endif   // EXECUTION_POLICY_HPP
diff --git a/src/language/node_processor/FakeProcessor.hpp b/src/language/node_processor/FakeProcessor.hpp
index ac75d68ad6ae0f527c606025018a02f5ccb62530..a93af47de772c0ba3da421b6e42abe72c9c33ae4 100644
--- a/src/language/node_processor/FakeProcessor.hpp
+++ b/src/language/node_processor/FakeProcessor.hpp
@@ -6,10 +6,10 @@
 class FakeProcessor final : public INodeProcessor
 {
  public:
-  void
-  execute(ExecUntilBreakOrContinue&)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy&)
   {
-    ;
+    return {};
   }
 
   FakeProcessor() = default;
diff --git a/src/language/node_processor/ForProcessor.hpp b/src/language/node_processor/ForProcessor.hpp
index e06db01d08fd2cdf540f59be51f8fec0042f14e4..09362e7fa9110cd5da5843b1629d4d202b594b96 100644
--- a/src/language/node_processor/ForProcessor.hpp
+++ b/src/language/node_processor/ForProcessor.hpp
@@ -9,15 +9,14 @@ class ForProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    ExecUntilBreakOrContinue exec_until_jump;
+    ExecutionPolicy exec_until_jump;
     m_node.children[0]->execute(exec_policy);
     while ([&]() {
-      m_node.children[1]->execute(exec_policy);
       return static_cast<bool>(std::visit(
-        [](const auto& value) -> bool {
+        [](auto&& value) -> bool {
           using T = std::decay_t<decltype(value)>;
           if constexpr (std::is_arithmetic_v<T>) {
             return value;
@@ -25,19 +24,20 @@ class ForProcessor final : public INodeProcessor
             return false;   // LCOV_EXCL_LINE (unreachable: only there for compilation purpose)
           }
         },
-        m_node.children[1]->m_value));
+        m_node.children[1]->execute(exec_policy)));
     }()) {
       m_node.children[3]->execute(exec_until_jump);
       if (not exec_until_jump.exec()) {
-        if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::break_jump) {
+        if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::break_jump) {
           break;
-        } else if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::continue_jump) {
-          exec_until_jump = ExecUntilBreakOrContinue{};   // getting ready for next loop traversal
+        } else if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::continue_jump) {
+          exec_until_jump = ExecutionPolicy{};   // getting ready for next loop traversal
         }
       }
 
       m_node.children[2]->execute(exec_policy);
     }
+    return {};
   }
 
   ForProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp
index ccc7ce560b9ca09213dd4a8aebc796dfea66442b..e2759e260498ac5fc9bc2758facb2e09b95f9ce5 100644
--- a/src/language/node_processor/FunctionProcessor.hpp
+++ b/src/language/node_processor/FunctionProcessor.hpp
@@ -12,26 +12,29 @@ template <typename ExpectedValueType, typename ProvidedValueType>
 class FunctionArgumentProcessor final : public INodeProcessor
 {
  private:
-  ASTNodeDataVariant& m_symbol_value;
+  size_t m_symbol_id;
   ASTNode& m_provided_value_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_provided_value_node.execute(exec_policy);
+    ;
 
     if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
-      m_symbol_value = m_provided_value_node.m_value;
+      exec_policy.context()[m_symbol_id] = m_provided_value_node.execute(exec_policy);
     } else if constexpr (std::is_same_v<ExpectedValueType, std::string>) {
-      m_symbol_value = std::to_string(std::get<ProvidedValueType>(m_provided_value_node.m_value));
+      exec_policy.context()[m_symbol_id] =
+        std::to_string(std::get<ProvidedValueType>(m_provided_value_node.execute(exec_policy)));
     } else {
-      m_symbol_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value));
+      exec_policy.context()[m_symbol_id] =
+        static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.execute(exec_policy)));
     }
+    return {};
   }
 
   FunctionArgumentProcessor(SymbolTable::Symbol& argument_symbol, ASTNode& provided_value_node)
-    : m_symbol_value{argument_symbol.attributes().value()}, m_provided_value_node{provided_value_node}
+    : m_symbol_id{std::get<size_t>(argument_symbol.attributes().value())}, m_provided_value_node{provided_value_node}
   {}
 };
 
@@ -39,32 +42,31 @@ template <typename ReturnType, typename ExpressionValueType>
 class FunctionExpressionProcessor final : public INodeProcessor
 {
  private:
-  ASTNodeDataVariant& m_value;
   ASTNode& m_function_expression;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_function_expression.execute(exec_policy);
-
     if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) {
-      m_value = m_function_expression.m_value;
+      return m_function_expression.execute(exec_policy);
     } else if constexpr (std::is_same_v<ReturnType, std::string>) {
-      m_value = std::to_string(std::get<ExpressionValueType>(m_function_expression.m_value));
+      return std::to_string(std::get<ExpressionValueType>(m_function_expression.execute(exec_policy)));
     } else {
-      m_value = static_cast<ReturnType>(std::get<ExpressionValueType>(m_function_expression.m_value));
+      return static_cast<ReturnType>(std::get<ExpressionValueType>(m_function_expression.execute(exec_policy)));
     }
   }
 
-  FunctionExpressionProcessor(ASTNode& function_component_expression, ASTNodeDataVariant& value)
-    : m_value{value}, m_function_expression{function_component_expression}
+  FunctionExpressionProcessor(ASTNode& function_component_expression)
+    : m_function_expression{function_component_expression}
   {}
 };
 
 class FunctionProcessor : public INodeProcessor
 {
  private:
+  const size_t m_context_size;
+
   std::vector<std::unique_ptr<INodeProcessor>> m_argument_processors;
   std::vector<std::unique_ptr<INodeProcessor>> m_function_expression_processors;
 
@@ -81,19 +83,29 @@ class FunctionProcessor : public INodeProcessor
     m_function_expression_processors.emplace_back(std::move(function_processor));
   }
 
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
+    ExecutionPolicy context_exec_policy{exec_policy.jumpType(),
+                                        std::make_shared<ExecutionPolicy::Context>(m_context_size)};
+
     for (auto& argument_processor : m_argument_processors) {
-      argument_processor->execute(exec_policy);
+      argument_processor->execute(context_exec_policy);
     }
 
-    for (auto& function_expression_processor : m_function_expression_processors) {
-      function_expression_processor->execute(exec_policy);
+#warning ugly: should define special case for multi-valued functions
+    if (m_function_expression_processors.size() == 1) {
+      return m_function_expression_processors[0]->execute(context_exec_policy);
+    } else {
+      for (auto& function_expression_processor : m_function_expression_processors) {
+        function_expression_processor->execute(context_exec_policy);
+      }
+#warning incorrect return value
+      return {};
     }
   }
 
-  FunctionProcessor() = default;
+  FunctionProcessor(const size_t& context_size) : m_context_size{context_size} {}
 };
 
 #endif   // FUNCTION_PROCESSOR_HPP
diff --git a/src/language/node_processor/INodeProcessor.hpp b/src/language/node_processor/INodeProcessor.hpp
index 7c582b491fcb2b2a3a92b82d0433125a3b0f7c29..90317538397c689416c3bbbcdd8c9b0186daf6f4 100644
--- a/src/language/node_processor/INodeProcessor.hpp
+++ b/src/language/node_processor/INodeProcessor.hpp
@@ -2,14 +2,16 @@
 #define I_NODE_PROCESSOR_HPP
 
 #include <Demangle.hpp>
-#include <node_processor/ExecUntilBreakOrContinue.hpp>
+#include <node_processor/ExecutionPolicy.hpp>
 
 #include <string>
 #include <typeinfo>
 
+#include <ASTNodeDataVariant.hpp>
+
 struct INodeProcessor
 {
-  virtual void execute(ExecUntilBreakOrContinue& exec_policy) = 0;
+  virtual ASTNodeDataVariant execute(ExecutionPolicy& exec_policy) = 0;
 
   std::string
   typeIdName() const
diff --git a/src/language/node_processor/IfProcessor.hpp b/src/language/node_processor/IfProcessor.hpp
index 46d6777241178e399242f51307d2caafead46ae9..c7c735162ccfc3b3b85ce9e704de87ef22860116 100644
--- a/src/language/node_processor/IfProcessor.hpp
+++ b/src/language/node_processor/IfProcessor.hpp
@@ -9,10 +9,9 @@ class IfProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_node.children[0]->execute(exec_policy);
     const bool is_true = static_cast<bool>(std::visit(   // LCOV_EXCL_LINE (false negative)
       [](const auto& value) -> bool {
         using T = std::decay_t<decltype(value)>;
@@ -22,7 +21,7 @@ class IfProcessor final : public INodeProcessor
           return false;   // LCOV_EXCL_LINE (unreachable: only there for compilation purpose)
         }
       },
-      m_node.children[0]->m_value));
+      m_node.children[0]->execute(exec_policy)));
     if (is_true) {
       Assert(m_node.children[1] != nullptr);
       m_node.children[1]->execute(exec_policy);
@@ -33,6 +32,8 @@ class IfProcessor final : public INodeProcessor
         m_node.children[2]->execute(exec_policy);
       }
     }
+
+    return {};
   }
 
   IfProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/IncDecExpressionProcessor.hpp b/src/language/node_processor/IncDecExpressionProcessor.hpp
index 7eccb590e9122ebf71f490cd61f2e537cccf620a..91f8259490ff3636efb3f606c84a9cfdb103355a 100644
--- a/src/language/node_processor/IncDecExpressionProcessor.hpp
+++ b/src/language/node_processor/IncDecExpressionProcessor.hpp
@@ -60,10 +60,10 @@ class IncDecExpressionProcessor final : public INodeProcessor
   ASTNodeDataVariant* p_value{nullptr};
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue&)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy&)
   {
-    m_node.m_value = IncDecOp<IncDecOpT>().eval(std::get<DataT>(*p_value));
+    return IncDecOp<IncDecOpT>().eval(std::get<DataT>(*p_value));
   }
 
   IncDecExpressionProcessor(ASTNode& node) : m_node{node}
diff --git a/src/language/node_processor/LocalNameProcessor.hpp b/src/language/node_processor/LocalNameProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6076fc37910248f39e9107120cc67bb6d05c431b
--- /dev/null
+++ b/src/language/node_processor/LocalNameProcessor.hpp
@@ -0,0 +1,31 @@
+#ifndef LOCAL_NODE_PROCESSOR_HPP
+#define LOCAL_NODE_PROCESSOR_HPP
+
+#include <node_processor/INodeProcessor.hpp>
+
+#include <ASTNode.hpp>
+#include <SymbolTable.hpp>
+
+class LocalNameProcessor final : public INodeProcessor
+{
+ private:
+  ASTNode& m_node;
+  uint64_t m_value_id;
+
+ public:
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
+  {
+    return exec_policy.context()[m_value_id];
+  }
+
+  LocalNameProcessor(ASTNode& node) : m_node{node}
+  {
+    const std::string& symbol = m_node.string();
+    auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.begin());
+    Assert(found);
+    m_value_id = std::get<uint64_t>(i_symbol->attributes().value());
+  }
+};
+
+#endif   // LOCAL_NODE_PROCESSOR_HPP
diff --git a/src/language/node_processor/NameProcessor.hpp b/src/language/node_processor/NameProcessor.hpp
index edb5d026cb2646d5bdb509955c460059e8b425cc..c9515d7e97c13afdc77cd7bcb3b873a8e0cc014c 100644
--- a/src/language/node_processor/NameProcessor.hpp
+++ b/src/language/node_processor/NameProcessor.hpp
@@ -13,10 +13,10 @@ class NameProcessor final : public INodeProcessor
   ASTNodeDataVariant* p_value{nullptr};
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue&)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy&)
   {
-    m_node.m_value = *p_value;
+    return *p_value;
   }
 
   NameProcessor(ASTNode& node) : m_node{node}
diff --git a/src/language/node_processor/OStreamProcessor.hpp b/src/language/node_processor/OStreamProcessor.hpp
index 615047e553b9fe105a80c1b84f959aafd4612cb4..3ce3ca063260782cd3f30bc8334728bf433ff040 100644
--- a/src/language/node_processor/OStreamProcessor.hpp
+++ b/src/language/node_processor/OStreamProcessor.hpp
@@ -10,11 +10,10 @@ class OStreamProcessor final : public INodeProcessor
   std::ostream& m_os;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
     for (size_t i = 0; i < m_node.children.size(); ++i) {
-      m_node.children[i]->execute(exec_policy);
       std::visit(
         [&](auto&& value) {
           using ValueT = std::decay_t<decltype(value)>;
@@ -26,8 +25,10 @@ class OStreamProcessor final : public INodeProcessor
             }
           }
         },
-        m_node.children[i]->m_value);
+        m_node.children[i]->execute(exec_policy));
     }
+
+    return {};
   }
 
   OStreamProcessor(ASTNode& node, std::ostream& os) : m_node{node}, m_os(os)
diff --git a/src/language/node_processor/UnaryExpressionProcessor.hpp b/src/language/node_processor/UnaryExpressionProcessor.hpp
index 8f53bd09ea3c8acf42d7007745011edaf9f6817b..7e5c539160003aa11b8f979181630e5c1719074b 100644
--- a/src/language/node_processor/UnaryExpressionProcessor.hpp
+++ b/src/language/node_processor/UnaryExpressionProcessor.hpp
@@ -43,11 +43,10 @@ class UnaryExpressionProcessor final : public INodeProcessor
   }
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    m_node.children[0]->execute(exec_policy);
-    m_node.m_value = this->_eval(m_node.children[0]->m_value);
+    return this->_eval(m_node.children[0]->execute(exec_policy));
   }
 
   UnaryExpressionProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/ValueProcessor.hpp b/src/language/node_processor/ValueProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..134726f7b847f5f02825308427866c5fc1ba672b
--- /dev/null
+++ b/src/language/node_processor/ValueProcessor.hpp
@@ -0,0 +1,48 @@
+#ifndef VALUE_PROCESSOR_HPP
+#define VALUE_PROCESSOR_HPP
+
+#include <PEGGrammar.hpp>
+#include <node_processor/INodeProcessor.hpp>
+
+#include <EscapedString.hpp>
+
+class ValueProcessor final : public INodeProcessor
+{
+ private:
+  ASTNodeDataVariant m_value;
+
+ public:
+  PUGS_INLINE
+  ASTNodeDataVariant
+  execute(ExecutionPolicy&)
+  {
+    return m_value;
+  }
+
+  ValueProcessor(ASTNode& node)
+  {
+    if (node.is_type<language::real>()) {
+      std::stringstream ss(node.string());
+      double v;
+      ss >> v;
+      m_value = v;
+    } else if (node.is_type<language::integer>()) {
+      std::stringstream ss(node.string());
+      int64_t v;
+      ss >> v;
+      m_value = v;
+    } else if (node.is_type<language::literal>()) {
+      m_value = unescapeString(node.string());
+    } else if (node.is_type<language::for_test>()) {
+      // if AST contains a for_test statement, it means that no test were
+      // given to the for-loop, so its value is always true
+      m_value = true;
+    } else if (node.is_type<language::true_kw>()) {
+      m_value = true;
+    } else if (node.is_type<language::false_kw>()) {
+      m_value = false;
+    }
+  }
+};
+
+#endif   // VALUE_PROCESSOR_HPP
diff --git a/src/language/node_processor/WhileProcessor.hpp b/src/language/node_processor/WhileProcessor.hpp
index 1a180f20dcd428b912d8aef44d283c587adf2fe9..3f66194bf5ae89fca0150e43241262b19f4c4312 100644
--- a/src/language/node_processor/WhileProcessor.hpp
+++ b/src/language/node_processor/WhileProcessor.hpp
@@ -9,12 +9,11 @@ class WhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  void
-  execute(ExecUntilBreakOrContinue& exec_policy)
+  ASTNodeDataVariant
+  execute(ExecutionPolicy& exec_policy)
   {
-    ExecUntilBreakOrContinue exec_until_jump;
+    ExecutionPolicy exec_until_jump;
     while ([&]() {
-      m_node.children[0]->execute(exec_policy);
       return static_cast<bool>(std::visit(
         [](const auto& value) -> bool {
           using T = std::decay_t<decltype(value)>;
@@ -24,17 +23,19 @@ class WhileProcessor final : public INodeProcessor
             return false;   // LCOV_EXCL_LINE (unreachable: only there for compilation purpose)
           }
         },
-        m_node.children[0]->m_value));
+        m_node.children[0]->execute(exec_policy)));
     }()) {
       m_node.children[1]->execute(exec_until_jump);
       if (not exec_until_jump.exec()) {
-        if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::break_jump) {
+        if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::break_jump) {
           break;
-        } else if (exec_until_jump.jumpType() == ExecUntilBreakOrContinue::JumpType::continue_jump) {
-          exec_until_jump = ExecUntilBreakOrContinue{};   // getting ready for next loop traversal
+        } else if (exec_until_jump.jumpType() == ExecutionPolicy::JumpType::continue_jump) {
+          exec_until_jump = ExecutionPolicy{};   // getting ready for next loop traversal
         }
       }
     }
+
+    return {};
   }
 
   WhileProcessor(ASTNode& node) : m_node{node} {}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 48856c05eb60139334a2f09e704bc4b64cb98522..11242857c4741c0732c8f764fde4cc6d894595a1 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -27,7 +27,6 @@ add_executable (unit_tests
   test_ASTNodeListProcessor.cpp
   test_ASTNodeTypeCleaner.cpp
   test_ASTNodeUnaryOperatorExpressionBuilder.cpp
-  test_ASTNodeValueBuilder.cpp
   test_ASTPrinter.cpp
   test_ASTSymbolTableBuilder.cpp
   test_ASTSymbolInitializationChecker.cpp
@@ -45,7 +44,7 @@ add_executable (unit_tests
   test_ConcatExpressionProcessor.cpp
   test_CRSMatrix.cpp
   test_DoWhileProcessor.cpp
-  test_ExecUntilBreakOrContinue.cpp
+  test_ExecutionPolicy.cpp
   test_FakeProcessor.cpp
   test_ForProcessor.cpp
   test_FunctionProcessor.cpp
diff --git a/tests/test_ASTModulesImporter.cpp b/tests/test_ASTModulesImporter.cpp
index a8592778375a315bd43158101949166686502e51..a2fed9058f307296fc83781dd568e33290620ad4 100644
--- a/tests/test_ASTModulesImporter.cpp
+++ b/tests/test_ASTModulesImporter.cpp
@@ -23,7 +23,7 @@
     ASTNodeTypeCleaner<language::import_instruction>{*ast};                                         \
                                                                                                     \
     ASTNodeExpressionBuilder{*ast};                                                                 \
-    ExecUntilBreakOrContinue exec_policy;                                                           \
+    ExecutionPolicy exec_policy;                                                                    \
     ast->execute(exec_policy);                                                                      \
                                                                                                     \
     std::stringstream ast_output;                                                                   \
diff --git a/tests/test_ASTNode.cpp b/tests/test_ASTNode.cpp
index 4505c8664b5258a9d9b21c67e920d8ddbd3a8b5f..a8366f4b1a7d79316e2b88e0adee049fd8a26a1e 100644
--- a/tests/test_ASTNode.cpp
+++ b/tests/test_ASTNode.cpp
@@ -12,7 +12,7 @@ TEST_CASE("ASTNode", "[language]")
   SECTION("execute")
   {
     ASTNode ast_node;
-    ExecUntilBreakOrContinue exec_policy;
+    ExecutionPolicy exec_policy;
 
 #ifndef NDEBUG
     REQUIRE_THROWS(ast_node.execute(exec_policy));
@@ -26,7 +26,7 @@ TEST_CASE("ASTNode", "[language]")
   SECTION("name")
   {
     ASTNode ast_node;
-    ExecUntilBreakOrContinue exec_policy;
+    ExecutionPolicy exec_policy;
 
     ast_node.set_type<language::name>();
 
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index cdceab4538c075bfc3d34ec69db2fdc1871f795b..4883f0995d4c214f79c9bcbbf24146da3a517404 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -31,7 +29,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -62,7 +59,7 @@ B b=true;
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -129,7 +126,7 @@ N n=true;
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, bool>)
      +-(language::name:n:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -194,7 +191,6 @@ N n="foo";
 
         ASTSymbolTableBuilder{*ast};
         ASTNodeDataTypeBuilder{*ast};
-        ASTNodeValueBuilder{*ast};
 
         ASTNodeDeclarationToAffectationConverter{*ast};
         ASTNodeTypeCleaner<language::declaration>{*ast};
@@ -215,7 +211,7 @@ Z z=true;
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, long, bool>)
      +-(language::name:z:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -280,7 +276,6 @@ Z z="foo";
 
         ASTSymbolTableBuilder{*ast};
         ASTNodeDataTypeBuilder{*ast};
-        ASTNodeValueBuilder{*ast};
 
         ASTNodeDeclarationToAffectationConverter{*ast};
         ASTNodeTypeCleaner<language::declaration>{*ast};
@@ -301,7 +296,7 @@ R r=true;
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, double, bool>)
      +-(language::name:r:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -366,7 +361,6 @@ R r="foo";
 
         ASTSymbolTableBuilder{*ast};
         ASTNodeDataTypeBuilder{*ast};
-        ASTNodeValueBuilder{*ast};
 
         ASTNodeDeclarationToAffectationConverter{*ast};
         ASTNodeTypeCleaner<language::declaration>{*ast};
@@ -388,7 +382,7 @@ string s=true;
  `-(language::eq_op:AffectationProcessor<language::eq_op, )" +
                              demangled_stdstring + R"(, bool>)
      +-(language::name:s:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -458,7 +452,7 @@ string s="foo";
  `-(language::eq_op:AffectationProcessor<language::eq_op, )" +
                              demangled_stdstring + ", " + demangled_stdstring + R"( >)
      +-(language::name:s:NameProcessor)
-     `-(language::literal:"foo":FakeProcessor)
+     `-(language::literal:"foo":ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -478,7 +472,7 @@ N n=1; n+=n;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:n:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::pluseq_op:AffectationProcessor<language::pluseq_op, unsigned long, unsigned long>)
      +-(language::name:n:NameProcessor)
      `-(language::name:n:NameProcessor)
@@ -497,10 +491,10 @@ R x=1; x+=2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::pluseq_op:AffectationProcessor<language::pluseq_op, double, long>)
      +-(language::name:x:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -517,12 +511,12 @@ string s="foo"; s+=2;
  +-(language::eq_op:AffectationProcessor<language::eq_op, )" +
                            demangled_stdstring + ", " + demangled_stdstring + R"( >)
  |   +-(language::name:s:NameProcessor)
- |   `-(language::literal:"foo":FakeProcessor)
+ |   `-(language::literal:"foo":ValueProcessor)
  `-(language::pluseq_op:AffectationProcessor<language::pluseq_op, )" +
                            demangled_stdstring +
                            R"(, long>)
      +-(language::name:s:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -541,10 +535,10 @@ Z z=1; z-=2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:z:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::minuseq_op:AffectationProcessor<language::minuseq_op, long, long>)
      +-(language::name:z:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -560,10 +554,10 @@ R x=1; x-=2.3;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::minuseq_op:AffectationProcessor<language::minuseq_op, double, double>)
      +-(language::name:x:NameProcessor)
-     `-(language::real:2.3:FakeProcessor)
+     `-(language::real:2.3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -580,7 +574,6 @@ string s="foo"; s-="bar";
 
       ASTSymbolTableBuilder{*ast};
       ASTNodeDataTypeBuilder{*ast};
-      ASTNodeValueBuilder{*ast};
 
       ASTNodeDeclarationToAffectationConverter{*ast};
       ASTNodeTypeCleaner<language::declaration>{*ast};
@@ -601,10 +594,10 @@ Z z=1; z*=2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:z:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::multiplyeq_op:AffectationProcessor<language::multiplyeq_op, long, long>)
      +-(language::name:z:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -620,10 +613,10 @@ R x=1; x*=2.3;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::multiplyeq_op:AffectationProcessor<language::multiplyeq_op, double, double>)
      +-(language::name:x:NameProcessor)
-     `-(language::real:2.3:FakeProcessor)
+     `-(language::real:2.3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -640,7 +633,6 @@ string s="foo"; s*=2;
 
       ASTSymbolTableBuilder{*ast};
       ASTNodeDataTypeBuilder{*ast};
-      ASTNodeValueBuilder{*ast};
 
       ASTNodeDeclarationToAffectationConverter{*ast};
       ASTNodeTypeCleaner<language::declaration>{*ast};
@@ -661,10 +653,10 @@ Z z=6; z/=2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:z:NameProcessor)
- |   `-(language::integer:6:FakeProcessor)
+ |   `-(language::integer:6:ValueProcessor)
  `-(language::divideeq_op:AffectationProcessor<language::divideeq_op, long, long>)
      +-(language::name:z:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -680,10 +672,10 @@ R x=1; x/=2.3;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::divideeq_op:AffectationProcessor<language::divideeq_op, double, double>)
      +-(language::name:x:NameProcessor)
-     `-(language::real:2.3:FakeProcessor)
+     `-(language::real:2.3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -700,7 +692,6 @@ string s="foo"; s/="bar";
 
       ASTSymbolTableBuilder{*ast};
       ASTNodeDataTypeBuilder{*ast};
-      ASTNodeValueBuilder{*ast};
 
       ASTNodeDeclarationToAffectationConverter{*ast};
       ASTNodeTypeCleaner<language::declaration>{*ast};
diff --git a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
index 1bff3eb40a8deea19c13160c68556a7687637dbe..22a93e75b7fd69397742cc0a044e83df1f8bff4b 100644
--- a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -31,7 +29,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -54,7 +51,6 @@
                                                                                                 \
     ASTSymbolTableBuilder{*ast};                                                                \
     ASTNodeDataTypeBuilder{*ast};                                                               \
-    ASTNodeValueBuilder{*ast};                                                                  \
                                                                                                 \
     ASTNodeDeclarationToAffectationConverter{*ast};                                             \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                            \
@@ -78,12 +74,12 @@ false*b*true;
 (root:ASTNodeListProcessor)
  +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, bool>)
      +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -121,7 +117,7 @@ a*3*a;
  `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
      +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -139,10 +135,10 @@ a*3*a;
  `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, bool>)
      +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, long>)
      |   +-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -163,12 +159,12 @@ false/b/true;
 (root:ASTNodeListProcessor)
  +-(language::divide_op:BinaryExpressionProcessor<language::divide_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::divide_op:BinaryExpressionProcessor<language::divide_op, long, bool>)
      +-(language::divide_op:BinaryExpressionProcessor<language::divide_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -206,7 +202,7 @@ a/3/a;
  `-(language::divide_op:BinaryExpressionProcessor<language::divide_op, long, long>)
      +-(language::divide_op:BinaryExpressionProcessor<language::divide_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -224,10 +220,10 @@ a/3/a;
  `-(language::divide_op:BinaryExpressionProcessor<language::divide_op, double, bool>)
      +-(language::divide_op:BinaryExpressionProcessor<language::divide_op, double, long>)
      |   +-(language::divide_op:BinaryExpressionProcessor<language::divide_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -248,12 +244,12 @@ false+b+true;
 (root:ASTNodeListProcessor)
  +-(language::plus_op:BinaryExpressionProcessor<language::plus_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, long, bool>)
      +-(language::plus_op:BinaryExpressionProcessor<language::plus_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -291,7 +287,7 @@ a+3+a;
  `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, long, long>)
      +-(language::plus_op:BinaryExpressionProcessor<language::plus_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -309,10 +305,10 @@ a+3+a;
  `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, double, bool>)
      +-(language::plus_op:BinaryExpressionProcessor<language::plus_op, double, long>)
      |   +-(language::plus_op:BinaryExpressionProcessor<language::plus_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -327,8 +323,8 @@ a+3+a;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::plus_op:ConcatExpressionProcessor<bool>)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::true_kw:FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -345,9 +341,9 @@ N n=0;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:n:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::plus_op:ConcatExpressionProcessor<unsigned long>)
-     +-(language::literal:"foo":FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
      `-(language::name:n:NameProcessor)
 )";
 
@@ -363,8 +359,8 @@ N n=0;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::plus_op:ConcatExpressionProcessor<long>)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::integer:1:FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -379,8 +375,8 @@ N n=0;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::plus_op:ConcatExpressionProcessor<double>)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -398,8 +394,8 @@ N n=0;
 (root:ASTNodeListProcessor)
  `-(language::plus_op:ConcatExpressionProcessor<)" +
                            string_name + R"( >)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::literal:"bar":FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::literal:"bar":ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -420,12 +416,12 @@ false-b-true;
 (root:ASTNodeListProcessor)
  +-(language::minus_op:BinaryExpressionProcessor<language::minus_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, long, bool>)
      +-(language::minus_op:BinaryExpressionProcessor<language::minus_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -463,7 +459,7 @@ a-3-a;
  `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, long, long>)
      +-(language::minus_op:BinaryExpressionProcessor<language::minus_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -481,10 +477,10 @@ a-3-a;
  `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, double, bool>)
      +-(language::minus_op:BinaryExpressionProcessor<language::minus_op, double, long>)
      |   +-(language::minus_op:BinaryExpressionProcessor<language::minus_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -505,12 +501,12 @@ false or b or true;
 (root:ASTNodeListProcessor)
  +-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, bool>)
      +-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -548,7 +544,7 @@ a or 3 or a;
  `-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, long>)
      +-(language::or_op:BinaryExpressionProcessor<language::or_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -566,10 +562,10 @@ a or 3 or a;
  `-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, bool>)
      +-(language::or_op:BinaryExpressionProcessor<language::or_op, bool, long>)
      |   +-(language::or_op:BinaryExpressionProcessor<language::or_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -590,12 +586,12 @@ false and b and true;
 (root:ASTNodeListProcessor)
  +-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, bool>)
      +-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -633,7 +629,7 @@ a and 3 and a;
  `-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, long>)
      +-(language::and_op:BinaryExpressionProcessor<language::and_op, long, long>)
      |   +-(language::name:a:NameProcessor)
-     |   `-(language::integer:3:FakeProcessor)
+     |   `-(language::integer:3:ValueProcessor)
      `-(language::name:a:NameProcessor)
 )";
 
@@ -651,10 +647,10 @@ a and 3 and a;
  `-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, bool>)
      +-(language::and_op:BinaryExpressionProcessor<language::and_op, bool, long>)
      |   +-(language::and_op:BinaryExpressionProcessor<language::and_op, double, double>)
-     |   |   +-(language::real:2.3:FakeProcessor)
-     |   |   `-(language::real:1.2:FakeProcessor)
-     |   `-(language::integer:2:FakeProcessor)
-     `-(language::false_kw:FakeProcessor)
+     |   |   +-(language::real:2.3:ValueProcessor)
+     |   |   `-(language::real:1.2:ValueProcessor)
+     |   `-(language::integer:2:ValueProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -675,12 +671,12 @@ false xor b xor true;
 (root:ASTNodeListProcessor)
  +-(language::xor_op:BinaryExpressionProcessor<language::xor_op, bool, bool>)
  |   +-(language::name:b:NameProcessor)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::xor_op:BinaryExpressionProcessor<language::xor_op, bool, bool>)
      +-(language::xor_op:BinaryExpressionProcessor<language::xor_op, bool, bool>)
-     |   +-(language::false_kw:FakeProcessor)
+     |   +-(language::false_kw:ValueProcessor)
      |   `-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -717,7 +713,7 @@ a xor 3;
 (root:ASTNodeListProcessor)
  `-(language::xor_op:BinaryExpressionProcessor<language::xor_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -747,7 +743,7 @@ b > true;
 (root:ASTNodeListProcessor)
  `-(language::greater_op:BinaryExpressionProcessor<language::greater_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -782,7 +778,7 @@ a > 3;
 (root:ASTNodeListProcessor)
  `-(language::greater_op:BinaryExpressionProcessor<language::greater_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -797,8 +793,8 @@ a > 3;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::greater_op:BinaryExpressionProcessor<language::greater_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -818,7 +814,7 @@ b < true;
 (root:ASTNodeListProcessor)
  `-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -853,7 +849,7 @@ a < 3;
 (root:ASTNodeListProcessor)
  `-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -868,8 +864,8 @@ a < 3;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -888,7 +884,7 @@ b >= true;
 (root:ASTNodeListProcessor)
  `-(language::greater_or_eq_op:BinaryExpressionProcessor<language::greater_or_eq_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -923,7 +919,7 @@ a >= 3;
 (root:ASTNodeListProcessor)
  `-(language::greater_or_eq_op:BinaryExpressionProcessor<language::greater_or_eq_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -938,8 +934,8 @@ a >= 3;
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::greater_or_eq_op:BinaryExpressionProcessor<language::greater_or_eq_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -959,7 +955,7 @@ b <= true;
 (root:ASTNodeListProcessor)
  `-(language::lesser_or_eq_op:BinaryExpressionProcessor<language::lesser_or_eq_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -994,7 +990,7 @@ a <= 3;
 (root:ASTNodeListProcessor)
  `-(language::lesser_or_eq_op:BinaryExpressionProcessor<language::lesser_or_eq_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1009,8 +1005,8 @@ a <= 3;
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::lesser_or_eq_op:BinaryExpressionProcessor<language::lesser_or_eq_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1030,7 +1026,7 @@ b == true;
 (root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1065,7 +1061,7 @@ a == 3;
 (root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1080,8 +1076,8 @@ a == 3;
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1099,8 +1095,8 @@ a == 3;
 (root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, )" +
                              string_name + ", " + string_name + R"( >)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::literal:"bar":FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::literal:"bar":ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1120,7 +1116,7 @@ b != true;
 (root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, bool, bool>)
      +-(language::name:b:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1155,7 +1151,7 @@ a != 3;
 (root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, long, long>)
      +-(language::name:a:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1170,8 +1166,8 @@ a != 3;
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, double, double>)
-     +-(language::real:2.3:FakeProcessor)
-     `-(language::real:1.2:FakeProcessor)
+     +-(language::real:2.3:ValueProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -1189,8 +1185,8 @@ a != 3;
 (root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, )" +
                              string_name + ", " + string_name + R"( >)
-     +-(language::literal:"foo":FakeProcessor)
-     `-(language::literal:"bar":FakeProcessor)
+     +-(language::literal:"foo":ValueProcessor)
+     `-(language::literal:"bar":ValueProcessor)
 )";
 
         CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeCFunctionExpressionBuilder.cpp b/tests/test_ASTNodeCFunctionExpressionBuilder.cpp
index 7ce9f1f32823a46f97b8f44e2b55fe1b9cd77ed5..da62df5a0e1e9d2adf4b6ba53d5673e428fa7e2c 100644
--- a/tests/test_ASTNodeCFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeCFunctionExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -101,7 +99,6 @@ class CFunctionRegister
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
     ASTNodeExpressionBuilder{*ast};                                                                 \
@@ -125,7 +122,6 @@ class CFunctionRegister
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
     REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, Catch::Matchers::Contains(expected_error)); \
@@ -145,7 +141,7 @@ RtoR(1.);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:RtoR:NameProcessor)
-     `-(language::real:1.:FakeProcessor)
+     `-(language::real:1.:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -161,7 +157,7 @@ RtoR(1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:RtoR:NameProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -194,7 +190,7 @@ RtoR(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:RtoR:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -213,7 +209,7 @@ ZtoR(1.);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:ZtoR:NameProcessor)
-     `-(language::real:1.:FakeProcessor)
+     `-(language::real:1.:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -229,7 +225,7 @@ ZtoR(1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:ZtoR:NameProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -262,7 +258,7 @@ ZtoR(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:ZtoR:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -281,7 +277,7 @@ NtoR(1.);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:NtoR:NameProcessor)
-     `-(language::real:1.:FakeProcessor)
+     `-(language::real:1.:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -297,7 +293,7 @@ NtoR(1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:NtoR:NameProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -330,7 +326,7 @@ NtoR(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:NtoR:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -349,7 +345,7 @@ BtoR(1.);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:BtoR:NameProcessor)
-     `-(language::real:1.:FakeProcessor)
+     `-(language::real:1.:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -365,7 +361,7 @@ BtoR(1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:BtoR:NameProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -398,7 +394,7 @@ BtoR(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:BtoR:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -416,8 +412,8 @@ R2toB(1., 0.);
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:R2toB:NameProcessor)
      `-(language::function_argument_list:FakeProcessor)
-         +-(language::real:1.:FakeProcessor)
-         `-(language::real:0.:FakeProcessor)
+         +-(language::real:1.:ValueProcessor)
+         `-(language::real:0.:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeDeclarationToAffectationConverter.cpp b/tests/test_ASTNodeDeclarationToAffectationConverter.cpp
index c1226f3ee39f85df006fd8934c13ee9280b08618..5d9503d9b5c00c6303a39bed5ba1342a0a53a536 100644
--- a/tests/test_ASTNodeDeclarationToAffectationConverter.cpp
+++ b/tests/test_ASTNodeDeclarationToAffectationConverter.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -21,7 +19,6 @@
                                                                                                \
     ASTSymbolTableBuilder{*ast};                                                               \
     ASTNodeDataTypeBuilder{*ast};                                                              \
-    ASTNodeValueBuilder{*ast};                                                                 \
                                                                                                \
     ASTNodeDeclarationToAffectationConverter{*ast};                                            \
                                                                                                \
diff --git a/tests/test_ASTNodeEmptyBlockCleaner.cpp b/tests/test_ASTNodeEmptyBlockCleaner.cpp
index f1076d45e8ba60f85a79af24377d05f336ac0240..5a804866221d38e0192075b26dc0dc9e0722959c 100644
--- a/tests/test_ASTNodeEmptyBlockCleaner.cpp
+++ b/tests/test_ASTNodeEmptyBlockCleaner.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -31,7 +29,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -72,7 +69,7 @@ TEST_CASE("ASTNodeEmptyBlockCleaner", "[language]")
  `-(language::block:ASTNodeListProcessor)
      `-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
          +-(language::name:x:NameProcessor)
-         `-(language::integer:3:FakeProcessor)
+         `-(language::integer:3:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -141,7 +138,7 @@ TEST_CASE("ASTNodeEmptyBlockCleaner", "[language]")
          `-(language::block:ASTNodeListProcessor)
              `-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
                  +-(language::name:w:NameProcessor)
-                 `-(language::integer:4:FakeProcessor)
+                 `-(language::integer:4:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeExpressionBuilder.cpp b/tests/test_ASTNodeExpressionBuilder.cpp
index fbadc0d1ebeb731d7c8de2af772964a751099d7a..53b7b963f955df386eef108c3e408865e8ad33ef 100644
--- a/tests/test_ASTNodeExpressionBuilder.cpp
+++ b/tests/test_ASTNodeExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,7 +27,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -65,7 +62,7 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::integer:3:FakeProcessor)
+ `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -79,7 +76,7 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::real:2.3e-5:FakeProcessor)
+ `-(language::real:2.3e-5:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -93,7 +90,7 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::literal:"foo":FakeProcessor)
+ `-(language::literal:"foo":ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -107,7 +104,7 @@ true;
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::true_kw:FakeProcessor)
+ `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -121,7 +118,7 @@ false;
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::false_kw:FakeProcessor)
+ `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -139,7 +136,7 @@ false;
     std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::block:ASTNodeListProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -172,7 +169,7 @@ N i = 1;
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
      +-(language::name:i:NameProcessor)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -189,10 +186,10 @@ i *= 3;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::multiplyeq_op:AffectationProcessor<language::multiplyeq_op, unsigned long, long>)
      +-(language::name:i:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -209,10 +206,10 @@ x /= 2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::divideeq_op:AffectationProcessor<language::divideeq_op, double, long>)
      +-(language::name:x:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -229,10 +226,10 @@ i += 3.;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::pluseq_op:AffectationProcessor<language::pluseq_op, unsigned long, double>)
      +-(language::name:i:NameProcessor)
-     `-(language::real:3.:FakeProcessor)
+     `-(language::real:3.:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -249,10 +246,10 @@ z -= 2;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:z:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::minuseq_op:AffectationProcessor<language::minuseq_op, long, long>)
      +-(language::name:z:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -270,7 +267,7 @@ z -= 2;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, bool>)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -301,7 +298,7 @@ N n;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -316,7 +313,7 @@ N n;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, double, double>)
-     `-(language::real:1.2:FakeProcessor)
+     `-(language::real:1.2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -331,7 +328,7 @@ not 1;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_not:UnaryExpressionProcessor<language::unary_not, bool, long>)
-     `-(language::integer:1:FakeProcessor)
+     `-(language::integer:1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -348,7 +345,7 @@ Z a=1;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:a:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, long>)
      `-(language::name:a:NameProcessor)
 )";
@@ -367,7 +364,7 @@ Z a=1;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:a:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::unary_minusminus:IncDecExpressionProcessor<language::unary_minusminus, long>)
      `-(language::name:a:NameProcessor)
 )";
@@ -386,7 +383,7 @@ a++;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:a:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::post_plusplus:IncDecExpressionProcessor<language::post_plusplus, long>)
      `-(language::name:a:NameProcessor)
 )";
@@ -405,7 +402,7 @@ a--;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:a:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::post_minusminus:IncDecExpressionProcessor<language::post_minusminus, long>)
      `-(language::name:a:NameProcessor)
 )";
@@ -425,8 +422,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -441,8 +438,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::divide_op:BinaryExpressionProcessor<language::divide_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -457,8 +454,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -473,8 +470,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -489,8 +486,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::or_op:BinaryExpressionProcessor<language::or_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -505,8 +502,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::and_op:BinaryExpressionProcessor<language::and_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -521,8 +518,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::xor_op:BinaryExpressionProcessor<language::xor_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -537,8 +534,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -553,8 +550,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::lesser_or_eq_op:BinaryExpressionProcessor<language::lesser_or_eq_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -569,8 +566,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::greater_op:BinaryExpressionProcessor<language::greater_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -585,8 +582,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::greater_or_eq_op:BinaryExpressionProcessor<language::greater_or_eq_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -601,8 +598,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -617,8 +614,8 @@ a--;
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, long, long>)
-     +-(language::integer:1:FakeProcessor)
-     `-(language::integer:2:FakeProcessor)
+     +-(language::integer:1:ValueProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -681,7 +678,7 @@ if(true);
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::if_statement:IfProcessor)
-     +-(language::true_kw:FakeProcessor)
+     +-(language::true_kw:ValueProcessor)
      `-(language::statement_block:ASTNodeListProcessor)
 )";
 
@@ -698,7 +695,7 @@ do; while(true);
 (root:ASTNodeListProcessor)
  `-(language::do_while_statement:DoWhileProcessor)
      +-(language::statement_block:ASTNodeListProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -713,7 +710,7 @@ while(true);
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::while_statement:WhileProcessor)
-     +-(language::true_kw:FakeProcessor)
+     +-(language::true_kw:ValueProcessor)
      `-(language::statement_block:ASTNodeListProcessor)
 )";
 
@@ -733,10 +730,10 @@ for(N i=0; i<10; ++i);
  `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:0:FakeProcessor)
+     |   `-(language::integer:0:ValueProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:10:FakeProcessor)
+     |   `-(language::integer:10:ValueProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
      `-(language::for_statement_block:ASTNodeListProcessor)
@@ -756,12 +753,12 @@ for(; i<10; ++i);
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::for_statement:ForProcessor)
      +-(language::for_init:FakeProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:10:FakeProcessor)
+     |   `-(language::integer:10:ValueProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
      `-(language::for_statement_block:ASTNodeListProcessor)
@@ -781,8 +778,8 @@ for(N i=0; ; ++i);
  `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:0:FakeProcessor)
-     +-(language::for_test:FakeProcessor)
+     |   `-(language::integer:0:ValueProcessor)
+     +-(language::for_test:ValueProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
      `-(language::for_statement_block:ASTNodeListProcessor)
@@ -802,10 +799,10 @@ for(N i=0; i<10;);
  `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:0:FakeProcessor)
+     |   `-(language::integer:0:ValueProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
      |   +-(language::name:i:NameProcessor)
-     |   `-(language::integer:10:FakeProcessor)
+     |   `-(language::integer:10:ValueProcessor)
      +-(language::for_post:FakeProcessor)
      `-(language::for_statement_block:ASTNodeListProcessor)
 )";
diff --git a/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp b/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
index cd9583f7a4ba912f3633de7dd874bbdd6f33f9d5..80844f7bebca9e7fa9c9bbb78ff356a734408712 100644
--- a/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -33,7 +31,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeTypeCleaner<language::let_declaration>{*ast};                                            \
                                                                                                     \
@@ -57,7 +54,7 @@ sin(3);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:CFunctionProcessor)
      +-(language::name:sin:NameProcessor)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -75,8 +72,8 @@ sum(1,2);
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:sum:NameProcessor)
      `-(language::function_argument_list:FakeProcessor)
-         +-(language::integer:1:FakeProcessor)
-         `-(language::integer:2:FakeProcessor)
+         +-(language::integer:1:ValueProcessor)
+         `-(language::integer:2:ValueProcessor)
 )";
 
     CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeFunctionExpressionBuilder.cpp b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
index 3512e213353305e392f90fbc600fe09ce91af5bc..a98670a13ffce592cd8ee73700daf74e1e8d9735 100644
--- a/tests/test_ASTNodeFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -34,7 +32,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
     ASTNodeTypeCleaner<language::let_declaration>{*ast};                                            \
@@ -58,7 +55,6 @@
                                                                                    \
     ASTSymbolTableBuilder{*ast};                                                   \
     ASTNodeDataTypeBuilder{*ast};                                                  \
-    ASTNodeValueBuilder{*ast};                                                     \
                                                                                    \
     ASTNodeTypeCleaner<language::declaration>{*ast};                               \
     ASTNodeTypeCleaner<language::let_declaration>{*ast};                           \
@@ -82,7 +78,7 @@ not_v(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:not_v:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -118,7 +114,7 @@ not_v(-1);
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:not_v:NameProcessor)
      `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
-         `-(language::integer:1:FakeProcessor)
+         `-(language::integer:1:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -135,7 +131,7 @@ not_v(1.3);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:not_v:NameProcessor)
-     `-(language::real:1.3:FakeProcessor)
+     `-(language::real:1.3:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -153,7 +149,7 @@ test(2);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:test:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -170,7 +166,7 @@ test(2);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:test:NameProcessor)
-     `-(language::integer:2:FakeProcessor)
+     `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -187,7 +183,7 @@ test(2.1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:test:NameProcessor)
-     `-(language::real:2.1:FakeProcessor)
+     `-(language::real:2.1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -207,7 +203,7 @@ test(2.1);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:test:NameProcessor)
-     `-(language::real:2.1:FakeProcessor)
+     `-(language::real:2.1:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -225,7 +221,7 @@ absolute(-2);
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:absolute:NameProcessor)
      `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
-         `-(language::integer:2:FakeProcessor)
+         `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -245,7 +241,7 @@ minus(true);
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:minus:NameProcessor)
-     `-(language::true_kw:FakeProcessor)
+     `-(language::true_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -263,7 +259,7 @@ times_2_3(-2);
  `-(language::function_evaluation:FunctionProcessor)
      +-(language::name:times_2_3:NameProcessor)
      `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
-         `-(language::integer:2:FakeProcessor)
+         `-(language::integer:2:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeIncDecExpressionBuilder.cpp b/tests/test_ASTNodeIncDecExpressionBuilder.cpp
index b3a2971c7a767631244c274d081b778776d6900f..7a68d8ca623760e03390412e219dcb4023a778f7 100644
--- a/tests/test_ASTNodeIncDecExpressionBuilder.cpp
+++ b/tests/test_ASTNodeIncDecExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -31,7 +29,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -55,7 +52,6 @@
                                                                                               \
     ASTSymbolTableBuilder{*ast};                                                              \
     ASTNodeDataTypeBuilder{*ast};                                                             \
-    ASTNodeValueBuilder{*ast};                                                                \
                                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                          \
@@ -78,7 +74,7 @@ N i=0;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -97,7 +93,7 @@ Z i=0;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -116,7 +112,7 @@ R x=0;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, double>)
      `-(language::name:x:NameProcessor)
 )";
@@ -138,7 +134,7 @@ N i=1;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::unary_minusminus:IncDecExpressionProcessor<language::unary_minusminus, unsigned long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -157,7 +153,7 @@ Z i=0;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::unary_minusminus:IncDecExpressionProcessor<language::unary_minusminus, long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -176,7 +172,7 @@ R x=2.3;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, double>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::real:2.3:FakeProcessor)
+ |   `-(language::real:2.3:ValueProcessor)
  `-(language::unary_minusminus:IncDecExpressionProcessor<language::unary_minusminus, double>)
      `-(language::name:x:NameProcessor)
 )";
@@ -198,7 +194,7 @@ i++;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::post_plusplus:IncDecExpressionProcessor<language::post_plusplus, unsigned long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -217,7 +213,7 @@ i++;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::post_plusplus:IncDecExpressionProcessor<language::post_plusplus, long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -236,7 +232,7 @@ x++;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::post_plusplus:IncDecExpressionProcessor<language::post_plusplus, double>)
      `-(language::name:x:NameProcessor)
 )";
@@ -258,7 +254,7 @@ i--;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:1:FakeProcessor)
+ |   `-(language::integer:1:ValueProcessor)
  `-(language::post_minusminus:IncDecExpressionProcessor<language::post_minusminus, unsigned long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -277,7 +273,7 @@ i--;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
  |   +-(language::name:i:NameProcessor)
- |   `-(language::integer:0:FakeProcessor)
+ |   `-(language::integer:0:ValueProcessor)
  `-(language::post_minusminus:IncDecExpressionProcessor<language::post_minusminus, long>)
      `-(language::name:i:NameProcessor)
 )";
@@ -296,7 +292,7 @@ x--;
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, double>)
  |   +-(language::name:x:NameProcessor)
- |   `-(language::real:2.3:FakeProcessor)
+ |   `-(language::real:2.3:ValueProcessor)
  `-(language::post_minusminus:IncDecExpressionProcessor<language::post_minusminus, double>)
      `-(language::name:x:NameProcessor)
 )";
diff --git a/tests/test_ASTNodeListProcessor.cpp b/tests/test_ASTNodeListProcessor.cpp
index 49bc6fe34bd3b1b68c2294a4b4aa0b54a9923910..aaa78a060440ceb36076a8ab0463d59140b03b55 100644
--- a/tests/test_ASTNodeListProcessor.cpp
+++ b/tests/test_ASTNodeListProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -33,13 +31,12 @@ true;
 
   ASTSymbolTableBuilder{*ast};
   ASTNodeDataTypeBuilder{*ast};
-  ASTNodeValueBuilder{*ast};
 
   ASTNodeDeclarationToAffectationConverter{*ast};
   ASTNodeTypeCleaner<language::declaration>{*ast};
 
   ASTNodeExpressionBuilder{*ast};
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
   ast->execute(exec_policy);
 
   REQUIRE(ast->children[0]->is_type<language::integer>());
diff --git a/tests/test_ASTNodeTypeCleaner.cpp b/tests/test_ASTNodeTypeCleaner.cpp
index 02da34b90672ecca41d7a1e2dab405c135e65e07..e166b11d23be9484d64b8e3cf35f6314c7149146 100644
--- a/tests/test_ASTNodeTypeCleaner.cpp
+++ b/tests/test_ASTNodeTypeCleaner.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -21,7 +19,6 @@
                                                                                                \
     ASTSymbolTableBuilder{*ast};                                                               \
     ASTNodeDataTypeBuilder{*ast};                                                              \
-    ASTNodeValueBuilder{*ast};                                                                 \
                                                                                                \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                           \
                                                                                                \
diff --git a/tests/test_ASTNodeUnaryOperatorExpressionBuilder.cpp b/tests/test_ASTNodeUnaryOperatorExpressionBuilder.cpp
index 402b9f417f5d839a70f74420c84bdfbec73067ab..4854868890d3c5ca93e7404ea66b1e7781829c17 100644
--- a/tests/test_ASTNodeUnaryOperatorExpressionBuilder.cpp
+++ b/tests/test_ASTNodeUnaryOperatorExpressionBuilder.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -31,7 +29,6 @@
                                                                                                     \
     ASTSymbolTableBuilder{*ast};                                                                    \
     ASTNodeDataTypeBuilder{*ast};                                                                   \
-    ASTNodeValueBuilder{*ast};                                                                      \
                                                                                                     \
     ASTNodeDeclarationToAffectationConverter{*ast};                                                 \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                                \
@@ -62,9 +59,9 @@ B b;
  +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, bool>)
  |   `-(language::name:b:NameProcessor)
  +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, bool>)
- |   `-(language::true_kw:FakeProcessor)
+ |   `-(language::true_kw:ValueProcessor)
  `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, bool>)
-     `-(language::false_kw:FakeProcessor)
+     `-(language::false_kw:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -162,7 +159,7 @@ not 3;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_not:UnaryExpressionProcessor<language::unary_not, bool, long>)
-     `-(language::integer:3:FakeProcessor)
+     `-(language::integer:3:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -177,7 +174,7 @@ not 3.5;
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::unary_not:UnaryExpressionProcessor<language::unary_not, bool, double>)
-     `-(language::real:3.5:FakeProcessor)
+     `-(language::real:3.5:ValueProcessor)
 )";
 
       CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeValueBuilder.cpp b/tests/test_ASTNodeValueBuilder.cpp
deleted file mode 100644
index a39ca80a151cfbf3bc126486087dc661bda51a4e..0000000000000000000000000000000000000000
--- a/tests/test_ASTNodeValueBuilder.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#include <catch2/catch.hpp>
-
-#include <ASTNodeValueBuilder.hpp>
-
-#include <ASTBuilder.hpp>
-#include <ASTNodeDataTypeBuilder.hpp>
-
-#include <ASTSymbolTableBuilder.hpp>
-
-#include <ASTPrinter.hpp>
-
-#define CHECK_AST_VALUES(data, expected_output)                                                      \
-  {                                                                                                  \
-    static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>);                   \
-    static_assert(std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view>);        \
-                                                                                                     \
-    string_input input{data, "test.pgs"};                                                            \
-    auto ast = ASTBuilder::build(input);                                                             \
-                                                                                                     \
-    ASTSymbolTableBuilder{*ast};                                                                     \
-    ASTNodeDataTypeBuilder{*ast};                                                                    \
-    ASTNodeValueBuilder{*ast};                                                                       \
-                                                                                                     \
-    std::stringstream ast_output;                                                                    \
-    ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::data_value}}; \
-                                                                                                     \
-    REQUIRE(ast_output.str() == expected_output);                                                    \
-  }
-
-TEST_CASE("ASTNodeValuebuilder", "[language]")
-{
-  SECTION("integer")
-  {
-    std::string_view data = R"(
-01;
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::integer:01:1)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("real")
-  {
-    std::string_view data = R"(
-1.300;
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::real:1.300:1.3)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("true")
-  {
-    std::string_view data = R"(
-true;
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::true_kw:1)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("false")
-  {
-    std::string_view data = R"(
-false;
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::false_kw:0)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("string")
-  {
-    std::string_view data = R"(
-"\"foo\" or \"bar\"";
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::literal:"\"foo\" or \"bar\"":"\"foo\" or \"bar\"")
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("for empty test")
-  {
-    std::string_view data = R"(
-for(;;);
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::for_statement:--)
-     +-(language::for_init:--)
-     +-(language::for_test:1)
-     +-(language::for_post:--)
-     `-(language::for_statement_block:--)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-
-  SECTION("block values")
-  {
-    std::string_view data = R"(
-{
-  1;
-  2.3;
-}
-)";
-
-    std::string_view result = R"(
-(root:--)
- `-(language::block:--)
-     +-(language::integer:1:1)
-     `-(language::real:2.3:2.3)
-)";
-
-    CHECK_AST_VALUES(data, result);
-  }
-}
diff --git a/tests/test_ASTPrinter.cpp b/tests/test_ASTPrinter.cpp
index a81699a608d6174ce218046b0eb231aaace7e9fd..a2e593e0d87654b3406db769898f00660e87baf4 100644
--- a/tests/test_ASTPrinter.cpp
+++ b/tests/test_ASTPrinter.cpp
@@ -32,13 +32,13 @@ N n = 2 + 3;
 )";
 
     std::string_view result = R"(
-(root:undefined:--)
- `-(language::declaration:undefined:--)
-     +-(language::N_set:undefined:--)
-     +-(language::name:n:undefined:--)
-     `-(language::plus_op:undefined:--)
-         +-(language::integer:2:undefined:--)
-         `-(language::integer:3:undefined:--)
+(root:undefined)
+ `-(language::declaration:undefined)
+     +-(language::N_set:undefined)
+     +-(language::name:n:undefined)
+     `-(language::plus_op:undefined)
+         +-(language::integer:2:undefined)
+         `-(language::integer:3:undefined)
 )";
     CHECK_OUTPUT(data, result, ASTPrinter::Format::raw);
   }
@@ -50,13 +50,13 @@ N n = 2 + 3;
 )";
 
     std::string_view result = R"(
-(root:undefined:--)
- └──(language::declaration:undefined:--)
-     ├──(language::N_set:undefined:--)
-     ├──(language::name:n:undefined:--)
-     └──(language::plus_op:undefined:--)
-         ├──(language::integer:2:undefined:--)
-         └──(language::integer:3:undefined:--)
+(root:undefined)
+ └──(language::declaration:undefined)
+     ├──(language::N_set:undefined)
+     ├──(language::name:n:undefined)
+     └──(language::plus_op:undefined)
+         ├──(language::integer:2:undefined)
+         └──(language::integer:3:undefined)
 )";
     CHECK_OUTPUT(data, result, ASTPrinter::Format::pretty);
   }
@@ -68,11 +68,11 @@ string s = "a string";
 )";
 
     std::string_view result = R"(
-(root:undefined:--)
- `-(language::declaration:undefined:--)
-     +-(language::string_type:undefined:--)
-     +-(language::name:s:undefined:--)
-     `-(language::literal:"a string":undefined:--)
+(root:undefined)
+ `-(language::declaration:undefined)
+     +-(language::string_type:undefined)
+     +-(language::name:s:undefined)
+     `-(language::literal:"a string":undefined)
 )";
     CHECK_OUTPUT(data, result, ASTPrinter::Format::raw);
   }
diff --git a/tests/test_AffectationProcessor.cpp b/tests/test_AffectationProcessor.cpp
index aeb6e48595a72c06582faab31ab2bbe7b43a0a52..b37a47c7174110aa42056d6a34724f2569acae0b 100644
--- a/tests/test_AffectationProcessor.cpp
+++ b/tests/test_AffectationProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
@@ -58,7 +55,6 @@
                                                                                              \
     ASTSymbolTableBuilder{*ast};                                                             \
     ASTNodeDataTypeBuilder{*ast};                                                            \
-    ASTNodeValueBuilder{*ast};                                                               \
                                                                                              \
     ASTNodeDeclarationToAffectationConverter{*ast};                                          \
     ASTNodeTypeCleaner<language::declaration>{*ast};                                         \
diff --git a/tests/test_AffectationToStringProcessor.cpp b/tests/test_AffectationToStringProcessor.cpp
index bdd384762b3210753663ede8ea38a1275837b9e7..57209b308197b42b5fd9d74851aed7c15e79db12 100644
--- a/tests/test_AffectationToStringProcessor.cpp
+++ b/tests/test_AffectationToStringProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_BinaryExpressionProcessor_utils.hpp b/tests/test_BinaryExpressionProcessor_utils.hpp
index d442a67631681b69a793c00d38e8625dc2338561..6481ff8301cd08866ba7854087d6b967aa162f85 100644
--- a/tests/test_BinaryExpressionProcessor_utils.hpp
+++ b/tests/test_BinaryExpressionProcessor_utils.hpp
@@ -1,8 +1,6 @@
 #ifndef TEST_BINARY_EXPRESSION_PROCESSOR_UTILS_HPP
 #define TEST_BINARY_EXPRESSION_PROCESSOR_UTILS_HPP
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -30,13 +28,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_BreakProcessor.cpp b/tests/test_BreakProcessor.cpp
index 7fb00cebb4f0298ce95135cc5551c02cdeab65d2..d96f94ed20404caa1de93b4eaf11fdc6f18ab752 100644
--- a/tests/test_BreakProcessor.cpp
+++ b/tests/test_BreakProcessor.cpp
@@ -8,7 +8,7 @@ TEST_CASE("BreakProcessor", "[language]")
 {
   rang::setControlMode(rang::control::Off);
 
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
 
   REQUIRE(exec_policy.exec() == true);
 
@@ -16,5 +16,5 @@ TEST_CASE("BreakProcessor", "[language]")
   break_processor.execute(exec_policy);
 
   REQUIRE(exec_policy.exec() == false);
-  REQUIRE(exec_policy.jumpType() == ExecUntilBreakOrContinue::JumpType::break_jump);
+  REQUIRE(exec_policy.jumpType() == ExecutionPolicy::JumpType::break_jump);
 }
diff --git a/tests/test_CFunctionEmbedder.cpp b/tests/test_CFunctionEmbedder.cpp
index 032cf7f66274c654c9e23b84df4c28e5271b4d35..df76af84cb2dbd2b1597af16f26a0789962a831e 100644
--- a/tests/test_CFunctionEmbedder.cpp
+++ b/tests/test_CFunctionEmbedder.cpp
@@ -14,9 +14,7 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     double arg                     = 2;
     ASTNodeDataVariant arg_variant = arg;
 
-    ASTNodeDataVariant result;
-
-    embedded_sin.apply({arg_variant}, result);
+    ASTNodeDataVariant result = embedded_sin.apply({arg_variant});
 
     REQUIRE(std::get<double>(result) == std::sin(arg));
     REQUIRE(embedded_sin.numberOfParameters() == 1);
@@ -38,9 +36,7 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     args.push_back(d_arg);
     args.push_back(i_arg);
 
-    ASTNodeDataVariant result;
-
-    embedded_c.apply(args, result);
+    ASTNodeDataVariant result = embedded_c.apply(args);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
     REQUIRE(embedded_c.numberOfParameters() == 2);
@@ -63,9 +59,7 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     args.push_back(d_arg);
     args.push_back(i_arg);
 
-    ASTNodeDataVariant result;
-
-    i_embedded_c->apply(args, result);
+    ASTNodeDataVariant result = i_embedded_c->apply(args);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
     REQUIRE(i_embedded_c->numberOfParameters() == 2);
@@ -86,8 +80,6 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     std::vector<ASTNodeDataVariant> args;
     args.push_back(arg);
 
-    ASTNodeDataVariant result;
-
-    REQUIRE_THROWS(embedded_positive.apply(args, result));
+    REQUIRE_THROWS(embedded_positive.apply(args));
   }
 }
diff --git a/tests/test_CFunctionProcessor.cpp b/tests/test_CFunctionProcessor.cpp
index 0a0a83230a3c6a6dde5cdec9b88a686e978ad0dd..7f47ada2314ad9329c3ddacd573d6226bb9fb2ad 100644
--- a/tests/test_CFunctionProcessor.cpp
+++ b/tests/test_CFunctionProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -26,14 +24,13 @@
                                                                                \
     ASTSymbolTableBuilder{*ast};                                               \
     ASTNodeDataTypeBuilder{*ast};                                              \
-    ASTNodeValueBuilder{*ast};                                                 \
                                                                                \
     ASTNodeDeclarationToAffectationConverter{*ast};                            \
     ASTNodeTypeCleaner<language::declaration>{*ast};                           \
     ASTNodeTypeCleaner<language::let_declaration>{*ast};                       \
                                                                                \
     ASTNodeExpressionBuilder{*ast};                                            \
-    ExecUntilBreakOrContinue exec_policy;                                      \
+    ExecutionPolicy exec_policy;                                               \
     ast->execute(exec_policy);                                                 \
                                                                                \
     auto symbol_table = ast->m_symbol_table;                                   \
diff --git a/tests/test_CMathModule.cpp b/tests/test_CMathModule.cpp
index 7d2b3b878beaf1f9e83f2f3b1963474638cadfb4..9ef32bf86a3cb8f5d0b6d62bbd951ad46eea10e0 100644
--- a/tests/test_CMathModule.cpp
+++ b/tests/test_CMathModule.cpp
@@ -19,7 +19,6 @@ TEST_CASE("CMathModule", "[language]")
     double arg = 0.7;
 
     ASTNodeDataVariant arg_variant = arg;
-    ASTNodeDataVariant result_variant;
 
     SECTION("sqrt")
     {
@@ -27,8 +26,8 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
-      function_embedder.apply({arg_variant}, result_variant);
       auto result = std::sqrt(arg);
 
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -40,21 +39,25 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
+      {
+        ASTNodeDataVariant result_variant = function_embedder.apply({arg_variant});
 
-      function_embedder.apply({arg_variant}, result_variant);
-      auto result = std::abs(arg);
+        auto result = std::abs(arg);
 
-      REQUIRE(std::get<decltype(result)>(result_variant) == std::abs(arg));
+        REQUIRE(std::get<decltype(result)>(result_variant) == std::abs(arg));
+      }
 
-      double arg = -3;
+      {
+        arg = -3;
 
-      ASTNodeDataVariant arg_variant = arg;
+        ASTNodeDataVariant arg_variant = arg;
 
-      function_embedder.apply({arg_variant}, result_variant);
+        ASTNodeDataVariant result_variant = function_embedder.apply({arg_variant});
 
-      result = std::abs(arg);
+        auto result = std::abs(arg);
 
-      REQUIRE(std::get<decltype(result)>(result_variant) == result);
+        REQUIRE(std::get<decltype(result)>(result_variant) == result);
+      }
     }
 
     SECTION("sin")
@@ -63,8 +66,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::sin(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -76,8 +78,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::cos(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -89,8 +90,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::tan(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -102,8 +102,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::asin(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -115,8 +114,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::acos(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -128,8 +126,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::atan(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -144,8 +141,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::sinh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -157,8 +153,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::cosh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -170,8 +165,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::tanh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -183,8 +177,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::asinh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -199,8 +192,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::acosh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -212,8 +204,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::atanh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -225,8 +216,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::exp(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -238,8 +228,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::log(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -251,8 +240,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::nearbyint(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -264,8 +252,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::ceil(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -277,8 +264,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::floor(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -290,8 +276,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::trunc(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -303,8 +288,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::round(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -316,8 +300,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::rint(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -329,7 +312,6 @@ TEST_CASE("CMathModule", "[language]")
     double arg = 1.3;
 
     ASTNodeDataVariant arg_variant = arg;
-    ASTNodeDataVariant result_variant;
 
     SECTION("lround")
     {
@@ -337,8 +319,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       auto result = std::lround(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -350,8 +331,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
 
       //      REQUIRE(std::get<int64_t>(result_variant) == std::lrint(arg));
       auto result = std::lrint(arg);
@@ -366,7 +346,6 @@ TEST_CASE("CMathModule", "[language]")
 
     ASTNodeDataVariant arg0_variant = arg0;
     ASTNodeDataVariant arg1_variant = arg1;
-    ASTNodeDataVariant result_variant;
 
     SECTION("atan2")
     {
@@ -374,8 +353,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg0_variant, arg1_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg0_variant, arg1_variant});
 
       auto result = std::atan2(arg0, arg1);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -387,8 +365,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-
-      function_embedder.apply({arg0_variant, arg1_variant}, result_variant);
+      ASTNodeDataVariant result_variant     = function_embedder.apply({arg0_variant, arg1_variant});
 
       auto result = std::pow(arg0, arg1);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
diff --git a/tests/test_ConcatExpressionProcessor.cpp b/tests/test_ConcatExpressionProcessor.cpp
index 7bcfc0a1d4cab9c3cb24081c0913875a5be91cef..79c20b9d4708700f2e2e89f64f68c99dcc59077e 100644
--- a/tests/test_ConcatExpressionProcessor.cpp
+++ b/tests/test_ConcatExpressionProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_ContinueProcessor.cpp b/tests/test_ContinueProcessor.cpp
index 24cc87dcf9c2585d6e2a7f8624ea46a2ce2e9162..5dc50dfe2cc6211e3cac6babfe9b958d1b83cc15 100644
--- a/tests/test_ContinueProcessor.cpp
+++ b/tests/test_ContinueProcessor.cpp
@@ -8,7 +8,7 @@ TEST_CASE("ContinueProcessor", "[language]")
 {
   rang::setControlMode(rang::control::Off);
 
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
 
   REQUIRE(exec_policy.exec() == true);
 
@@ -16,5 +16,5 @@ TEST_CASE("ContinueProcessor", "[language]")
   continue_processor.execute(exec_policy);
 
   REQUIRE(exec_policy.exec() == false);
-  REQUIRE(exec_policy.jumpType() == ExecUntilBreakOrContinue::JumpType::continue_jump);
+  REQUIRE(exec_policy.jumpType() == ExecutionPolicy::JumpType::continue_jump);
 }
diff --git a/tests/test_DoWhileProcessor.cpp b/tests/test_DoWhileProcessor.cpp
index 9ccf21e37f0e553fc9d3d1cbb1662867c30e0968..135c8d221dda475ca2552826e7f338fa80b3e8c2 100644
--- a/tests/test_DoWhileProcessor.cpp
+++ b/tests/test_DoWhileProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_ExecUntilBreakOrContinue.cpp b/tests/test_ExecUntilBreakOrContinue.cpp
deleted file mode 100644
index 4b96a799a79b8e9b2041fb3772061cf84d0f1b5c..0000000000000000000000000000000000000000
--- a/tests/test_ExecUntilBreakOrContinue.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <catch2/catch.hpp>
-
-#include <node_processor/ExecUntilBreakOrContinue.hpp>
-
-#include <rang.hpp>
-
-TEST_CASE("ExecUntilBreakOrContinue", "[language]")
-{
-  rang::setControlMode(rang::control::Off);
-
-  ExecUntilBreakOrContinue exec_policy;
-  SECTION("no jump")
-  {
-    exec_policy = ExecUntilBreakOrContinue{ExecUntilBreakOrContinue::JumpType::no_jump};
-    REQUIRE(exec_policy.exec() == true);
-    REQUIRE(exec_policy.jumpType() == ExecUntilBreakOrContinue::JumpType::no_jump);
-  }
-
-  SECTION("break jump")
-  {
-    exec_policy = ExecUntilBreakOrContinue{ExecUntilBreakOrContinue::JumpType::break_jump};
-    REQUIRE(exec_policy.exec() == false);
-    REQUIRE(exec_policy.jumpType() == ExecUntilBreakOrContinue::JumpType::break_jump);
-  }
-
-  SECTION("continue jump")
-  {
-    exec_policy = ExecUntilBreakOrContinue{ExecUntilBreakOrContinue::JumpType::continue_jump};
-    REQUIRE(exec_policy.exec() == false);
-    REQUIRE(exec_policy.jumpType() == ExecUntilBreakOrContinue::JumpType::continue_jump);
-  }
-}
diff --git a/tests/test_ExecutionPolicy.cpp b/tests/test_ExecutionPolicy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f69dc72c005d1063b2a35aff5b4ffb03040337cc
--- /dev/null
+++ b/tests/test_ExecutionPolicy.cpp
@@ -0,0 +1,32 @@
+#include <catch2/catch.hpp>
+
+#include <node_processor/ExecutionPolicy.hpp>
+
+#include <rang.hpp>
+
+TEST_CASE("ExecutionPolicy", "[language]")
+{
+  rang::setControlMode(rang::control::Off);
+
+  ExecutionPolicy exec_policy;
+  SECTION("no jump")
+  {
+    exec_policy = ExecutionPolicy{ExecutionPolicy::JumpType::no_jump, nullptr};
+    REQUIRE(exec_policy.exec() == true);
+    REQUIRE(exec_policy.jumpType() == ExecutionPolicy::JumpType::no_jump);
+  }
+
+  SECTION("break jump")
+  {
+    exec_policy = ExecutionPolicy{ExecutionPolicy::JumpType::break_jump, nullptr};
+    REQUIRE(exec_policy.exec() == false);
+    REQUIRE(exec_policy.jumpType() == ExecutionPolicy::JumpType::break_jump);
+  }
+
+  SECTION("continue jump")
+  {
+    exec_policy = ExecutionPolicy{ExecutionPolicy::JumpType::continue_jump, nullptr};
+    REQUIRE(exec_policy.exec() == false);
+    REQUIRE(exec_policy.jumpType() == ExecutionPolicy::JumpType::continue_jump);
+  }
+}
diff --git a/tests/test_FakeProcessor.cpp b/tests/test_FakeProcessor.cpp
index 85e6ab827c69d6db8b7a0a1e2ff742cf7b74598a..c391423bc159d34df15b6cc0c13db4dc0b1ec3c6 100644
--- a/tests/test_FakeProcessor.cpp
+++ b/tests/test_FakeProcessor.cpp
@@ -12,6 +12,6 @@ TEST_CASE("FakeProcessor", "[language]")
   FakeProcessor fake_processor;
   REQUIRE(fake_processor.typeIdName() == demangle<FakeProcessor>());
 
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
   REQUIRE_NOTHROW(fake_processor.execute(exec_policy));
 }
diff --git a/tests/test_ForProcessor.cpp b/tests/test_ForProcessor.cpp
index 4261a8193fcbe672494152cc717bb2e50f76f434..7b4faa85585e36290794a39ea5a5199f2487f3b8 100644
--- a/tests/test_ForProcessor.cpp
+++ b/tests/test_ForProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_FunctionProcessor.cpp b/tests/test_FunctionProcessor.cpp
index b4e2ea79a3462f3183c193903d6d3c27f6fb8e64..9b163f0226ebc133c952e410a17b44747e00ec68 100644
--- a/tests/test_FunctionProcessor.cpp
+++ b/tests/test_FunctionProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,14 +27,13 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
     ASTNodeTypeCleaner<language::let_declaration>{*ast};                      \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_INodeProcessor.cpp b/tests/test_INodeProcessor.cpp
index 5ccb1b88ab67b7b61ce96228a38a997d75f5e678..8295e977f9bbb10dd30ad736c56ccbc57eecc966 100644
--- a/tests/test_INodeProcessor.cpp
+++ b/tests/test_INodeProcessor.cpp
@@ -12,6 +12,6 @@ TEST_CASE("INodeProcessor", "[language]")
   std::unique_ptr<INodeProcessor> node_processor = std::make_unique<FakeProcessor>();
   REQUIRE(node_processor->typeIdName() == demangle<FakeProcessor>());
 
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
   REQUIRE_NOTHROW(node_processor->execute(exec_policy));
 }
diff --git a/tests/test_IfProcessor.cpp b/tests/test_IfProcessor.cpp
index 4ec5973522d37b986575b08f76c9cd3913f69590..9df57fc071bb385ce57b86ec484145682dd5ad59 100644
--- a/tests/test_IfProcessor.cpp
+++ b/tests/test_IfProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_IncDecExpressionProcessor.cpp b/tests/test_IncDecExpressionProcessor.cpp
index 0562c3f3180248aa9fec2bb98ba4474a992e9445..a2a2d988f14c54b44a81fe863ed8a6542ba497e4 100644
--- a/tests/test_IncDecExpressionProcessor.cpp
+++ b/tests/test_IncDecExpressionProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_NameProcessor.cpp b/tests/test_NameProcessor.cpp
index cd7374ae773106b164a522806e4af934cd0f6db7..28e81a4618406c40b6f3ed79aabaeadc70dfdca3 100644
--- a/tests/test_NameProcessor.cpp
+++ b/tests/test_NameProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -37,13 +35,12 @@ n = 2;
 
   ASTSymbolTableBuilder{*ast};
   ASTNodeDataTypeBuilder{*ast};
-  ASTNodeValueBuilder{*ast};
 
   ASTNodeDeclarationToAffectationConverter{*ast};
   ASTNodeTypeCleaner<language::declaration>{*ast};
 
   ASTNodeExpressionBuilder{*ast};
-  ExecUntilBreakOrContinue exec_policy;
+  ExecutionPolicy exec_policy;
   ast->execute(exec_policy);
 
   auto symbol_table = ast->m_symbol_table;
diff --git a/tests/test_OStreamProcessor.cpp b/tests/test_OStreamProcessor.cpp
index e217fa107faa3152ec39128fe947a7d10bf52edc..ad6b8578e7045a338e5e4f27dc094f20a94948f2 100644
--- a/tests/test_OStreamProcessor.cpp
+++ b/tests/test_OStreamProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -43,13 +41,12 @@ _replaceOStream(ASTNode& node, std::ostringstream& sout)
                                                               \
     ASTSymbolTableBuilder{*ast};                              \
     ASTNodeDataTypeBuilder{*ast};                             \
-    ASTNodeValueBuilder{*ast};                                \
                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};           \
     ASTNodeTypeCleaner<language::declaration>{*ast};          \
                                                               \
     ASTNodeExpressionBuilder{*ast};                           \
-    ExecUntilBreakOrContinue exec_policy;                     \
+    ExecutionPolicy exec_policy;                              \
                                                               \
     std::ostringstream sout;                                  \
     _replaceOStream(*ast, sout);                              \
diff --git a/tests/test_UnaryExpressionProcessor.cpp b/tests/test_UnaryExpressionProcessor.cpp
index 5c6a694369721726227ad15d6b6640718d34db6d..d141ec0f2ec3475fdaacdde76edea786bc8def2a 100644
--- a/tests/test_UnaryExpressionProcessor.cpp
+++ b/tests/test_UnaryExpressionProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
diff --git a/tests/test_WhileProcessor.cpp b/tests/test_WhileProcessor.cpp
index b94cd973804728f214cde41f6efd89c112837b53..d9200a1f5395a59de3edeb26297ba856869cf486 100644
--- a/tests/test_WhileProcessor.cpp
+++ b/tests/test_WhileProcessor.cpp
@@ -1,7 +1,5 @@
 #include <catch2/catch.hpp>
 
-#include <ASTNodeValueBuilder.hpp>
-
 #include <ASTBuilder.hpp>
 #include <ASTNodeDataTypeBuilder.hpp>
 
@@ -29,13 +27,12 @@
                                                                               \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
-    ASTNodeValueBuilder{*ast};                                                \
                                                                               \
     ASTNodeDeclarationToAffectationConverter{*ast};                           \
     ASTNodeTypeCleaner<language::declaration>{*ast};                          \
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
-    ExecUntilBreakOrContinue exec_policy;                                     \
+    ExecutionPolicy exec_policy;                                              \
     ast->execute(exec_policy);                                                \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \