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