From 46f9c3d947769d87eeed34a037811405374bd511 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com>
Date: Tue, 17 Nov 2020 11:13:39 +0100
Subject: [PATCH] Change affectation operators handling
This commit introduces an OperatorRepository which handles operator to
node processor builders. This gives more flexibility to operators
definition (especially for incoming non basic types).
This also lead to slightly faster compilation and important memory use
reduction.
---
.gitignore | 1 +
src/language/PugsParser.cpp | 5 +
src/language/ast/ASTNode.hpp | 2 +-
.../ASTNodeAffectationExpressionBuilder.cpp | 461 ++----------------
.../ast/ASTNodeNaturalConversionChecker.hpp | 2 +-
src/language/ast/ASTNodeSubDataType.hpp | 2 +-
src/language/ast/CMakeLists.txt | 2 +-
src/language/modules/BuiltinModule.hpp | 2 +-
src/language/modules/ModuleRepository.cpp | 6 +
.../node_processor/AffectationProcessor.hpp | 7 +-
.../{ast => utils}/ASTNodeDataType.cpp | 2 +-
.../{ast => utils}/ASTNodeDataType.hpp | 0
src/language/utils/ASTNodeDataTypeTraits.hpp | 8 +-
src/language/utils/AffectationMangler.hpp | 54 ++
.../utils/AffectationProcessorBuilder.hpp | 86 ++++
.../utils/AffectationRegisterForB.cpp | 10 +
.../utils/AffectationRegisterForB.hpp | 12 +
.../utils/AffectationRegisterForN.cpp | 120 +++++
.../utils/AffectationRegisterForN.hpp | 19 +
.../utils/AffectationRegisterForR.cpp | 141 ++++++
.../utils/AffectationRegisterForR.hpp | 19 +
.../utils/AffectationRegisterForR1.cpp | 102 ++++
.../utils/AffectationRegisterForR1.hpp | 18 +
.../utils/AffectationRegisterForR2.cpp | 84 ++++
.../utils/AffectationRegisterForR2.hpp | 18 +
.../utils/AffectationRegisterForR3.cpp | 84 ++++
.../utils/AffectationRegisterForR3.hpp | 18 +
.../utils/AffectationRegisterForString.cpp | 140 ++++++
.../utils/AffectationRegisterForString.hpp | 16 +
.../utils/AffectationRegisterForZ.cpp | 119 +++++
.../utils/AffectationRegisterForZ.hpp | 19 +
.../utils/BasicAffectationRegistrerFor.hpp | 36 ++
.../utils/BuiltinFunctionEmbedder.hpp | 2 +-
src/language/utils/CMakeLists.txt | 10 +
src/language/utils/FunctionTable.hpp | 8 +-
.../utils/IAffectationProcessorBuilder.hpp | 17 +
src/language/utils/OperatorRepository.cpp | 51 ++
src/language/utils/OperatorRepository.hpp | 65 +++
src/language/utils/PugsFunctionAdapter.hpp | 2 +-
src/language/utils/SymbolTable.hpp | 2 +-
tests/CMakeLists.txt | 9 +
tests/mpi_test_main.cpp | 5 +
...st_ASTNodeAffectationExpressionBuilder.cpp | 320 ++++++------
tests/test_ASTNodeDataType.cpp | 2 +-
tests/test_main.cpp | 5 +
45 files changed, 1510 insertions(+), 603 deletions(-)
rename src/language/{ast => utils}/ASTNodeDataType.cpp (99%)
rename src/language/{ast => utils}/ASTNodeDataType.hpp (100%)
create mode 100644 src/language/utils/AffectationMangler.hpp
create mode 100644 src/language/utils/AffectationProcessorBuilder.hpp
create mode 100644 src/language/utils/AffectationRegisterForB.cpp
create mode 100644 src/language/utils/AffectationRegisterForB.hpp
create mode 100644 src/language/utils/AffectationRegisterForN.cpp
create mode 100644 src/language/utils/AffectationRegisterForN.hpp
create mode 100644 src/language/utils/AffectationRegisterForR.cpp
create mode 100644 src/language/utils/AffectationRegisterForR.hpp
create mode 100644 src/language/utils/AffectationRegisterForR1.cpp
create mode 100644 src/language/utils/AffectationRegisterForR1.hpp
create mode 100644 src/language/utils/AffectationRegisterForR2.cpp
create mode 100644 src/language/utils/AffectationRegisterForR2.hpp
create mode 100644 src/language/utils/AffectationRegisterForR3.cpp
create mode 100644 src/language/utils/AffectationRegisterForR3.hpp
create mode 100644 src/language/utils/AffectationRegisterForString.cpp
create mode 100644 src/language/utils/AffectationRegisterForString.hpp
create mode 100644 src/language/utils/AffectationRegisterForZ.cpp
create mode 100644 src/language/utils/AffectationRegisterForZ.hpp
create mode 100644 src/language/utils/BasicAffectationRegistrerFor.hpp
create mode 100644 src/language/utils/IAffectationProcessorBuilder.hpp
create mode 100644 src/language/utils/OperatorRepository.cpp
create mode 100644 src/language/utils/OperatorRepository.hpp
diff --git a/.gitignore b/.gitignore
index e8ba87475..3bb6d6cbc 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 ed00e3032..faab47780 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 a3b9bd215..d9568c612 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 66420138c..6e712e3d8 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 ebf83d7ca..9e96e49b9 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 d7844d367..358aca9a1 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 f4c317743..458690fbd 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 6ea3ee56a..2be1d1625 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 abb5d527d..65bfcafd1 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 6cdb19dfd..88d448836 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 1f0847f86..02a352ac3 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 946d63483..ed668e5e4 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 000000000..b128da936
--- /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 000000000..02042ad88
--- /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 000000000..69feaee70
--- /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 000000000..4064d4988
--- /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 000000000..e7d54008f
--- /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 000000000..56f7699e8
--- /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 000000000..ae7c63c40
--- /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 000000000..141a0d8ae
--- /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 000000000..20873d6fd
--- /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 000000000..04016bd67
--- /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 000000000..0fca199a9
--- /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 000000000..0c1c5c1fa
--- /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 000000000..d5925d7bc
--- /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 000000000..09ae3f3e8
--- /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 000000000..37446e243
--- /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 000000000..2aa4b319b
--- /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 000000000..9937a0edb
--- /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 000000000..2f13e10f6
--- /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 000000000..ccae4c32b
--- /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 d394aa20f..afb991aca 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 1cb991d6c..aee593608 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 43232fd60..6c6450c22 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 000000000..6d5f8540d
--- /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 000000000..cbd520dd4
--- /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 000000000..509410d98
--- /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 17d97f509..278c7274f 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 39d414b1e..6aa089bd8 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 edaa8069a..5ae8aeef9 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 87953af0c..44162aba3 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 64d60d9bf..ecd72b1f0 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 3d4ea9b69..2e6e9afb4 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 74f695682..b2703a595 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();
--
GitLab