diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index 0f8f1d287b88435c904c00557e7fc0dc729dcb56..54697f4a0b3aa0cd6b18f6cdac970e7ffd69e67d 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -615,6 +615,6 @@ ASTNodeDataTypeBuilder::ASTNodeDataTypeBuilder(ASTNode& node)
this->_buildNodeDataTypes(node);
if (ConsoleManager::showPreamble()) {
- std::cout << " - build node data types\n";
+ std::cout << " - built node data types\n";
}
}
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index f4c0d731a7a11ab91ffe7cb005bf14ebb5525dcf..b06a96ac54f055f12b5afb626d7740a89d07b485 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -549,6 +549,58 @@ class AffectationToTupleProcessor final : public AffectationToDataVariantProcess
{}
};
+template <typename ValueT>
+class AffectationFromTupleProcessor final : public AffectationToDataVariantProcessorBase
+{
+ private:
+ ASTNode& m_lhs_node;
+ ASTNode& m_rhs_node;
+
+ public:
+ DataVariant
+ execute(ExecutionPolicy& exec_policy)
+ {
+ DataVariant value = m_rhs_node.execute(exec_policy);
+
+ std::visit(
+ [&](auto&& v) {
+ using T = std::decay_t<decltype(v)>;
+ if constexpr (is_std_vector_v<T>) {
+ using TupleContentType = std::decay_t<typename T::value_type>;
+ if (v.size() == 1) {
+ std::cout << "TUPLE [" << demangle<TupleContentType>() << "] -> " << demangle<ValueT>() << '\n';
+ if constexpr (std::is_same_v<TupleContentType, ValueT>) {
+ *m_lhs = v[0];
+ } else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<TupleContentType, ValueT>) {
+#warning treat the case (Z) -> N (check sign)
+ *m_lhs = static_cast<ValueT>(v[0]);
+ } else {
+#warning missing cases
+ throw NotImplementedError("remaining cases?");
+ }
+ } else {
+ std::ostringstream error_msg;
+ error_msg << "cannot affect a " << rang::fgB::yellow << dataTypeName(m_rhs_node.m_data_type)
+ << rang::fg::reset << " of size " << v.size() << " to a " << rang::fgB::yellow
+ << dataTypeName(m_lhs_node.m_data_type) << rang::fg::reset;
+ throw ParseError(error_msg.str(), m_rhs_node.begin());
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("right hand side must be a tuple");
+ // LCOV_EXCL_STOP
+ }
+ },
+ value);
+
+ return {};
+ }
+
+ AffectationFromTupleProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_lhs_node(lhs_node), m_rhs_node{rhs_node}
+ {}
+};
+
template <typename ValueT>
class AffectationToTupleFromListProcessor final : public AffectationToDataVariantProcessorBase
{
@@ -627,15 +679,57 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
*m_lhs = std::move(tuple_value);
}
+ public:
+ DataVariant
+ execute(ExecutionPolicy& exec_policy)
+ {
+ try {
+ std::visit(
+ [&](auto&& value_list) {
+ using ValueListT = std::decay_t<decltype(value_list)>;
+ if constexpr (std::is_same_v<AggregateDataVariant, ValueListT>) {
+ this->_copyAggregateDataVariant(value_list);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("invalid rhs (expecting list)");
+ // LCOV_EXCL_STOP
+ }
+ },
+ m_rhs_node.execute(exec_policy));
+ }
+ catch (std::domain_error& e) {
+ throw ParseError(e.what(), m_rhs_node.begin());
+ }
+ return {};
+ }
+
+ AffectationToTupleFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
+ {}
+};
+
+template <typename ValueT>
+class AffectationToTupleFromTupleProcessor final : public AffectationToDataVariantProcessorBase
+{
+ private:
+ ASTNode& m_rhs_node;
+
+ template <typename T>
+ std::string
+ stringify(const T& value)
+ {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ }
+
template <typename DataType>
void
_copyVector(const std::vector<DataType>& values)
{
std::vector<ValueT> v(values.size());
if constexpr (std::is_same_v<ValueT, DataType>) {
- for (size_t i = 0; i < values.size(); ++i) {
- v[i] = values[i];
- }
+ v = std::move(values);
} else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<DataType, ValueT>) {
for (size_t i = 0; i < values.size(); ++i) {
const DataType& vi = values[i];
@@ -646,6 +740,14 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
}
v[i] = static_cast<DataType>(vi);
}
+ } else if constexpr (std::is_same_v<TinyVector<1>, ValueT> and std::is_arithmetic_v<DataType>) {
+ for (size_t i = 0; i < values.size(); ++i) {
+ v[i][0] = values[i];
+ }
+ } else if constexpr (std::is_same_v<TinyMatrix<1>, ValueT> and std::is_arithmetic_v<DataType>) {
+ for (size_t i = 0; i < values.size(); ++i) {
+ v[i](0, 0) = values[i];
+ }
} else if constexpr (std::is_same_v<ValueT, std::string>) {
for (size_t i = 0; i < values.size(); ++i) {
v[i] = std::move(stringify(values[i]));
@@ -667,13 +769,11 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
std::visit(
[&](auto&& value_list) {
using ValueListT = std::decay_t<decltype(value_list)>;
- if constexpr (std::is_same_v<AggregateDataVariant, ValueListT>) {
- this->_copyAggregateDataVariant(value_list);
- } else if constexpr (is_std_vector_v<ValueListT>) {
+ if constexpr (is_std_vector_v<ValueListT>) {
this->_copyVector(value_list);
} else {
// LCOV_EXCL_START
- throw UnexpectedError("invalid lhs (expecting list or tuple)");
+ throw UnexpectedError("invalid rhs (expecting tuple)");
// LCOV_EXCL_STOP
}
},
@@ -685,7 +785,7 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
return {};
}
- AffectationToTupleFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ AffectationToTupleFromTupleProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
: AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
{}
};
diff --git a/src/language/utils/AffectationMangler.hpp b/src/language/utils/AffectationMangler.hpp
index 85aaab35bfbabde5b9bdbc9b250f8440e68829e6..42592a091d1e1792f99d3d76e5af0d167732aeba 100644
--- a/src/language/utils/AffectationMangler.hpp
+++ b/src/language/utils/AffectationMangler.hpp
@@ -40,8 +40,6 @@ affectationMangler(const ASTNodeDataType& lhs, const ASTNodeDataType& rhs)
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);
}
diff --git a/src/language/utils/AffectationProcessorBuilder.hpp b/src/language/utils/AffectationProcessorBuilder.hpp
index cc66971b2ccfbcc4a9a16ae708121c7905a1478b..6b5ff55841863b9e93afd8a12498bf306e4d51f4 100644
--- a/src/language/utils/AffectationProcessorBuilder.hpp
+++ b/src/language/utils/AffectationProcessorBuilder.hpp
@@ -44,6 +44,18 @@ class AffectationToTupleProcessorBuilder final : public IAffectationProcessorBui
}
};
+template <typename ValueT>
+class AffectationFromTupleProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationFromTupleProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
+ {
+ return std::make_unique<AffectationFromTupleProcessor<ValueT>>(lhs_node, rhs_node);
+ }
+};
+
template <typename ValueT>
class AffectationToTupleFromListProcessorBuilder final : public IAffectationProcessorBuilder
{
@@ -57,6 +69,19 @@ class AffectationToTupleFromListProcessorBuilder final : public IAffectationProc
}
};
+template <typename ValueT>
+class AffectationToTupleFromTupleProcessorBuilder final : public IAffectationProcessorBuilder
+{
+ public:
+ AffectationToTupleFromTupleProcessorBuilder() = default;
+ std::unique_ptr<INodeProcessor>
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
+ {
+ ASTNodeNaturalConversionChecker<AllowRToR1Conversion>(rhs_node, lhs_node.m_data_type);
+ return std::make_unique<AffectationToTupleFromTupleProcessor<ValueT>>(lhs_node, rhs_node);
+ }
+};
+
template <typename OperatorT, typename ValueT>
class AffectationFromZeroProcessorBuilder final : public IAffectationProcessorBuilder
{
diff --git a/src/language/utils/AffectationRegisterForN.cpp b/src/language/utils/AffectationRegisterForN.cpp
index 64f93ad0f74da6490b636c3643de62bcf7afc0fc..ecb982c23359c716aaf7e799cfa13288e03bdd9a 100644
--- a/src/language/utils/AffectationRegisterForN.cpp
+++ b/src/language/utils/AffectationRegisterForN.cpp
@@ -9,23 +9,30 @@ AffectationRegisterForN::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository
- .addAffectation<language::eq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ .addAffectation<language::eq_op>(N, B,
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>>());
+ language::eq_op>(N, Z, 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>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N), B,
std::make_shared<AffectationToTupleProcessorBuilder<uint64_t>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N), Z,
std::make_shared<AffectationToTupleProcessorBuilder<uint64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<uint64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<uint64_t>>());
}
void
@@ -33,19 +40,19 @@ AffectationRegisterForN::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addAffectation<
- language::pluseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
- std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, bool>>());
+ language::pluseq_op>(N, B, std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, bool>>());
repository.addAffectation<
- language::pluseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::pluseq_op>(N, N,
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>>());
+ language::pluseq_op>(N, Z, std::make_shared<AffectationProcessorBuilder<language::pluseq_op, uint64_t, int64_t>>());
}
void
@@ -53,18 +60,19 @@ AffectationRegisterForN::_register_minuseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addAffectation<
- language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
- std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, bool>>());
+ language::minuseq_op>(N, B, std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, bool>>());
repository.addAffectation<
- language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::minuseq_op>(N, N,
std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, uint64_t>>());
repository.addAffectation<
- language::minuseq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::minuseq_op>(N, Z,
std::make_shared<AffectationProcessorBuilder<language::minuseq_op, uint64_t, int64_t>>());
}
@@ -73,17 +81,19 @@ AffectationRegisterForN::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addAffectation<
- language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ language::multiplyeq_op>(N, B,
std::make_shared<AffectationProcessorBuilder<language::multiplyeq_op, uint64_t, bool>>());
- repository.addAffectation<language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(N, N,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, uint64_t, uint64_t>>());
- repository.addAffectation<language::multiplyeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(N, Z,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, uint64_t, int64_t>>());
}
@@ -94,13 +104,14 @@ AffectationRegisterForN::_register_divideeq_op()
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addAffectation<
- language::divideeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::divideeq_op>(N, N,
std::make_shared<AffectationProcessorBuilder<language::divideeq_op, uint64_t, uint64_t>>());
repository.addAffectation<
- language::divideeq_op>(N, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::divideeq_op>(N, Z,
std::make_shared<AffectationProcessorBuilder<language::divideeq_op, uint64_t, int64_t>>());
}
diff --git a/src/language/utils/AffectationRegisterForR.cpp b/src/language/utils/AffectationRegisterForR.cpp
index 7959b35b3d2119a8b6930cc6d4beb7d61f115da8..f7c5d3efa7867f18bbdad15552317b086ba695d9 100644
--- a/src/language/utils/AffectationRegisterForR.cpp
+++ b/src/language/utils/AffectationRegisterForR.cpp
@@ -9,31 +9,42 @@ AffectationRegisterForR::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
repository
- .addAffectation<language::eq_op>(R, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ .addAffectation<language::eq_op>(R, B,
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>>());
+ language::eq_op>(R, N, std::make_shared<AffectationProcessorBuilder<language::eq_op, double, uint64_t>>());
repository
- .addAffectation<language::eq_op>(R, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ .addAffectation<language::eq_op>(R, Z,
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>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R), B,
std::make_shared<AffectationToTupleProcessorBuilder<double>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
- ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R), N,
std::make_shared<AffectationToTupleProcessorBuilder<double>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R), Z,
std::make_shared<AffectationToTupleProcessorBuilder<double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<double>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<double>>());
}
void
diff --git a/src/language/utils/AffectationRegisterForRn.cpp b/src/language/utils/AffectationRegisterForRn.cpp
index 180bd5ebce8d19dd8aa6f4b628a700632ea44ab0..5ab23dba39b1c6192c67d8fa705692fb2d0e2f87 100644
--- a/src/language/utils/AffectationRegisterForRn.cpp
+++ b/src/language/utils/AffectationRegisterForRn.cpp
@@ -11,14 +11,14 @@ AffectationRegisterForRn<Dimension>::_register_eq_op()
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addAffectation<
- language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::eq_op>(Rn, Z,
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn), Z,
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
}
@@ -30,43 +30,64 @@ AffectationRegisterForRn<1>::_register_eq_op()
OperatorRepository& repository = OperatorRepository::instance();
- auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository.addAffectation<
- language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ language::eq_op>(R1, B,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, bool>>());
repository.addAffectation<
- language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::eq_op>(R1, N,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, uint64_t>>());
repository.addAffectation<
- language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::eq_op>(R1, Z,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, int64_t>>());
repository.addAffectation<
- language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ language::eq_op>(R1, R,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, double>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
- ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1), B,
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
- ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1), N,
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1), Z,
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
- ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1), R,
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyVector<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyVector<1>>>());
}
template <size_t Dimension>
@@ -105,19 +126,24 @@ AffectationRegisterForRn<Dimension>::_register_multiplyeq_op()
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
- repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ repository.addAffectation<language::multiplyeq_op>(Rn, B,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, bool>>());
- repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rn, N,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, uint64_t>>());
- repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rn, Z,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, int64_t>>());
- repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rn, R,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, double>>());
}
diff --git a/src/language/utils/AffectationRegisterForRnxn.cpp b/src/language/utils/AffectationRegisterForRnxn.cpp
index 0eaf1c6af2e0caccf0fa143208c774a047d6e550..2ca3f7f6eee10147c5211164aae2d91fb36872d8 100644
--- a/src/language/utils/AffectationRegisterForRnxn.cpp
+++ b/src/language/utils/AffectationRegisterForRnxn.cpp
@@ -10,15 +10,16 @@ AffectationRegisterForRnxn<Dimension>::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
auto Rnxn = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(Dimension, Dimension);
repository.addAffectation<
- language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::eq_op>(Rnxn, Z,
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyMatrix<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn), Z,
std::make_shared<AffectationToTupleProcessorBuilder<TinyMatrix<Dimension>>>());
}
@@ -30,43 +31,64 @@ AffectationRegisterForRnxn<1>::_register_eq_op()
OperatorRepository& repository = OperatorRepository::instance();
- auto Rnxn = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(Dimension, Dimension);
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+ auto R1x1 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(Dimension, Dimension);
repository.addAffectation<
- language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ language::eq_op>(R1x1, B,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyMatrix<Dimension>, bool>>());
repository.addAffectation<
- language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::eq_op>(R1x1, N,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyMatrix<Dimension>, uint64_t>>());
repository.addAffectation<
- language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::eq_op>(R1x1, Z,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyMatrix<Dimension>, int64_t>>());
repository.addAffectation<
- language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ language::eq_op>(R1x1, R,
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyMatrix<Dimension>, double>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
- ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1), B,
std::make_shared<AffectationToTupleProcessorBuilder<TinyMatrix<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
- ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1), N,
std::make_shared<AffectationToTupleProcessorBuilder<TinyMatrix<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1), Z,
std::make_shared<AffectationToTupleProcessorBuilder<TinyMatrix<Dimension>>>());
repository
- .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
- ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1), R,
std::make_shared<AffectationToTupleProcessorBuilder<TinyMatrix<Dimension>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyMatrix<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyMatrix<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyMatrix<1>>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<TinyMatrix<1>>>());
}
template <size_t Dimension>
@@ -103,21 +125,26 @@ AffectationRegisterForRnxn<Dimension>::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
auto Rnxn = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(Dimension, Dimension);
- repository.addAffectation<language::multiplyeq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rnxn, B,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyMatrix<Dimension>, bool>>());
- repository.addAffectation<language::multiplyeq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rnxn, N,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyMatrix<Dimension>, uint64_t>>());
- repository.addAffectation<language::multiplyeq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rnxn, Z,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyMatrix<Dimension>, int64_t>>());
- repository.addAffectation<language::multiplyeq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ repository.addAffectation<language::multiplyeq_op>(Rnxn, R,
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyMatrix<Dimension>, double>>());
}
diff --git a/src/language/utils/AffectationRegisterForString.cpp b/src/language/utils/AffectationRegisterForString.cpp
index 7946aeb45fc72e7569e5d8299e184c220baa7106..44f8a561ef3fdbec225adc59acc126908e4628ec 100644
--- a/src/language/utils/AffectationRegisterForString.cpp
+++ b/src/language/utils/AffectationRegisterForString.cpp
@@ -9,87 +9,136 @@ AffectationRegisterForString::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+ auto R1x1 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1);
+ auto R2x2 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2);
+ auto R3x3 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3);
+
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>>());
+ language::eq_op>(string_t, B, std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, bool>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::eq_op>(string_t, N,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, uint64_t>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::eq_op>(string_t, Z,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, int64_t>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ language::eq_op>(string_t, R,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, double_t>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ language::eq_op>(string_t, R1,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<1>>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ language::eq_op>(string_t, R2,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<2>>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ language::eq_op>(string_t, R3,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyVector<3>>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1),
+ language::eq_op>(string_t, R1x1,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyMatrix<1>>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2),
+ language::eq_op>(string_t, R2x2,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyMatrix<2>>>());
repository.addAffectation<
- language::eq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3),
+ language::eq_op>(string_t, R3x3,
std::make_shared<AffectationProcessorBuilder<language::eq_op, std::string, TinyMatrix<3>>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), B,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), N,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), Z,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R1,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R2,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R3,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R1x1,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R2x2,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t), R3x3,
std::make_shared<AffectationToTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R2),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R3),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1x1),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R2x2),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
+
+ repository
+ .addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(string_t),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R3x3),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<std::string>>());
}
void
@@ -97,6 +146,17 @@ AffectationRegisterForString::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+ auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
+ auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
+ auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
+ auto R1x1 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1);
+ auto R2x2 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2);
+ auto R3x3 = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3);
+
auto string_t = ASTNodeDataType::build<ASTNodeDataType::string_t>();
repository.addAffectation<language::pluseq_op>(string_t, string_t,
@@ -104,42 +164,42 @@ AffectationRegisterForString::_register_pluseq_op()
language::pluseq_op, std::string, std::string>>());
repository.addAffectation<
- language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ language::pluseq_op>(string_t, B,
std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, bool>>());
repository.addAffectation<
- language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ language::pluseq_op>(string_t, N,
std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, uint64_t>>());
repository.addAffectation<
- language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
+ language::pluseq_op>(string_t, Z,
std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, int64_t>>());
repository.addAffectation<
- language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
+ language::pluseq_op>(string_t, R,
std::make_shared<AffectationProcessorBuilder<language::pluseq_op, std::string, double>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1),
+ repository.addAffectation<language::pluseq_op>(string_t, R1,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyVector<1>>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2),
+ repository.addAffectation<language::pluseq_op>(string_t, R2,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyVector<2>>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3),
+ repository.addAffectation<language::pluseq_op>(string_t, R3,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyVector<3>>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1),
+ repository.addAffectation<language::pluseq_op>(string_t, R1x1,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyMatrix<1>>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2),
+ repository.addAffectation<language::pluseq_op>(string_t, R2x2,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyMatrix<2>>>());
- repository.addAffectation<language::pluseq_op>(string_t, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3),
+ repository.addAffectation<language::pluseq_op>(string_t, R3x3,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, std::string, TinyMatrix<3>>>());
}
diff --git a/src/language/utils/AffectationRegisterForZ.cpp b/src/language/utils/AffectationRegisterForZ.cpp
index 09c493e711cf96b913607da732da7dd9ef937bc5..553a0e83cb72ec1b29c733746c8d5048b117e5fb 100644
--- a/src/language/utils/AffectationRegisterForZ.cpp
+++ b/src/language/utils/AffectationRegisterForZ.cpp
@@ -9,23 +9,30 @@ AffectationRegisterForZ::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
+ auto B = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository
- .addAffectation<language::eq_op>(Z, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
+ .addAffectation<language::eq_op>(Z, B,
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>>());
+ language::eq_op>(Z, N, 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>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z), B,
std::make_shared<AffectationToTupleProcessorBuilder<int64_t>>());
- repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
- ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z), N,
std::make_shared<AffectationToTupleProcessorBuilder<int64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(B),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<int64_t>>());
+
+ repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Z),
+ ASTNodeDataType::build<ASTNodeDataType::tuple_t>(N),
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<int64_t>>());
}
void
diff --git a/src/language/utils/BasicAffectationRegistrerFor.hpp b/src/language/utils/BasicAffectationRegistrerFor.hpp
index ccae4c32b596b39ce7b663da38e31e70c8dfbebc..06f905ca239750964cea9945206484d52a2da05f 100644
--- a/src/language/utils/BasicAffectationRegistrerFor.hpp
+++ b/src/language/utils/BasicAffectationRegistrerFor.hpp
@@ -29,7 +29,7 @@ class BasicAffectationRegisterFor
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>>());
+ std::make_shared<AffectationToTupleFromTupleProcessorBuilder<T>>());
}
};
diff --git a/tests/test_AffectationToTupleProcessor.cpp b/tests/test_AffectationToTupleProcessor.cpp
index 1ecaf971ffa09028c6baf59093c1517326c0dc14..434162ac1bc7a2e9a2e496547b76f3b359475ea0 100644
--- a/tests/test_AffectationToTupleProcessor.cpp
+++ b/tests/test_AffectationToTupleProcessor.cpp
@@ -206,35 +206,279 @@ let t :(R^1x1); t = (x,2);
SECTION("Affectations from tuple")
{
- CHECK_AFFECTATION_RESULT(R"(
-let x :(R^3), x = [1,2,3];
-let s :(string); s = x;
+ SECTION(" -> (B)")
+ {
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(B), b = a;
)",
- "s", (std::vector<std::string>{stringify(TinyVector<3, double>{1, 2, 3})}));
+ "b", (std::vector<bool>{true, false, true}));
+ }
- CHECK_AFFECTATION_RESULT(R"(
-let A :(R^3x3), A = ([[1,2,3],[4,5,6],[7,8,9]]);
-let s :(string); s = A;
+ SECTION(" -> (N)")
+ {
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(N), b = a;
)",
- "s", (std::vector<std::string>{stringify(TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9})}));
+ "b", (std::vector<uint64_t>{true, false, true}));
- CHECK_AFFECTATION_RESULT(R"(
-let x :(R), x = (1,2,3);
-let s :(string); s = x;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(N), b = a;
)",
- "s", (std::vector<std::string>{stringify(1.), stringify(2.), stringify(3.)}));
+ "b", (std::vector<uint64_t>{1, 2, 3}));
- CHECK_AFFECTATION_RESULT(R"(
-let n :(N), n = (1,2,3);
-let t :(R); t = n;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, 6, 2);
+let b:(N), b = a;
+)",
+ "b", (std::vector<uint64_t>{5, 6, 2}));
+ }
+
+ SECTION(" -> (Z)")
+ {
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(Z), b = a;
)",
- "t", (std::vector<double>{1, 2, 3}));
+ "b", (std::vector<int64_t>{true, false, true}));
- CHECK_AFFECTATION_RESULT(R"(
-let s :(N), s = (1,2,3);
-let t :(N); t = s;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(Z), b = a;
+)",
+ "b", (std::vector<int64_t>{1, 2, 3}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, -6, 2);
+let b:(Z), b = a;
+)",
+ "b", (std::vector<int64_t>{5, -6, 2}));
+ }
+
+ SECTION(" -> (R)")
+ {
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(R), b = a;
+)",
+ "b", (std::vector<double>{true, false, true}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(R), b = a;
)",
- "t", (std::vector<uint64_t>{1, 2, 3}));
+ "b", (std::vector<double>{1, 2, 3}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, -6, 2);
+let b:(R), b = a;
+)",
+ "b", (std::vector<double>{5, -6, 2}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R), a = (5.2, -6.3, 2.1);
+let b:(R), b = a;
+)",
+ "b", (std::vector<double>{5.2, -6.3, 2.1}));
+ }
+
+ SECTION(" -> (R^1)")
+ {
+ using R1 = TinyVector<1>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(R^1), b = a;
+)",
+ "b", (std::vector<R1>{R1{true}, R1{false}, R1{true}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(R^1), b = a;
+)",
+ "b", (std::vector<R1>{R1{1}, R1{2}, R1{3}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, -6, 2);
+let b:(R^1), b = a;
+)",
+ "b", (std::vector<R1>{R1{5}, R1{-6}, R1{2}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R), a = (5.2, -6.3, 2.1);
+let b:(R^1), b = a;
+)",
+ "b", (std::vector<R1>{R1{5.2}, R1{-6.3}, R1{2.1}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^1), a = (5.2, -6.3, 2.1);
+let b:(R^1), b = a;
+)",
+ "b", (std::vector<R1>{R1{5.2}, R1{-6.3}, R1{2.1}}));
+ }
+
+ SECTION(" -> (R^2)")
+ {
+ using R2 = TinyVector<2>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^2), a = ([5.2, -6.3], [2.1, 0]);
+let b:(R^2), b = a;
+)",
+ "b", (std::vector<R2>{R2{5.2, -6.3}, R2{2.1, 0}}));
+ }
+
+ SECTION(" -> (R^3)")
+ {
+ using R3 = TinyVector<3>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^3), a = ([5.2, -6.3, 2], [2.1, 0, -1.1]);
+let b:(R^3), b = a;
+)",
+ "b", (std::vector<R3>{R3{5.2, -6.3, 2}, R3{2.1, 0, -1.1}}));
+ }
+
+ SECTION(" -> (R^1x1)")
+ {
+ using R1x1 = TinyMatrix<1>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(R^1x1), b = a;
+)",
+ "b", (std::vector<R1x1>{R1x1{true}, R1x1{false}, R1x1{true}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(R^1x1), b = a;
+)",
+ "b", (std::vector<R1x1>{R1x1{1}, R1x1{2}, R1x1{3}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, -6, 2);
+let b:(R^1x1), b = a;
+)",
+ "b", (std::vector<R1x1>{R1x1{5}, R1x1{-6}, R1x1{2}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R), a = (5.2, -6.3, 2.1);
+let b:(R^1x1), b = a;
+)",
+ "b", (std::vector<R1x1>{R1x1{5.2}, R1x1{-6.3}, R1x1{2.1}}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^1x1), a = (5.2, -6.3, 2.1);
+let b:(R^1x1), b = a;
+)",
+ "b", (std::vector<R1x1>{R1x1{5.2}, R1x1{-6.3}, R1x1{2.1}}));
+ }
+
+ SECTION(" -> (R^2x2)")
+ {
+ using R2x2 = TinyMatrix<2>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^2x2), a = ([[5.2, -6.3], [2.1, 0]], 0);
+let b:(R^2x2), b = a;
+)",
+ "b", (std::vector<R2x2>{R2x2{5.2, -6.3, 2.1, 0}, R2x2{zero}}));
+ }
+
+ SECTION(" -> (R^3x3)")
+ {
+ using R3x3 = TinyMatrix<3>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^3x3), a = ([[5.2, -6.3, 2], [2.1, 0, -1.1], [1,-1.2,-0.7]] , 0);
+let b:(R^3x3), b = a;
+)",
+ "b", (std::vector<R3x3>{R3x3{5.2, -6.3, 2, 2.1, 0, -1.1, 1, -1.2, -0.7}, R3x3{zero}}));
+ }
+
+ SECTION(" -> (string)")
+ {
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(B), a = (true, false, true);
+let b:(string), b = a;
+)",
+ "b", (std::vector<std::string>{stringify(true), stringify(false), stringify(true)}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(N), a = (1, 2, 3);
+let b:(string), b = a;
+)",
+ "b", (std::vector<std::string>{stringify(1ul), stringify(2ul), stringify(3ul)}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(Z), a = (5, -6, 2);
+let b:(string), b = a;
+)",
+ "b", (std::vector<std::string>{stringify(5l), stringify(-6l), stringify(2l)}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R), a = (5.2, -6.3, 2.1);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(double{5.2}), stringify(double{-6.3}),
+ stringify(double{2.1})}));
+
+ using R1 = TinyVector<1>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^1), a = ([5.2], [-6.3], [2.1]);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R1{5.2}), stringify(R1{-6.3}), stringify(R1{2.1})}));
+
+ using R2 = TinyVector<2>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^2), a = ([5.2, 1.2], [-6.3, 4], [2.1, -1]);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R2{5.2, 1.2}), stringify(R2{-6.3, 4}),
+ stringify(R2{2.1, -1})}));
+
+ using R3 = TinyVector<3>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^3), a = ([5.2, 1.2, 2.1], [-6.3, 4, 0], [2.1, -1, 3]);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R3{5.2, 1.2, 2.1}), stringify(R3{-6.3, 4, 0}),
+ stringify(R3{2.1, -1, 3})}));
+
+ using R1x1 = TinyMatrix<1>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^1x1), a = ([[5.2]], [[-6.3]], [[2.1]]);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R1x1{5.2}), stringify(R1x1{-6.3}),
+ stringify(R1x1{2.1})}));
+
+ using R2x2 = TinyMatrix<2>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^2x2), a = ([[5.2, 1.2], [-6.3, 4]], [[2.1, -1],[1,3]], 0);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R2x2{5.2, 1.2, -6.3, 4}),
+ stringify(R2x2{2.1, -1, 1, 3}), stringify(R2x2{zero})}));
+
+ using R3x3 = TinyMatrix<3>;
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(R^3x3), a = ([[5.2, 1.2, 2.1], [-6.3, 4, 0], [2.1, -1, 3]], 0);
+let b:(string), b = a;
+)",
+ "b",
+ (std::vector<std::string>{stringify(R3x3{5.2, 1.2, 2.1, -6.3, 4, 0, 2.1, -1, 3}),
+ stringify(R3x3{zero})}));
+
+ CHECK_AFFECTATION_RESULT(R"(
+let a:(string), a = ("foo", "bar", "foobar");
+let b:(string), b = a;
+)",
+ "b", (std::vector<std::string>{"foo", "bar", "foobar"}));
+ }
}
SECTION("errors")