diff --git a/.gitignore b/.gitignore
index e8ba8747559abdacd563868545e2a6666be82a3c..3bb6d6cbcf2906a99d3302595285d50145395fe5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,4 @@ CMakeCache.txt
GPATH
GRTAGS
GTAGS
+/.clangd/
diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index ed00e3032b5efddcbfbd21124836f737889041e3..faab47780f0736c43285b3245a8ee07cc966f036 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -16,6 +16,7 @@
#include <language/utils/ASTDotPrinter.hpp>
#include <language/utils/ASTExecutionInfo.hpp>
#include <language/utils/ASTPrinter.hpp>
+#include <language/utils/OperatorRepository.hpp>
#include <language/utils/SymbolTable.hpp>
#include <utils/PugsAssert.hpp>
#include <utils/PugsUtils.hpp>
@@ -48,6 +49,8 @@ parser(const std::string& filename)
<< rang::style::reset << " ...\n";
auto parse_and_execute = [](auto& input) {
+ OperatorRepository::create();
+
std::unique_ptr<ASTNode> root_node = ASTBuilder::build(input);
ASTModulesImporter module_importer{*root_node};
@@ -81,6 +84,8 @@ parser(const std::string& filename)
root_node->execute(exec_all);
root_node->m_symbol_table->clearValues();
+
+ OperatorRepository::destroy();
};
if (not SignalManager::pauseOnError()) {
diff --git a/src/language/ast/ASTNode.hpp b/src/language/ast/ASTNode.hpp
index a3b9bd21569d490b1bc7f450eee546279b91a681..d9568c612dd3e3a6223994cff6273b43d900b3c0 100644
--- a/src/language/ast/ASTNode.hpp
+++ b/src/language/ast/ASTNode.hpp
@@ -1,9 +1,9 @@
#ifndef AST_NODE_HPP
#define AST_NODE_HPP
-#include <language/ast/ASTNodeDataType.hpp>
#include <language/node_processor/ExecutionPolicy.hpp>
#include <language/node_processor/INodeProcessor.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/DataVariant.hpp>
#include <utils/PugsAssert.hpp>
#include <utils/PugsMacros.hpp>
diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index 66420138cd85f3fcf220ceec883f6c2b1b012759..6e712e3d84c0eb6d52064fdfecabd9dd6f9016db 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -3,437 +3,54 @@
#include <algebra/TinyVector.hpp>
#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNodeNaturalConversionChecker.hpp>
-#include <language/node_processor/AffectationProcessor.hpp>
+#include <language/node_processor/INodeProcessor.hpp>
+#include <language/utils/AffectationMangler.hpp>
+#include <language/utils/OperatorRepository.hpp>
#include <language/utils/ParseError.hpp>
-
#include <utils/Exceptions.hpp>
ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& n)
{
- auto set_affectation_processor = [](ASTNode& n, const auto& operator_v) {
- auto set_affectation_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) {
- using OperatorT = std::decay_t<decltype(operator_v)>;
- using ValueT = std::decay_t<decltype(value)>;
-
- switch (data_type) {
- case ASTNodeDataType::bool_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, bool>>(n);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, uint64_t>>(n);
- break;
- }
- case ASTNodeDataType::int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, int64_t>>(n);
- break;
- }
- case ASTNodeDataType::double_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: undefined operand type for affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- };
-
- auto set_affectation_processor_for_vector_data = [&](const auto& value, const ASTNodeDataType& data_type) {
- using OperatorT = std::decay_t<decltype(operator_v)>;
- using ValueT = std::decay_t<decltype(value)>;
-
- if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
- switch (data_type) {
- case ASTNodeDataType::vector_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, ValueT>>(n);
- break;
- }
- case ASTNodeDataType::list_t: {
- n.m_node_processor = std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(n);
- break;
- }
- case ASTNodeDataType::bool_t: {
- if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, bool>>(n);
- break;
- }
- }
- case ASTNodeDataType::unsigned_int_t: {
- if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, uint64_t>>(n);
- break;
- }
- }
- case ASTNodeDataType::int_t: {
- if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
- if (n.children[1]->is_type<language::integer>()) {
- if (std::stoi(n.children[1]->string()) == 0) {
- n.m_node_processor = std::make_unique<AffectationFromZeroProcessor<ValueT>>(n);
- break;
- }
- }
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, int64_t>>(n);
- break;
- } else if (n.children[1]->is_type<language::integer>()) {
- if (std::stoi(n.children[1]->string()) == 0) {
- n.m_node_processor = std::make_unique<AffectationFromZeroProcessor<ValueT>>(n);
- break;
- }
- }
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid integral value", std::vector{n.children[1]->begin()});
- // LCOV_EXCL_STOP
- }
- case ASTNodeDataType::double_t: {
- if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n);
- break;
- }
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid operand type", std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else if constexpr (std::is_same_v<OperatorT, language::pluseq_op> or
- std::is_same_v<OperatorT, language::minuseq_op>) {
- switch (data_type) {
- case ASTNodeDataType::vector_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, ValueT>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid operand type", std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else if constexpr (std::is_same_v<OperatorT, language::multiplyeq_op>) {
- switch (data_type) {
- case ASTNodeDataType::bool_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, bool>>(n);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, uint64_t>>(n);
- break;
- }
- case ASTNodeDataType::int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, int64_t>>(n);
- break;
- }
- case ASTNodeDataType::double_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n);
- break;
- }
- default: {
- throw ParseError("expecting scalar operand type", std::vector{n.children[1]->begin()});
- }
- }
- } else {
- throw ParseError("invalid affectation operator for " + dataTypeName(n.m_data_type), std::vector{n.begin()});
- }
- };
-
- auto set_affectation_processor_for_string_data = [&](const ASTNodeDataType& data_type) {
- using OperatorT = std::decay_t<decltype(operator_v)>;
-
- 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: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, bool>>(n);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, uint64_t>>(n);
- break;
- }
- case ASTNodeDataType::int_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, int64_t>>(n);
- break;
- }
- case ASTNodeDataType::double_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, double>>(n);
- break;
- }
- case ASTNodeDataType::string_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, std::string>>(n);
- break;
- }
- case ASTNodeDataType::vector_t: {
- switch (data_type.dimension()) {
- case 1: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, TinyVector<1>>>(n);
- break;
- }
- case 2: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, TinyVector<2>>>(n);
- break;
- }
- case 3: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, TinyVector<3>>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid vector dimension for string affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: undefined operand type for string affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else {
- throw ParseError("invalid affectation operator for string", std::vector{n.begin()});
- }
- };
-
- auto set_affectation_processor_for_embedded_data = [&](const ASTNodeDataType& data_type) {
- using OperatorT = std::decay_t<decltype(operator_v)>;
-
- if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
- switch (data_type) {
- case ASTNodeDataType::type_id_t: {
- n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, EmbeddedData, EmbeddedData>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: undefined operand type for embedded data affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else {
- throw ParseError("invalid affectation operator for '" + dataTypeName(n.children[0]->m_data_type) + "'",
- std::vector{n.begin()});
- }
- };
-
- auto set_affectation_processor_for_tuple_data = [&](const ASTNodeDataType& content_data_type,
- const ASTNodeDataType& data_type) {
- using OperatorT = std::decay_t<decltype(operator_v)>;
- if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
- if ((data_type == ASTNodeDataType::list_t) or (data_type == ASTNodeDataType::tuple_t)) {
- switch (content_data_type) {
- case ASTNodeDataType::type_id_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, EmbeddedData>>(n);
- break;
- }
- case ASTNodeDataType::bool_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, bool>>(n);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, uint64_t>>(n);
- break;
- }
- case ASTNodeDataType::int_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, int64_t>>(n);
- break;
- }
- case ASTNodeDataType::double_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, double>>(n);
- break;
- }
- case ASTNodeDataType::string_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, std::string>>(n);
- break;
- }
- case ASTNodeDataType::vector_t: {
- switch (content_data_type.dimension()) {
- case 1: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<1>>>(n);
- break;
- }
- case 2: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<2>>>(n);
- break;
- }
- case 3: {
- n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<3>>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid vector dimension for tuple affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw UnexpectedError("invalid tuple content " + dataTypeName(content_data_type));
- }
- // LCOV_EXCL_STOP
- }
- } else {
- switch (content_data_type) {
- case ASTNodeDataType::type_id_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, EmbeddedData>>(n);
- break;
- }
- case ASTNodeDataType::bool_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, bool>>(n);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, uint64_t>>(n);
- break;
- }
- case ASTNodeDataType::int_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, int64_t>>(n);
- break;
- }
- case ASTNodeDataType::double_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, double>>(n);
- break;
- }
- case ASTNodeDataType::string_t: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, std::string>>(n);
- break;
- }
- case ASTNodeDataType::vector_t: {
- switch (content_data_type.dimension()) {
- case 1: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, TinyVector<1>>>(n);
- break;
- }
- case 2: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, TinyVector<2>>>(n);
- break;
- }
- case 3: {
- n.m_node_processor = std::make_unique<AffectationToTupleProcessor<OperatorT, TinyVector<3>>>(n);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid vector dimension for tuple affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: undefined operand type for tuple affectation",
- std::vector{n.children[1]->begin()});
- }
- // LCOV_EXCL_STOP
- }
- }
- } else {
- throw ParseError("invalid affectation operator for '" + dataTypeName(n.children[0]->m_data_type) + "'",
- std::vector{n.begin()});
- }
- };
-
- auto set_affectation_processor_for_value = [&](const ASTNodeDataType& value_type) {
- const ASTNodeDataType data_type = n.children[1]->m_data_type;
-
- switch (value_type) {
- case ASTNodeDataType::bool_t: {
- set_affectation_processor_for_data(bool{}, data_type);
- break;
- }
- case ASTNodeDataType::unsigned_int_t: {
- set_affectation_processor_for_data(uint64_t{}, data_type);
- break;
- }
- case ASTNodeDataType::int_t: {
- set_affectation_processor_for_data(int64_t{}, data_type);
- break;
- }
- case ASTNodeDataType::double_t: {
- set_affectation_processor_for_data(double{}, data_type);
- break;
- }
- case ASTNodeDataType::vector_t: {
- switch (value_type.dimension()) {
- case 1: {
- set_affectation_processor_for_vector_data(TinyVector<1>{}, data_type);
- break;
- }
- case 2: {
- set_affectation_processor_for_vector_data(TinyVector<2>{}, data_type);
- break;
- }
- case 3: {
- set_affectation_processor_for_vector_data(TinyVector<3>{}, data_type);
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: unexpected vector dimension", std::vector{n.begin()});
- }
- // LCOV_EXCL_STOP
- }
- break;
- }
- case ASTNodeDataType::string_t: {
- set_affectation_processor_for_string_data(data_type);
- break;
- }
- case ASTNodeDataType::type_id_t: {
- set_affectation_processor_for_embedded_data(data_type);
- break;
- }
- case ASTNodeDataType::tuple_t: {
- const ASTNodeDataType& content_type = value_type.contentType();
- set_affectation_processor_for_tuple_data(content_type, data_type);
- break;
- }
- default: {
- throw ParseError("unexpected error: undefined value type for affectation", std::vector{n.children[0]->begin()});
- }
- }
- };
-
- using OperatorT = std::decay_t<decltype(operator_v)>;
-
- const ASTNodeDataType& target_data_type = n.children[0]->m_data_type;
- const ASTNodeDataType& source_data_type = n.children[1]->m_data_type;
-
- // Special treatment dedicated to R^1 to be able to initialize them
- if (((target_data_type != source_data_type) and (target_data_type == ASTNodeDataType::vector_t) and
- (target_data_type.dimension() == 1)) or
- // Special treatment for R^d vectors and operator *=
- ((target_data_type == ASTNodeDataType::vector_t) and (source_data_type != ASTNodeDataType::vector_t) and
- std::is_same_v<OperatorT, language::multiplyeq_op>)) {
- ASTNodeNaturalConversionChecker{*n.children[1], ASTNodeDataType::build<ASTNodeDataType::double_t>()};
+ const ASTNodeDataType& target_data_type = n.children[0]->m_data_type;
+ const ASTNodeDataType& source_data_type = n.children[1]->m_data_type;
+
+ const std::string affectation_name = [&] {
+ if (n.is_type<language::eq_op>()) {
+ return affectationMangler<language::eq_op>(target_data_type, source_data_type);
+ } else if (n.is_type<language::multiplyeq_op>()) {
+ return affectationMangler<language::multiplyeq_op>(target_data_type, source_data_type);
+ } else if (n.is_type<language::divideeq_op>()) {
+ return affectationMangler<language::divideeq_op>(target_data_type, source_data_type);
+ } else if (n.is_type<language::pluseq_op>()) {
+ return affectationMangler<language::pluseq_op>(target_data_type, source_data_type);
+ } else if (n.is_type<language::minuseq_op>()) {
+ return affectationMangler<language::minuseq_op>(target_data_type, source_data_type);
} else {
- ASTNodeNaturalConversionChecker{*n.children[1], target_data_type};
+ throw ParseError("unexpected error: undefined affectation operator", std::vector{n.begin()});
}
+ }();
+
+ // Special treatment dedicated to R^1 to be able to initialize them
+ if (((target_data_type != source_data_type) and (target_data_type == ASTNodeDataType::vector_t) and
+ (target_data_type.dimension() == 1)) or
+ // Special treatment for R^d vectors and operator *=
+ ((target_data_type == ASTNodeDataType::vector_t) and (source_data_type != ASTNodeDataType::vector_t) and
+ n.is_type<language::multiplyeq_op>())) {
+ ASTNodeNaturalConversionChecker{*n.children[1], ASTNodeDataType::build<ASTNodeDataType::double_t>()};
+ } else {
+ ASTNodeNaturalConversionChecker{*n.children[1], target_data_type};
+ }
- set_affectation_processor_for_value(target_data_type);
- };
+ const auto& optional_processor_builder =
+ OperatorRepository::instance().getAffectationProcessorBuilder(affectation_name);
- if (n.is_type<language::eq_op>()) {
- set_affectation_processor(n, language::eq_op{});
- } else if (n.is_type<language::multiplyeq_op>()) {
- set_affectation_processor(n, language::multiplyeq_op{});
- } else if (n.is_type<language::divideeq_op>()) {
- set_affectation_processor(n, language::divideeq_op{});
- } else if (n.is_type<language::pluseq_op>()) {
- set_affectation_processor(n, language::pluseq_op{});
- } else if (n.is_type<language::minuseq_op>()) {
- set_affectation_processor(n, language::minuseq_op{});
+ if (optional_processor_builder.has_value()) {
+ n.m_node_processor = optional_processor_builder.value()->getNodeProcessor(n);
} else {
- throw ParseError("unexpected error: undefined affectation operator", std::vector{n.begin()});
+ std::ostringstream error_message;
+ error_message << "undefined affectation type: ";
+ error_message << rang::fgB::red << affectation_name << rang::fg::reset;
+
+ throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
}
}
diff --git a/src/language/ast/ASTNodeNaturalConversionChecker.hpp b/src/language/ast/ASTNodeNaturalConversionChecker.hpp
index ebf83d7ca3d750d33fe6d18a6d0388bdea4c627c..9e96e49b90d5f7931aa4796a10f67dee0cfff6db 100644
--- a/src/language/ast/ASTNodeNaturalConversionChecker.hpp
+++ b/src/language/ast/ASTNodeNaturalConversionChecker.hpp
@@ -2,8 +2,8 @@
#define AST_NODE_NATURAL_CONVERSION_CHECKER_HPP
#include <language/ast/ASTNode.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
#include <language/ast/ASTNodeSubDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
struct AllowRToR1Conversion
{
diff --git a/src/language/ast/ASTNodeSubDataType.hpp b/src/language/ast/ASTNodeSubDataType.hpp
index d7844d367ae686fe88e05bc119d198288eca45c6..358aca9a1419309796b9fcb9baf8eb9825e7a4eb 100644
--- a/src/language/ast/ASTNodeSubDataType.hpp
+++ b/src/language/ast/ASTNodeSubDataType.hpp
@@ -2,7 +2,7 @@
#define AST_NODE_SUB_DATA_TYPE_HPP
#include <language/ast/ASTNode.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
struct ASTNodeSubDataType
{
diff --git a/src/language/ast/CMakeLists.txt b/src/language/ast/CMakeLists.txt
index f4c31774302ccff20b3d24f686fd7e381ff43822..458690fbd4fa341b257fcfe997e489048d1f961c 100644
--- a/src/language/ast/CMakeLists.txt
+++ b/src/language/ast/CMakeLists.txt
@@ -9,7 +9,7 @@ add_library(PugsLanguageAST
ASTNodeBuiltinFunctionExpressionBuilder.cpp
ASTNodeDataTypeBuilder.cpp
ASTNodeDataTypeChecker.cpp
- ASTNodeDataType.cpp
+# ASTNodeDataType.cpp
ASTNodeDataTypeFlattener.cpp
ASTNodeDeclarationToAffectationConverter.cpp
ASTNodeEmptyBlockCleaner.cpp
diff --git a/src/language/modules/BuiltinModule.hpp b/src/language/modules/BuiltinModule.hpp
index 6ea3ee56ae6f4b8c3cbfd86ede3370a638d0bff4..2be1d162578fb0d111e6eac7ae93e10dae981bce 100644
--- a/src/language/modules/BuiltinModule.hpp
+++ b/src/language/modules/BuiltinModule.hpp
@@ -1,8 +1,8 @@
#ifndef BUILTIN_MODULE_HPP
#define BUILTIN_MODULE_HPP
-#include <language/ast/ASTNodeDataType.hpp>
#include <language/modules/IModule.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
class IBuiltinFunctionEmbedder;
class TypeDescriptor;
diff --git a/src/language/modules/ModuleRepository.cpp b/src/language/modules/ModuleRepository.cpp
index abb5d527d4858f86ff3a25e68f4d666c2da8193b..65bfcafd1f1c85f077a97f6e932fa97da0079537 100644
--- a/src/language/modules/ModuleRepository.cpp
+++ b/src/language/modules/ModuleRepository.cpp
@@ -8,6 +8,7 @@
#include <language/modules/SchemeModule.hpp>
#include <language/modules/UtilsModule.hpp>
#include <language/modules/VTKModule.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
#include <language/utils/ParseError.hpp>
#include <language/utils/SymbolTable.hpp>
@@ -77,6 +78,11 @@ ModuleRepository::populateSymbolTable(const ASTNode& module_name_node, SymbolTab
this->_populateEmbedderTableT(module_name_node, module_name, populating_module.getNameTypeMap(),
ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>(), symbol_table,
symbol_table.typeEmbedderTable());
+
+ for (auto [symbol_name, embedded] : populating_module.getNameTypeMap()) {
+ BasicAffectationRegisterFor<EmbeddedData>(ASTNodeDataType::build<ASTNodeDataType::type_id_t>(symbol_name));
+ }
+
} else {
throw ParseError(std::string{"could not find module "} + module_name, std::vector{module_name_node.begin()});
}
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 6cdb19dfdd36359f6cd798149c7f2908770aadd0..88d4488365427aecbffd48abf9e37a3b08e55707 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -391,7 +391,7 @@ class AffectationToTinyVectorFromListProcessor final : public INodeProcessor
}
};
-template <typename OperatorT, typename ValueT>
+template <typename ValueT>
class AffectationToTupleProcessor final : public INodeProcessor
{
private:
@@ -403,7 +403,6 @@ class AffectationToTupleProcessor final : public INodeProcessor
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator to tuples");
DataVariant value = m_node.children[1]->execute(exec_policy);
std::visit(
@@ -450,7 +449,7 @@ class AffectationToTupleProcessor final : public INodeProcessor
}
};
-template <typename OperatorT, typename ValueT>
+template <typename ValueT>
class AffectationToTupleFromListProcessor final : public INodeProcessor
{
private:
@@ -562,8 +561,6 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to tuple");
-
std::visit(
[&](auto&& value_list) {
using ValueListT = std::decay_t<decltype(value_list)>;
diff --git a/src/language/ast/ASTNodeDataType.cpp b/src/language/utils/ASTNodeDataType.cpp
similarity index 99%
rename from src/language/ast/ASTNodeDataType.cpp
rename to src/language/utils/ASTNodeDataType.cpp
index 1f0847f865a6972e7865f4b50601898ab5930616..02a352ac3d0f7435c89445d4113b037bd0f54c2c 100644
--- a/src/language/ast/ASTNodeDataType.cpp
+++ b/src/language/utils/ASTNodeDataType.cpp
@@ -1,4 +1,4 @@
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNode.hpp>
diff --git a/src/language/ast/ASTNodeDataType.hpp b/src/language/utils/ASTNodeDataType.hpp
similarity index 100%
rename from src/language/ast/ASTNodeDataType.hpp
rename to src/language/utils/ASTNodeDataType.hpp
diff --git a/src/language/utils/ASTNodeDataTypeTraits.hpp b/src/language/utils/ASTNodeDataTypeTraits.hpp
index 946d63483dc8a61c33ade0b223c0619a66880fdd..ed668e5e40e1ff4920602014367f379aa384adb9 100644
--- a/src/language/utils/ASTNodeDataTypeTraits.hpp
+++ b/src/language/utils/ASTNodeDataTypeTraits.hpp
@@ -1,8 +1,8 @@
-#ifndef AST_NODE_DATA_TYPE_TRAITS_H
-#define AST_NODE_DATA_TYPE_TRAITS_H
+#ifndef AST_NODE_DATA_TYPE_TRAITS_HPP
+#define AST_NODE_DATA_TYPE_TRAITS_HPP
#include <algebra/TinyVector.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/FunctionSymbolId.hpp>
#include <vector>
@@ -32,4 +32,4 @@ template <typename T>
inline ASTNodeDataType ast_node_data_type_from<std::vector<T>> =
ASTNodeDataType::build<ASTNodeDataType::tuple_t>(ast_node_data_type_from<T>);
-#endif // AST_NODE_DATA_TYPE_TRAITS_H
+#endif // AST_NODE_DATA_TYPE_TRAITS_HPP
diff --git a/src/language/utils/AffectationMangler.hpp b/src/language/utils/AffectationMangler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b128da936298916241bb7b0bac1be73c53324361
--- /dev/null
+++ b/src/language/utils/AffectationMangler.hpp
@@ -0,0 +1,54 @@
+#ifndef AFFECTATION_MANGLER_HPP
+#define AFFECTATION_MANGLER_HPP
+
+#include <language/utils/ASTNodeDataType.hpp>
+#include <utils/Exceptions.hpp>
+
+#include <string>
+
+namespace language
+{
+struct eq_op;
+struct multiplyeq_op;
+struct divideeq_op;
+struct pluseq_op;
+struct minuseq_op;
+} // namespace language
+
+template <typename AffectationOperatorT>
+std::string
+affectationMangler(const ASTNodeDataType& lhs, const ASTNodeDataType& rhs)
+{
+ const std::string lhs_name = dataTypeName(lhs);
+
+ const std::string operator_name = [] {
+ if constexpr (std::is_same_v<language::eq_op, AffectationOperatorT>) {
+ return "=";
+ } else if constexpr (std::is_same_v<language::multiplyeq_op, AffectationOperatorT>) {
+ return "*=";
+ } else if constexpr (std::is_same_v<language::divideeq_op, AffectationOperatorT>) {
+ return "/=";
+ } else if constexpr (std::is_same_v<language::pluseq_op, AffectationOperatorT>) {
+ return "+=";
+ } else if constexpr (std::is_same_v<language::minuseq_op, AffectationOperatorT>) {
+ return "-=";
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("undefined affectation operator");
+ // LCOV_EXCL_STOP
+ }
+ }();
+
+ const std::string rhs_name = [&]() -> std::string {
+ if (rhs == ASTNodeDataType::list_t) {
+ return "list";
+ } else if (rhs == ASTNodeDataType::tuple_t) {
+ return "tuple";
+ } else {
+ return dataTypeName(rhs);
+ }
+ }();
+ return lhs_name + " " + operator_name + " " + rhs_name;
+}
+
+#endif // AFFECTATION_MANGLER_HPP
diff --git a/src/language/utils/AffectationProcessorBuilder.hpp b/src/language/utils/AffectationProcessorBuilder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..02042ad8825c7c890727edba6dd5dc41691a7d9e
--- /dev/null
+++ b/src/language/utils/AffectationProcessorBuilder.hpp
@@ -0,0 +1,86 @@
+#ifndef AFFECTATION_PROCESSOR_BUILDER_HPP
+#define AFFECTATION_PROCESSOR_BUILDER_HPP
+
+#include <algebra/TinyVector.hpp>
+#include <language/PEGGrammar.hpp>
+#include <language/node_processor/AffectationProcessor.hpp>
+#include <language/utils/IAffectationProcessorBuilder.hpp>
+
+#include <type_traits>
+
+template <typename OperatorT, typename ValueT, typename DataT>
+class AffectationProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& node) const
+ {
+ if constexpr (std::is_same_v<ValueT, TinyVector<1>> and std::is_same_v<DataT, int64_t> and
+ std::is_same_v<OperatorT, language::eq_op>) {
+ // Special treatment for the case 0 -> R^1
+ if ((node.children[1]->is_type<language::integer>()) and (std::stoi(node.children[1]->string()) == 0)) {
+ return std::make_unique<AffectationFromZeroProcessor<ValueT>>(node);
+ } else {
+ return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(node);
+ }
+ } else {
+ return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(node);
+ }
+ }
+};
+
+template <typename ValueT>
+class AffectationToTupleProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationToTupleProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& node) const
+ {
+ return std::make_unique<AffectationToTupleProcessor<ValueT>>(node);
+ }
+};
+
+template <typename ValueT>
+class AffectationToTupleFromListProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationToTupleFromListProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& node) const
+ {
+ return std::make_unique<AffectationToTupleFromListProcessor<ValueT>>(node);
+ }
+};
+
+template <typename OperatorT, typename ValueT>
+class AffectationToTinyVectorFromListProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationToTinyVectorFromListProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& node) const
+ {
+ return std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(node);
+ }
+};
+
+template <typename OperatorT, typename ValueT>
+class AffectationFromZeroProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationFromZeroProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& node) const
+ {
+ if (std::stoi(node.children[1]->string()) == 0) {
+ return std::make_unique<AffectationFromZeroProcessor<ValueT>>(node);
+ }
+ // LCOV_EXCL_START
+ throw ParseError("unexpected error: invalid integral value", std::vector{node.children[1]->begin()});
+ // LCOV_EXCL_STOP
+ }
+};
+
+#endif // AFFECTATION_PROCESSOR_BUILDER_HPP
diff --git a/src/language/utils/AffectationRegisterForB.cpp b/src/language/utils/AffectationRegisterForB.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69feaee7066a7d95f17bf539df75e46cf3fe27c5
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForB.cpp
@@ -0,0 +1,10 @@
+#include <language/utils/AffectationRegisterForB.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+AffectationRegisterForB::AffectationRegisterForB()
+{
+ BasicAffectationRegisterFor<bool>{};
+}
diff --git a/src/language/utils/AffectationRegisterForB.hpp b/src/language/utils/AffectationRegisterForB.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4064d498890563e433c325696e447045e00b495d
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForB.hpp
@@ -0,0 +1,12 @@
+#ifndef AFFECTATION_REGISTER_FOR_B_HPP
+#define AFFECTATION_REGISTER_FOR_B_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForB
+{
+ public:
+ AffectationRegisterForB();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_B_HPP
diff --git a/src/language/utils/AffectationRegisterForN.cpp b/src/language/utils/AffectationRegisterForN.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e7d54008f22845f8233b8475091c8cec774c6756
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForN.cpp
@@ -0,0 +1,120 @@
+#include <language/utils/AffectationRegisterForN.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForN::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+ repository
+ .addAffectation<language::eq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, uint64_t, bool>>());
+
+ repository.addAffectation<
+ language::eq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, uint64_t, int64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<uint64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<uint64_t>>());
+}
+
+void
+AffectationRegisterForN::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+ repository.addAffectation<
+ language::pluseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, bool>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForN::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+ repository.addAffectation<
+ language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, bool>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForN::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+ repository.addAffectation<
+ language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, uint64_t, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, uint64_t, uint64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, uint64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForN::_register_divideeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+ repository.addAffectation<
+ language::divideeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, uint64_t, bool>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, uint64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, uint64_t, int64_t>>());
+}
+
+AffectationRegisterForN::AffectationRegisterForN()
+{
+ BasicAffectationRegisterFor<uint64_t>{};
+
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+ this->_register_divideeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForN.hpp b/src/language/utils/AffectationRegisterForN.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..56f7699e8874a93823a90c4a2078c1fac7a7eabd
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForN.hpp
@@ -0,0 +1,19 @@
+#ifndef AFFECTATION_REGISTER_FOR_N_HPP
+#define AFFECTATION_REGISTER_FOR_N_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForN
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+ void _register_divideeq_op();
+
+ public:
+ AffectationRegisterForN();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_N_HPP
diff --git a/src/language/utils/AffectationRegisterForR.cpp b/src/language/utils/AffectationRegisterForR.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae7c63c4031f39871f64713c39cc7dcba8e0bae4
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR.cpp
@@ -0,0 +1,141 @@
+#include <language/utils/AffectationRegisterForR.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForR::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository
+ .addAffectation<language::eq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, double, bool>>());
+
+ repository.addAffectation<
+ language::eq_op>(R, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, double, uint64_t>>());
+
+ repository
+ .addAffectation<language::eq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, double, int64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<double>>());
+}
+
+void
+AffectationRegisterForR::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository.addAffectation<
+ language::pluseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, double, bool>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, double, uint64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, double, int64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(R, R, std::make_shared<AffectationProcessorBuilder<language::pluseq_op, double, double>>());
+}
+
+void
+AffectationRegisterForR::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository.addAffectation<
+ language::minuseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, double, bool>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, double, uint64_t>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, double, int64_t>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(R, R, std::make_shared<AffectationProcessorBuilder<language::minuseq_op, double, double>>());
+}
+
+void
+AffectationRegisterForR::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository.addAffectation<
+ language::multiplyeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, double, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, double, uint64_t>>());
+
+ repository.addAffectation<
+ language::multiplyeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, double, int64_t>>());
+
+ repository.addAffectation<
+ language::multiplyeq_op>(R, R,
+ std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, double, double>>());
+}
+
+void
+AffectationRegisterForR::_register_divideeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository.addAffectation<
+ language::divideeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, double, bool>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, double, uint64_t>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, double, int64_t>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(R, R,
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, double, double>>());
+}
+
+AffectationRegisterForR::AffectationRegisterForR()
+{
+ BasicAffectationRegisterFor<double>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+ this->_register_divideeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForR.hpp b/src/language/utils/AffectationRegisterForR.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..141a0d8ae86f6c2e6355cd1ca74e801fc00bc0f0
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR.hpp
@@ -0,0 +1,19 @@
+#ifndef AFFECTATION_REGISTER_FOR_R_HPP
+#define AFFECTATION_REGISTER_FOR_R_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForR
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+ void _register_divideeq_op();
+
+ public:
+ AffectationRegisterForR();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_R_HPP
diff --git a/src/language/utils/AffectationRegisterForR1.cpp b/src/language/utils/AffectationRegisterForR1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..20873d6fda648ee254ae5cca965026a30033c92a
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR1.cpp
@@ -0,0 +1,102 @@
+#include <language/utils/AffectationRegisterForR1.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForR1::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+
+ repository.addAffectation<
+ language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, bool>>());
+
+ repository.addAffectation<
+ language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, uint64_t>>());
+
+ repository.addAffectation<
+ language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, int64_t>>());
+
+ repository.addAffectation<
+ language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
+}
+
+void
+AffectationRegisterForR1::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+
+ repository.addAffectation<language::pluseq_op>(R1, R1,
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, TinyVector<1>, TinyVector<1>>>());
+}
+
+void
+AffectationRegisterForR1::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+
+ repository.addAffectation<language::minuseq_op>(R1, R1,
+ std::make_shared<AffectationProcessorBuilder<
+ language::minuseq_op, TinyVector<1>, TinyVector<1>>>());
+}
+
+void
+AffectationRegisterForR1::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+
+ repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<1>, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<1>, uint64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<1>, int64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<1>, double>>());
+}
+
+AffectationRegisterForR1::AffectationRegisterForR1()
+{
+ BasicAffectationRegisterFor<TinyVector<1>>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForR1.hpp b/src/language/utils/AffectationRegisterForR1.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..04016bd6742c9635f2a3599d0852186364a81350
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR1.hpp
@@ -0,0 +1,18 @@
+#ifndef AFFECTATION_REGISTER_FOR_R1_HPP
+#define AFFECTATION_REGISTER_FOR_R1_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForR1
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+
+ public:
+ AffectationRegisterForR1();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_R1_HPP
diff --git a/src/language/utils/AffectationRegisterForR2.cpp b/src/language/utils/AffectationRegisterForR2.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0fca199a929d2f35698cc6857f80a0b127352607
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR2.cpp
@@ -0,0 +1,84 @@
+#include <language/utils/AffectationRegisterForR2.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForR2::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+
+ repository.addAffectation<
+ language::eq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<2>>>());
+
+ repository.addAffectation<language::eq_op>(R2,
+ ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
+ std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
+ language::eq_op, TinyVector<2>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R2),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<2>>>());
+}
+
+void
+AffectationRegisterForR2::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+
+ repository.addAffectation<language::pluseq_op>(R2, R2,
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, TinyVector<2>, TinyVector<2>>>());
+}
+
+void
+AffectationRegisterForR2::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+
+ repository.addAffectation<language::minuseq_op>(R2, R2,
+ std::make_shared<AffectationProcessorBuilder<
+ language::minuseq_op, TinyVector<2>, TinyVector<2>>>());
+}
+
+void
+AffectationRegisterForR2::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+
+ repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<2>, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<2>, uint64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<2>, int64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<2>, double>>());
+}
+
+AffectationRegisterForR2::AffectationRegisterForR2()
+{
+ BasicAffectationRegisterFor<TinyVector<2>>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForR2.hpp b/src/language/utils/AffectationRegisterForR2.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c1c5c1fa51f0282cfb4a63de15b4f0c015d8fd4
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR2.hpp
@@ -0,0 +1,18 @@
+#ifndef AFFECTATION_REGISTER_FOR_R2_HPP
+#define AFFECTATION_REGISTER_FOR_R2_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForR2
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+
+ public:
+ AffectationRegisterForR2();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_R2_HPP
diff --git a/src/language/utils/AffectationRegisterForR3.cpp b/src/language/utils/AffectationRegisterForR3.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d5925d7bcb828bc013cefbb130626dce9af9ddec
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR3.cpp
@@ -0,0 +1,84 @@
+#include <language/utils/AffectationRegisterForR3.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForR3::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+
+ repository.addAffectation<
+ language::eq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<3>>>());
+
+ repository.addAffectation<language::eq_op>(R3,
+ ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
+ std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
+ language::eq_op, TinyVector<3>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R3),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<3>>>());
+}
+
+void
+AffectationRegisterForR3::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+
+ repository.addAffectation<language::pluseq_op>(R3, R3,
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, TinyVector<3>, TinyVector<3>>>());
+}
+
+void
+AffectationRegisterForR3::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+
+ repository.addAffectation<language::minuseq_op>(R3, R3,
+ std::make_shared<AffectationProcessorBuilder<
+ language::minuseq_op, TinyVector<3>, TinyVector<3>>>());
+}
+
+void
+AffectationRegisterForR3::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+
+ repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<3>, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<3>, uint64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<3>, int64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, TinyVector<3>, double>>());
+}
+
+AffectationRegisterForR3::AffectationRegisterForR3()
+{
+ BasicAffectationRegisterFor<TinyVector<3>>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForR3.hpp b/src/language/utils/AffectationRegisterForR3.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..09ae3f3e85062e9f3e33bf02dac1693558ae49f1
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForR3.hpp
@@ -0,0 +1,18 @@
+#ifndef AFFECTATION_REGISTER_FOR_R3_HPP
+#define AFFECTATION_REGISTER_FOR_R3_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForR3
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+
+ public:
+ AffectationRegisterForR3();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_R3_HPP
diff --git a/src/language/utils/AffectationRegisterForString.cpp b/src/language/utils/AffectationRegisterForString.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37446e243d6fcb14fcd6c3e97a845d17b831c2e6
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForString.cpp
@@ -0,0 +1,140 @@
+#include <language/utils/AffectationRegisterForString.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForString::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto string_t = ASTNodeDataType::build<ASTNodeDataType::string_t>();
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, bool>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, uint64_t>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, int64_t>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, double_t>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<1>>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<2>>>());
+
+ repository.addAffectation<
+ language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<3>>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+}
+
+void
+AffectationRegisterForString::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto string_t = ASTNodeDataType::build<ASTNodeDataType::string_t>();
+
+ repository.addAffectation<language::pluseq_op>(string_t, string_t,
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, std::string, std::string>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, bool>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, uint64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, int64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, double>>());
+
+ repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, std::string, TinyVector<1>>>());
+
+ repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, std::string, TinyVector<2>>>());
+
+ repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ std::make_shared<AffectationProcessorBuilder<
+ language::pluseq_op, std::string, TinyVector<3>>>());
+
+ // this->_addAffectation("string += string",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string,
+ // std::string>>());
+ // this->_addAffectation("string += B",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, bool>>());
+ // this->_addAffectation("string += N",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, uint64_t>>());
+ // this->_addAffectation("string += Z",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, int64_t>>());
+ // this->_addAffectation("string += R",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, double>>());
+ // this
+ // ->_addAffectation("string += R^1",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string,
+ // TinyVector<1>>>());
+ // this
+ // ->_addAffectation("string += R^2",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string,
+ // TinyVector<2>>>());
+ // this
+ // ->_addAffectation("string += R^3",
+ // std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string,
+ // TinyVector<3>>>());
+}
+
+AffectationRegisterForString::AffectationRegisterForString()
+{
+ BasicAffectationRegisterFor<std::string>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForString.hpp b/src/language/utils/AffectationRegisterForString.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2aa4b319ba1029ebffdc3dcd919f250dd963113e
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForString.hpp
@@ -0,0 +1,16 @@
+#ifndef AFFECTATION_REGISTER_FOR_STRING_HPP
+#define AFFECTATION_REGISTER_FOR_STRING_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForString
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+
+ public:
+ AffectationRegisterForString();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_STRING_HPP
diff --git a/src/language/utils/AffectationRegisterForZ.cpp b/src/language/utils/AffectationRegisterForZ.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9937a0edbaedce2ae054d02fc13d7c4e1168c698
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForZ.cpp
@@ -0,0 +1,119 @@
+#include <language/utils/AffectationRegisterForZ.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+AffectationRegisterForZ::_register_eq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+ repository
+ .addAffectation<language::eq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, int64_t, bool>>());
+
+ repository.addAffectation<
+ language::eq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, int64_t, uint64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<int64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationToTupleProcessorBuilder<int64_t>>());
+}
+
+void
+AffectationRegisterForZ::_register_pluseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+ repository.addAffectation<
+ language::pluseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, int64_t, bool>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, int64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::pluseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::pluseq_op, int64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForZ::_register_minuseq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+ repository.addAffectation<
+ language::minuseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, int64_t, bool>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, int64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::minuseq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::minuseq_op, int64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForZ::_register_multiplyeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+ repository.addAffectation<
+ language::multiplyeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, int64_t, bool>>());
+
+ repository.addAffectation<language::multiplyeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, int64_t, uint64_t>>());
+
+ repository.addAffectation<language::multiplyeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<
+ language::multiplyeq_op, int64_t, int64_t>>());
+}
+
+void
+AffectationRegisterForZ::_register_divideeq_op()
+{
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+ repository.addAffectation<
+ language::divideeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, int64_t, bool>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, int64_t, uint64_t>>());
+
+ repository.addAffectation<
+ language::divideeq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ std::make_shared<AffectationProcessorBuilder<language::divideeq_op, int64_t, int64_t>>());
+}
+
+AffectationRegisterForZ::AffectationRegisterForZ()
+{
+ BasicAffectationRegisterFor<int64_t>{};
+ this->_register_eq_op();
+ this->_register_pluseq_op();
+ this->_register_minuseq_op();
+ this->_register_multiplyeq_op();
+ this->_register_divideeq_op();
+}
diff --git a/src/language/utils/AffectationRegisterForZ.hpp b/src/language/utils/AffectationRegisterForZ.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2f13e10f67bd02e7d616a16d271a7ffb14a2351f
--- /dev/null
+++ b/src/language/utils/AffectationRegisterForZ.hpp
@@ -0,0 +1,19 @@
+#ifndef AFFECTATION_REGISTER_FOR_Z_HPP
+#define AFFECTATION_REGISTER_FOR_Z_HPP
+
+#include <language/utils/OperatorRepository.hpp>
+
+class AffectationRegisterForZ
+{
+ private:
+ void _register_eq_op();
+ void _register_pluseq_op();
+ void _register_minuseq_op();
+ void _register_multiplyeq_op();
+ void _register_divideeq_op();
+
+ public:
+ AffectationRegisterForZ();
+};
+
+#endif // AFFECTATION_REGISTER_FOR_Z_HPP
diff --git a/src/language/utils/BasicAffectationRegistrerFor.hpp b/src/language/utils/BasicAffectationRegistrerFor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ccae4c32b596b39ce7b663da38e31e70c8dfbebc
--- /dev/null
+++ b/src/language/utils/BasicAffectationRegistrerFor.hpp
@@ -0,0 +1,36 @@
+#ifndef BASIC_AFFECTATION_REGISTRER_FOR_HPP
+#define BASIC_AFFECTATION_REGISTRER_FOR_HPP
+
+#include <language/utils/ASTNodeDataTypeTraits.hpp>
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+template <typename T>
+class BasicAffectationRegisterFor
+{
+ public:
+ BasicAffectationRegisterFor() : BasicAffectationRegisterFor(ast_node_data_type_from<T>) {}
+
+ BasicAffectationRegisterFor(const ASTNodeDataType& ast_node_data_type)
+ {
+ OperatorRepository& repository = OperatorRepository::instance();
+
+ repository.addAffectation<language::eq_op>(ast_node_data_type, ast_node_data_type,
+ std::make_shared<AffectationProcessorBuilder<language::eq_op, T, T>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(ast_node_data_type),
+ ast_node_data_type,
+ std::make_shared<AffectationToTupleProcessorBuilder<T>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(ast_node_data_type),
+ ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
+ std::make_shared<AffectationToTupleFromListProcessorBuilder<T>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(ast_node_data_type),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(ast_node_data_type),
+ std::make_shared<AffectationToTupleFromListProcessorBuilder<T>>());
+ }
+};
+
+#endif // BASIC_AFFECTATION_REGISTRER_FOR_HPP
diff --git a/src/language/utils/BuiltinFunctionEmbedder.hpp b/src/language/utils/BuiltinFunctionEmbedder.hpp
index d394aa20f9721a1dc12821960890d0c1f0b6db1c..afb991acadcb36236bcd55a34c7840ca399ab6f0 100644
--- a/src/language/utils/BuiltinFunctionEmbedder.hpp
+++ b/src/language/utils/BuiltinFunctionEmbedder.hpp
@@ -1,7 +1,7 @@
#ifndef BUILTIN_FUNCTION_EMBEDDER_HPP
#define BUILTIN_FUNCTION_EMBEDDER_HPP
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/DataHandler.hpp>
#include <language/utils/DataVariant.hpp>
diff --git a/src/language/utils/CMakeLists.txt b/src/language/utils/CMakeLists.txt
index 1cb991d6c6d19a18579d3c0802a6ea032891d5c2..aee593608a269217f3a7c05791bd642ccfa79b72 100644
--- a/src/language/utils/CMakeLists.txt
+++ b/src/language/utils/CMakeLists.txt
@@ -1,11 +1,21 @@
# ------------------- Source files --------------------
add_library(PugsLanguageUtils
+ AffectationRegisterForB
+ AffectationRegisterForN
+ AffectationRegisterForR
+ AffectationRegisterForR1
+ AffectationRegisterForR2
+ AffectationRegisterForR3
+ AffectationRegisterForString
+ AffectationRegisterForZ
ASTDotPrinter.cpp
ASTExecutionInfo.cpp
+ ASTNodeDataType.cpp
ASTPrinter.cpp
DataVariant.cpp
EmbeddedData.cpp
+ OperatorRepository.cpp
)
diff --git a/src/language/utils/FunctionTable.hpp b/src/language/utils/FunctionTable.hpp
index 43232fd60e4482a73dca1a4b257c7a6c0b6ef28a..6c6450c22ff8ff845ddd0c90dbcead1eec52203c 100644
--- a/src/language/utils/FunctionTable.hpp
+++ b/src/language/utils/FunctionTable.hpp
@@ -2,7 +2,7 @@
#define FUNCTION_TABLE_HPP
#include <language/ast/ASTNode.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/DataVariant.hpp>
#include <utils/PugsAssert.hpp>
@@ -63,14 +63,16 @@ class FunctionTable
}
PUGS_INLINE
- FunctionDescriptor& operator[](size_t function_id)
+ FunctionDescriptor&
+ operator[](size_t function_id)
{
Assert(function_id < m_function_descriptor_list.size());
return m_function_descriptor_list[function_id];
}
PUGS_INLINE
- const FunctionDescriptor& operator[](size_t function_id) const
+ const FunctionDescriptor&
+ operator[](size_t function_id) const
{
Assert(function_id < m_function_descriptor_list.size());
return m_function_descriptor_list[function_id];
diff --git a/src/language/utils/IAffectationProcessorBuilder.hpp b/src/language/utils/IAffectationProcessorBuilder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d5f8540df9435bba4b86e6bee22f980b5727d7b
--- /dev/null
+++ b/src/language/utils/IAffectationProcessorBuilder.hpp
@@ -0,0 +1,17 @@
+#ifndef I_AFFECTATION_PROCESSOR_BUILDER_HPP
+#define I_AFFECTATION_PROCESSOR_BUILDER_HPP
+
+class ASTNode;
+class INodeProcessor;
+
+#include <memory>
+
+class IAffectationProcessorBuilder
+{
+ public:
+ virtual std::unique_ptr<INodeProcessor> getNodeProcessor(ASTNode& node) const = 0;
+
+ virtual ~IAffectationProcessorBuilder() = default;
+};
+
+#endif // I_AFFECTATION_PROCESSOR_BUILDER_HPP
diff --git a/src/language/utils/OperatorRepository.cpp b/src/language/utils/OperatorRepository.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cbd520dd402990188cb44685088eecdfab015907
--- /dev/null
+++ b/src/language/utils/OperatorRepository.cpp
@@ -0,0 +1,51 @@
+#include <language/utils/OperatorRepository.hpp>
+
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/AffectationRegisterForB.hpp>
+#include <language/utils/AffectationRegisterForN.hpp>
+#include <language/utils/AffectationRegisterForR.hpp>
+#include <language/utils/AffectationRegisterForR1.hpp>
+#include <language/utils/AffectationRegisterForR2.hpp>
+#include <language/utils/AffectationRegisterForR3.hpp>
+#include <language/utils/AffectationRegisterForString.hpp>
+#include <language/utils/AffectationRegisterForZ.hpp>
+
+#include <utils/PugsAssert.hpp>
+
+OperatorRepository* OperatorRepository::m_instance = nullptr;
+
+void
+OperatorRepository::reset()
+{
+ m_affectation_builder_list.clear();
+ this->_initialize();
+}
+
+void
+OperatorRepository::create()
+{
+ Assert(m_instance == nullptr, "AffectationRepository was already created");
+ m_instance = new OperatorRepository;
+ m_instance->_initialize();
+}
+
+void
+OperatorRepository::destroy()
+{
+ Assert(m_instance != nullptr, "AffectationRepository was not created");
+ delete m_instance;
+ m_instance = nullptr;
+}
+
+void
+OperatorRepository::_initialize()
+{
+ AffectationRegisterForB{};
+ AffectationRegisterForN{};
+ AffectationRegisterForZ{};
+ AffectationRegisterForR{};
+ AffectationRegisterForR1{};
+ AffectationRegisterForR2{};
+ AffectationRegisterForR3{};
+ AffectationRegisterForString{};
+}
diff --git a/src/language/utils/OperatorRepository.hpp b/src/language/utils/OperatorRepository.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..509410d98930e0c4805e1dd62955842e120165da
--- /dev/null
+++ b/src/language/utils/OperatorRepository.hpp
@@ -0,0 +1,65 @@
+#ifndef OPERATOR_REPOSITORY_HPP
+#define OPERATOR_REPOSITORY_HPP
+
+#include <language/node_processor/INodeProcessor.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
+#include <language/utils/AffectationMangler.hpp>
+#include <language/utils/IAffectationProcessorBuilder.hpp>
+
+#include <utils/Exceptions.hpp>
+
+#include <optional>
+
+class OperatorRepository
+{
+ private:
+ std::unordered_map<std::string, std::shared_ptr<const IAffectationProcessorBuilder>> m_affectation_builder_list;
+
+ void _initialize();
+
+ public:
+ void reset();
+
+ template <typename OperatorTypeT, typename AffectationProcessorBuilderT>
+ void
+ addAffectation(const ASTNodeDataType& lhs,
+ const ASTNodeDataType& rhs,
+ const std::shared_ptr<AffectationProcessorBuilderT>& processor_builder)
+ {
+ const std::string affectation_type_name = affectationMangler<OperatorTypeT>(lhs, rhs);
+ if (not m_affectation_builder_list.try_emplace(affectation_type_name, processor_builder).second) {
+ throw UnexpectedError(affectation_type_name + " has already an entry");
+ }
+ }
+
+ std::optional<std::shared_ptr<const IAffectationProcessorBuilder>>
+ getAffectationProcessorBuilder(const std::string& affectation_name) const
+ {
+ auto&& processor_builder = m_affectation_builder_list.find(affectation_name);
+ if (processor_builder != m_affectation_builder_list.end()) {
+ return processor_builder->second;
+ }
+ return {};
+ }
+
+ static void create();
+
+ PUGS_INLINE
+ static OperatorRepository&
+ instance()
+ {
+ Assert(m_instance != nullptr);
+ return *m_instance;
+ }
+
+ static void destroy();
+
+ private:
+ static OperatorRepository* m_instance;
+
+ OperatorRepository() = default;
+
+ ~OperatorRepository() = default;
+};
+
+#endif // OPERATOR_REPOSITORY_HPP
diff --git a/src/language/utils/PugsFunctionAdapter.hpp b/src/language/utils/PugsFunctionAdapter.hpp
index 17d97f509c2466b97d3a8ee46cc34ca8ee6b06fe..278c7274ff702cfc5e97f7b6075b5487e440580b 100644
--- a/src/language/utils/PugsFunctionAdapter.hpp
+++ b/src/language/utils/PugsFunctionAdapter.hpp
@@ -2,8 +2,8 @@
#define PUGS_FUNCTION_ADAPTER_HPP
#include <language/ast/ASTNode.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
#include <language/node_processor/ExecutionPolicy.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/SymbolTable.hpp>
#include <utils/Array.hpp>
diff --git a/src/language/utils/SymbolTable.hpp b/src/language/utils/SymbolTable.hpp
index 39d414b1e120255e9d51c17266512458fcc5f1b8..6aa089bd8de7aa5a3a6a6cf2a8115e77de25dbe8 100644
--- a/src/language/utils/SymbolTable.hpp
+++ b/src/language/utils/SymbolTable.hpp
@@ -1,7 +1,7 @@
#ifndef SYMBOL_TABLE_HPP
#define SYMBOL_TABLE_HPP
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
#include <language/utils/DataVariant.hpp>
#include <language/utils/EmbedderTable.hpp>
#include <language/utils/FunctionTable.hpp>
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index edaa8069ad867aeaa139f68f646519a6219097d0..5ae8aeef954932a6051be1f6f916d20dbad2b9f3 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -125,7 +125,16 @@ target_link_libraries (unit_tests
target_link_libraries (mpi_unit_tests
test_Pugs_MeshDataBase
+ PugsAlgebra
+ PugsUtils
+ PugsLanguage
+ PugsLanguageAST
+ PugsLanguageModules
+ PugsLanguageAlgorithms
+ PugsMesh
+ PugsAlgebra
PugsUtils
+ PugsLanguageUtils PugsUtils
PugsAlgebra
PugsMesh
kokkos
diff --git a/tests/mpi_test_main.cpp b/tests/mpi_test_main.cpp
index 87953af0c1d98a6b099b8d99606d8f4eaa686a40..44162aba3edce0e992b7f37e6df6cca1040b3291 100644
--- a/tests/mpi_test_main.cpp
+++ b/tests/mpi_test_main.cpp
@@ -4,6 +4,7 @@
#include <Kokkos_Core.hpp>
#include <algebra/PETScWrapper.hpp>
+#include <language/utils/OperatorRepository.hpp>
#include <mesh/DiamondDualConnectivityManager.hpp>
#include <mesh/DiamondDualMeshManager.hpp>
#include <mesh/MeshDataManager.hpp>
@@ -78,8 +79,12 @@ main(int argc, char* argv[])
}
}
+ OperatorRepository::create();
+
result = session.run();
+ OperatorRepository::destroy();
+
MeshDataBaseForTests::destroy();
DiamondDualMeshManager::destroy();
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index 64d60d9bfbed21703850f2d945092a9d5ae49fe0..ecd72b1f04b52b47431e10d07b83d3dab441066e 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -10,33 +10,40 @@
#include <language/ast/ASTSymbolTableBuilder.hpp>
#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/ASTPrinter.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/EmbeddedData.hpp>
#include <language/utils/TypeDescriptor.hpp>
#include <utils/Demangle.hpp>
#include <utils/Exceptions.hpp>
#include <pegtl/string_input.hpp>
-#define CHECK_AST(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> or \
- std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>); \
- \
- string_input input{data, "test.pgs"}; \
- auto ast = ASTBuilder::build(input); \
- \
- ASTSymbolTableBuilder{*ast}; \
- ASTNodeDataTypeBuilder{*ast}; \
- \
- ASTNodeDeclarationToAffectationConverter{*ast}; \
- ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
- \
- ASTNodeExpressionBuilder{*ast}; \
- \
- std::stringstream ast_output; \
- ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
- \
- REQUIRE(ast_output.str() == expected_output); \
+#define CHECK_AST(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> or \
+ std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>); \
+ \
+ string_input input{data, "test.pgs"}; \
+ \
+ BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
+ \
+ auto ast = ASTBuilder::build(input); \
+ \
+ ASTSymbolTableBuilder{*ast}; \
+ ASTNodeDataTypeBuilder{*ast}; \
+ \
+ ASTNodeDeclarationToAffectationConverter{*ast}; \
+ ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
+ \
+ ASTNodeExpressionBuilder{*ast}; \
+ \
+ std::stringstream ast_output; \
+ ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
+ \
+ REQUIRE(ast_output.str() == expected_output); \
+ \
+ OperatorRepository::instance().reset(); \
}
template <>
@@ -44,51 +51,55 @@ inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const double>> =
ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t");
const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const double>>;
-#define CHECK_AST_WITH_BUILTIN(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> or \
- std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>); \
- \
- string_input input{data, "test.pgs"}; \
- auto ast = ASTBuilder::build(input); \
- \
- SymbolTable& symbol_table = *ast->m_symbol_table; \
- auto [i_symbol, success] = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin()); \
- if (not success) { \
- throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing"); \
- } \
- \
- i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>()); \
- i_symbol->attributes().setIsInitialized(); \
- i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size(); \
- symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId())); \
- \
- auto [i_symbol_a, success_a] = symbol_table.add("a", ast->begin()); \
- if (not success_a) { \
- throw UnexpectedError("cannot add 'a' of type builtin_t for testing"); \
- } \
- i_symbol_a->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
- i_symbol_a->attributes().setIsInitialized(); \
- auto [i_symbol_b, success_b] = symbol_table.add("b", ast->begin()); \
- if (not success_b) { \
- throw UnexpectedError("cannot add 'b' of type builtin_t for testing"); \
- } \
- i_symbol_b->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
- i_symbol_b->attributes().setIsInitialized(); \
- \
- ASTSymbolTableBuilder{*ast}; \
- ASTNodeDataTypeBuilder{*ast}; \
- \
- ASTNodeDeclarationToAffectationConverter{*ast}; \
- ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
- \
- ASTNodeExpressionBuilder{*ast}; \
- \
- std::stringstream ast_output; \
- ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
- \
- REQUIRE(ast_output.str() == expected_output); \
+#define CHECK_AST_WITH_BUILTIN(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> or \
+ std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>); \
+ \
+ BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
+ \
+ string_input input{data, "test.pgs"}; \
+ auto ast = ASTBuilder::build(input); \
+ \
+ SymbolTable& symbol_table = *ast->m_symbol_table; \
+ auto [i_symbol, success] = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin()); \
+ if (not success) { \
+ throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing"); \
+ } \
+ \
+ i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>()); \
+ i_symbol->attributes().setIsInitialized(); \
+ i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size(); \
+ symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId())); \
+ \
+ auto [i_symbol_a, success_a] = symbol_table.add("a", ast->begin()); \
+ if (not success_a) { \
+ throw UnexpectedError("cannot add 'a' of type builtin_t for testing"); \
+ } \
+ i_symbol_a->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
+ i_symbol_a->attributes().setIsInitialized(); \
+ auto [i_symbol_b, success_b] = symbol_table.add("b", ast->begin()); \
+ if (not success_b) { \
+ throw UnexpectedError("cannot add 'b' of type builtin_t for testing"); \
+ } \
+ i_symbol_b->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
+ i_symbol_b->attributes().setIsInitialized(); \
+ \
+ ASTSymbolTableBuilder{*ast}; \
+ ASTNodeDataTypeBuilder{*ast}; \
+ \
+ ASTNodeDeclarationToAffectationConverter{*ast}; \
+ ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
+ \
+ ASTNodeExpressionBuilder{*ast}; \
+ \
+ std::stringstream ast_output; \
+ ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
+ \
+ REQUIRE(ast_output.str() == expected_output); \
+ \
+ OperatorRepository::instance().reset(); \
}
#define CHECK_AST_THROWS_WITH(data, expected_error) \
@@ -109,46 +120,50 @@ const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const dou
REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, expected_error); \
}
-#define CHECK_AST_WITH_BUILTIN_THROWS_WITH(data, expected_error) \
- { \
- 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_error)>, std::string_view> or \
- std::is_same_v<std::decay_t<decltype(expected_error)>, std::string>); \
- \
- string_input input{data, "test.pgs"}; \
- auto ast = ASTBuilder::build(input); \
- \
- SymbolTable& symbol_table = *ast->m_symbol_table; \
- auto [i_symbol, success] = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin()); \
- if (not success) { \
- throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing"); \
- } \
- \
- i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>()); \
- i_symbol->attributes().setIsInitialized(); \
- i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size(); \
- symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId())); \
- \
- auto [i_symbol_a, success_a] = symbol_table.add("a", ast->begin()); \
- if (not success_a) { \
- throw UnexpectedError("cannot add 'a' of type builtin_t for testing"); \
- } \
- i_symbol_a->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
- i_symbol_a->attributes().setIsInitialized(); \
- auto [i_symbol_b, success_b] = symbol_table.add("b", ast->begin()); \
- if (not success_b) { \
- throw UnexpectedError("cannot add 'b' of type builtin_t for testing"); \
- } \
- i_symbol_b->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
- i_symbol_b->attributes().setIsInitialized(); \
- \
- ASTSymbolTableBuilder{*ast}; \
- ASTNodeDataTypeBuilder{*ast}; \
- \
- ASTNodeDeclarationToAffectationConverter{*ast}; \
- ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
- \
- REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, expected_error); \
+#define CHECK_AST_WITH_BUILTIN_THROWS_WITH(data, expected_error) \
+ { \
+ 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_error)>, std::string_view> or \
+ std::is_same_v<std::decay_t<decltype(expected_error)>, std::string>); \
+ \
+ BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
+ \
+ string_input input{data, "test.pgs"}; \
+ auto ast = ASTBuilder::build(input); \
+ \
+ SymbolTable& symbol_table = *ast->m_symbol_table; \
+ auto [i_symbol, success] = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin()); \
+ if (not success) { \
+ throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing"); \
+ } \
+ \
+ i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>()); \
+ i_symbol->attributes().setIsInitialized(); \
+ i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size(); \
+ symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId())); \
+ \
+ auto [i_symbol_a, success_a] = symbol_table.add("a", ast->begin()); \
+ if (not success_a) { \
+ throw UnexpectedError("cannot add 'a' of type builtin_t for testing"); \
+ } \
+ i_symbol_a->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
+ i_symbol_a->attributes().setIsInitialized(); \
+ auto [i_symbol_b, success_b] = symbol_table.add("b", ast->begin()); \
+ if (not success_b) { \
+ throw UnexpectedError("cannot add 'b' of type builtin_t for testing"); \
+ } \
+ i_symbol_b->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>); \
+ i_symbol_b->attributes().setIsInitialized(); \
+ \
+ ASTSymbolTableBuilder{*ast}; \
+ ASTNodeDataTypeBuilder{*ast}; \
+ \
+ ASTNodeDeclarationToAffectationConverter{*ast}; \
+ ASTNodeTypeCleaner<language::var_declaration>{*ast}; \
+ \
+ REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, expected_error); \
+ \
+ OperatorRepository::instance().reset(); \
}
// clazy:excludeall=non-pod-global-static
@@ -672,7 +687,7 @@ let t : (B), t = (true, false);
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, bool>)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::true_kw:ValueProcessor)
@@ -690,7 +705,7 @@ let t : (N), t = (1, 2, 3, 5);
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, unsigned long>)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:1:ValueProcessor)
@@ -714,7 +729,7 @@ let t : (Z), t = (2, n, true);
+-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
| +-(language::name:n:NameProcessor)
| `-(language::integer:3:ValueProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, long>)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:2:ValueProcessor)
@@ -733,7 +748,7 @@ let t : (R), t = (2, 3.1, 5);
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, double>)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:2:ValueProcessor)
@@ -760,7 +775,7 @@ let t3 : (R^1), t3 = (1, 2.3, 0);
| `-(language::expression_list:ASTNodeExpressionListProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::real:3.1:ValueProcessor)
- +-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
| +-(language::name:t1:NameProcessor)
| `-(language::expression_list:ASTNodeExpressionListProcessor)
| +-(language::name:a:NameProcessor)
@@ -768,12 +783,12 @@ let t3 : (R^1), t3 = (1, 2.3, 0);
| | +-(language::integer:1:ValueProcessor)
| | `-(language::integer:2:ValueProcessor)
| `-(language::integer:0:ValueProcessor)
- +-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >)
| +-(language::name:t2:NameProcessor)
| `-(language::expression_list:ASTNodeExpressionListProcessor)
| +-(language::integer:0:ValueProcessor)
| `-(language::integer:0:ValueProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, TinyVector<1ul, double> >)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >)
+-(language::name:t3:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:1:ValueProcessor)
@@ -792,7 +807,7 @@ let t : (string), t = ("foo", "bar");
std::string result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, )" +
+ `-(language::eq_op:AffectationToTupleFromListProcessor<)" +
demangled_stdstring + R"( >)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
@@ -811,7 +826,7 @@ let t : (builtin_t), t= (a,b,a);
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleFromListProcessor<language::eq_op, EmbeddedData>)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<EmbeddedData>)
+-(language::name:t:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::name:a:NameProcessor)
@@ -833,7 +848,7 @@ let t : (B), t = true;
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, bool>)
+ `-(language::eq_op:AffectationToTupleProcessor<bool>)
+-(language::name:t:NameProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -849,7 +864,7 @@ let t : (N), t = 1;
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, unsigned long>)
+ `-(language::eq_op:AffectationToTupleProcessor<unsigned long>)
+-(language::name:t:NameProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -869,7 +884,7 @@ let t : (Z), t = n;
+-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
| +-(language::name:n:NameProcessor)
| `-(language::integer:3:ValueProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, long>)
+ `-(language::eq_op:AffectationToTupleProcessor<long>)
+-(language::name:t:NameProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -885,7 +900,7 @@ let t : (R), t = 3.1;
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, double>)
+ `-(language::eq_op:AffectationToTupleProcessor<double>)
+-(language::name:t:NameProcessor)
`-(language::real:3.1:ValueProcessor)
)";
@@ -909,13 +924,13 @@ let t3 : (R^1), t3 = 2.3;
| `-(language::expression_list:ASTNodeExpressionListProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::real:3.1:ValueProcessor)
- +-(language::eq_op:AffectationToTupleProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTupleProcessor<TinyVector<2ul, double> >)
| +-(language::name:t1:NameProcessor)
| `-(language::name:a:NameProcessor)
- +-(language::eq_op:AffectationToTupleProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTupleProcessor<TinyVector<3ul, double> >)
| +-(language::name:t2:NameProcessor)
| `-(language::integer:0:ValueProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, TinyVector<1ul, double> >)
+ `-(language::eq_op:AffectationToTupleProcessor<TinyVector<1ul, double> >)
+-(language::name:t3:NameProcessor)
`-(language::real:2.3:ValueProcessor)
)";
@@ -931,7 +946,7 @@ let t : (string), t = "foo";
std::string result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, )" +
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
demangled_stdstring + R"( >)
+-(language::name:t:NameProcessor)
`-(language::literal:"foo":ValueProcessor)
@@ -948,7 +963,7 @@ let t : (builtin_t), t = a;
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTupleProcessor<language::eq_op, EmbeddedData>)
+ `-(language::eq_op:AffectationToTupleProcessor<EmbeddedData>)
+-(language::name:t:NameProcessor)
`-(language::name:a:NameProcessor)
)";
@@ -1511,33 +1526,20 @@ let x : R, x=1; x/=2.3;
{
SECTION("Invalid affectation operator")
{
- auto ast = std::make_unique<ASTNode>();
+ auto ast = std::make_unique<ASTNode>();
+ ast->m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>();
+ {
+ auto child_0 = std::make_unique<ASTNode>();
+ child_0->m_data_type = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto child_1 = std::make_unique<ASTNode>();
+ child_1->m_data_type = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ ast->children.emplace_back(std::move(child_0));
+ ast->children.emplace_back(std::move(child_1));
+ }
REQUIRE_THROWS_WITH(ASTNodeAffectationExpressionBuilder{*ast},
"unexpected error: undefined affectation operator");
}
- SECTION("Invalid lhs")
- {
- auto ast = std::make_unique<ASTNode>();
- ast->set_type<language::eq_op>();
- ast->children.emplace_back(std::make_unique<ASTNode>());
- ast->children.emplace_back(std::make_unique<ASTNode>());
- REQUIRE_THROWS_WITH(ASTNodeAffectationExpressionBuilder{*ast},
- "unexpected error: undefined value type for affectation");
- }
-
- SECTION("Invalid rhs")
- {
- auto ast = std::make_unique<ASTNode>();
- ast->set_type<language::eq_op>();
-
- ast->children.emplace_back(std::make_unique<ASTNode>());
- ast->children[0]->m_data_type = ASTNodeDataType::build<ASTNodeDataType::int_t>();
- ast->children.emplace_back(std::make_unique<ASTNode>());
- REQUIRE_THROWS_WITH(ASTNodeAffectationExpressionBuilder{*ast},
- "unexpected error: invalid implicit conversion: undefined -> Z");
- }
-
SECTION("Invalid string rhs")
{
auto ast = std::make_unique<ASTNode>();
@@ -1558,7 +1560,7 @@ let x : R, x=1; x/=2.3;
let s : string, s="foo"; s-="bar";
)";
- std::string error_message = "invalid affectation operator for string";
+ std::string error_message = "undefined affectation type: string -= string";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1569,7 +1571,7 @@ let s : string, s="foo"; s-="bar";
let s : string, s="foo"; s*=2;
)";
- std::string error_message = "invalid affectation operator for string";
+ std::string error_message = "undefined affectation type: string *= Z";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1580,7 +1582,7 @@ let s : string, s="foo"; s*=2;
let s : string, s="foo"; s/="bar";
)";
- std::string error_message = "invalid affectation operator for string";
+ std::string error_message = "undefined affectation type: string /= string";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1592,7 +1594,7 @@ let s : string, s="foo"; s*=2;
let s :builtin_t, s = a; s *= b;
)";
- std::string error_message = "invalid affectation operator for 'builtin_t'";
+ std::string error_message = "undefined affectation type: builtin_t *= builtin_t";
CHECK_AST_WITH_BUILTIN_THROWS_WITH(data, error_message);
}
@@ -1603,7 +1605,7 @@ let s : string, s="foo"; s*=2;
let s :(R), s=(1,2,3); s *= 4;
)";
- std::string error_message = "invalid affectation operator for 'tuple(R)'";
+ std::string error_message = "undefined affectation type: tuple(R) *= Z";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1614,7 +1616,7 @@ let s : string, s="foo"; s*=2;
let s : (builtin_t), s =(a,b); s *= b;
)";
- std::string error_message = "invalid affectation operator for 'tuple(builtin_t)'";
+ std::string error_message = "undefined affectation type: tuple(builtin_t) *= builtin_t";
CHECK_AST_WITH_BUILTIN_THROWS_WITH(data, error_message);
}
@@ -1721,7 +1723,7 @@ let x : R^2, x = 2;
let x : R^3; let y : R^3; x /= y;
)";
- std::string error_message = "invalid affectation operator for R^3";
+ std::string error_message = "undefined affectation type: R^3 /= R^3";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1732,7 +1734,7 @@ let x : R^3; let y : R^3; x /= y;
let x : R^2; let y : R^2; x /= y;
)";
- std::string error_message = "invalid affectation operator for R^2";
+ std::string error_message = "undefined affectation type: R^2 /= R^2";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1743,7 +1745,7 @@ let x : R^2; let y : R^2; x /= y;
let x : R^1; let y : R^1; x /= y;
)";
- std::string error_message = "invalid affectation operator for R^1";
+ std::string error_message = "undefined affectation type: R^1 /= R^1";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1757,7 +1759,7 @@ let x : R^1; let y : R^1; x /= y;
let x : R^3; let y : R^3; x *= y;
)";
- std::string error_message = "expecting scalar operand type";
+ std::string error_message = "undefined affectation type: R^3 *= R^3";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1768,7 +1770,7 @@ let x : R^3; let y : R^3; x *= y;
let x : R^2; let y : R^2; x *= y;
)";
- std::string error_message = "expecting scalar operand type";
+ std::string error_message = "undefined affectation type: R^2 *= R^2";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1779,7 +1781,7 @@ let x : R^2; let y : R^2; x *= y;
let x : R^1; let y : R^1; x *= y;
)";
- std::string error_message = "expecting scalar operand type";
+ std::string error_message = "undefined affectation type: R^1 *= R^1";
CHECK_AST_THROWS_WITH(data, error_message);
}
diff --git a/tests/test_ASTNodeDataType.cpp b/tests/test_ASTNodeDataType.cpp
index 3d4ea9b6954363cdd9007679e425d5f4f4c74c36..2e6e9afb4715b86c67fa2511e7472418e912f8e8 100644
--- a/tests/test_ASTNodeDataType.cpp
+++ b/tests/test_ASTNodeDataType.cpp
@@ -2,7 +2,7 @@
#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNode.hpp>
-#include <language/ast/ASTNodeDataType.hpp>
+#include <language/utils/ASTNodeDataType.hpp>
namespace language
{
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index 74f695682992ad951c3b2c33e3c8c0f6b53b657a..b2703a5950eeabe8eea33ba61cab4fc2e2f9157a 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -4,6 +4,7 @@
#include <Kokkos_Core.hpp>
#include <algebra/PETScWrapper.hpp>
+#include <language/utils/OperatorRepository.hpp>
#include <mesh/DiamondDualConnectivityManager.hpp>
#include <mesh/DiamondDualMeshManager.hpp>
#include <mesh/MeshDataManager.hpp>
@@ -38,8 +39,12 @@ main(int argc, char* argv[])
MeshDataBaseForTests::create();
+ OperatorRepository::create();
+
result = session.run();
+ OperatorRepository::destroy();
+
MeshDataBaseForTests::destroy();
DiamondDualMeshManager::destroy();