diff --git a/src/language/ASTNodeCFunctionExpressionBuilder.cpp b/src/language/ASTNodeCFunctionExpressionBuilder.cpp index 0218bda83d12846e6eab106c91dd747dd5429c2b..0219ef3097acc20767e98eeac9a3105894b0296a 100644 --- a/src/language/ASTNodeCFunctionExpressionBuilder.cpp +++ b/src/language/ASTNodeCFunctionExpressionBuilder.cpp @@ -6,48 +6,47 @@ #include <node_processor/CFunctionProcessor.hpp> PUGS_INLINE std::unique_ptr<INodeProcessor> -ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, - const ASTNodeDataType& argument_type, +ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(const ASTNodeDataType& parameter_type, + ASTNode& argument_node, ASTNodeDataVariant& argument_value) { - auto get_function_argument_processor_for_parameter_type = - [&](const auto& argument_v) -> std::unique_ptr<INodeProcessor> { - using ArgumentT = std::decay_t<decltype(argument_v)>; - switch (argument_type) { + auto get_function_argument_processor_for = [&](const auto& parameter_v) -> std::unique_ptr<INodeProcessor> { + using ParameterT = std::decay_t<decltype(parameter_v)>; + switch (argument_node.m_data_type) { case ASTNodeDataType::bool_t: { - return std::make_unique<CFunctionArgumentProcessor<ArgumentT, bool>>(argument_node, argument_value); + return std::make_unique<CFunctionArgumentProcessor<ParameterT, bool>>(argument_node, argument_value); } case ASTNodeDataType::unsigned_int_t: { - return std::make_unique<CFunctionArgumentProcessor<ArgumentT, uint64_t>>(argument_node, argument_value); + return std::make_unique<CFunctionArgumentProcessor<ParameterT, uint64_t>>(argument_node, argument_value); } case ASTNodeDataType::int_t: { - return std::make_unique<CFunctionArgumentProcessor<ArgumentT, int64_t>>(argument_node, argument_value); + return std::make_unique<CFunctionArgumentProcessor<ParameterT, int64_t>>(argument_node, argument_value); } case ASTNodeDataType::double_t: { - return std::make_unique<CFunctionArgumentProcessor<ArgumentT, double>>(argument_node, argument_value); + return std::make_unique<CFunctionArgumentProcessor<ParameterT, double>>(argument_node, argument_value); } default: { - throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()}); + throw parse_error("invalid argument type for function", std::vector{argument_node.begin()}); } } }; auto get_function_argument_processor_for_argument_type = [&]() { - switch (argument_node.m_data_type) { + switch (parameter_type) { case ASTNodeDataType::bool_t: { - return get_function_argument_processor_for_parameter_type(bool{}); + return get_function_argument_processor_for(bool{}); } case ASTNodeDataType::unsigned_int_t: { - return get_function_argument_processor_for_parameter_type(uint64_t{}); + return get_function_argument_processor_for(uint64_t{}); } case ASTNodeDataType::int_t: { - return get_function_argument_processor_for_parameter_type(int64_t{}); + return get_function_argument_processor_for(int64_t{}); } case ASTNodeDataType::double_t: { - return get_function_argument_processor_for_parameter_type(double{}); + return get_function_argument_processor_for(double{}); } default: { - throw parse_error("invalid argument type for function", std::vector{argument_node.begin()}); + throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()}); } } }; @@ -57,21 +56,21 @@ ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, PUGS_INLINE void -ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const size_t argument_number, +ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const std::vector<ASTNodeDataType>& parameter_type_list, + const size_t argument_number, ASTNode& argument_node, - const std::vector<ASTNodeDataType>& argument_type_list, CFunctionProcessor& c_function_processor) { auto& argument_values = c_function_processor.argumentValues(); c_function_processor.addArgumentProcessor( - this->_getArgumentProcessor(argument_node, argument_type_list[argument_number], argument_values[argument_number])); + this->_getArgumentProcessor(parameter_type_list[argument_number], argument_node, argument_values[argument_number])); } PUGS_INLINE void -ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, - const std::vector<ASTNodeDataType>& argument_type_list, +ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(const std::vector<ASTNodeDataType>& parameter_type_list, + ASTNode& node, CFunctionProcessor& c_function_processor) { ASTNode& argument_nodes = *node.children[1]; @@ -81,7 +80,7 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, c_function_processor.setNumberOfArguments(arguments_number); - const size_t parameters_number = argument_type_list.size(); + const size_t parameters_number = parameter_type_list.size(); if (arguments_number != parameters_number) { std::ostringstream error_message; @@ -93,10 +92,10 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, if (arguments_number > 1) { for (size_t i = 0; i < arguments_number; ++i) { ASTNode& argument_node = *argument_nodes.children[i]; - this->_storeArgumentProcessor(i, argument_node, argument_type_list, c_function_processor); + this->_storeArgumentProcessor(parameter_type_list, i, argument_node, c_function_processor); } } else { - this->_storeArgumentProcessor(0, argument_nodes, argument_type_list, c_function_processor); + this->_storeArgumentProcessor(parameter_type_list, 0, argument_nodes, c_function_processor); } } @@ -111,11 +110,11 @@ ASTNodeCFunctionExpressionBuilder::ASTNodeCFunctionExpressionBuilder(ASTNode& no CFunctionEmbedderTable& c_function_embedder_table = node.m_symbol_table->cFunctionEbedderTable(); std::shared_ptr c_function_embedder = c_function_embedder_table[c_function_id]; - std::vector<ASTNodeDataType> c_function_argument_type_list = c_function_embedder->getArgumentDataTypes(); + std::vector<ASTNodeDataType> c_function_parameter_type_list = c_function_embedder->getParameterDataTypes(); std::unique_ptr c_function_processor = std::make_unique<CFunctionProcessor>(); - this->_buildArgumentProcessors(node, c_function_argument_type_list, *c_function_processor); + this->_buildArgumentProcessors(c_function_parameter_type_list, node, *c_function_processor); c_function_processor->setFunctionExpressionProcessor( std::make_unique<CFunctionExpressionProcessor>(node, c_function_embedder, c_function_processor->argumentValues())); diff --git a/src/language/ASTNodeCFunctionExpressionBuilder.hpp b/src/language/ASTNodeCFunctionExpressionBuilder.hpp index 8523ff9a05f8cec3bde55387162e4e20f5c2baa1..f2e2de4f372057780548064a330c05ecfb14210a 100644 --- a/src/language/ASTNodeCFunctionExpressionBuilder.hpp +++ b/src/language/ASTNodeCFunctionExpressionBuilder.hpp @@ -9,19 +9,19 @@ class CFunctionProcessor; class ASTNodeCFunctionExpressionBuilder { private: - PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node, - const ASTNodeDataType& argument_type, + PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(const ASTNodeDataType& parameter_type, + ASTNode& argument_node, ASTNodeDataVariant& argument_value); PUGS_INLINE - void _storeArgumentProcessor(const size_t argument_number, + void _storeArgumentProcessor(const std::vector<ASTNodeDataType>& parameter_type_list, + const size_t argument_number, ASTNode& argument_node, - const std::vector<ASTNodeDataType>& argument_type_list, CFunctionProcessor& c_function_processor); PUGS_INLINE - void _buildArgumentProcessors(ASTNode& node, - const std::vector<ASTNodeDataType>& argument_type_list, + void _buildArgumentProcessors(const std::vector<ASTNodeDataType>& parameter_type_list, + ASTNode& node, CFunctionProcessor& c_function_processor); public: diff --git a/src/language/ASTNodeDataTypeBuilder.cpp b/src/language/ASTNodeDataTypeBuilder.cpp index 05cbe470300b4f98b092c1193f90ce63a0e719c0..e110ee46c2772ad2c5cb7f22440e53b2b9a1ff9a 100644 --- a/src/language/ASTNodeDataTypeBuilder.cpp +++ b/src/language/ASTNodeDataTypeBuilder.cpp @@ -110,6 +110,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) data_type = ASTNodeDataType::unsigned_int_t; } else if (type_node.is_type<language::R_set>()) { data_type = ASTNodeDataType::double_t; + } else if (type_node.is_type<language::string_type>()) { + data_type = ASTNodeDataType::string_t; } if (data_type == ASTNodeDataType::undefined_t) { @@ -158,6 +160,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) value_type = ASTNodeDataType::unsigned_int_t; } else if (image_node.is_type<language::R_set>()) { value_type = ASTNodeDataType::double_t; + } else if (image_node.is_type<language::string_type>()) { + value_type = ASTNodeDataType::string_t; } if (value_type == ASTNodeDataType::undefined_t) { @@ -282,6 +286,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) data_type = ASTNodeDataType::unsigned_int_t; } else if (image_domain_node.is_type<language::R_set>()) { data_type = ASTNodeDataType::double_t; + } else if (image_domain_node.is_type<language::string_type>()) { + data_type = ASTNodeDataType::string_t; } } diff --git a/src/language/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ASTNodeFunctionExpressionBuilder.cpp index 90c7559a9182a7be4c72541a9c4d098561c2ce25..ebf00082e315227a23ab2a5f9f520d6a758cc398 100644 --- a/src/language/ASTNodeFunctionExpressionBuilder.cpp +++ b/src/language/ASTNodeFunctionExpressionBuilder.cpp @@ -8,23 +8,22 @@ template <typename SymbolType> PUGS_INLINE std::unique_ptr<INodeProcessor> -ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, SymbolType& parameter_symbol) +ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_symbol, ASTNode& argument_node) { - auto get_function_argument_processor_for_parameter_type = - [&](const auto& argument_v) -> std::unique_ptr<INodeProcessor> { - using ArgumentT = std::decay_t<decltype(argument_v)>; - switch (parameter_symbol.attributes().dataType()) { + auto get_function_argument_processor_for = [&](const auto& parameter_v) -> std::unique_ptr<INodeProcessor> { + using ParameterT = std::decay_t<decltype(parameter_v)>; + switch (argument_node.m_data_type) { case ASTNodeDataType::bool_t: { - return std::make_unique<FunctionArgumentProcessor<ArgumentT, bool>>(argument_node, parameter_symbol); + return std::make_unique<FunctionArgumentProcessor<ParameterT, bool>>(parameter_symbol, argument_node); } case ASTNodeDataType::unsigned_int_t: { - return std::make_unique<FunctionArgumentProcessor<ArgumentT, uint64_t>>(argument_node, parameter_symbol); + return std::make_unique<FunctionArgumentProcessor<ParameterT, uint64_t>>(parameter_symbol, argument_node); } case ASTNodeDataType::int_t: { - return std::make_unique<FunctionArgumentProcessor<ArgumentT, int64_t>>(argument_node, parameter_symbol); + return std::make_unique<FunctionArgumentProcessor<ParameterT, int64_t>>(parameter_symbol, argument_node); } case ASTNodeDataType::double_t: { - return std::make_unique<FunctionArgumentProcessor<ArgumentT, double>>(argument_node, parameter_symbol); + return std::make_unique<FunctionArgumentProcessor<ParameterT, double>>(parameter_symbol, argument_node); } // LCOV_EXCL_START default: { @@ -34,29 +33,58 @@ ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, } }; - auto get_function_argument_processor_for_argument_type = [&]() { + auto get_function_argument_processor_for_string = [&]() -> std::unique_ptr<INodeProcessor> { switch (argument_node.m_data_type) { case ASTNodeDataType::bool_t: { - return get_function_argument_processor_for_parameter_type(bool{}); + return std::make_unique<FunctionArgumentProcessor<std::string, bool>>(parameter_symbol, argument_node); } case ASTNodeDataType::unsigned_int_t: { - return get_function_argument_processor_for_parameter_type(uint64_t{}); + return std::make_unique<FunctionArgumentProcessor<std::string, uint64_t>>(parameter_symbol, argument_node); } case ASTNodeDataType::int_t: { - return get_function_argument_processor_for_parameter_type(int64_t{}); + return std::make_unique<FunctionArgumentProcessor<std::string, int64_t>>(parameter_symbol, argument_node); } case ASTNodeDataType::double_t: { - return get_function_argument_processor_for_parameter_type(double{}); + return std::make_unique<FunctionArgumentProcessor<std::string, double>>(parameter_symbol, argument_node); + } + case ASTNodeDataType::string_t: { + return std::make_unique<FunctionArgumentProcessor<std::string, std::string>>(parameter_symbol, argument_node); } // LCOV_EXCL_START default: { - throw parse_error("unexpected error: undefined argument type for function", std::vector{argument_node.begin()}); + throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()}); } // LCOV_EXCL_STOP } }; - return get_function_argument_processor_for_argument_type(); + auto get_function_argument_processor_for_parameter_type = [&]() { + switch (parameter_symbol.attributes().dataType()) { + case ASTNodeDataType::bool_t: { + return get_function_argument_processor_for(bool{}); + } + case ASTNodeDataType::unsigned_int_t: { + return get_function_argument_processor_for(uint64_t{}); + } + case ASTNodeDataType::int_t: { + return get_function_argument_processor_for(int64_t{}); + } + case ASTNodeDataType::double_t: { + return get_function_argument_processor_for(double{}); + } + case ASTNodeDataType::string_t: { + return get_function_argument_processor_for_string(); + } + + // LCOV_EXCL_START + default: { + throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()}); + } + // LCOV_EXCL_STOP + } + }; + + return get_function_argument_processor_for_parameter_type(); } PUGS_INLINE @@ -71,7 +99,7 @@ ASTNodeFunctionExpressionBuilder::_storeArgumentProcessor(ASTNode& parameter_var parameter_variable.m_symbol_table->find(parameter_variable.string(), parameter_variable.begin()); Assert(found); - function_processor.addArgumentProcessor(this->_getArgumentProcessor(argument_node, *i_parameter_symbol)); + function_processor.addArgumentProcessor(this->_getArgumentProcessor(*i_parameter_symbol, argument_node)); } PUGS_INLINE @@ -128,6 +156,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex } case ASTNodeDataType::double_t: { return std::make_unique<FunctionExpressionProcessor<ReturnT, double>>(node); + } + case ASTNodeDataType::string_t: { + if constexpr (std::is_same_v<ReturnT, std::string>) { + return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(node); + } else { + throw parse_error("invalid string conversion", std::vector{node.children[1]->begin()}); + } } // LCOV_EXCL_START default: { @@ -151,6 +186,9 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex } case ASTNodeDataType::double_t: { return get_function_processor_for_expression_value(double{}); + } + case ASTNodeDataType::string_t: { + return get_function_processor_for_expression_value(std::string{}); } // LCOV_EXCL_START default: { diff --git a/src/language/ASTNodeFunctionExpressionBuilder.hpp b/src/language/ASTNodeFunctionExpressionBuilder.hpp index 7ece3d6600d7d09aa147369996eca9d2148f2a78..4bcd172b9a46b8300d0e14c6eb1db4b182564ea1 100644 --- a/src/language/ASTNodeFunctionExpressionBuilder.hpp +++ b/src/language/ASTNodeFunctionExpressionBuilder.hpp @@ -11,8 +11,8 @@ class ASTNodeFunctionExpressionBuilder { private: template <typename SymbolType> - PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node, - SymbolType& parameter_symbol); + PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(SymbolType& parameter_symbol, + ASTNode& argument_node); PUGS_INLINE void _storeArgumentProcessor(ASTNode& parameter_variable, diff --git a/src/language/CFunctionEmbedder.hpp b/src/language/CFunctionEmbedder.hpp index 10a7209baa13cb9f296741f741624713670f878e..1abbde7aabd416777b57f81fed2d7a2451f6cfea 100644 --- a/src/language/CFunctionEmbedder.hpp +++ b/src/language/CFunctionEmbedder.hpp @@ -18,11 +18,11 @@ class ICFunctionEmbedder { public: - virtual size_t numberOfArguments() const = 0; + virtual size_t numberOfParameters() const = 0; virtual ASTNodeDataType getReturnDataType() const = 0; - virtual std::vector<ASTNodeDataType> getArgumentDataTypes() const = 0; + virtual std::vector<ASTNodeDataType> getParameterDataTypes() const = 0; virtual void apply(const std::vector<ASTNodeDataVariant>& x, ASTNodeDataVariant& f_x) const = 0; @@ -61,18 +61,18 @@ class CFunctionEmbedder : public ICFunctionEmbedder template <size_t I> PUGS_INLINE ASTNodeDataType - _getOneArgumentDataType(ArgsTuple& t) const + _getOneParameterDataType(ArgsTuple& t) const { return ast_node_data_type_from_pod<std::decay_t<decltype(std::get<I>(t))>>; } template <size_t... I> PUGS_INLINE std::vector<ASTNodeDataType> - _getArgumentDataTypes(ArgsTuple t, std::index_sequence<I...>) const + _getParameterDataTypes(ArgsTuple t, std::index_sequence<I...>) const { - std::vector<ASTNodeDataType> argument_type_list; - (argument_type_list.push_back(this->_getOneArgumentDataType<I>(t)), ...); - return argument_type_list; + std::vector<ASTNodeDataType> parameter_type_list; + (parameter_type_list.push_back(this->_getOneParameterDataType<I>(t)), ...); + return parameter_type_list; } public: @@ -83,17 +83,17 @@ class CFunctionEmbedder : public ICFunctionEmbedder } PUGS_INLINE std::vector<ASTNodeDataType> - getArgumentDataTypes() const final + getParameterDataTypes() const final { constexpr size_t N = std::tuple_size_v<ArgsTuple>; ArgsTuple t; using IndexSequence = std::make_index_sequence<N>; - return this->_getArgumentDataTypes(t, IndexSequence{}); + return this->_getParameterDataTypes(t, IndexSequence{}); } PUGS_INLINE size_t - numberOfArguments() const final + numberOfParameters() const final { return sizeof...(Args); } diff --git a/src/language/node_processor/CFunctionProcessor.hpp b/src/language/node_processor/CFunctionProcessor.hpp index a5b253072f98e78345700f37905ce52e51adf4eb..2cefd9def75403d2921f6807197ba89e73f34a26 100644 --- a/src/language/node_processor/CFunctionProcessor.hpp +++ b/src/language/node_processor/CFunctionProcessor.hpp @@ -7,7 +7,7 @@ #include <CFunctionEmbedder.hpp> -template <typename ProvidedValueType, typename ExpectedValueType> +template <typename ExpectedValueType, typename ProvidedValueType> class CFunctionArgumentProcessor final : public INodeProcessor { private: diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp index ff1ffb09aeebabcfbb8572d8125d236f9cad9b47..a4e803b14093b55fdf9259f2be53c4555ac3bfe8 100644 --- a/src/language/node_processor/FunctionProcessor.hpp +++ b/src/language/node_processor/FunctionProcessor.hpp @@ -8,12 +8,12 @@ #include <node_processor/INodeProcessor.hpp> -template <typename ProvidedValueType, typename ExpectedValueType> +template <typename ExpectedValueType, typename ProvidedValueType> class FunctionArgumentProcessor final : public INodeProcessor { private: - ASTNode& m_provided_value_node; ASTNodeDataVariant& m_symbol_value; + ASTNode& m_provided_value_node; public: void @@ -23,13 +23,15 @@ class FunctionArgumentProcessor final : public INodeProcessor if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) { m_symbol_value = m_provided_value_node.m_value; + } else if constexpr (std::is_same_v<ExpectedValueType, std::string>) { + m_symbol_value = std::to_string(std::get<ProvidedValueType>(m_provided_value_node.m_value)); } else { m_symbol_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value)); } } - FunctionArgumentProcessor(ASTNode& provided_value_node, SymbolTable::Symbol& argument_symbol) - : m_provided_value_node{provided_value_node}, m_symbol_value{argument_symbol.attributes().value()} + FunctionArgumentProcessor(SymbolTable::Symbol& argument_symbol, ASTNode& provided_value_node) + : m_symbol_value{argument_symbol.attributes().value()}, m_provided_value_node{provided_value_node} {} }; @@ -48,6 +50,8 @@ class FunctionExpressionProcessor final : public INodeProcessor if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) { m_node.m_value = m_function_expression.m_value; + } else if constexpr (std::is_same_v<ReturnType, std::string>) { + m_node.m_value = std::to_string(std::get<ExpressionValueType>(m_function_expression.m_value)); } else { m_node.m_value = static_cast<ReturnType>(std::get<ExpressionValueType>(m_function_expression.m_value)); } diff --git a/tests/test_ASTNodeDataTypeBuilder.cpp b/tests/test_ASTNodeDataTypeBuilder.cpp index 45595e0b21e1203ee1204a2b583593d52cf299ad..3fecc130b0daf20e177e3c9fe61aecb947ebb280 100644 --- a/tests/test_ASTNodeDataTypeBuilder.cpp +++ b/tests/test_ASTNodeDataTypeBuilder.cpp @@ -280,54 +280,6 @@ let f : R -> B, (x,y) -> 3; REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error); } - - SECTION("invalid parameter type") - { - std::string_view data = R"( -let f : string -> N, s -> 3; -)"; - string_input input{data, "test.pgs"}; - auto ast = ASTBuilder::build(input); - ASTSymbolTableBuilder{*ast}; - - REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error); - } - - SECTION("invalid parameter type 2") - { - std::string_view data = R"( -let f : N*string -> N, (i,s) -> i; -)"; - string_input input{data, "test.pgs"}; - auto ast = ASTBuilder::build(input); - ASTSymbolTableBuilder{*ast}; - - REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error); - } - - SECTION("invalid return type") - { - std::string_view data = R"( -let f : R -> string, x -> "foo"; -)"; - string_input input{data, "test.pgs"}; - auto ast = ASTBuilder::build(input); - ASTSymbolTableBuilder{*ast}; - - REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error); - } - - SECTION("invalid return type 2") - { - std::string_view data = R"( -let f : R -> N*string, x -> (2,"foo"); -)"; - string_input input{data, "test.pgs"}; - auto ast = ASTBuilder::build(input); - ASTSymbolTableBuilder{*ast}; - - REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error); - } } } diff --git a/tests/test_CFunctionEmbedder.cpp b/tests/test_CFunctionEmbedder.cpp index 2a1e127a33eac73795b0491eb346e464cd4e4c0d..032cf7f66274c654c9e23b84df4c28e5271b4d35 100644 --- a/tests/test_CFunctionEmbedder.cpp +++ b/tests/test_CFunctionEmbedder.cpp @@ -19,10 +19,10 @@ TEST_CASE("CFunctionEmbedder", "[language]") embedded_sin.apply({arg_variant}, result); REQUIRE(std::get<double>(result) == std::sin(arg)); - REQUIRE(embedded_sin.numberOfArguments() == 1); + REQUIRE(embedded_sin.numberOfParameters() == 1); REQUIRE(embedded_sin.getReturnDataType() == ASTNodeDataType::double_t); - REQUIRE(embedded_sin.getArgumentDataTypes()[0] == ASTNodeDataType::double_t); + REQUIRE(embedded_sin.getParameterDataTypes()[0] == ASTNodeDataType::double_t); } SECTION("multiple variant args") @@ -43,11 +43,11 @@ TEST_CASE("CFunctionEmbedder", "[language]") embedded_c.apply(args, result); REQUIRE(std::get<bool>(result) == c(d_arg, i_arg)); - REQUIRE(embedded_c.numberOfArguments() == 2); + REQUIRE(embedded_c.numberOfParameters() == 2); REQUIRE(embedded_c.getReturnDataType() == ASTNodeDataType::bool_t); - REQUIRE(embedded_c.getArgumentDataTypes()[0] == ASTNodeDataType::double_t); - REQUIRE(embedded_c.getArgumentDataTypes()[1] == ASTNodeDataType::unsigned_int_t); + REQUIRE(embedded_c.getParameterDataTypes()[0] == ASTNodeDataType::double_t); + REQUIRE(embedded_c.getParameterDataTypes()[1] == ASTNodeDataType::unsigned_int_t); } SECTION("ICFunctionEmbedder") @@ -68,11 +68,11 @@ TEST_CASE("CFunctionEmbedder", "[language]") i_embedded_c->apply(args, result); REQUIRE(std::get<bool>(result) == c(d_arg, i_arg)); - REQUIRE(i_embedded_c->numberOfArguments() == 2); + REQUIRE(i_embedded_c->numberOfParameters() == 2); REQUIRE(i_embedded_c->getReturnDataType() == ASTNodeDataType::bool_t); - REQUIRE(i_embedded_c->getArgumentDataTypes()[0] == ASTNodeDataType::double_t); - REQUIRE(i_embedded_c->getArgumentDataTypes()[1] == ASTNodeDataType::unsigned_int_t); + REQUIRE(i_embedded_c->getParameterDataTypes()[0] == ASTNodeDataType::double_t); + REQUIRE(i_embedded_c->getParameterDataTypes()[1] == ASTNodeDataType::unsigned_int_t); } SECTION("error")