From 620be0d6523bf3f2430d6453bad84e89f69bad45 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Wed, 27 Nov 2019 14:04:42 +0100
Subject: [PATCH] Remove ASTNode::m_value member
Values are no more stored into AST nodes. The reason for that is that it was not
appropriate for multi-threaded evaluation of functions, since multiple
evaluations could not occur at the same time.
Now expression evaluation do not fill the node value but eventually return the
computed value.
Also, function are evaluated using a context array of values. Thus each function
calls is done in a separated context (as it should have always been).
This is a big change in the AST execution strategy. Nonetheless, it leads to a
seemingly better code, and there will be no more undefined trailing values in
the AST (for some node ASTNode::m_value would never be initialized/used).
---
src/language/ASTNode.hpp | 11 +-
.../ASTNodeCFunctionExpressionBuilder.cpp | 20 +-
.../ASTNodeCFunctionExpressionBuilder.hpp | 3 +-
src/language/ASTNodeDataTypeBuilder.cpp | 1 -
src/language/ASTNodeDataVariant.hpp | 2 +-
src/language/ASTNodeExpressionBuilder.cpp | 26 ++-
.../ASTNodeFunctionExpressionBuilder.cpp | 39 ++--
.../ASTNodeFunctionExpressionBuilder.hpp | 3 +-
...STNodeListAffectationExpressionBuilder.cpp | 18 +-
src/language/ASTNodeValueBuilder.cpp | 67 -------
src/language/ASTNodeValueBuilder.hpp | 15 --
src/language/ASTPrinter.cpp | 18 --
src/language/ASTPrinter.hpp | 9 +-
src/language/ASTSymbolTableBuilder.cpp | 10 +-
src/language/CFunctionEmbedder.hpp | 8 +-
src/language/CMakeLists.txt | 1 -
src/language/PugsParser.cpp | 6 +-
src/language/SymbolTable.hpp | 93 +++++++--
.../ASTNodeExpressionListProcessor.hpp | 29 +++
.../node_processor/ASTNodeListProcessor.hpp | 6 +-
.../node_processor/AffectationProcessor.hpp | 53 ++---
.../BinaryExpressionProcessor.hpp | 23 ++-
.../node_processor/BreakProcessor.hpp | 7 +-
.../node_processor/CFunctionProcessor.hpp | 59 ++----
.../ConcatExpressionProcessor.hpp | 19 +-
.../node_processor/ContinueProcessor.hpp | 7 +-
.../node_processor/DoWhileProcessor.hpp | 20 +-
.../ExecUntilBreakOrContinue.hpp | 45 -----
.../node_processor/ExecutionPolicy.hpp | 70 +++++++
src/language/node_processor/FakeProcessor.hpp | 6 +-
src/language/node_processor/ForProcessor.hpp | 18 +-
.../node_processor/FunctionProcessor.hpp | 60 +++---
.../node_processor/INodeProcessor.hpp | 6 +-
src/language/node_processor/IfProcessor.hpp | 9 +-
.../IncDecExpressionProcessor.hpp | 6 +-
.../node_processor/LocalNameProcessor.hpp | 31 +++
src/language/node_processor/NameProcessor.hpp | 6 +-
.../node_processor/OStreamProcessor.hpp | 9 +-
.../UnaryExpressionProcessor.hpp | 7 +-
.../node_processor/ValueProcessor.hpp | 48 +++++
.../node_processor/WhileProcessor.hpp | 17 +-
tests/CMakeLists.txt | 3 +-
tests/test_ASTModulesImporter.cpp | 2 +-
tests/test_ASTNode.cpp | 4 +-
...st_ASTNodeAffectationExpressionBuilder.cpp | 55 +++---
...ASTNodeBinaryOperatorExpressionBuilder.cpp | 184 +++++++++---------
...test_ASTNodeCFunctionExpressionBuilder.cpp | 32 ++-
...TNodeDeclarationToAffectationConverter.cpp | 3 -
tests/test_ASTNodeEmptyBlockCleaner.cpp | 7 +-
tests/test_ASTNodeExpressionBuilder.cpp | 123 ++++++------
...odeFunctionEvaluationExpressionBuilder.cpp | 9 +-
.../test_ASTNodeFunctionExpressionBuilder.cpp | 24 +--
tests/test_ASTNodeIncDecExpressionBuilder.cpp | 28 ++-
tests/test_ASTNodeListProcessor.cpp | 5 +-
tests/test_ASTNodeTypeCleaner.cpp | 3 -
..._ASTNodeUnaryOperatorExpressionBuilder.cpp | 11 +-
tests/test_ASTNodeValueBuilder.cpp | 138 -------------
tests/test_ASTPrinter.cpp | 38 ++--
tests/test_AffectationProcessor.cpp | 6 +-
tests/test_AffectationToStringProcessor.cpp | 5 +-
.../test_BinaryExpressionProcessor_utils.hpp | 5 +-
tests/test_BreakProcessor.cpp | 4 +-
tests/test_CFunctionEmbedder.cpp | 16 +-
tests/test_CFunctionProcessor.cpp | 5 +-
tests/test_CMathModule.cpp | 97 ++++-----
tests/test_ConcatExpressionProcessor.cpp | 5 +-
tests/test_ContinueProcessor.cpp | 4 +-
tests/test_DoWhileProcessor.cpp | 5 +-
tests/test_ExecUntilBreakOrContinue.cpp | 32 ---
tests/test_ExecutionPolicy.cpp | 32 +++
tests/test_FakeProcessor.cpp | 2 +-
tests/test_ForProcessor.cpp | 5 +-
tests/test_FunctionProcessor.cpp | 5 +-
tests/test_INodeProcessor.cpp | 2 +-
tests/test_IfProcessor.cpp | 5 +-
tests/test_IncDecExpressionProcessor.cpp | 5 +-
tests/test_NameProcessor.cpp | 5 +-
tests/test_OStreamProcessor.cpp | 5 +-
tests/test_UnaryExpressionProcessor.cpp | 5 +-
tests/test_WhileProcessor.cpp | 5 +-
80 files changed, 839 insertions(+), 1001 deletions(-)
delete mode 100644 src/language/ASTNodeValueBuilder.cpp
delete mode 100644 src/language/ASTNodeValueBuilder.hpp
create mode 100644 src/language/node_processor/ASTNodeExpressionListProcessor.hpp
delete mode 100644 src/language/node_processor/ExecUntilBreakOrContinue.hpp
create mode 100644 src/language/node_processor/ExecutionPolicy.hpp
create mode 100644 src/language/node_processor/LocalNameProcessor.hpp
create mode 100644 src/language/node_processor/ValueProcessor.hpp
delete mode 100644 tests/test_ASTNodeValueBuilder.cpp
delete mode 100644 tests/test_ExecUntilBreakOrContinue.cpp
create mode 100644 tests/test_ExecutionPolicy.cpp
diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp
index 80b2a8c6e..5e6706a43 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 0219ef309..b958907ab 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 f2e2de4f3..db4533bdb 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 3e0033920..73be74fe8 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 5dc17b57f..b2e4cbb25 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 c9378f165..e745d24f8 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 8833958c6..3d8000370 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 f8f69e9c6..193d60e27 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 7db25c42b..8b0005c90 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 d0320c4ea..000000000
--- 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 0e60ccc71..000000000
--- 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 ca09efc5f..5b71a7094 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 d8eb0802a..22566006e 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 d78100060..7db59aae4 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 1abbde7aa..5434d4fa0 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 21a0c78fe..d37835666 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 5603fa424..ea4a37cd5 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 328e200cb..648f71c6e 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 000000000..88703b838
--- /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 b907b6fda..2303d3f2f 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 a538c351a..cbb7c4e74 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 da8fa59f7..c8561f61c 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 e00bf861f..292184271 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 2cefd9def..55354f788 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 a82495607..5f493b8d6 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 a6d64d3d5..29cd31a47 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 3a1a9d59b..a9c8a2005 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 c9aea0bc5..000000000
--- 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 000000000..3374a694c
--- /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 ac75d68ad..a93af47de 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 e06db01d0..09362e7fa 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 ccc7ce560..e2759e260 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 7c582b491..903175383 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 46d677724..c7c735162 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 7eccb590e..91f825949 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 000000000..6076fc379
--- /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 edb5d026c..c9515d7e9 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 615047e55..3ce3ca063 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 8f53bd09e..7e5c53916 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 000000000..134726f7b
--- /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 1a180f20d..3f66194bf 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 48856c05e..11242857c 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 a85927783..a2fed9058 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 4505c8664..a8366f4b1 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 cdceab453..4883f0995 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 1bff3eb40..22a93e75b 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 7ce9f1f32..da62df5a0 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 c1226f3ee..5d9503d9b 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 f1076d45e..5a8048662 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 fbadc0d1e..53b7b963f 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 cd9583f7a..80844f7be 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 3512e2133..a98670a13 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 b3a2971c7..7a68d8ca6 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 49bc6fe34..aaa78a060 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 02da34b90..e166b11d2 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 402b9f417..485486889 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 a39ca80a1..000000000
--- 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 a81699a60..a2e593e0d 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 aeb6e4859..b37a47c71 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 bdd384762..57209b308 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 d442a6763..6481ff830 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 7fb00cebb..d96f94ed2 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 032cf7f66..df76af84c 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 0a0a83230..7f47ada23 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 7d2b3b878..9ef32bf86 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 7bcfc0a1d..79c20b9d4 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 24cc87dcf..5dc50dfe2 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 9ccf21e37..135c8d221 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 4b96a799a..000000000
--- 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 000000000..f69dc72c0
--- /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 85e6ab827..c391423bc 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 4261a8193..7b4faa855 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 b4e2ea79a..9b163f022 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 5ccb1b88a..8295e977f 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 4ec597352..9df57fc07 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 0562c3f31..a2a2d988f 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 cd7374ae7..28e81a461 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 e217fa107..ad6b8578e 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 5c6a69436..d141ec0f2 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 b94cd9738..d9200a1f5 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; \
--
GitLab