diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index 884711c081ded349d32663f80180c06c4911bfba..a97c13443bd628a2226de54623c673d464916a0c 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -9,24 +9,24 @@
#include <language/utils/ParseError.hpp>
#include <utils/Exceptions.hpp>
-ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& n)
+ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& node)
{
- const ASTNodeDataType& target_data_type = n.children[0]->m_data_type;
- const ASTNodeDataType& source_data_type = n.children[1]->m_data_type;
+ const ASTNodeDataType& target_data_type = node.children[0]->m_data_type;
+ const ASTNodeDataType& source_data_type = node.children[1]->m_data_type;
const std::string affectation_name = [&] {
- if (n.is_type<language::eq_op>()) {
+ if (node.is_type<language::eq_op>()) {
return affectationMangler<language::eq_op>(target_data_type, source_data_type);
- } else if (n.is_type<language::multiplyeq_op>()) {
+ } else if (node.is_type<language::multiplyeq_op>()) {
return affectationMangler<language::multiplyeq_op>(target_data_type, source_data_type);
- } else if (n.is_type<language::divideeq_op>()) {
+ } else if (node.is_type<language::divideeq_op>()) {
return affectationMangler<language::divideeq_op>(target_data_type, source_data_type);
- } else if (n.is_type<language::pluseq_op>()) {
+ } else if (node.is_type<language::pluseq_op>()) {
return affectationMangler<language::pluseq_op>(target_data_type, source_data_type);
- } else if (n.is_type<language::minuseq_op>()) {
+ } else if (node.is_type<language::minuseq_op>()) {
return affectationMangler<language::minuseq_op>(target_data_type, source_data_type);
} else {
- throw ParseError("unexpected error: undefined affectation operator", std::vector{n.begin()});
+ throw ParseError("unexpected error: undefined affectation operator", std::vector{node.begin()});
}
}();
@@ -34,12 +34,15 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
OperatorRepository::instance().getAffectationProcessorBuilder(affectation_name);
if (optional_processor_builder.has_value()) {
- n.m_node_processor = optional_processor_builder.value()->getNodeProcessor(n);
+ ASTNode& lhs_node = *node.children[0];
+ ASTNode& rhs_node = *node.children[1];
+
+ node.m_node_processor = optional_processor_builder.value()->getNodeProcessor(lhs_node, rhs_node);
} else {
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()});
+ throw ParseError(error_message.str(), std::vector{node.begin()});
}
}
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 959578619b023bc28236b1ae52141b018aad8c69..db5d0fc75d2da20977fbd5df3ced68d09f90783b 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -222,7 +222,7 @@ class MatrixComponentAffectationExecutor final : public IAffectationExecutor
}()};
public:
- MatrixComponentAffectationExecutor(ASTNode& node,
+ MatrixComponentAffectationExecutor(ASTNode& lhs_node,
ArrayT& lhs_array,
ASTNode& index0_expression,
ASTNode& index1_expression)
@@ -230,7 +230,7 @@ class MatrixComponentAffectationExecutor final : public IAffectationExecutor
{
// LCOV_EXCL_START
if constexpr (not m_is_defined) {
- throw ParseError("unexpected error: invalid operands to affectation expression", std::vector{node.begin()});
+ throw ParseError("unexpected error: invalid operands to affectation expression", std::vector{lhs_node.begin()});
}
// LCOV_EXCL_STOP
}
@@ -371,7 +371,7 @@ template <typename OperatorT, typename ValueT, typename DataT>
class AffectationProcessor final : public INodeProcessor
{
private:
- ASTNode& m_node;
+ ASTNode& m_rhs_node;
std::unique_ptr<IAffectationExecutor> m_affectation_executor;
@@ -379,16 +379,16 @@ class AffectationProcessor final : public INodeProcessor
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- m_affectation_executor->affect(exec_policy, m_node.children[1]->execute(exec_policy));
+ m_affectation_executor->affect(exec_policy, m_rhs_node.execute(exec_policy));
return {};
}
- AffectationProcessor(ASTNode& node) : m_node{node}
+ AffectationProcessor(ASTNode& lhs_node, ASTNode& rhs_node) : m_rhs_node{rhs_node}
{
- if (node.children[0]->is_type<language::name>()) {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
+ if (lhs_node.is_type<language::name>()) {
+ const std::string& symbol = lhs_node.string();
+ auto [i_symbol, found] = lhs_node.m_symbol_table->find(symbol, lhs_node.begin());
Assert(found);
DataVariant& value = i_symbol->attributes().value();
@@ -397,23 +397,21 @@ class AffectationProcessor final : public INodeProcessor
}
using AffectationExecutorT = AffectationExecutor<OperatorT, ValueT, DataT>;
- m_affectation_executor = std::make_unique<AffectationExecutorT>(m_node, std::get<ValueT>(value));
- } else if (node.children[0]->is_type<language::subscript_expression>()) {
- auto& array_subscript_expression = *node.children[0];
-
- auto& array_expression = *array_subscript_expression.children[0];
+ m_affectation_executor = std::make_unique<AffectationExecutorT>(lhs_node, std::get<ValueT>(value));
+ } else if (lhs_node.is_type<language::subscript_expression>()) {
+ auto& array_expression = *lhs_node.children[0];
Assert(array_expression.is_type<language::name>());
const std::string& symbol = array_expression.string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, array_subscript_expression.begin());
+ auto [i_symbol, found] = lhs_node.m_symbol_table->find(symbol, lhs_node.begin());
Assert(found);
DataVariant& value = i_symbol->attributes().value();
if (array_expression.m_data_type == ASTNodeDataType::vector_t) {
- Assert(array_subscript_expression.children.size() == 2);
+ Assert(lhs_node.children.size() == 2);
- auto& index_expression = *array_subscript_expression.children[1];
+ auto& index_expression = *lhs_node.children[1];
switch (array_expression.m_data_type.dimension()) {
case 1: {
@@ -423,7 +421,7 @@ class AffectationProcessor final : public INodeProcessor
}
using AffectationExecutorT = VectorComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
m_affectation_executor =
- std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value), index_expression);
+ std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value), index_expression);
break;
}
case 2: {
@@ -433,7 +431,7 @@ class AffectationProcessor final : public INodeProcessor
}
using AffectationExecutorT = VectorComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
m_affectation_executor =
- std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value), index_expression);
+ std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value), index_expression);
break;
}
case 3: {
@@ -443,22 +441,21 @@ class AffectationProcessor final : public INodeProcessor
}
using AffectationExecutorT = VectorComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
m_affectation_executor =
- std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value), index_expression);
+ std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value), index_expression);
break;
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error: invalid vector dimension",
- std::vector{array_subscript_expression.begin()});
+ throw ParseError("unexpected error: invalid vector dimension", std::vector{lhs_node.begin()});
}
// LCOV_EXCL_STOP
}
} else if (array_expression.m_data_type == ASTNodeDataType::matrix_t) {
- Assert(array_subscript_expression.children.size() == 3);
+ Assert(lhs_node.children.size() == 3);
Assert(array_expression.m_data_type.nbRows() == array_expression.m_data_type.nbColumns());
- auto& index0_expression = *array_subscript_expression.children[1];
- auto& index1_expression = *array_subscript_expression.children[2];
+ auto& index0_expression = *lhs_node.children[1];
+ auto& index1_expression = *lhs_node.children[2];
switch (array_expression.m_data_type.nbRows()) {
case 1: {
@@ -467,7 +464,8 @@ class AffectationProcessor final : public INodeProcessor
value = ArrayTypeT{};
}
using AffectationExecutorT = MatrixComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
- m_affectation_executor = std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value),
+
+ m_affectation_executor = std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value),
index0_expression, index1_expression);
break;
}
@@ -477,7 +475,8 @@ class AffectationProcessor final : public INodeProcessor
value = ArrayTypeT{};
}
using AffectationExecutorT = MatrixComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
- m_affectation_executor = std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value),
+
+ m_affectation_executor = std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value),
index0_expression, index1_expression);
break;
}
@@ -487,14 +486,14 @@ class AffectationProcessor final : public INodeProcessor
value = ArrayTypeT{};
}
using AffectationExecutorT = MatrixComponentAffectationExecutor<OperatorT, ArrayTypeT, ValueT, DataT>;
- m_affectation_executor = std::make_unique<AffectationExecutorT>(node, std::get<ArrayTypeT>(value),
+
+ m_affectation_executor = std::make_unique<AffectationExecutorT>(lhs_node, std::get<ArrayTypeT>(value),
index0_expression, index1_expression);
break;
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error: invalid vector dimension",
- std::vector{array_subscript_expression.begin()});
+ throw ParseError("unexpected error: invalid vector dimension", std::vector{lhs_node.begin()});
}
// LCOV_EXCL_STOP
}
@@ -505,25 +504,41 @@ class AffectationProcessor final : public INodeProcessor
}
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid lhs", std::vector{node.children[0]->begin()});
+ throw ParseError("unexpected error: invalid lhs", std::vector{lhs_node.begin()});
// LCOV_EXCL_STOP
}
}
};
+class AffectationToDataVariantProcessorBase : public INodeProcessor
+{
+ protected:
+ DataVariant* m_lhs;
+
+ public:
+ AffectationToDataVariantProcessorBase(ASTNode& lhs_node)
+ {
+ const std::string& symbol = lhs_node.string();
+ auto [i_symbol, found] = lhs_node.m_symbol_table->find(symbol, lhs_node.begin());
+ Assert(found);
+
+ m_lhs = &i_symbol->attributes().value();
+ }
+
+ virtual ~AffectationToDataVariantProcessorBase() = default;
+};
+
template <typename OperatorT, typename ValueT>
-class AffectationToTinyVectorFromListProcessor final : public INodeProcessor
+class AffectationToTinyVectorFromListProcessor final : public AffectationToDataVariantProcessorBase
{
private:
- ASTNode& m_node;
-
- DataVariant* m_lhs;
+ ASTNode& m_rhs_node;
public:
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_node.children[1]->execute(exec_policy));
+ AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_rhs_node.execute(exec_policy));
static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to vectors");
@@ -537,7 +552,7 @@ class AffectationToTinyVectorFromListProcessor final : public INodeProcessor
v[i] = child_value;
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_node.begin());
+ throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
// LCOV_EXCL_STOP
}
},
@@ -548,29 +563,22 @@ class AffectationToTinyVectorFromListProcessor final : public INodeProcessor
return {};
}
- AffectationToTinyVectorFromListProcessor(ASTNode& node) : m_node{node}
- {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
- Assert(found);
-
- m_lhs = &i_symbol->attributes().value();
- }
+ AffectationToTinyVectorFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
+ {}
};
template <typename OperatorT, typename ValueT>
-class AffectationToTinyMatrixFromListProcessor final : public INodeProcessor
+class AffectationToTinyMatrixFromListProcessor final : public AffectationToDataVariantProcessorBase
{
private:
- ASTNode& m_node;
-
- DataVariant* m_lhs;
+ ASTNode& m_rhs_node;
public:
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_node.children[1]->execute(exec_policy));
+ AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_rhs_node.execute(exec_policy));
static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to vectors");
@@ -585,7 +593,7 @@ class AffectationToTinyMatrixFromListProcessor final : public INodeProcessor
v(i, j) = child_value;
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_node.begin());
+ throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
// LCOV_EXCL_STOP
}
},
@@ -597,29 +605,22 @@ class AffectationToTinyMatrixFromListProcessor final : public INodeProcessor
return {};
}
- AffectationToTinyMatrixFromListProcessor(ASTNode& node) : m_node{node}
- {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
- Assert(found);
-
- m_lhs = &i_symbol->attributes().value();
- }
+ AffectationToTinyMatrixFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
+ {}
};
template <typename ValueT>
-class AffectationToTupleProcessor final : public INodeProcessor
+class AffectationToTupleProcessor final : public AffectationToDataVariantProcessorBase
{
private:
- ASTNode& m_node;
-
- DataVariant* m_lhs;
+ ASTNode& m_rhs_node;
public:
DataVariant
execute(ExecutionPolicy& exec_policy)
{
- DataVariant value = m_node.children[1]->execute(exec_policy);
+ DataVariant value = m_rhs_node.execute(exec_policy);
std::visit(
[&](auto&& v) {
@@ -646,12 +647,12 @@ class AffectationToTupleProcessor final : public INodeProcessor
*m_lhs = std::vector<ValueT>{ValueT{zero}};
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_node.begin());
+ throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
// LCOV_EXCL_STOP
}
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_node.begin());
+ throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
// LCOV_EXCL_STOP
}
},
@@ -660,23 +661,16 @@ class AffectationToTupleProcessor final : public INodeProcessor
return {};
}
- AffectationToTupleProcessor(ASTNode& node) : m_node{node}
- {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
- Assert(found);
-
- m_lhs = &i_symbol->attributes().value();
- }
+ AffectationToTupleProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
+ {}
};
template <typename ValueT>
-class AffectationToTupleFromListProcessor final : public INodeProcessor
+class AffectationToTupleFromListProcessor final : public AffectationToDataVariantProcessorBase
{
private:
- ASTNode& m_node;
-
- DataVariant* m_lhs;
+ ASTNode& m_rhs_node;
void
_copyAggregateDataVariant(const AggregateDataVariant& children_values)
@@ -711,7 +705,7 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
} else {
// LCOV_EXCL_START
throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_node.children[1]->children[i]->begin());
+ m_rhs_node.children[i]->begin());
// LCOV_EXCL_STOP
}
},
@@ -728,7 +722,7 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
} else {
// LCOV_EXCL_START
throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_node.children[1]->children[i]->begin());
+ m_rhs_node.children[i]->begin());
// LCOV_EXCL_STOP
}
} else if constexpr (is_tiny_matrix_v<ValueT>) {
@@ -745,7 +739,7 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
} else {
// LCOV_EXCL_START
throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_node.children[1]->children[i]->begin());
+ m_rhs_node.children[i]->begin());
// LCOV_EXCL_STOP
}
},
@@ -763,13 +757,13 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
} else {
// LCOV_EXCL_START
throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_node.children[1]->children[i]->begin());
+ m_rhs_node.children[i]->begin());
// LCOV_EXCL_STOP
}
} else {
// LCOV_EXCL_START
throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_node.children[1]->children[i]->begin());
+ m_rhs_node.children[i]->begin());
// LCOV_EXCL_STOP
}
},
@@ -805,8 +799,7 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
}
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in tuple affectation",
- m_node.children[1]->begin());
+ throw ParseError("unexpected error: unexpected right hand side type in tuple affectation", m_rhs_node.begin());
// LCOV_EXCL_STOP
}
@@ -826,34 +819,23 @@ class AffectationToTupleFromListProcessor final : public INodeProcessor
this->_copyVector(value_list);
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid lhs (expecting list or tuple)",
- std::vector{m_node.children[1]->begin()});
+ throw ParseError("unexpected error: invalid lhs (expecting list or tuple)", std::vector{m_rhs_node.begin()});
// LCOV_EXCL_STOP
}
},
- m_node.children[1]->execute(exec_policy));
+ m_rhs_node.execute(exec_policy));
return {};
}
- AffectationToTupleFromListProcessor(ASTNode& node) : m_node{node}
- {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
- Assert(found);
-
- m_lhs = &i_symbol->attributes().value();
- }
+ AffectationToTupleFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
+ : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
+ {}
};
template <typename ValueT>
-class AffectationFromZeroProcessor final : public INodeProcessor
+class AffectationFromZeroProcessor final : public AffectationToDataVariantProcessorBase
{
- private:
- ASTNode& m_node;
-
- DataVariant* m_lhs;
-
public:
DataVariant
execute(ExecutionPolicy&)
@@ -862,14 +844,7 @@ class AffectationFromZeroProcessor final : public INodeProcessor
return {};
}
- AffectationFromZeroProcessor(ASTNode& node) : m_node{node}
- {
- const std::string& symbol = m_node.children[0]->string();
- auto [i_symbol, found] = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
- Assert(found);
-
- m_lhs = &i_symbol->attributes().value();
- }
+ AffectationFromZeroProcessor(ASTNode& lhs_node) : AffectationToDataVariantProcessorBase(lhs_node) {}
};
template <typename OperatorT>
diff --git a/src/language/utils/AffectationProcessorBuilder.hpp b/src/language/utils/AffectationProcessorBuilder.hpp
index 8d11599a01c67566e0f88fcb34cad581bc76de45..0e4b7ace65654b650989e817dbe2e4a545ae320f 100644
--- a/src/language/utils/AffectationProcessorBuilder.hpp
+++ b/src/language/utils/AffectationProcessorBuilder.hpp
@@ -15,18 +15,18 @@ class AffectationProcessorBuilder final : public IAffectationProcessorBuilder
public:
AffectationProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
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);
+ if ((rhs_node.is_type<language::integer>()) and (std::stoi(rhs_node.string()) == 0)) {
+ return std::make_unique<AffectationFromZeroProcessor<ValueT>>(lhs_node);
} else {
- return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(node);
+ return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(lhs_node, rhs_node);
}
} else {
- return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(node);
+ return std::make_unique<AffectationProcessor<OperatorT, ValueT, DataT>>(lhs_node, rhs_node);
}
}
};
@@ -37,9 +37,9 @@ class AffectationToTupleProcessorBuilder final : public IAffectationProcessorBui
public:
AffectationToTupleProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
- return std::make_unique<AffectationToTupleProcessor<ValueT>>(node);
+ return std::make_unique<AffectationToTupleProcessor<ValueT>>(lhs_node, rhs_node);
}
};
@@ -49,10 +49,10 @@ class AffectationToTupleFromListProcessorBuilder final : public IAffectationProc
public:
AffectationToTupleFromListProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
- ASTNodeNaturalConversionChecker(*node.children[1], node.children[0]->m_data_type);
- return std::make_unique<AffectationToTupleFromListProcessor<ValueT>>(node);
+ ASTNodeNaturalConversionChecker(rhs_node, lhs_node.m_data_type);
+ return std::make_unique<AffectationToTupleFromListProcessor<ValueT>>(lhs_node, rhs_node);
}
};
@@ -62,9 +62,9 @@ class AffectationToTinyVectorFromListProcessorBuilder final : public IAffectatio
public:
AffectationToTinyVectorFromListProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
- return std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(node);
+ return std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(lhs_node, rhs_node);
}
};
@@ -74,9 +74,9 @@ class AffectationToTinyMatrixFromListProcessorBuilder final : public IAffectatio
public:
AffectationToTinyMatrixFromListProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
- return std::make_unique<AffectationToTinyMatrixFromListProcessor<OperatorT, ValueT>>(node);
+ return std::make_unique<AffectationToTinyMatrixFromListProcessor<OperatorT, ValueT>>(lhs_node, rhs_node);
}
};
@@ -86,12 +86,12 @@ class AffectationFromZeroProcessorBuilder final : public IAffectationProcessorBu
public:
AffectationFromZeroProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& node) const
+ getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
{
- if (std::stoi(node.children[1]->string()) == 0) {
- return std::make_unique<AffectationFromZeroProcessor<ValueT>>(node);
+ if (std::stoi(rhs_node.string()) == 0) {
+ return std::make_unique<AffectationFromZeroProcessor<ValueT>>(lhs_node);
} else {
- throw ParseError("invalid integral value (0 is the solely valid value)", std::vector{node.children[1]->begin()});
+ throw ParseError("invalid integral value (0 is the solely valid value)", std::vector{lhs_node.begin()});
}
}
};
diff --git a/src/language/utils/IAffectationProcessorBuilder.hpp b/src/language/utils/IAffectationProcessorBuilder.hpp
index 6d5f8540df9435bba4b86e6bee22f980b5727d7b..cc0ca85f67ece81b6c1313a13c429dfeb9718cd7 100644
--- a/src/language/utils/IAffectationProcessorBuilder.hpp
+++ b/src/language/utils/IAffectationProcessorBuilder.hpp
@@ -9,7 +9,7 @@ class INodeProcessor;
class IAffectationProcessorBuilder
{
public:
- virtual std::unique_ptr<INodeProcessor> getNodeProcessor(ASTNode& node) const = 0;
+ virtual std::unique_ptr<INodeProcessor> getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const = 0;
virtual ~IAffectationProcessorBuilder() = default;
};