diff --git a/src/language/PEGGrammar.hpp b/src/language/PEGGrammar.hpp index 2771a48e6a481a42400a6dd55ad7c67af44e8af2..78aaafe96e4795542a639144827851bbc3421029 100644 --- a/src/language/PEGGrammar.hpp +++ b/src/language/PEGGrammar.hpp @@ -161,8 +161,8 @@ struct vector_expression : if_must< open_bracket, list_must<expression, COMMA >, struct row_expression : if_must< open_bracket, list_must<expression, COMMA >, close_bracket >{}; struct matrix_expression : seq< open_bracket, list_must<row_expression, COMMA >, close_bracket >{}; -struct tuple_expression; -struct function_argument_list : if_must< open_parent, opt< list_must< sor< tuple_expression, expression >, COMMA > >, close_parent >{}; +struct inner_expression_list; +struct function_argument_list : if_must< open_parent, opt< list_must< sor< inner_expression_list, expression >, COMMA > >, close_parent >{}; struct function_evaluation : seq< NAME, function_argument_list > {}; struct primary_expression : sor< BOOL, REAL, INTEGER, LITERAL, function_evaluation, NAME, parented_expression, matrix_expression, vector_expression >{}; @@ -233,12 +233,12 @@ struct logical_or : list_must< logical_and, or_op >{}; struct expression : logical_or {}; -struct tuple_expression : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{}; +struct inner_expression_list : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{}; -struct expression_list : seq< open_parent, sor< seq< tuple_expression, - star< if_must< COMMA, sor< tuple_expression, expression > > > >, +struct expression_list : seq< open_parent, sor< seq< inner_expression_list, + star< if_must< COMMA, sor< inner_expression_list, expression > > > >, seq< expression, - plus< if_must< COMMA, sor< tuple_expression, expression > > > > >, close_parent >{}; + plus< if_must< COMMA, sor< inner_expression_list, expression > > > > >, close_parent >{}; struct affect_op : sor< eq_op, multiplyeq_op, divideeq_op, pluseq_op, minuseq_op > {}; diff --git a/src/language/ast/ASTBuilder.cpp b/src/language/ast/ASTBuilder.cpp index 47642d04e2bc9a745a7962954844cd54f74d2ba0..4e380783e3af91072e130f9fa71a19164fcae08f 100644 --- a/src/language/ast/ASTBuilder.cpp +++ b/src/language/ast/ASTBuilder.cpp @@ -229,7 +229,7 @@ using selector = TAO_PEGTL_NAMESPACE::parse_tree::selector< language::Z_set, language::R_set, language::type_name_id, - language::tuple_expression, + language::inner_expression_list, language::vector_expression, language::vector_type, language::matrix_expression, diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp index 2473205ae73d8caf552ac561c14907159d192622..6793bdcd1078fa738e1edd3f7a6146c4101e766c 100644 --- a/src/language/ast/ASTNodeDataTypeBuilder.cpp +++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp @@ -298,7 +298,7 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const n.is_type<language::minuseq_op>()) { n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>(); - } else if (n.is_type<language::tuple_expression>()) { + } else if (n.is_type<language::inner_expression_list>()) { std::vector<std::shared_ptr<const ASTNodeDataType>> sub_data_type_list; sub_data_type_list.reserve(n.children.size()); diff --git a/src/language/ast/ASTNodeExpressionBuilder.cpp b/src/language/ast/ASTNodeExpressionBuilder.cpp index 4e61d118ead28e0a20345cc264a8bf3edc566d47..70722aea1a1ac73851df7157820a029e87266a66 100644 --- a/src/language/ast/ASTNodeExpressionBuilder.cpp +++ b/src/language/ast/ASTNodeExpressionBuilder.cpp @@ -16,11 +16,11 @@ #include <language/node_processor/FakeProcessor.hpp> #include <language/node_processor/ForProcessor.hpp> #include <language/node_processor/IfProcessor.hpp> +#include <language/node_processor/InnerListToVectorProcessor.hpp> #include <language/node_processor/LocalNameProcessor.hpp> #include <language/node_processor/NameProcessor.hpp> #include <language/node_processor/TinyMatrixExpressionProcessor.hpp> #include <language/node_processor/TinyVectorExpressionProcessor.hpp> -#include <language/node_processor/TupleToVectorProcessor.hpp> #include <language/node_processor/ValueProcessor.hpp> #include <language/node_processor/WhileProcessor.hpp> #include <language/utils/ParseError.hpp> @@ -52,8 +52,9 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n) ASTNodeAffectationExpressionBuilder{n}; } - } else if (n.is_type<language::tuple_expression>()) { - n.m_node_processor = std::make_unique<TupleToVectorProcessor<ASTNodeExpressionListProcessor>>(n); + } else if (n.is_type<language::inner_expression_list>()) { + n.m_node_processor = std::make_unique<InnerListToVectorProcessor>(n); + } else if (n.is_type<language::function_definition>()) { this->_checkIsPureFunction(n); diff --git a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp index 6697967d2ab54950f7781ddfe41fa1c2197a28c8..8d77e1044e99750c3b9efba0157c4886264fa709 100644 --- a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp +++ b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp @@ -37,8 +37,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error: invalid operand type for affectation", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid operand type for affectation"); } // LCOV_EXCL_STOP } @@ -63,17 +62,16 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( list_affectation_processor->template add<ValueT, ZeroType>(value_node); } else { // LCOV_EXCL_START - throw ParseError("unexpected error: invalid operand value", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("unexpected error: invalid operand value"); // LCOV_EXCL_STOP } } else { // LCOV_EXCL_START - throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid dimension"); // LCOV_EXCL_STOP } } else { - throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()}); + static_assert(std::is_same_v<ValueT, TinyVector<1>>, "unexpected value type"); } }; @@ -98,17 +96,16 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( list_affectation_processor->template add<ValueT, ZeroType>(value_node); } else { // LCOV_EXCL_START - throw ParseError("unexpected error: invalid operand value", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid operand value"); // LCOV_EXCL_STOP } } else { // LCOV_EXCL_START - throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid dimension"); // LCOV_EXCL_STOP } } else { - throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()}); + static_assert(std::is_same_v<ValueT, TinyMatrix<1>>, "unexpected value type"); } }; @@ -201,7 +198,6 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( break; } } - break; } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) { Assert(rhs_tuple_content.numberOfRows() == rhs_tuple_content.numberOfColumns()); switch (rhs_tuple_content.numberOfRows()) { @@ -221,7 +217,129 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( break; } } + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::vector_t: { + switch (tuple_type.contentType().dimension()) { + case 1: { + if (rhs_tuple_content == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<bool>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<uint64_t>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<int64_t>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<double>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::vector_t) { + Assert(rhs_tuple_content.dimension() == 1); + list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<TinyVector<1>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } break; + } + case 2: { + if (rhs_tuple_content == ASTNodeDataType::vector_t) { + Assert(rhs_tuple_content.dimension() == 2); + list_affectation_processor->template add<std::vector<TinyVector<2>>, std::vector<TinyVector<2>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 3: { + if (rhs_tuple_content == ASTNodeDataType::vector_t) { + Assert(rhs_tuple_content.dimension() == 3); + list_affectation_processor->template add<std::vector<TinyVector<3>>, std::vector<TinyVector<3>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid dimension"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::matrix_t: { + Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns()); + switch (tuple_type.contentType().numberOfRows()) { + case 1: { + if (rhs_tuple_content == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<bool>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<uint64_t>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<int64_t>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<double>>(value_node); + } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) { + Assert(rhs_tuple_content.numberOfRows() == 1); + Assert(rhs_tuple_content.numberOfColumns() == 1); + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<TinyMatrix<1>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 2: { + if (rhs_tuple_content == ASTNodeDataType::matrix_t) { + Assert(rhs_tuple_content.numberOfRows() == 2); + Assert(rhs_tuple_content.numberOfColumns() == 2); + list_affectation_processor->template add<std::vector<TinyMatrix<2>>, std::vector<TinyMatrix<2>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 3: { + if (rhs_tuple_content == ASTNodeDataType::matrix_t) { + Assert(rhs_tuple_content.numberOfRows() == 3); + Assert(rhs_tuple_content.numberOfColumns() == 3); + list_affectation_processor->template add<std::vector<TinyMatrix<3>>, std::vector<TinyMatrix<3>>>( + value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid dimension"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::type_id_t: { + if (rhs_tuple_content == ASTNodeDataType::type_id_t) { + Assert(rhs_tuple_content.nameOfTypeId() == tuple_type.contentType().nameOfTypeId()); + list_affectation_processor->template add<std::vector<EmbeddedData>, std::vector<EmbeddedData>>(value_node); } else { // LCOV_EXCL_START throw UnexpectedError("incompatible tuple types in affectation"); @@ -231,23 +349,319 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error:invalid operand type for tuple affectation", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid operand type for tuple affectation"); } // LCOV_EXCL_STOP } } else if (node_sub_data_type.m_data_type == ASTNodeDataType::list_t) { - list_affectation_processor->template add<std::vector<std::string>, AggregateDataVariant>(value_node); - // throw NotImplementedError("here"); + switch (tuple_type.contentType()) { + case ASTNodeDataType::bool_t: { + list_affectation_processor->template add<std::vector<bool>, AggregateDataVariant>(value_node); + break; + } + case ASTNodeDataType::unsigned_int_t: { + list_affectation_processor->template add<std::vector<uint64_t>, AggregateDataVariant>(value_node); + break; + } + case ASTNodeDataType::int_t: { + list_affectation_processor->template add<std::vector<int64_t>, AggregateDataVariant>(value_node); + break; + } + case ASTNodeDataType::double_t: { + list_affectation_processor->template add<std::vector<double_t>, AggregateDataVariant>(value_node); + break; + } + case ASTNodeDataType::string_t: { + list_affectation_processor->template add<std::vector<std::string>, AggregateDataVariant>(value_node); + break; + } + case ASTNodeDataType::vector_t: { + switch (tuple_type.contentType().dimension()) { + case 1: { + list_affectation_processor->template add<std::vector<TinyVector<1>>, AggregateDataVariant>(value_node); + break; + } + case 2: { + list_affectation_processor->template add<std::vector<TinyVector<2>>, AggregateDataVariant>(value_node); + break; + } + case 3: { + list_affectation_processor->template add<std::vector<TinyVector<3>>, AggregateDataVariant>(value_node); + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid vector dimension"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::matrix_t: { + Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns()); + switch (tuple_type.contentType().numberOfRows()) { + case 1: { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, AggregateDataVariant>(value_node); + break; + } + case 2: { + list_affectation_processor->template add<std::vector<TinyMatrix<2>>, AggregateDataVariant>(value_node); + break; + } + case 3: { + list_affectation_processor->template add<std::vector<TinyMatrix<3>>, AggregateDataVariant>(value_node); + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid matrix dimension"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::type_id_t: { + list_affectation_processor->template add<std::vector<EmbeddedData>, AggregateDataVariant>(value_node); + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid operand type for tuple affectation"); + } + // LCOV_EXCL_STOP + } } else { - // LCOV_EXCL_START - throw ParseError("unexpected error:invalid operand type for tuple affectation", std::vector{m_node.begin()}); - // LCOV_EXCL_STOP + const ASTNodeDataType& rhs_type = node_sub_data_type.m_data_type; + switch (tuple_type.contentType()) { + case ASTNodeDataType::bool_t: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<bool>, bool>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::unsigned_int_t: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<uint64_t>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<uint64_t>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<uint64_t>, int64_t>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::int_t: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<int64_t>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<int64_t>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<int64_t>, int64_t>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::double_t: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<double>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<double>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<double>, int64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<double>, double>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::string_t: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<std::string>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<std::string>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<std::string>, int64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<std::string>, double>(value_node); + } else if (rhs_type == ASTNodeDataType::string_t) { + list_affectation_processor->template add<std::vector<std::string>, std::string>(value_node); + } else if (rhs_type == ASTNodeDataType::vector_t) { + switch (rhs_type.dimension()) { + case 1: { + list_affectation_processor->template add<std::vector<std::string>, TinyVector<1>>(value_node); + break; + } + case 2: { + list_affectation_processor->template add<std::vector<std::string>, TinyVector<2>>(value_node); + break; + } + case 3: { + list_affectation_processor->template add<std::vector<std::string>, TinyVector<3>>(value_node); + break; + } + } + } else if (rhs_type == ASTNodeDataType::matrix_t) { + Assert(rhs_type.numberOfRows() == rhs_type.numberOfColumns()); + switch (rhs_type.numberOfRows()) { + case 1: { + list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<1>>(value_node); + break; + } + case 2: { + list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<2>>(value_node); + break; + } + case 3: { + list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<3>>(value_node); + break; + } + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible rhs type in tuple affectation"); + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::vector_t: { + switch (tuple_type.contentType().dimension()) { + case 1: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, int64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<TinyVector<1>>, double>(value_node); + } else if (rhs_type == ASTNodeDataType::vector_t) { + Assert(rhs_type.dimension() == 1); + list_affectation_processor->template add<std::vector<TinyVector<1>>, TinyVector<1>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 2: { + if (rhs_type == ASTNodeDataType::vector_t) { + Assert(rhs_type.dimension() == 2); + list_affectation_processor->template add<std::vector<TinyVector<2>>, TinyVector<2>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 3: { + if (rhs_type == ASTNodeDataType::vector_t) { + Assert(rhs_type.dimension() == 3); + list_affectation_processor->template add<std::vector<TinyVector<3>>, TinyVector<3>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid vector dimension for tuple affectation"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::matrix_t: { + Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns()); + switch (tuple_type.contentType().numberOfRows()) { + case 1: { + if (rhs_type == ASTNodeDataType::bool_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, bool>(value_node); + } else if (rhs_type == ASTNodeDataType::unsigned_int_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, uint64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::int_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, int64_t>(value_node); + } else if (rhs_type == ASTNodeDataType::double_t) { + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, double>(value_node); + } else if (rhs_type == ASTNodeDataType::matrix_t) { + Assert(rhs_type.numberOfRows() == 1); + Assert(rhs_type.numberOfColumns() == 1); + list_affectation_processor->template add<std::vector<TinyMatrix<1>>, TinyMatrix<1>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 2: { + if (rhs_type == ASTNodeDataType::matrix_t) { + Assert(rhs_type.numberOfRows() == 2); + Assert(rhs_type.numberOfColumns() == 2); + list_affectation_processor->template add<std::vector<TinyMatrix<2>>, TinyMatrix<2>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + case 3: { + if (rhs_type == ASTNodeDataType::matrix_t) { + Assert(rhs_type.numberOfRows() == 3); + Assert(rhs_type.numberOfColumns() == 3); + list_affectation_processor->template add<std::vector<TinyMatrix<3>>, TinyMatrix<3>>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid vector dimension for tuple affectation"); + } + // LCOV_EXCL_STOP + } + break; + } + case ASTNodeDataType::type_id_t: { + if (rhs_type == ASTNodeDataType::type_id_t) { + Assert(rhs_type.nameOfTypeId() == tuple_type.contentType().nameOfTypeId()); + list_affectation_processor->template add<std::vector<EmbeddedData>, EmbeddedData>(value_node); + } else { + // LCOV_EXCL_START + throw UnexpectedError("incompatible tuple types in affectation"); + // LCOV_EXCL_STOP + } + break; + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("invalid operand type for tuple affectation"); + } + // LCOV_EXCL_STOP + } } } else { - // LCOV_EXCL_START - throw ParseError("unexpected error:invalid operand type for tuple affectation", std::vector{m_node.begin()}); - // LCOV_EXCL_STOP + static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type"); } }; @@ -260,14 +674,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error:invalid operand type for embedded data affectation", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid operand type for embedded data affectation"); } // LCOV_EXCL_STOP } } else { - throw ParseError("unexpected error: undefined operator type for embedded data affectation", - std::vector{m_node.begin()}); + static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type"); } }; @@ -310,8 +722,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error: invalid vector dimension", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid vector dimension"); } // LCOV_EXCL_STOP } @@ -334,8 +745,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error: invalid vector dimension", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid vector dimension"); } // LCOV_EXCL_STOP } @@ -344,13 +754,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( // LCOV_EXCL_START default: { - throw ParseError("unexpected error:invalid operand type for string affectation", - std::vector{node_sub_data_type.m_parent_node.begin()}); + throw UnexpectedError("invalid operand type for string affectation"); } // LCOV_EXCL_STOP } } else { - throw ParseError("unexpected error: undefined operator type for string affectation", std::vector{m_node.begin()}); + static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type"); } }; @@ -393,7 +802,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("invalid dimension", std::vector{value_node.begin()}); + throw UnexpectedError("invalid dimension"); } // LCOV_EXCL_STOP } @@ -416,7 +825,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("invalid dimension", std::vector{value_node.begin()}); + throw UnexpectedError("invalid dimension"); } // LCOV_EXCL_STOP } @@ -432,7 +841,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } // LCOV_EXCL_START default: { - throw ParseError("unexpected error: undefined value type for tuple affectation", std::vector{value_node.begin()}); + throw UnexpectedError("unexpected error: undefined value type for tuple affectation"); } // LCOV_EXCL_STOP } diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp index 933afbff4f297df12c7aa4751c20b62f69e9af77..af8482a22a614e683336fd4118dc703007f9a170 100644 --- a/src/language/node_processor/AffectationProcessor.hpp +++ b/src/language/node_processor/AffectationProcessor.hpp @@ -101,7 +101,7 @@ class AffectationExecutor final : public IAffectationExecutor if constexpr (std::is_same_v<OperatorT, language::eq_op>) { if constexpr (std::is_same_v<std::string, DataT>) { m_lhs = std::get<DataT>(rhs); - } else if constexpr (std::is_arithmetic_v<DataT>) { + } else if constexpr (std::is_arithmetic_v<DataT> and not std::is_same_v<DataT, bool>) { m_lhs = std::to_string(std::get<DataT>(rhs)); } else { std::ostringstream os; @@ -111,7 +111,7 @@ class AffectationExecutor final : public IAffectationExecutor } else { if constexpr (std::is_same_v<std::string, DataT>) { m_lhs += std::get<std::string>(rhs); - } else if constexpr (std::is_arithmetic_v<DataT>) { + } else if constexpr (std::is_arithmetic_v<DataT> and not std::is_same_v<DataT, bool>) { m_lhs += std::to_string(std::get<DataT>(rhs)); } else { std::ostringstream os; @@ -153,9 +153,9 @@ class AffectationExecutor final : public IAffectationExecutor using ValueContentT = typename ValueT::value_type; using DataContentT = typename DataT::value_type; - if constexpr (std::is_same_v<ValueContentT, DataContentT>) { - m_lhs = std::move(std::get<DataT>(rhs)); - } else if constexpr (std::is_convertible_v<DataContentT, ValueContentT>) { + static_assert(not std::is_same_v<ValueContentT, DataContentT>, + "the case should have been treated previously"); + if constexpr (std::is_convertible_v<DataContentT, ValueContentT>) { m_lhs.resize(std::get<DataT>(rhs).size()); std::visit( [&](auto&& v) { @@ -185,7 +185,7 @@ class AffectationExecutor final : public IAffectationExecutor if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) { using Vi_T = typename std::decay_t<decltype(v)>::value_type; for (size_t i = 0; i < v.size(); ++i) { - if constexpr (std::is_arithmetic_v<Vi_T>) { + if constexpr (std::is_arithmetic_v<Vi_T> and not std::is_same_v<DataT, bool>) { m_lhs[i] = std::move(std::to_string(v[i])); } else { std::ostringstream os; @@ -200,6 +200,61 @@ class AffectationExecutor final : public IAffectationExecutor } }, rhs); + } else if constexpr (is_tiny_vector_v<ValueContentT>) { + static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before"); + static_assert(ValueContentT::Dimension == 1, + "conversions are only allowed for dimension 1 TinyVector's"); + + m_lhs.resize(std::get<DataT>(rhs).size()); + + std::visit( + [&](auto&& v) { + if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) { + using Vi_T = typename std::decay_t<decltype(v)>::value_type; + for (size_t i = 0; i < v.size(); ++i) { + if constexpr (std::is_arithmetic_v<Vi_T>) { + m_lhs[i][0] = v[i]; + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected rhs type in affectation"); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected rhs type in affectation"); + // LCOV_EXCL_STOP + } + }, + rhs); + + } else if constexpr (is_tiny_matrix_v<ValueContentT>) { + static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before"); + static_assert(ValueContentT::Dimension == 1, "conversions are only allowed for 1x1 TinyMatrix's"); + + m_lhs.resize(std::get<DataT>(rhs).size()); + + std::visit( + [&](auto&& v) { + if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) { + using Vi_T = typename std::decay_t<decltype(v)>::value_type; + for (size_t i = 0; i < v.size(); ++i) { + if constexpr (std::is_arithmetic_v<Vi_T>) { + m_lhs[i](0, 0) = v[i]; + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected rhs type in affectation"); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected rhs type in affectation"); + // LCOV_EXCL_STOP + } + }, + rhs); + } else { // LCOV_EXCL_START throw UnexpectedError("invalid value type"); @@ -220,7 +275,7 @@ class AffectationExecutor final : public IAffectationExecutor std::is_convertible_v<T, ValueContentT>) { tuple_value[i] = static_cast<ValueContentT>(child_value); } else if constexpr (std::is_same_v<std::string, ValueContentT>) { - if constexpr (std::is_arithmetic_v<T>) { + if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) { tuple_value[i] = std::to_string(child_value); } else { std::ostringstream os; @@ -263,7 +318,62 @@ class AffectationExecutor final : public IAffectationExecutor }, children_values[i]); } - // throw NotImplementedError("list -> tuple"); + } else if constexpr (is_std_vector_v<ValueT>) { + using ValueContentT = typename ValueT::value_type; + m_lhs.resize(1); + auto& tuple_value = m_lhs; + std::visit( + [&](auto&& child_value) { + using T = std::decay_t<decltype(child_value)>; + if constexpr (std::is_same_v<T, ValueContentT>) { + tuple_value[0] = child_value; + } else if constexpr (std::is_arithmetic_v<ValueContentT> and + std::is_convertible_v<T, ValueContentT>) { + tuple_value[0] = static_cast<ValueContentT>(child_value); + } else if constexpr (std::is_same_v<std::string, ValueContentT>) { + if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<DataT, bool>) { + tuple_value[0] = std::to_string(child_value); + } else { + std::ostringstream os; + os << std::boolalpha << child_value; + tuple_value[0] = os.str(); + } + } else if constexpr (is_tiny_vector_v<ValueContentT>) { + if constexpr (std::is_arithmetic_v<T>) { + if constexpr (std::is_same_v<ValueContentT, TinyVector<1>>) { + tuple_value[0][0] = child_value; + } else { + // in this case a 0 is given + Assert(child_value == 0); + tuple_value[0] = ZeroType{}; + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected error: unexpected right hand side type in affectation"); + // LCOV_EXCL_STOP + } + } else if constexpr (is_tiny_matrix_v<ValueContentT>) { + if constexpr (std::is_arithmetic_v<T>) { + if constexpr (std::is_same_v<ValueContentT, TinyMatrix<1>>) { + tuple_value[0](0, 0) = child_value; + } else { + // in this case a 0 is given + Assert(child_value == 0); + tuple_value[0] = ZeroType{}; + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected error: unexpected right hand side type in affectation"); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START + throw UnexpectedError("unexpected error: unexpected right hand side type in affectation"); + // LCOV_EXCL_STOP + } + }, + rhs); + } else { // LCOV_EXCL_START throw UnexpectedError("invalid value type"); @@ -364,7 +474,7 @@ class AffectationToTupleProcessor final : public AffectationToDataVariantProcess } else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) { *m_lhs = std::vector{std::move(static_cast<ValueT>(v))}; } else if constexpr (std::is_same_v<std::string, ValueT>) { - if constexpr (std::is_arithmetic_v<T>) { + if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) { *m_lhs = std::vector{std::move(std::to_string(v))}; } else { std::ostringstream os; @@ -419,7 +529,7 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian } else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) { tuple_value[i] = static_cast<ValueT>(child_value); } else if constexpr (std::is_same_v<std::string, ValueT>) { - if constexpr (std::is_arithmetic_v<T>) { + if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) { tuple_value[i] = std::to_string(child_value); } else { std::ostringstream os; diff --git a/src/language/node_processor/InnerListToVectorProcessor.hpp b/src/language/node_processor/InnerListToVectorProcessor.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ef74daaabe5c0e2f475b1693b7bb9627ed600f40 --- /dev/null +++ b/src/language/node_processor/InnerListToVectorProcessor.hpp @@ -0,0 +1,30 @@ +#ifndef INNER_LIST_TO_VECTOR_PROCESSOR_HPP +#define INNER_LIST_TO_VECTOR_PROCESSOR_HPP + +#include <language/ast/ASTNode.hpp> +#include <language/node_processor/ASTNodeExpressionListProcessor.hpp> +#include <language/node_processor/INodeProcessor.hpp> + +class InnerListToVectorProcessor final : public INodeProcessor +{ + private: + std::unique_ptr<ASTNodeExpressionListProcessor> m_expression_list_processor; + + public: + DataVariant + execute(ExecutionPolicy& exec_policy) + { + AggregateDataVariant v = std::get<AggregateDataVariant>(m_expression_list_processor->execute(exec_policy)); + + v.setIsFlattenable(false); + return v; + } + + InnerListToVectorProcessor(ASTNode& node) + : m_expression_list_processor{std::make_unique<ASTNodeExpressionListProcessor>(node)} + {} + + ~InnerListToVectorProcessor() = default; +}; + +#endif // INNER_LIST_TO_VECTOR_PROCESSOR_HPP diff --git a/src/language/node_processor/TupleToVectorProcessor.hpp b/src/language/node_processor/TupleToVectorProcessor.hpp deleted file mode 100644 index 74ad59acb95e0e853a880fb171e93d77c55dcd74..0000000000000000000000000000000000000000 --- a/src/language/node_processor/TupleToVectorProcessor.hpp +++ /dev/null @@ -1,32 +0,0 @@ -#ifndef TUPLE_TO_VECTOR_PROCESSOR_HPP -#define TUPLE_TO_VECTOR_PROCESSOR_HPP - -#include <language/ast/ASTNode.hpp> -#include <language/node_processor/INodeProcessor.hpp> - -template <typename TupleProcessorT> -class TupleToVectorProcessor final : public INodeProcessor -{ - private: - ASTNode& m_node; - - std::unique_ptr<TupleProcessorT> m_tuple_processor; - - public: - DataVariant - execute(ExecutionPolicy& exec_policy) - { - AggregateDataVariant v = std::get<AggregateDataVariant>(m_tuple_processor->execute(exec_policy)); - - v.setIsFlattenable(false); - return v; - } - - TupleToVectorProcessor(ASTNode& node) : m_node{node}, m_tuple_processor{std::make_unique<TupleProcessorT>(node)} {} - - TupleToVectorProcessor(ASTNode& node, std::unique_ptr<TupleProcessorT>&& tuple_processor) - : m_node{node}, m_tuple_processor{std::move(tuple_processor)} - {} -}; - -#endif // TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP diff --git a/tests/test_ASTBuilder.cpp b/tests/test_ASTBuilder.cpp index 262a0cd30b60cee5da070fe6fa8d62d8981e7b1d..2a9bcf4e41c039ac87dd6d3535a47710fb1a86e7 100644 --- a/tests/test_ASTBuilder.cpp +++ b/tests/test_ASTBuilder.cpp @@ -636,10 +636,10 @@ let y:(R^2), y=((0)); | | `-(language::integer:2) | +-(language::name:x) | `-(language::expression_list) - | +-(language::tuple_expression) + | +-(language::inner_expression_list) | | +-(language::integer:0) | | `-(language::integer:0) - | `-(language::tuple_expression) + | `-(language::inner_expression_list) | +-(language::integer:2) | `-(language::integer:3) `-(language::var_declaration) diff --git a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp index 7c96baebb0ad6b9771bda10b7065dd72208b5b09..05b64ce5127758d9772e297c5d8a2c62bb62119c 100644 --- a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp +++ b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp @@ -1229,7 +1229,7 @@ tuple_RtoB((1.2, 2, true, n)); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:tuple_RtoB:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::real:1.2:ValueProcessor) +-(language::integer:2:ValueProcessor) +-(language::true_kw:ValueProcessor) @@ -1332,7 +1332,7 @@ tuple_stringtoB(("foo",2,"bar")); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:tuple_stringtoB:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::literal:"foo":ValueProcessor) +-(language::integer:2:ValueProcessor) `-(language::literal:"bar":ValueProcessor) @@ -1367,7 +1367,7 @@ tuple_builtinToB((a,b,a)); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:tuple_builtinToB:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::name:a:NameProcessor) +-(language::name:b:NameProcessor) `-(language::name:a:NameProcessor) @@ -1535,7 +1535,7 @@ tuple_R2ToR((r,r)); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:tuple_R2ToR:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::name:r:NameProcessor) `-(language::name:r:NameProcessor) )"; @@ -1587,7 +1587,7 @@ tuple_R22ToR((r,r)); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:tuple_R22ToR:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::name:r:NameProcessor) `-(language::name:r:NameProcessor) )"; @@ -1689,7 +1689,7 @@ fidTupleToR((f,f)); (root:ASTNodeListProcessor) `-(language::function_evaluation:BuiltinFunctionProcessor) +-(language::name:fidTupleToR:FakeProcessor) - `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>) + `-(language::inner_expression_list:InnerListToVectorProcessor) +-(language::name:f:NameProcessor) `-(language::name:f:NameProcessor) )"; diff --git a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp index 44f3d6713e9256cbaf0e12814200aac4f8b333fa..02aa43085baca268485d48af950cfde2f3485846 100644 --- a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp +++ b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp @@ -330,6 +330,1019 @@ let (x1,x2,x3,x) : R^1x1*R^2x2*R^3x3*R, (x1,x2,x3,x) = (0, 0, 0, 0); CHECK_AST(data, result); } + SECTION("with tuples from lists") + { + std::string_view data = R"( +let (x,n,s) : (R)*(N)*(string), (x,n,s) = ((1.2,3.4), (1,2,3), (2.1,4,3.3,17.2)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:x:NameProcessor) + | +-(language::name:n:NameProcessor) + | `-(language::name:s:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::real:1.2:ValueProcessor) + | `-(language::real:3.4:ValueProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::real:2.1:ValueProcessor) + +-(language::integer:4:ValueProcessor) + +-(language::real:3.3:ValueProcessor) + `-(language::real:17.2:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("with tuples from tuples") + { + SECTION("tuple of B") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let (b1,b2,b3) : (B)*(B)*(B), (b1,b2,b3) = (b, false, (true, true, false)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:b1:NameProcessor) + | +-(language::name:b2:NameProcessor) + | `-(language::name:b3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::false_kw:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::true_kw:ValueProcessor) + +-(language::true_kw:ValueProcessor) + `-(language::false_kw:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of N") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (n1,n2,n3,n4,n5,n6,n7,n8) : (N)*(N)*(N)*(N)*(N)*(N)*(N)*(N), + (n1,n2,n3,n4,n5,n6,n7,n8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:n1:NameProcessor) + | +-(language::name:n2:NameProcessor) + | +-(language::name:n3:NameProcessor) + | +-(language::name:n4:NameProcessor) + | +-(language::name:n5:NameProcessor) + | +-(language::name:n6:NameProcessor) + | +-(language::name:n7:NameProcessor) + | `-(language::name:n8:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:n:NameProcessor) + +-(language::name:z:NameProcessor) + +-(language::false_kw:ValueProcessor) + +-(language::integer:2:ValueProcessor) + +-(language::name:i1:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::name:i1:NameProcessor) + `-(language::name:i2:NameProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of Z") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (z1,z2,z3,z4,z5,z6,z7,z8) : (Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z), + (z1,z2,z3,z4,z5,z6,z7,z8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:z1:NameProcessor) + | +-(language::name:z2:NameProcessor) + | +-(language::name:z3:NameProcessor) + | +-(language::name:z4:NameProcessor) + | +-(language::name:z5:NameProcessor) + | +-(language::name:z6:NameProcessor) + | +-(language::name:z7:NameProcessor) + | `-(language::name:z8:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:n:NameProcessor) + +-(language::name:z:NameProcessor) + +-(language::false_kw:ValueProcessor) + +-(language::integer:2:ValueProcessor) + +-(language::name:i1:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::name:i1:NameProcessor) + `-(language::name:i2:NameProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let r:(R), r = (1.2, 3.3, 2.4); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) : (R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R), + (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) = (b, n, z, r, true, 2, i1, 2.3, (2, 3, 2), (i1, i2), (2.2, 1.4)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<double>) + | +-(language::name:r:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:r1:NameProcessor) + | +-(language::name:r2:NameProcessor) + | +-(language::name:r3:NameProcessor) + | +-(language::name:r4:NameProcessor) + | +-(language::name:r5:NameProcessor) + | +-(language::name:r6:NameProcessor) + | +-(language::name:r7:NameProcessor) + | +-(language::name:r8:NameProcessor) + | +-(language::name:r9:NameProcessor) + | +-(language::name:r10:NameProcessor) + | `-(language::name:r11:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:n:NameProcessor) + +-(language::name:z:NameProcessor) + +-(language::name:r:NameProcessor) + +-(language::true_kw:ValueProcessor) + +-(language::integer:2:ValueProcessor) + +-(language::name:i1:NameProcessor) + +-(language::real:2.3:ValueProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::name:i1:NameProcessor) + | `-(language::name:i2:NameProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::real:2.2:ValueProcessor) + `-(language::real:1.4:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of string") + { + std::string_view data = R"( +import utils; + +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let r:(R), r = (1.2, 3.3, 2.4); +let s:(string), s = ("foo", "bar"); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13): + (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string), + (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13) + = (b, n, z, r, s, 2, i1, 2.3, "foobar", (2, 3, 2), (i1, i2), (2.2, 1.4), ("hello", "world")); + +let v1:(R^1), v1 = (2, [3], [5]); +let v2:(R^2), v2 = ([2,3], [3,5]); +let v3:(R^3), v3 = ([2,2,3], 0, [1,3,5]); +let A1:(R^1x1), A1 = (2, [[3]]); +let A2:(R^2x2), A2 = ([[2,3], [3,5]],0); +let A3:(R^3x3), A3 = ([[2,2,3], [1,2,7], [1,3,5]], [[1,3,2], [6,3,5], [3,2,-1]]); +let (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10): + (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string), + (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10) + = (v1, v2, v3, A1, A2, A3, [[0]], [2,3], [[1,2],[3,4]], ([1,2,3], [2,3,1])); + +let (u1,u2,u3,u4): (string)*(string)*(string)*(string), + (u1,u2,u3,u4) = (true, [1], [1,2,3], [[1,2,3],[4,5,6],[7,8,9]]); +)"; + + std::string result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<double>) + | +-(language::name:r:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<)" + + demangled_stdstring + R"( >) + | +-(language::name:s:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::literal:"foo":ValueProcessor) + | `-(language::literal:"bar":ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:ListAffectationProcessor<language::eq_op>) + | +-(language::name_list:FakeProcessor) + | | +-(language::name:s1:NameProcessor) + | | +-(language::name:s2:NameProcessor) + | | +-(language::name:s3:NameProcessor) + | | +-(language::name:s4:NameProcessor) + | | +-(language::name:s5:NameProcessor) + | | +-(language::name:s6:NameProcessor) + | | +-(language::name:s7:NameProcessor) + | | +-(language::name:s8:NameProcessor) + | | +-(language::name:s9:NameProcessor) + | | +-(language::name:s10:NameProcessor) + | | +-(language::name:s11:NameProcessor) + | | +-(language::name:s12:NameProcessor) + | | `-(language::name:s13:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::name:b:NameProcessor) + | +-(language::name:n:NameProcessor) + | +-(language::name:z:NameProcessor) + | +-(language::name:r:NameProcessor) + | +-(language::name:s:NameProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::name:i1:NameProcessor) + | +-(language::real:2.3:ValueProcessor) + | +-(language::literal:"foobar":ValueProcessor) + | +-(language::inner_expression_list:InnerListToVectorProcessor) + | | +-(language::integer:2:ValueProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | +-(language::inner_expression_list:InnerListToVectorProcessor) + | | +-(language::name:i1:NameProcessor) + | | `-(language::name:i2:NameProcessor) + | +-(language::inner_expression_list:InnerListToVectorProcessor) + | | +-(language::real:2.2:ValueProcessor) + | | `-(language::real:1.4:ValueProcessor) + | `-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::literal:"hello":ValueProcessor) + | `-(language::literal:"world":ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >) + | +-(language::name:v1:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | | `-(language::integer:3:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | `-(language::integer:5:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >) + | +-(language::name:v2:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:3:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:5:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >) + | +-(language::name:v3:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | | +-(language::integer:2:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:3:ValueProcessor) + | +-(language::integer:0:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:5:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >) + | +-(language::name:A1:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | `-(language::row_expression:FakeProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >) + | +-(language::name:A2:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::integer:2:ValueProcessor) + | | | `-(language::integer:3:ValueProcessor) + | | `-(language::row_expression:FakeProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:5:ValueProcessor) + | `-(language::integer:0:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >) + | +-(language::name:A3:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::integer:2:ValueProcessor) + | | | +-(language::integer:2:ValueProcessor) + | | | `-(language::integer:3:ValueProcessor) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::integer:1:ValueProcessor) + | | | +-(language::integer:2:ValueProcessor) + | | | `-(language::integer:7:ValueProcessor) + | | `-(language::row_expression:FakeProcessor) + | | +-(language::integer:1:ValueProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:5:ValueProcessor) + | `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:1:ValueProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:6:ValueProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:5:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::integer:3:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>) + | `-(language::integer:1:ValueProcessor) + +-(language::eq_op:ListAffectationProcessor<language::eq_op>) + | +-(language::name_list:FakeProcessor) + | | +-(language::name:t1:NameProcessor) + | | +-(language::name:t2:NameProcessor) + | | +-(language::name:t3:NameProcessor) + | | +-(language::name:t4:NameProcessor) + | | +-(language::name:t5:NameProcessor) + | | +-(language::name:t6:NameProcessor) + | | +-(language::name:t7:NameProcessor) + | | +-(language::name:t8:NameProcessor) + | | +-(language::name:t9:NameProcessor) + | | `-(language::name:t10:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::name:v1:NameProcessor) + | +-(language::name:v2:NameProcessor) + | +-(language::name:v3:NameProcessor) + | +-(language::name:A1:NameProcessor) + | +-(language::name:A2:NameProcessor) + | +-(language::name:A3:NameProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | | `-(language::row_expression:FakeProcessor) + | | `-(language::integer:0:ValueProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:3:ValueProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::integer:1:ValueProcessor) + | | | `-(language::integer:2:ValueProcessor) + | | `-(language::row_expression:FakeProcessor) + | | +-(language::integer:3:ValueProcessor) + | | `-(language::integer:4:ValueProcessor) + | `-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | | +-(language::integer:1:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:3:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:1:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:u1:NameProcessor) + | +-(language::name:u2:NameProcessor) + | +-(language::name:u3:NameProcessor) + | `-(language::name:u4:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::true_kw:ValueProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | `-(language::integer:1:ValueProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + +-(language::row_expression:FakeProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::row_expression:FakeProcessor) + | +-(language::integer:4:ValueProcessor) + | +-(language::integer:5:ValueProcessor) + | `-(language::integer:6:ValueProcessor) + `-(language::row_expression:FakeProcessor) + +-(language::integer:7:ValueProcessor) + +-(language::integer:8:ValueProcessor) + `-(language::integer:9:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R^1") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let r:(R), r = (1.2, 3.3, 2.4); +let X:(R^1), X = (1.2, [3.3], 2.4); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) : (R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1), + (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) = (b, n, z, r, true, 2, i1, 2.3, [1.2], X, (2, 3, 2), (i1, i2), (2.2, 1.4), ([1], [2])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<double>) + | +-(language::name:r:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >) + | +-(language::name:X:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | | `-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:X1:NameProcessor) + | +-(language::name:X2:NameProcessor) + | +-(language::name:X3:NameProcessor) + | +-(language::name:X4:NameProcessor) + | +-(language::name:X5:NameProcessor) + | +-(language::name:X6:NameProcessor) + | +-(language::name:X7:NameProcessor) + | +-(language::name:X8:NameProcessor) + | +-(language::name:X9:NameProcessor) + | +-(language::name:X10:NameProcessor) + | +-(language::name:X11:NameProcessor) + | +-(language::name:X12:NameProcessor) + | +-(language::name:X13:NameProcessor) + | `-(language::name:X14:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:n:NameProcessor) + +-(language::name:z:NameProcessor) + +-(language::name:r:NameProcessor) + +-(language::true_kw:ValueProcessor) + +-(language::integer:2:ValueProcessor) + +-(language::name:i1:NameProcessor) + +-(language::real:2.3:ValueProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | `-(language::real:1.2:ValueProcessor) + +-(language::name:X:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::name:i1:NameProcessor) + | `-(language::name:i2:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::real:2.2:ValueProcessor) + | `-(language::real:1.4:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | `-(language::integer:1:ValueProcessor) + `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + `-(language::integer:2:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R^2") + { + std::string_view data = R"( +let X:(R^2), X = ([1.2,2], 0, [2.4, 2]); +let (X1,X2,X3) : (R^2)*(R^2)*(R^2), (X1,X2,X3) = (X, [1,2], ([0,2], [1,0])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >) + | +-(language::name:X:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | | +-(language::real:1.2:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | +-(language::integer:0:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | +-(language::real:2.4:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:X1:NameProcessor) + | +-(language::name:X2:NameProcessor) + | `-(language::name:X3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:X:NameProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | +-(language::integer:0:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + +-(language::integer:1:ValueProcessor) + `-(language::integer:0:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R^3") + { + std::string_view data = R"( +let X:(R^3), X = ([1.2,2,4.2], 0, [2.4, 1, 2]); +let (X1,X2,X3) : (R^3)*(R^3)*(R^3), (X1,X2,X3) = (X, [2,1,4], ([0,2,1.2], [1,2.1,3.1])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >) + | +-(language::name:X:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | | +-(language::real:1.2:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::real:4.2:ValueProcessor) + | +-(language::integer:0:ValueProcessor) + | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::real:2.4:ValueProcessor) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:X1:NameProcessor) + | +-(language::name:X2:NameProcessor) + | `-(language::name:X3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:X:NameProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + | +-(language::integer:0:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::real:1.2:ValueProcessor) + `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + +-(language::integer:1:ValueProcessor) + +-(language::real:2.1:ValueProcessor) + `-(language::real:3.1:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R^1x1") + { + std::string_view data = R"( +let b:(B), b = (true, false); +let n:(N), n = (2, 3, 2); +let z:(Z), z = (1, 3, 4); +let r:(R), r = (1.2, 3.3, 2.4); +let A:(R^1x1), A = (1.2, [[3.3]], 2.4); +let i1:N, i1 = 3; +let i2:N, i2 = 3; +let (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) : (R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1), + (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) = (b, n, z, r, true, 2, i1, 2.3, [[1.2]], A, (2, 3, 2), (i1, i2), (2.2, 1.4), ([[1]], [[2]])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<bool>) + | +-(language::name:b:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::true_kw:ValueProcessor) + | `-(language::false_kw:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>) + | +-(language::name:n:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<long>) + | +-(language::name:z:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<double>) + | +-(language::name:r:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >) + | +-(language::name:A:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::real:1.2:ValueProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | | `-(language::row_expression:FakeProcessor) + | | `-(language::real:3.3:ValueProcessor) + | `-(language::real:2.4:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i1:NameProcessor) + | `-(language::integer:3:ValueProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>) + | +-(language::name:i2:NameProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:A1:NameProcessor) + | +-(language::name:A2:NameProcessor) + | +-(language::name:A3:NameProcessor) + | +-(language::name:A4:NameProcessor) + | +-(language::name:A5:NameProcessor) + | +-(language::name:A6:NameProcessor) + | +-(language::name:A7:NameProcessor) + | +-(language::name:A8:NameProcessor) + | +-(language::name:A9:NameProcessor) + | +-(language::name:A10:NameProcessor) + | +-(language::name:A11:NameProcessor) + | +-(language::name:A12:NameProcessor) + | +-(language::name:A13:NameProcessor) + | `-(language::name:A14:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:n:NameProcessor) + +-(language::name:z:NameProcessor) + +-(language::name:r:NameProcessor) + +-(language::true_kw:ValueProcessor) + +-(language::integer:2:ValueProcessor) + +-(language::name:i1:NameProcessor) + +-(language::real:2.3:ValueProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | `-(language::row_expression:FakeProcessor) + | `-(language::real:1.2:ValueProcessor) + +-(language::name:A:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::name:i1:NameProcessor) + | `-(language::name:i2:NameProcessor) + +-(language::inner_expression_list:InnerListToVectorProcessor) + | +-(language::real:2.2:ValueProcessor) + | `-(language::real:1.4:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | `-(language::row_expression:FakeProcessor) + | `-(language::integer:1:ValueProcessor) + `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + `-(language::row_expression:FakeProcessor) + `-(language::integer:2:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of embedded data") + { + std::string_view data = R"( +let b: builtin_t, b = b; +let tb: (builtin_t), tb = (b,b); +let (tb1,tb2,tb3): (builtin_t)*(builtin_t)*(builtin_t), (tb1,tb2,tb3) = (b,tb, (b,b,b)); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationProcessor<language::eq_op, EmbeddedData, EmbeddedData>) + | +-(language::name:b:NameProcessor) + | `-(language::name:b:NameProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<EmbeddedData>) + | +-(language::name:tb:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::name:b:NameProcessor) + | `-(language::name:b:NameProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:tb1:NameProcessor) + | +-(language::name:tb2:NameProcessor) + | `-(language::name:tb3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:tb:NameProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::name:b:NameProcessor) + +-(language::name:b:NameProcessor) + `-(language::name:b:NameProcessor) +)"; + + CHECK_AST(data, result); + } + } + + SECTION("tuple of R^2x2") + { + std::string_view data = R"( +let A:(R^2x2), A = ([[1.2,2],[2.1,1]], 0, [[1.4, 2],[2.4, 2]]); +let (A1,A2,A3) : (R^2x2)*(R^2x2)*(R^2x2), (A1,A2,A3) = (A, [[1,2],[4,1]], ([[0,2], [1,0]], [[1.3,2], [3,1]])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >) + | +-(language::name:A:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::real:1.2:ValueProcessor) + | | | `-(language::integer:2:ValueProcessor) + | | `-(language::row_expression:FakeProcessor) + | | +-(language::real:2.1:ValueProcessor) + | | `-(language::integer:1:ValueProcessor) + | +-(language::integer:0:ValueProcessor) + | `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::real:1.4:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::real:2.4:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:A1:NameProcessor) + | +-(language::name:A2:NameProcessor) + | `-(language::name:A3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:A:NameProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:1:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::integer:4:ValueProcessor) + | `-(language::integer:1:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:0:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:0:ValueProcessor) + `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + +-(language::row_expression:FakeProcessor) + | +-(language::real:1.3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + `-(language::row_expression:FakeProcessor) + +-(language::integer:3:ValueProcessor) + `-(language::integer:1:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("tuple of R^3x3") + { + std::string_view data = R"( +let A:(R^3x3), A = ([[1.2,2,1],[2.1,1,3],[1.2,1.2,3.2]], 0, [[1.4, 2, 1],[2.4, 0, 2],[2.1, 0.1, 3.2]]); +let (A1,A2,A3) : (R^3x3)*(R^3x3)*(R^3x3), (A1,A2,A3) = (A, [[1,2,3],[1.2,3.1,1.8],[2,4,1]], ([[0,2,1], [2,1,0], [0.2,1,3]], [[1.3,2,1], [0.3,3,1], [0.1,2,4.3]])); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >) + | +-(language::name:A:NameProcessor) + | `-(language::expression_list:ASTNodeExpressionListProcessor) + | +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::real:1.2:ValueProcessor) + | | | +-(language::integer:2:ValueProcessor) + | | | `-(language::integer:1:ValueProcessor) + | | +-(language::row_expression:FakeProcessor) + | | | +-(language::real:2.1:ValueProcessor) + | | | +-(language::integer:1:ValueProcessor) + | | | `-(language::integer:3:ValueProcessor) + | | `-(language::row_expression:FakeProcessor) + | | +-(language::real:1.2:ValueProcessor) + | | +-(language::real:1.2:ValueProcessor) + | | `-(language::real:3.2:ValueProcessor) + | +-(language::integer:0:ValueProcessor) + | `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::real:1.4:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:1:ValueProcessor) + | +-(language::row_expression:FakeProcessor) + | | +-(language::real:2.4:ValueProcessor) + | | +-(language::integer:0:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::real:2.1:ValueProcessor) + | +-(language::real:0.1:ValueProcessor) + | `-(language::real:3.2:ValueProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:A1:NameProcessor) + | +-(language::name:A2:NameProcessor) + | `-(language::name:A3:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::name:A:NameProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:1:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:3:ValueProcessor) + | +-(language::row_expression:FakeProcessor) + | | +-(language::real:1.2:ValueProcessor) + | | +-(language::real:3.1:ValueProcessor) + | | `-(language::real:1.8:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:4:ValueProcessor) + | `-(language::integer:1:ValueProcessor) + `-(language::inner_expression_list:InnerListToVectorProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:0:ValueProcessor) + | | +-(language::integer:2:ValueProcessor) + | | `-(language::integer:1:ValueProcessor) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:2:ValueProcessor) + | | +-(language::integer:1:ValueProcessor) + | | `-(language::integer:0:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::real:0.2:ValueProcessor) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + +-(language::row_expression:FakeProcessor) + | +-(language::real:1.3:ValueProcessor) + | +-(language::integer:2:ValueProcessor) + | `-(language::integer:1:ValueProcessor) + +-(language::row_expression:FakeProcessor) + | +-(language::real:0.3:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:1:ValueProcessor) + `-(language::row_expression:FakeProcessor) + +-(language::real:0.1:ValueProcessor) + +-(language::integer:2:ValueProcessor) + `-(language::real:4.3:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + SECTION("from function") { std::string_view data = R"( @@ -371,10 +1384,10 @@ let (s,r): string*string, (s,r) = ("foo","bar"); CHECK_AST(data, result); } - SECTION("string with conversion") + SECTION("string with scalar conversions") { std::string_view data = R"( -let n:N, n =2; +let n:N, n = 2; let (r,s,t,u) : string*string*string*string, (r,s,t,u) = (3.2, -2, true, n); )"; @@ -401,6 +1414,80 @@ let (r,s,t,u) : string*string*string*string, CHECK_AST(data, result); } + SECTION("string with vector conversions") + { + std::string_view data = R"( +let (r,s,t) : string*string*string, + (r,s,t) = ([3.2], [-2, 3], [1,3,2]); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:r:NameProcessor) + | +-(language::name:s:NameProcessor) + | `-(language::name:t:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>) + | `-(language::real:3.2:ValueProcessor) + +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>) + | +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>) + | | `-(language::integer:2:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>) + +-(language::integer:1:ValueProcessor) + +-(language::integer:3:ValueProcessor) + `-(language::integer:2:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + + SECTION("string with matrix conversions") + { + std::string_view data = R"( +let (r,s,t) : string*string*string, + (r,s,t) = ([[3.2]], [[1, 2],[-2, 3]], [[1,3,2],[2,1,3],[4,1,2]]); +)"; + + std::string_view result = R"( +(root:ASTNodeListProcessor) + `-(language::eq_op:ListAffectationProcessor<language::eq_op>) + +-(language::name_list:FakeProcessor) + | +-(language::name:r:NameProcessor) + | +-(language::name:s:NameProcessor) + | `-(language::name:t:NameProcessor) + `-(language::expression_list:ASTNodeExpressionListProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>) + | `-(language::row_expression:FakeProcessor) + | `-(language::real:3.2:ValueProcessor) + +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>) + | +-(language::row_expression:FakeProcessor) + | | +-(language::integer:1:ValueProcessor) + | | `-(language::integer:2:ValueProcessor) + | `-(language::row_expression:FakeProcessor) + | +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>) + | | `-(language::integer:2:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>) + +-(language::row_expression:FakeProcessor) + | +-(language::integer:1:ValueProcessor) + | +-(language::integer:3:ValueProcessor) + | `-(language::integer:2:ValueProcessor) + +-(language::row_expression:FakeProcessor) + | +-(language::integer:2:ValueProcessor) + | +-(language::integer:1:ValueProcessor) + | `-(language::integer:3:ValueProcessor) + `-(language::row_expression:FakeProcessor) + +-(language::integer:4:ValueProcessor) + +-(language::integer:1:ValueProcessor) + `-(language::integer:2:ValueProcessor) +)"; + + CHECK_AST(data, result); + } + SECTION("embedded data") { std::string_view data = R"( diff --git a/tests/test_AffectationToStringProcessor.cpp b/tests/test_AffectationToStringProcessor.cpp index d65a18a2e106f9afbbee3ca580255182ecf880e3..040692a9ea79e9b7cd4f12b310f57d58040f5b68 100644 --- a/tests/test_AffectationToStringProcessor.cpp +++ b/tests/test_AffectationToStringProcessor.cpp @@ -56,7 +56,11 @@ TEST_CASE("ASTAffectationToStringProcessor", "[language]") CHECK_AFFECTATION_RESULT(R"(let s : string; s = "foo";)", "s", std::string("foo")); CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string; s = n;)", "s", std::to_string(2ul)); CHECK_AFFECTATION_RESULT(R"(let s : string; s = -1;)", "s", std::to_string(-1l)); - CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", std::to_string(true)); + { + std::ostringstream os; + os << std::boolalpha << true; + CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", os.str()); + } CHECK_AFFECTATION_RESULT(R"(let s : string; s = 2.3;)", "s", std::to_string(2.3)); { std::ostringstream os; @@ -81,8 +85,11 @@ TEST_CASE("ASTAffectationToStringProcessor", "[language]") CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string, s = "foo"; s += n;)", "s", (std::string("foo") + std::to_string(2ul))); CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += -1;)", "s", (std::string("foo") + std::to_string(-1l))); - CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s", - (std::string("foo") + std::to_string(true))); + { + std::ostringstream os; + os << "foo" << std::boolalpha << true; + CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s", os.str()); + } CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += 2.3;)", "s", (std::string("foo") + std::to_string(2.3))); {