diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index a97c13443bd628a2226de54623c673d464916a0c..32117039587e2c53907ea030ac73a7e10e544255 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -43,6 +43,6 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
error_message << "undefined affectation type: ";
error_message << rang::fgB::red << affectation_name << rang::fg::reset;
- throw ParseError(error_message.str(), std::vector{node.begin()});
+ throw ParseError(error_message.str(), std::vector{node.children[0]->begin()});
}
}
diff --git a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
index 248511e6c91c2eec08a94e87faa8179c06a0bf80..487259530b7c3e4872371e9623517c0546d31e4f 100644
--- a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -4,6 +4,7 @@
#include <language/ast/ASTNodeDataTypeFlattener.hpp>
#include <language/node_processor/BuiltinFunctionProcessor.hpp>
#include <language/utils/ASTNodeNaturalConversionChecker.hpp>
+#include <language/utils/BuiltinFunctionEmbedderUtils.hpp>
#include <language/utils/ParseError.hpp>
#include <language/utils/SymbolTable.hpp>
@@ -494,7 +495,8 @@ ASTNodeBuiltinFunctionExpressionBuilder::_buildArgumentProcessors(
if (arguments_number != parameters_number) {
std::ostringstream error_message;
error_message << "bad number of arguments: expecting " << rang::fgB::yellow << parameters_number
- << rang::style::reset << ", provided " << rang::fgB::yellow << arguments_number << rang::style::reset;
+ << rang::style::reset << rang::style::bold << ", provided " << rang::fgB::yellow << arguments_number
+ << rang::style::reset;
throw ParseError(error_message.str(), argument_nodes.begin());
}
@@ -505,14 +507,9 @@ ASTNodeBuiltinFunctionExpressionBuilder::_buildArgumentProcessors(
ASTNodeBuiltinFunctionExpressionBuilder::ASTNodeBuiltinFunctionExpressionBuilder(ASTNode& node)
{
- auto [i_function_symbol, found] = node.m_symbol_table->find(node.children[0]->string(), node.begin());
- Assert(found);
- Assert(i_function_symbol->attributes().dataType() == ASTNodeDataType::builtin_function_t);
+ Assert(node.children[0]->m_data_type == ASTNodeDataType::builtin_function_t);
- uint64_t builtin_function_id = std::get<uint64_t>(i_function_symbol->attributes().value());
-
- auto& builtin_function_embedder_table = node.m_symbol_table->builtinFunctionEmbedderTable();
- std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id];
+ std::shared_ptr builtin_function_embedder = getBuiltinFunctionEmbedder(node);
std::vector<ASTNodeDataType> builtin_function_parameter_type_list =
builtin_function_embedder->getParameterDataTypes();
diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index b5f65437ce1b45b4a403aaf079317de8f04c0de5..24841d797529750ba2adc6664c278a56c615fdd2 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -3,6 +3,7 @@
#include <language/PEGGrammar.hpp>
#include <language/utils/ASTNodeNaturalConversionChecker.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/BuiltinFunctionEmbedderUtils.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/ParseError.hpp>
#include <language/utils/SymbolTable.hpp>
@@ -284,8 +285,13 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;
auto [i_symbol, found] = symbol_table->find(n.string(), n.begin());
- Assert(found);
- n.m_data_type = i_symbol->attributes().dataType();
+ if (found) {
+ n.m_data_type = i_symbol->attributes().dataType();
+ } else if (symbol_table->has(n.string(), n.begin())) {
+ n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::builtin_function_t>();
+ } else {
+ throw UnexpectedError("could not find symbol " + n.string());
+ }
}
}
for (auto& child : n.children) {
@@ -522,15 +528,7 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
n.m_data_type = image_domain_node.m_data_type.contentType();
} else if (n.children[0]->m_data_type == ASTNodeDataType::builtin_function_t) {
- const std::string builtin_function_name = n.children[0]->string();
- auto& symbol_table = *n.m_symbol_table;
-
- auto [i_symbol, success] = symbol_table.find(builtin_function_name, n.begin());
- Assert(success);
-
- uint64_t builtin_function_id = std::get<uint64_t>(i_symbol->attributes().value());
- auto builtin_function_embedder = symbol_table.builtinFunctionEmbedderTable()[builtin_function_id];
- Assert(builtin_function_embedder);
+ auto builtin_function_embedder = getBuiltinFunctionEmbedder(n);
n.m_data_type = builtin_function_embedder->getReturnDataType();
} else {
diff --git a/src/language/ast/ASTNodeDataTypeFlattener.cpp b/src/language/ast/ASTNodeDataTypeFlattener.cpp
index 6a06c72bb66926af546ff0a130315eacc8b54c9a..a2f83e5923392163f54ccc1b8bdecd5b8ed96e86 100644
--- a/src/language/ast/ASTNodeDataTypeFlattener.cpp
+++ b/src/language/ast/ASTNodeDataTypeFlattener.cpp
@@ -2,6 +2,7 @@
#include <language/PEGGrammar.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/BuiltinFunctionEmbedderUtils.hpp>
#include <language/utils/FunctionTable.hpp>
#include <language/utils/SymbolTable.hpp>
@@ -16,12 +17,12 @@ ASTNodeDataTypeFlattener::ASTNodeDataTypeFlattener(ASTNode& node, FlattenedDataT
flattened_datatype_list.push_back({node.m_data_type, node});
} else {
ASTNode& function_name_node = *node.children[0];
+ Assert(node.m_symbol_table->has(function_name_node.string(), node.begin()));
- auto [i_function_symbol, found] = node.m_symbol_table->find(function_name_node.string(), node.begin());
- Assert(found);
-
- switch (i_function_symbol->attributes().dataType()) {
+ switch (function_name_node.m_data_type) {
case ASTNodeDataType::function_t: {
+ auto [i_function_symbol, found] = node.m_symbol_table->find(function_name_node.string(), node.begin());
+
uint64_t function_id = std::get<uint64_t>(i_function_symbol->attributes().value());
FunctionDescriptor& function_descriptor = node.m_symbol_table->functionTable()[function_id];
@@ -35,10 +36,8 @@ ASTNodeDataTypeFlattener::ASTNodeDataTypeFlattener(ASTNode& node, FlattenedDataT
break;
}
case ASTNodeDataType::builtin_function_t: {
- uint64_t builtin_function_id = std::get<uint64_t>(i_function_symbol->attributes().value());
- auto builtin_function_embedder = node.m_symbol_table->builtinFunctionEmbedderTable()[builtin_function_id];
+ const auto& compound_data_type = getBuiltinFunctionEmbedder(node)->getReturnDataType();
- const auto& compound_data_type = builtin_function_embedder->getReturnDataType();
for (auto data_type : compound_data_type.contentTypeList()) {
flattened_datatype_list.push_back({*data_type, node});
}
diff --git a/src/language/ast/ASTNodeExpressionBuilder.cpp b/src/language/ast/ASTNodeExpressionBuilder.cpp
index fcdc4e1b93ab9135a6942e0e338144dff9474116..f8d26d197e94ae33fef09eed675bfdd688c6cc44 100644
--- a/src/language/ast/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeExpressionBuilder.cpp
@@ -68,12 +68,17 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
n.m_node_processor = std::make_unique<FakeProcessor>();
} else if (n.is_type<language::name>()) {
- // Dealing with contexts
- auto [i_symbol, success] = n.m_symbol_table->find(n.string(), n.begin());
- if (i_symbol->attributes().hasLocalContext()) {
- n.m_node_processor = std::make_unique<LocalNameProcessor>(n);
+ if (n.m_data_type == ASTNodeDataType::builtin_function_t) {
+ n.m_node_processor = std::make_unique<FakeProcessor>();
} else {
- n.m_node_processor = std::make_unique<NameProcessor>(n);
+ // Dealing with contexts
+ auto [i_symbol, success] = n.m_symbol_table->find(n.string(), n.begin());
+ Assert(success, "could not find symbol");
+ if (i_symbol->attributes().hasLocalContext()) {
+ n.m_node_processor = std::make_unique<LocalNameProcessor>(n);
+ } else {
+ n.m_node_processor = std::make_unique<NameProcessor>(n);
+ }
}
} else if (n.is_type<language::unary_minus>() or n.is_type<language::unary_not>()) {
ASTNodeUnaryOperatorExpressionBuilder{n};
diff --git a/src/language/ast/ASTNodeFunctionEvaluationExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionEvaluationExpressionBuilder.cpp
index 13af5a812bd46ae0a6309eb65c1eecdda2cb027e..126ef86fc5dff7a1cb11f2f0f94f8a860b30138a 100644
--- a/src/language/ast/ASTNodeFunctionEvaluationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeFunctionEvaluationExpressionBuilder.cpp
@@ -7,10 +7,7 @@
ASTNodeFunctionEvaluationExpressionBuilder::ASTNodeFunctionEvaluationExpressionBuilder(ASTNode& node)
{
- auto [i_function_symbol, found] = node.m_symbol_table->find(node.children[0]->string(), node.begin());
- Assert(found);
-
- switch (i_function_symbol->attributes().dataType()) {
+ switch (node.children[0]->m_data_type) {
case ASTNodeDataType::function_t: {
ASTNodeFunctionExpressionBuilder{node};
break;
diff --git a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
index 6484b85b0fed5626df7f46ade79c479cfe5f23ae..1fb23a5de3287b8b685ce9ef2ea4789697cbe198 100644
--- a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
@@ -233,7 +233,8 @@ ASTNodeFunctionExpressionBuilder::_buildArgumentConverter(FunctionDescriptor& fu
if (arguments_number != parameters_number) {
std::ostringstream error_message;
error_message << "bad number of arguments: expecting " << rang::fgB::yellow << parameters_number
- << rang::style::reset << ", provided " << rang::fgB::yellow << arguments_number << rang::style::reset;
+ << rang::style::reset << rang::style::bold << ", provided " << rang::fgB::yellow << arguments_number
+ << rang::style::reset;
throw ParseError(error_message.str(), argument_nodes.begin());
}
diff --git a/src/language/ast/ASTSymbolInitializationChecker.cpp b/src/language/ast/ASTSymbolInitializationChecker.cpp
index c37d4ba6bbe45563a71c876c5d1b70e992762729..8fe9ac4f774a949600b1dadbb0018568722c37a7 100644
--- a/src/language/ast/ASTSymbolInitializationChecker.cpp
+++ b/src/language/ast/ASTSymbolInitializationChecker.cpp
@@ -107,8 +107,9 @@ ASTSymbolInitializationChecker::_checkSymbolInitialization(ASTNode& node)
}
} else if (node.is_type<language::name>()) {
auto [i_symbol, found] = node.m_symbol_table->find(node.string(), node.begin());
- Assert(found, "unexpected error, should have been detected through declaration checking");
- if (not i_symbol->attributes().isInitialized()) {
+ Assert(node.m_symbol_table->has(node.string(), node.begin()),
+ "unexpected error, should have been detected through declaration checking");
+ if (found and not i_symbol->attributes().isInitialized()) {
std::ostringstream error_message;
error_message << "uninitialized symbol '" << rang::fg::red << node.string() << rang::fg::reset << '\'';
throw ParseError(error_message.str(), std::vector{node.begin()});
diff --git a/src/language/ast/ASTSymbolTableBuilder.cpp b/src/language/ast/ASTSymbolTableBuilder.cpp
index feb0b0130dd316df1cf768ad3506fa31f42b68b8..44058de6f3739580dbcf3d34e22970647c6bb2ad 100644
--- a/src/language/ast/ASTSymbolTableBuilder.cpp
+++ b/src/language/ast/ASTSymbolTableBuilder.cpp
@@ -22,11 +22,19 @@ ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>
n.m_symbol_table = local_symbol_table;
const std::string& symbol = n.children[0]->string();
- auto [i_symbol, success] = symbol_table->add(symbol, n.children[0]->begin());
+
+ if (symbol_table->getBuiltinFunctionSymbolList(symbol, n.children[0]->begin()).size() > 0) {
+ std::ostringstream error_message;
+ error_message << "symbol '" << rang::fg::red << symbol << rang::fg::reset
+ << "' already denotes a builtin function!";
+ throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
+ }
+
+ auto [i_symbol, success] = symbol_table->add(symbol, n.children[0]->begin());
if (not success) {
std::ostringstream error_message;
error_message << "symbol '" << rang::fg::red << symbol << rang::fg::reset << "' was already defined!";
- throw ParseError(error_message.str(), std::vector{n.begin()});
+ throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
}
for (auto& child : n.children) {
@@ -42,6 +50,13 @@ ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>
if (n.has_content()) {
if (n.is_type<language::var_declaration>()) {
auto register_symbol = [&](const ASTNode& argument_node) {
+ if (symbol_table->getBuiltinFunctionSymbolList(argument_node.string(), argument_node.begin()).size() > 0) {
+ std::ostringstream error_message;
+ error_message << "symbol '" << rang::fg::red << argument_node.string() << rang::fg::reset
+ << "' already denotes a builtin function!";
+ throw ParseError(error_message.str(), std::vector{argument_node.begin()});
+ }
+
auto [i_symbol, success] = symbol_table->add(argument_node.string(), argument_node.begin());
if (not success) {
std::ostringstream error_message;
@@ -61,6 +76,13 @@ ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>
}
} else if (n.is_type<language::function_definition>()) {
auto register_and_initialize_symbol = [&](const ASTNode& argument_node) {
+ if (symbol_table->getBuiltinFunctionSymbolList(argument_node.string(), argument_node.begin()).size() > 0) {
+ std::ostringstream error_message;
+ error_message << "symbol '" << rang::fg::red << argument_node.string() << rang::fg::reset
+ << "' already denotes a builtin function!";
+ throw ParseError(error_message.str(), std::vector{argument_node.begin()});
+ }
+
auto [i_symbol, success] = symbol_table->add(argument_node.string(), argument_node.begin());
if (not success) {
std::ostringstream error_message;
@@ -81,8 +103,7 @@ ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>
}
}
} else if (n.is_type<language::name>()) {
- auto [i_symbol, found] = symbol_table->find(n.string(), n.begin());
- if (not found) {
+ if (not symbol_table->has(n.string(), n.begin())) {
std::ostringstream error_message;
error_message << "undefined symbol '" << rang::fg::red << n.string() << rang::fg::reset << '\'';
throw ParseError(error_message.str(), std::vector{n.begin()});
diff --git a/src/language/modules/BuiltinModule.cpp b/src/language/modules/BuiltinModule.cpp
index 22d23f8033604698f44ea18e42c63e9ba48ba345..98d8f71c6c91bd83ac53ff8d45b98f419c283fe9 100644
--- a/src/language/modules/BuiltinModule.cpp
+++ b/src/language/modules/BuiltinModule.cpp
@@ -12,8 +12,33 @@ void
BuiltinModule::_addBuiltinFunction(const std::string& name,
std::shared_ptr<IBuiltinFunctionEmbedder> builtin_function_embedder)
{
- auto [i_builtin_function, success] =
- m_name_builtin_function_map.insert(std::make_pair(name, builtin_function_embedder));
+ auto is_keyword = [](const std::string& s) -> bool {
+ if (s.size() == 0) {
+ return false;
+ } else {
+ if (not(std::isalpha(s[0]) or s[0] == '_')) {
+ return false;
+ }
+ for (size_t i = 1; i < s.size(); ++i) {
+ if (not(std::isalnum(s[0]) or s[0] == '_')) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ };
+
+ if (not is_keyword(name)) {
+ std::ostringstream os;
+ os << "while defining module " << this->name() << " invalid builtin function name: '" << name << "'\n";
+ throw UnexpectedError(os.str());
+ }
+
+ auto parameter_data_type_list = builtin_function_embedder->getParameterDataTypes();
+
+ auto [i_builtin_function, success] = m_name_builtin_function_map.insert(
+ std::make_pair(name + ':' + dataTypeName(parameter_data_type_list), builtin_function_embedder));
if (not success) {
throw NormalError("builtin-function '" + name + "' cannot be added!\n");
}
diff --git a/src/language/modules/ModuleRepository.cpp b/src/language/modules/ModuleRepository.cpp
index d0cd8260ba6d6a3de9d335833d42002519568592..e516ab800833f5503de27bcfdd73e8b8381e06e6 100644
--- a/src/language/modules/ModuleRepository.cpp
+++ b/src/language/modules/ModuleRepository.cpp
@@ -20,6 +20,29 @@
void
ModuleRepository::_subscribe(std::unique_ptr<IModule> m)
{
+ auto is_keyword = [](const std::string& s) -> bool {
+ if (s.size() == 0) {
+ return false;
+ } else {
+ if (not(std::isalpha(s[0]) or s[0] == '_')) {
+ return false;
+ }
+ for (size_t i = 1; i < s.size(); ++i) {
+ if (not(std::isalnum(s[0]) or s[0] == '_')) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ };
+
+ if (not is_keyword(std::string{m->name()})) {
+ std::ostringstream os;
+ os << "cannot subscribe module with invalid name: '" << m->name() << "'\n";
+ throw UnexpectedError(os.str());
+ }
+
auto [i_module, success] = m_module_set.emplace(m->name(), std::move(m));
Assert(success, "module has already been subscribed");
}
@@ -147,6 +170,15 @@ ModuleRepository::registerOperators(const std::string& module_name)
std::string
ModuleRepository::getModuleInfo(const std::string& module_name) const
{
+ auto demangleBuiltinFunction = [](const std::string& mangled_name) -> std::string {
+ size_t i = 0;
+ for (; i < mangled_name.size(); ++i) {
+ if (mangled_name[i] == '(')
+ break;
+ }
+ return mangled_name.substr(0, i);
+ };
+
std::stringstream os;
auto i_module = m_module_set.find(module_name);
if (i_module != m_module_set.end()) {
@@ -155,8 +187,8 @@ ModuleRepository::getModuleInfo(const std::string& module_name) const
const auto& builtin_function_map = i_module->second->getNameBuiltinFunctionMap();
if (builtin_function_map.size() > 0) {
os << " functions\n";
- for (auto& [name, function] : builtin_function_map) {
- os << " " << rang::fgB::green << name << rang::style::reset << ": ";
+ for (auto& [mangled_name, function] : builtin_function_map) {
+ os << " " << rang::fgB::green << demangleBuiltinFunction(mangled_name) << rang::style::reset << ": ";
os << dataTypeName(function->getParameterDataTypes());
os << rang::fgB::yellow << " -> " << rang::style::reset;
os << dataTypeName(function->getReturnDataType()) << '\n';
diff --git a/src/language/utils/ASTNodeDataType.cpp b/src/language/utils/ASTNodeDataType.cpp
index 81f3fc81caba045ca4ae719ddfa21c09c1c8fc98..3550025dd36e05c46e8ca20ce49a45d6b0fff30b 100644
--- a/src/language/utils/ASTNodeDataType.cpp
+++ b/src/language/utils/ASTNodeDataType.cpp
@@ -79,19 +79,27 @@ dataTypeName(const ASTNodeDataType& data_type)
name = "R^" + std::to_string(data_type.nbRows()) + "x" + std::to_string(data_type.nbColumns());
break;
case ASTNodeDataType::tuple_t:
- name = "tuple(" + dataTypeName(data_type.contentType()) + ')';
+ name = "(" + dataTypeName(data_type.contentType()) + "...)";
break;
case ASTNodeDataType::list_t: {
std::ostringstream data_type_name_list;
const auto& data_type_list = data_type.contentTypeList();
if (data_type_list.size() > 0) {
- data_type_name_list << dataTypeName(*data_type_list[0]);
+ if (*data_type_list[0] == ASTNodeDataType::list_t) {
+ data_type_name_list << '(' << dataTypeName(*data_type_list[0]) << ')';
+ } else {
+ data_type_name_list << dataTypeName(*data_type_list[0]);
+ }
for (size_t i = 1; i < data_type_list.size(); ++i) {
- data_type_name_list << '*' << dataTypeName(*data_type_list[i]);
+ if (*data_type_list[i] == ASTNodeDataType::list_t) {
+ data_type_name_list << "*(" << dataTypeName(*data_type_list[i]) << ')';
+ } else {
+ data_type_name_list << '*' << dataTypeName(*data_type_list[i]);
+ }
}
- name = "list(" + data_type_name_list.str() + ")";
+ name = data_type_name_list.str();
} else {
- name = "list(void)";
+ name = "void";
}
break;
}
@@ -99,7 +107,7 @@ dataTypeName(const ASTNodeDataType& data_type)
name = "string";
break;
case ASTNodeDataType::typename_t:
- name = std::string("typename(") + dataTypeName(data_type.contentType()) + ")";
+ name = dataTypeName(data_type.contentType());
break;
case ASTNodeDataType::type_name_id_t:
name = "type_name_id";
@@ -129,11 +137,10 @@ dataTypeName(const std::vector<ASTNodeDataType>& data_type_vector)
return dataTypeName(data_type_vector[0]);
} else {
std::ostringstream os;
- os << '(' << dataTypeName(data_type_vector[0]);
+ os << dataTypeName(data_type_vector[0]);
for (size_t i = 1; i < data_type_vector.size(); ++i) {
- os << ',' << dataTypeName(data_type_vector[i]);
+ os << '*' << dataTypeName(data_type_vector[i]);
}
- os << ')';
return os.str();
}
}
diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9899fee3e1855a2ded4e306dd5dcf041d84e051b
--- /dev/null
+++ b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
@@ -0,0 +1,255 @@
+#include <language/utils/BuiltinFunctionEmbedderUtils.hpp>
+
+#include <language/PEGGrammar.hpp>
+#include <language/ast/ASTNode.hpp>
+#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/ParseError.hpp>
+#include <language/utils/SymbolTable.hpp>
+
+std::shared_ptr<IBuiltinFunctionEmbedder>
+getBuiltinFunctionEmbedder(ASTNode& n)
+{
+ const std::string builtin_function_name = n.children[0]->string();
+ auto& symbol_table = *n.m_symbol_table;
+
+ auto& args_node = *n.children[1];
+
+ auto get_argument_value_type = [](ASTNode& argument_node, std::vector<ASTNodeDataType>& arg_type_list) -> void {
+ if (argument_node.is_type<language::function_evaluation>()) {
+ ASTNode& function_node = *argument_node.children[0];
+ switch (function_node.m_data_type) {
+ case ASTNodeDataType::function_t: {
+ auto [i_function_symbol, found] =
+ argument_node.m_symbol_table->find(function_node.string(), argument_node.begin());
+ Assert(found);
+ Assert(i_function_symbol->attributes().dataType() == ASTNodeDataType::function_t);
+
+ uint64_t function_id = std::get<uint64_t>(i_function_symbol->attributes().value());
+
+ FunctionDescriptor& function_descriptor = argument_node.m_symbol_table->functionTable()[function_id];
+ ASTNode& function_image_domain = *function_descriptor.domainMappingNode().children[1];
+
+ if (function_image_domain.children.size() > 0) {
+ for (size_t i = 0; i < function_image_domain.children.size(); ++i) {
+ arg_type_list.push_back(function_image_domain.children[i]->m_data_type);
+ }
+ } else {
+ arg_type_list.push_back(function_image_domain.m_data_type);
+ }
+ break;
+ }
+ case ASTNodeDataType::builtin_function_t: {
+ std::shared_ptr builtin_function = getBuiltinFunctionEmbedder(argument_node);
+ arg_type_list.push_back(builtin_function->getReturnDataType());
+ break;
+ }
+ default: {
+ throw UnexpectedError("unexpected function type");
+ }
+ }
+ } else {
+ arg_type_list.push_back(argument_node.m_data_type);
+ }
+ };
+
+ std::vector<ASTNodeDataType> arg_type_list;
+ if (args_node.is_type<language::function_argument_list>()) {
+ for (auto& arg : args_node.children) {
+ get_argument_value_type(*arg, arg_type_list);
+ }
+ } else {
+ get_argument_value_type(args_node, arg_type_list);
+ }
+
+ // replace typenames by their values
+ for (size_t i = 0; i < arg_type_list.size(); ++i) {
+ if (arg_type_list[i] == ASTNodeDataType::typename_t) {
+ arg_type_list[i] = arg_type_list[i].contentType();
+ }
+ }
+
+ std::string mangled_name = builtin_function_name + ':' + dataTypeName(args_node.m_data_type);
+
+ std::vector builtin_function_candidate_list =
+ symbol_table.getBuiltinFunctionSymbolList(builtin_function_name, n.begin());
+
+ auto is_castable_to_vector = [](const ASTNodeDataType& arg_type, const ASTNodeDataType& target_type) {
+ if (isNaturalConversion(arg_type, target_type)) {
+ return true;
+ }
+ bool is_castable = true;
+ if (target_type.dimension() > 1) {
+ switch (arg_type) {
+ case ASTNodeDataType::int_t: {
+ break;
+ }
+ case ASTNodeDataType::list_t: {
+ if (arg_type.contentTypeList().size() != target_type.dimension()) {
+ is_castable = false;
+ break;
+ }
+ for (auto list_arg : arg_type.contentTypeList()) {
+ is_castable &= isNaturalConversion(*list_arg, ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+ break;
+ }
+ default: {
+ is_castable &= false;
+ }
+ }
+ } else {
+ is_castable &= isNaturalConversion(arg_type, ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+ return is_castable;
+ };
+
+ auto is_castable_to_matrix = [](const ASTNodeDataType& arg_type, const ASTNodeDataType& target_type) {
+ if (isNaturalConversion(arg_type, target_type)) {
+ return true;
+ }
+
+ bool is_castable = true;
+ if (target_type.nbRows() > 1) {
+ switch (arg_type) {
+ case ASTNodeDataType::int_t: {
+ break;
+ }
+ case ASTNodeDataType::list_t: {
+ if (arg_type.contentTypeList().size() != target_type.nbRows() * target_type.nbColumns()) {
+ is_castable = false;
+ break;
+ }
+ for (auto list_arg : arg_type.contentTypeList()) {
+ is_castable &= isNaturalConversion(*list_arg, ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+ break;
+ }
+ default: {
+ is_castable &= false;
+ }
+ }
+ } else {
+ is_castable &= isNaturalConversion(arg_type, ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+ return is_castable;
+ };
+
+ std::vector<uint64_t> callable_id_list;
+ for (auto candidate : builtin_function_candidate_list) {
+ uint64_t builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
+
+ auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
+ std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id];
+
+ bool is_castable = true;
+
+ if (builtin_function_embedder->numberOfParameters() == arg_type_list.size()) {
+ std::vector<ASTNodeDataType> builtin_function_parameter_type_list =
+ builtin_function_embedder->getParameterDataTypes();
+ for (size_t i_arg = 0; i_arg < arg_type_list.size(); ++i_arg) {
+ const ASTNodeDataType& target_type = builtin_function_parameter_type_list[i_arg];
+ const ASTNodeDataType& arg_type = arg_type_list[i_arg];
+
+ if (not isNaturalConversion(arg_type, target_type)) {
+ switch (target_type) {
+ case ASTNodeDataType::vector_t: {
+ is_castable &= is_castable_to_vector(arg_type, target_type);
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ is_castable &= is_castable_to_matrix(arg_type, target_type);
+ break;
+ }
+ case ASTNodeDataType::tuple_t: {
+ ASTNodeDataType tuple_content_type = target_type.contentType();
+ if (not isNaturalConversion(arg_type, tuple_content_type)) {
+ switch (tuple_content_type) {
+ case ASTNodeDataType::vector_t: {
+ if (arg_type == ASTNodeDataType::list_t) {
+ for (auto element_type : arg_type.contentTypeList()) {
+ is_castable &= is_castable_to_vector(*element_type, tuple_content_type);
+ }
+ } else {
+ is_castable &= is_castable_to_vector(arg_type, tuple_content_type);
+ }
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ if (arg_type == ASTNodeDataType::list_t) {
+ for (auto element_type : arg_type.contentTypeList()) {
+ is_castable &= is_castable_to_matrix(*element_type, tuple_content_type);
+ }
+ } else {
+ is_castable &= is_castable_to_matrix(arg_type, tuple_content_type);
+ }
+ break;
+ }
+ default:
+ if (arg_type == ASTNodeDataType::list_t) {
+ for (auto element_type : arg_type.contentTypeList()) {
+ is_castable &= isNaturalConversion(*element_type, tuple_content_type);
+ }
+ } else {
+ is_castable &= false;
+ }
+ }
+ }
+ break;
+ }
+ default:
+ is_castable &= false;
+ }
+ }
+ }
+
+ if (is_castable) {
+ callable_id_list.push_back(builtin_function_id);
+ }
+ }
+ }
+
+ uint64_t builtin_function_id = [&] {
+ switch (size(callable_id_list)) {
+ case 0: {
+ std::ostringstream error_msg;
+ error_msg << "no matching function to call " << rang::fgB::red << builtin_function_name << rang::style::reset
+ << rang::style::bold << ": " << rang::fgB::yellow << dataTypeName(args_node.m_data_type)
+ << rang::style::reset << rang::style::bold << "\nnote: candidates are";
+
+ for (auto candidate : builtin_function_candidate_list) {
+ uint64_t builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
+
+ auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
+ std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id];
+
+ error_msg << "\n " << builtin_function_name << ": "
+ << dataTypeName(builtin_function_embedder->getParameterDataTypes()) << " -> "
+ << dataTypeName(builtin_function_embedder->getReturnDataType());
+ }
+
+ throw ParseError(error_msg.str(), n.begin());
+ }
+ case 1: {
+ return callable_id_list[0];
+ }
+ default: {
+ std::ostringstream error_msg;
+ error_msg << "ambiguous function call " << rang::fgB::red << builtin_function_name << rang::style::reset
+ << rang::style::bold << ": " << rang::fgB::yellow << dataTypeName(args_node.m_data_type)
+ << rang::style::reset << rang::style::bold << "\nnote: candidates are";
+
+ auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
+ for (auto callable_id : callable_id_list) {
+ std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[callable_id];
+
+ error_msg << "\n " << builtin_function_name << ": "
+ << dataTypeName(builtin_function_embedder->getParameterDataTypes()) << " -> "
+ << dataTypeName(builtin_function_embedder->getReturnDataType());
+ }
+ throw ParseError(error_msg.str(), n.begin());
+ }
+ }
+ }();
+
+ return n.m_symbol_table->builtinFunctionEmbedderTable()[builtin_function_id];
+}
diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.hpp b/src/language/utils/BuiltinFunctionEmbedderUtils.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f24acff477dcc4e782feba24cd2c1b4060e3f32
--- /dev/null
+++ b/src/language/utils/BuiltinFunctionEmbedderUtils.hpp
@@ -0,0 +1,11 @@
+#ifndef BUILTIN_FUNCTION_EMBEDDER_UTILS_HPP
+#define BUILTIN_FUNCTION_EMBEDDER_UTILS_HPP
+
+class IBuiltinFunctionEmbedder;
+class ASTNode;
+
+#include <memory>
+
+std::shared_ptr<IBuiltinFunctionEmbedder> getBuiltinFunctionEmbedder(ASTNode& n);
+
+#endif // BUILTIN_FUNCTION_EMBEDDER_UTILS_HPP
diff --git a/src/language/utils/CMakeLists.txt b/src/language/utils/CMakeLists.txt
index 80640af6e39ee7febd53562c4c89bc1d2bd9b8c3..bed3da329d5534e8aa4f48ef48cc0751dfa00f3b 100644
--- a/src/language/utils/CMakeLists.txt
+++ b/src/language/utils/CMakeLists.txt
@@ -20,6 +20,7 @@ add_library(PugsLanguageUtils
BinaryOperatorRegisterForRnxn.cpp
BinaryOperatorRegisterForString.cpp
BinaryOperatorRegisterForZ.cpp
+ BuiltinFunctionEmbedderUtils.cpp
DataVariant.cpp
EmbeddedData.cpp
EmbeddedIDiscreteFunctionOperators.cpp
diff --git a/src/language/utils/SymbolTable.hpp b/src/language/utils/SymbolTable.hpp
index 772ac6564859dd402ba2086d4fed7dc0b4c64059..7321994564a8810b10e81d60503a55226abf0c56 100644
--- a/src/language/utils/SymbolTable.hpp
+++ b/src/language/utils/SymbolTable.hpp
@@ -279,6 +279,55 @@ class SymbolTable
}
}
+ std::vector<Symbol>
+ getBuiltinFunctionSymbolList(const std::string& symbol, const TAO_PEGTL_NAMESPACE::position& use_position)
+ {
+ std::vector<Symbol> builtin_function_symbol_list;
+
+ for (auto i_stored_symbol : m_symbol_list) {
+ if (use_position.byte < i_stored_symbol.attributes().position().byte)
+ continue;
+
+ // Symbol must be defined before the call
+ std::string_view stored_symbol_name = i_stored_symbol.name();
+ if ((stored_symbol_name.size() > symbol.size()) and (stored_symbol_name[symbol.size()] == ':')) {
+ if (stored_symbol_name.substr(0, symbol.size()) == symbol) {
+ builtin_function_symbol_list.push_back(i_stored_symbol);
+ }
+ }
+ }
+
+ if (m_parent_table) {
+ return m_parent_table->getBuiltinFunctionSymbolList(symbol, use_position);
+ } else {
+ return builtin_function_symbol_list;
+ }
+ }
+
+ bool
+ has(const std::string& symbol, const TAO_PEGTL_NAMESPACE::position& use_position)
+ {
+ for (auto i_stored_symbol : m_symbol_list) {
+ if (use_position.byte < i_stored_symbol.attributes().position().byte)
+ continue;
+
+ // Symbol must be defined before the call
+ std::string_view stored_symbol_name = i_stored_symbol.name();
+ if ((stored_symbol_name.size() == symbol.size()) or
+ (stored_symbol_name.size() > symbol.size() and (stored_symbol_name[symbol.size()] == ':'))) {
+ if (stored_symbol_name.substr(0, symbol.size()) == symbol) {
+ return true;
+ }
+ }
+ }
+
+ if (m_parent_table) {
+ return m_parent_table->has(symbol, use_position);
+ } else {
+ return false;
+ }
+ }
+
auto
find(const std::string& symbol, const TAO_PEGTL_NAMESPACE::position& use_position)
{
@@ -306,8 +355,15 @@ class SymbolTable
add(const std::string& symbol_name, const TAO_PEGTL_NAMESPACE::position& symbol_position)
{
for (auto i_stored_symbol = m_symbol_list.begin(); i_stored_symbol != m_symbol_list.end(); ++i_stored_symbol) {
- if (i_stored_symbol->name() == symbol_name) {
- return std::make_pair(i_stored_symbol, false);
+ std::string_view stored_symbol_name = i_stored_symbol->name();
+ if (stored_symbol_name.size() == symbol_name.size()) {
+ if (stored_symbol_name == symbol_name) {
+ return std::make_pair(i_stored_symbol, false);
+ } else if (stored_symbol_name.size() > symbol_name.size() and (stored_symbol_name[symbol_name.size()] == ':')) {
+ if (stored_symbol_name.substr(0, symbol_name.size()) == symbol_name) {
+ return std::make_pair(i_stored_symbol, false);
+ }
+ }
}
}
diff --git a/tests/test_ASTModulesImporter.cpp b/tests/test_ASTModulesImporter.cpp
index 6d98d31fb33628873fb73369213351128dd6e71a..4be8e087dd89490caf6be0a8ba3132588fd919df 100644
--- a/tests/test_ASTModulesImporter.cpp
+++ b/tests/test_ASTModulesImporter.cpp
@@ -102,7 +102,7 @@ import unknown_module;
REQUIRE_THROWS_AS(ASTModulesImporter{*ast}, ParseError);
}
- SECTION("symbol already defined")
+ SECTION("symbol already defined (same builtin function)")
{
std::string_view data = R"(
import math;
@@ -111,7 +111,7 @@ import math;
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
auto ast = ASTBuilder::build(input);
- ast->m_symbol_table->add("sin", ast->begin());
+ ast->m_symbol_table->add("sin:R", ast->begin());
REQUIRE_THROWS_AS(ASTModulesImporter{*ast}, ParseError);
}
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index 85c443ebcc807d87ba197bc8f534763fcf46beba..81ff4f95cffb91fe3352ff5560043d75a309e700 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -1609,7 +1609,7 @@ let s : string, s="foo"; s*=2;
let s :(R), s=(1,2,3); s *= 4;
)";
- std::string error_message = "undefined affectation type: tuple(R) *= Z";
+ std::string error_message = "undefined affectation type: (R...) *= Z";
CHECK_AST_THROWS_WITH(data, error_message);
}
@@ -1620,7 +1620,7 @@ let s : string, s="foo"; s*=2;
let s : (builtin_t), s =(a,b); s *= b;
)";
- std::string error_message = "undefined affectation type: tuple(builtin_t) *= builtin_t";
+ std::string error_message = "undefined affectation type: (builtin_t...) *= builtin_t";
CHECK_AST_WITH_BUILTIN_THROWS_WITH(data, error_message);
}
diff --git a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
index a313d7c92577b33892c4128b4d5d88ec8c6daebc..d7cd62afe7e4260d14640287ad440355dab59898 100644
--- a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -63,6 +63,21 @@
REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, expected_error); \
}
+#define CHECK_AST_THROWS_AT_BUILD_WITH(data, expected_error) \
+ { \
+ static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>); \
+ static_assert((std::is_same_v<std::decay_t<decltype(expected_error)>, std::string_view>) or \
+ (std::is_same_v<std::decay_t<decltype(expected_error)>, std::string>)); \
+ \
+ TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"}; \
+ auto ast = ASTBuilder::build(input); \
+ \
+ test_only::test_BuiltinFunctionRegister{*ast}; \
+ \
+ ASTSymbolTableBuilder{*ast}; \
+ REQUIRE_THROWS_WITH(ASTNodeDataTypeBuilder{*ast}, expected_error); \
+ }
+
// clazy:excludeall=non-pod-global-static
TEST_CASE("ASTNodeBuiltinFunctionExpressionBuilder", "[language]")
@@ -78,7 +93,7 @@ RtoR(1.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR:NameProcessor)
+ +-(language::name:RtoR:FakeProcessor)
`-(language::real:1.:ValueProcessor)
)";
@@ -94,7 +109,7 @@ RtoR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR:NameProcessor)
+ +-(language::name:RtoR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -111,7 +126,7 @@ RtoR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR:NameProcessor)
+ +-(language::name:RtoR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -127,7 +142,7 @@ RtoR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR:NameProcessor)
+ +-(language::name:RtoR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -146,7 +161,7 @@ RtoR1(1.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR1:NameProcessor)
+ +-(language::name:RtoR1:FakeProcessor)
`-(language::real:1.:ValueProcessor)
)";
@@ -162,7 +177,7 @@ RtoR1(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR1:NameProcessor)
+ +-(language::name:RtoR1:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -179,7 +194,7 @@ RtoR1(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR1:NameProcessor)
+ +-(language::name:RtoR1:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -195,7 +210,7 @@ RtoR1(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR1:NameProcessor)
+ +-(language::name:RtoR1:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -214,7 +229,7 @@ RtoR11(1.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR11:NameProcessor)
+ +-(language::name:RtoR11:FakeProcessor)
`-(language::real:1.:ValueProcessor)
)";
@@ -230,7 +245,7 @@ RtoR11(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR11:NameProcessor)
+ +-(language::name:RtoR11:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -247,7 +262,7 @@ RtoR11(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR11:NameProcessor)
+ +-(language::name:RtoR11:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -263,7 +278,7 @@ RtoR11(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RtoR11:NameProcessor)
+ +-(language::name:RtoR11:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -283,7 +298,7 @@ R1toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R1toR:NameProcessor)
+ +-(language::name:R1toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -299,7 +314,7 @@ R1toR(1.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R1toR:NameProcessor)
+ +-(language::name:R1toR:FakeProcessor)
`-(language::real:1.:ValueProcessor)
)";
@@ -315,7 +330,7 @@ R1toR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R1toR:NameProcessor)
+ +-(language::name:R1toR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -332,7 +347,7 @@ R1toR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R1toR:NameProcessor)
+ +-(language::name:R1toR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -348,7 +363,7 @@ R1toR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R1toR:NameProcessor)
+ +-(language::name:R1toR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -368,7 +383,7 @@ R11toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R11toR:NameProcessor)
+ +-(language::name:R11toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -384,7 +399,7 @@ R11toR(1.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R11toR:NameProcessor)
+ +-(language::name:R11toR:FakeProcessor)
`-(language::real:1.:ValueProcessor)
)";
@@ -400,7 +415,7 @@ R11toR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R11toR:NameProcessor)
+ +-(language::name:R11toR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -417,7 +432,7 @@ R11toR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R11toR:NameProcessor)
+ +-(language::name:R11toR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -433,7 +448,7 @@ R11toR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R11toR:NameProcessor)
+ +-(language::name:R11toR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -452,7 +467,7 @@ R2toR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R2toR:NameProcessor)
+ +-(language::name:R2toR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -469,7 +484,7 @@ R2toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R2toR:NameProcessor)
+ +-(language::name:R2toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -485,7 +500,7 @@ R2toR((1,2));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R2toR:NameProcessor)
+ +-(language::name:R2toR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::integer:1:ValueProcessor)
`-(language::integer:2:ValueProcessor)
@@ -506,7 +521,7 @@ R22toR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R22toR:NameProcessor)
+ +-(language::name:R22toR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -523,7 +538,7 @@ R22toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R22toR:NameProcessor)
+ +-(language::name:R22toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -539,7 +554,7 @@ R22toR((1,2,3,4));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R22toR:NameProcessor)
+ +-(language::name:R22toR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
@@ -562,7 +577,7 @@ R3toR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3toR:NameProcessor)
+ +-(language::name:R3toR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -579,7 +594,7 @@ R3toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3toR:NameProcessor)
+ +-(language::name:R3toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -595,7 +610,7 @@ R3toR((1,2,3));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3toR:NameProcessor)
+ +-(language::name:R3toR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
@@ -617,7 +632,7 @@ R33toR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33toR:NameProcessor)
+ +-(language::name:R33toR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -634,7 +649,7 @@ R33toR(x);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33toR:NameProcessor)
+ +-(language::name:R33toR:FakeProcessor)
`-(language::name:x:NameProcessor)
)";
@@ -650,7 +665,7 @@ R33toR((1,2,3,4,5,6,7,8,9));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33toR:NameProcessor)
+ +-(language::name:R33toR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
@@ -678,7 +693,7 @@ ZtoR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:ZtoR:NameProcessor)
+ +-(language::name:ZtoR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -695,7 +710,7 @@ ZtoR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:ZtoR:NameProcessor)
+ +-(language::name:ZtoR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -711,7 +726,7 @@ ZtoR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:ZtoR:NameProcessor)
+ +-(language::name:ZtoR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -730,7 +745,7 @@ NtoR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:NtoR:NameProcessor)
+ +-(language::name:NtoR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -747,7 +762,7 @@ NtoR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:NtoR:NameProcessor)
+ +-(language::name:NtoR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -763,7 +778,7 @@ NtoR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:NtoR:NameProcessor)
+ +-(language::name:NtoR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -782,7 +797,7 @@ BtoR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:BtoR:NameProcessor)
+ +-(language::name:BtoR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -799,7 +814,7 @@ RRtoB(1., 0.);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:RRtoB:NameProcessor)
+ +-(language::name:RRtoB:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::real:1.:ValueProcessor)
`-(language::real:0.:ValueProcessor)
@@ -821,7 +836,7 @@ R3R2toR(x,y);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3R2toR:NameProcessor)
+ +-(language::name:R3R2toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::name:x:NameProcessor)
`-(language::name:y:NameProcessor)
@@ -839,7 +854,7 @@ R3R2toR((1,2,3),(3,4));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3R2toR:NameProcessor)
+ +-(language::name:R3R2toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
| +-(language::integer:1:ValueProcessor)
@@ -862,7 +877,7 @@ R3R2toR((1,2,3),0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R3R2toR:NameProcessor)
+ +-(language::name:R3R2toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
| +-(language::integer:1:ValueProcessor)
@@ -888,7 +903,7 @@ R33R22toR(x,y);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33R22toR:NameProcessor)
+ +-(language::name:R33R22toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::name:x:NameProcessor)
`-(language::name:y:NameProcessor)
@@ -906,7 +921,7 @@ R33R22toR((1,2,3,4,5,6,7,8,9),(1,2,3,4));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33R22toR:NameProcessor)
+ +-(language::name:R33R22toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
| +-(language::integer:1:ValueProcessor)
@@ -937,7 +952,7 @@ R33R22toR((1,2,3,4,5,6,7,8,9),0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:R33R22toR:NameProcessor)
+ +-(language::name:R33R22toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
| +-(language::integer:1:ValueProcessor)
@@ -965,7 +980,7 @@ StoB("foo");
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:StoB:NameProcessor)
+ +-(language::name:StoB:FakeProcessor)
`-(language::literal:"foo":ValueProcessor)
)";
@@ -981,7 +996,7 @@ builtinToBuiltin(a);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:builtinToBuiltin:NameProcessor)
+ +-(language::name:builtinToBuiltin:FakeProcessor)
`-(language::name:a:NameProcessor)
)";
@@ -999,7 +1014,7 @@ tuple_ZtoR(true);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::true_kw:ValueProcessor)
)";
@@ -1016,7 +1031,7 @@ tuple_ZtoR(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1033,7 +1048,7 @@ tuple_ZtoR(n);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::name:n:NameProcessor)
)";
@@ -1050,7 +1065,7 @@ tuple_BtoR(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_BtoR:NameProcessor)
+ +-(language::name:tuple_BtoR:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1067,7 +1082,7 @@ tuple_NtoR(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_NtoR:NameProcessor)
+ +-(language::name:tuple_NtoR:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1084,7 +1099,7 @@ tuple_ZtoR(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1100,7 +1115,7 @@ tuple_ZtoR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -1117,7 +1132,7 @@ tuple_ZtoR(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_ZtoR:NameProcessor)
+ +-(language::name:tuple_ZtoR:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1133,7 +1148,7 @@ tuple_RtoB(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_RtoB:NameProcessor)
+ +-(language::name:tuple_RtoB:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -1150,7 +1165,7 @@ tuple_RtoB(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_RtoB:NameProcessor)
+ +-(language::name:tuple_RtoB:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1166,7 +1181,7 @@ tuple_RtoB(1.2);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_RtoB:NameProcessor)
+ +-(language::name:tuple_RtoB:FakeProcessor)
`-(language::real:1.2:ValueProcessor)
)";
@@ -1183,7 +1198,7 @@ tuple_RtoB(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_RtoB:NameProcessor)
+ +-(language::name:tuple_RtoB:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1200,7 +1215,7 @@ tuple_RtoB((1.2, 2, true, n));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_RtoB:NameProcessor)
+ +-(language::name:tuple_RtoB:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::real:1.2:ValueProcessor)
+-(language::integer:2:ValueProcessor)
@@ -1220,7 +1235,7 @@ tuple_stringtoB(1.2);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::real:1.2:ValueProcessor)
)";
@@ -1237,7 +1252,7 @@ tuple_stringtoB(s);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::name:s:NameProcessor)
)";
@@ -1254,7 +1269,7 @@ tuple_stringtoB(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1271,7 +1286,7 @@ tuple_stringtoB(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1287,7 +1302,7 @@ tuple_stringtoB("foo");
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::literal:"foo":ValueProcessor)
)";
@@ -1303,7 +1318,7 @@ tuple_stringtoB(("foo",2,"bar"));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_stringtoB:NameProcessor)
+ +-(language::name:tuple_stringtoB:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::literal:"foo":ValueProcessor)
+-(language::integer:2:ValueProcessor)
@@ -1322,7 +1337,7 @@ tuple_builtinToB(a);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_builtinToB:NameProcessor)
+ +-(language::name:tuple_builtinToB:FakeProcessor)
`-(language::name:a:NameProcessor)
)";
@@ -1338,7 +1353,7 @@ tuple_builtinToB((a,b,a));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_builtinToB:NameProcessor)
+ +-(language::name:tuple_builtinToB:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::name:a:NameProcessor)
+-(language::name:b:NameProcessor)
@@ -1358,7 +1373,7 @@ tuple_builtinToB(t);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_builtinToB:NameProcessor)
+ +-(language::name:tuple_builtinToB:FakeProcessor)
`-(language::name:t:NameProcessor)
)";
@@ -1374,7 +1389,7 @@ tuple_R1ToR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R1ToR:NameProcessor)
+ +-(language::name:tuple_R1ToR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -1390,7 +1405,7 @@ tuple_R1ToR(1.2);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R1ToR:NameProcessor)
+ +-(language::name:tuple_R1ToR:FakeProcessor)
`-(language::real:1.2:ValueProcessor)
)";
@@ -1407,7 +1422,7 @@ tuple_R1ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R1ToR:NameProcessor)
+ +-(language::name:tuple_R1ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1423,7 +1438,7 @@ tuple_R11ToR(1);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R11ToR:NameProcessor)
+ +-(language::name:tuple_R11ToR:FakeProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -1439,7 +1454,7 @@ tuple_R11ToR(1.2);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R11ToR:NameProcessor)
+ +-(language::name:tuple_R11ToR:FakeProcessor)
`-(language::real:1.2:ValueProcessor)
)";
@@ -1456,7 +1471,7 @@ tuple_R11ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R11ToR:NameProcessor)
+ +-(language::name:tuple_R11ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1472,7 +1487,7 @@ tuple_R2ToR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R2ToR:NameProcessor)
+ +-(language::name:tuple_R2ToR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -1489,7 +1504,7 @@ tuple_R2ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R2ToR:NameProcessor)
+ +-(language::name:tuple_R2ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1506,7 +1521,7 @@ tuple_R2ToR((r,r));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R2ToR:NameProcessor)
+ +-(language::name:tuple_R2ToR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::name:r:NameProcessor)
`-(language::name:r:NameProcessor)
@@ -1524,7 +1539,7 @@ tuple_R22ToR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R22ToR:NameProcessor)
+ +-(language::name:tuple_R22ToR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -1541,7 +1556,7 @@ tuple_R22ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R22ToR:NameProcessor)
+ +-(language::name:tuple_R22ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1558,7 +1573,7 @@ tuple_R22ToR((r,r));
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R22ToR:NameProcessor)
+ +-(language::name:tuple_R22ToR:FakeProcessor)
`-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+-(language::name:r:NameProcessor)
`-(language::name:r:NameProcessor)
@@ -1576,7 +1591,7 @@ tuple_R3ToR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R3ToR:NameProcessor)
+ +-(language::name:tuple_R3ToR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -1593,7 +1608,7 @@ tuple_R3ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R3ToR:NameProcessor)
+ +-(language::name:tuple_R3ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1609,7 +1624,7 @@ tuple_R33ToR(0);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R33ToR:NameProcessor)
+ +-(language::name:tuple_R33ToR:FakeProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -1626,7 +1641,7 @@ tuple_R33ToR(r);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:tuple_R33ToR:NameProcessor)
+ +-(language::name:tuple_R33ToR:FakeProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1643,7 +1658,7 @@ fidToR(f);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:fidToR:NameProcessor)
+ +-(language::name:fidToR:FakeProcessor)
`-(language::name:f:NameProcessor)
)";
@@ -1658,7 +1673,12 @@ fidToR(f);
std::string_view data = R"(
BtoR(true, false);
)";
- CHECK_AST_THROWS_WITH(data, std::string{"bad number of arguments: expecting 1, provided 2"});
+
+ const std::string error_msg = "no matching function to call BtoR: B*B\n"
+ "note: candidates are\n"
+ " BtoR: B -> R";
+
+ CHECK_AST_THROWS_AT_BUILD_WITH(data, error_msg);
}
SECTION("bad number of arguments 2")
@@ -1666,7 +1686,12 @@ BtoR(true, false);
std::string_view data = R"(
RRtoB(3);
)";
- CHECK_AST_THROWS_WITH(data, std::string{"bad number of arguments: expecting 2, provided 1"});
+
+ const std::string error_msg = "no matching function to call RRtoB: Z\n"
+ "note: candidates are\n"
+ " RRtoB: R*R -> B";
+
+ CHECK_AST_THROWS_AT_BUILD_WITH(data, error_msg);
}
SECTION("invalid argument type")
@@ -1674,7 +1699,11 @@ RRtoB(3);
std::string_view data = R"(
RtoR("foo");
)";
- CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: string -> R"});
+
+ const std::string error_msg = "no matching function to call RtoR: string\n"
+ "note: candidates are\n"
+ " RtoR: R -> R";
+ CHECK_AST_THROWS_AT_BUILD_WITH(data, error_msg);
}
}
}
diff --git a/tests/test_ASTNodeDataType.cpp b/tests/test_ASTNodeDataType.cpp
index 1f2b2a2bffe4113ac8a01feb7ee9839f29b3bc6e..9316c27dbcf09f0f114500a6c04ca3dad1c8806b 100644
--- a/tests/test_ASTNodeDataType.cpp
+++ b/tests/test_ASTNodeDataType.cpp
@@ -44,17 +44,17 @@ TEST_CASE("ASTNodeDataType", "[language]")
REQUIRE(dataTypeName(int_dt) == "Z");
REQUIRE(dataTypeName(double_dt) == "R");
REQUIRE(dataTypeName(string_dt) == "string");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::typename_t>(double_dt)) == "typename(R)");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::typename_t>(double_dt)) == "R");
REQUIRE(dataTypeName(void_dt) == "void");
REQUIRE(dataTypeName(function_dt) == "function");
REQUIRE(dataTypeName(builtin_function_dt) == "builtin_function");
- REQUIRE(dataTypeName(list_dt) == "list(R*Z)");
- REQUIRE(dataTypeName(empty_list_dt) == "list(void)");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(bool_dt)) == "tuple(B)");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt)) == "tuple(N)");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt)) == "tuple(Z)");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt)) == "tuple(R)");
- REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt)) == "tuple(Z)");
+ REQUIRE(dataTypeName(list_dt) == "R*Z");
+ REQUIRE(dataTypeName(empty_list_dt) == "void");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(bool_dt)) == "(B...)");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt)) == "(N...)");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt)) == "(Z...)");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt)) == "(R...)");
+ REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt)) == "(Z...)");
REQUIRE(dataTypeName(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>()) == "type_name_id");
@@ -74,7 +74,7 @@ TEST_CASE("ASTNodeDataType", "[language]")
REQUIRE(dataTypeName(std::vector<ASTNodeDataType>{}) == "void");
REQUIRE(dataTypeName(std::vector<ASTNodeDataType>{bool_dt}) == "B");
- REQUIRE(dataTypeName(std::vector<ASTNodeDataType>{bool_dt, unsigned_int_dt}) == "(B,N)");
+ REQUIRE(dataTypeName(std::vector<ASTNodeDataType>{bool_dt, unsigned_int_dt}) == "B*N");
}
SECTION("promotion")
diff --git a/tests/test_ASTNodeDataTypeBuilder.cpp b/tests/test_ASTNodeDataTypeBuilder.cpp
index b8ce32c92b15e4560251811528b59a69ea48f0e7..79e01aef9a34ab2324c0c731e1a2079d3e985d99 100644
--- a/tests/test_ASTNodeDataTypeBuilder.cpp
+++ b/tests/test_ASTNodeDataTypeBuilder.cpp
@@ -279,16 +279,16 @@ let (x,b,n,s) : R*B*N*string;
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name_list:list(R*B*N*string))
+ +-(language::name_list:R*B*N*string)
| +-(language::name:x:R)
| +-(language::name:b:B)
| +-(language::name:n:N)
| `-(language::name:s:string)
- `-(language::type_expression:typename(list(typename(R)*typename(B)*typename(N)*typename(string))))
- +-(language::R_set:typename(R))
- +-(language::B_set:typename(B))
- +-(language::N_set:typename(N))
- `-(language::string_type:typename(string))
+ `-(language::type_expression:R*B*N*string)
+ +-(language::R_set:R)
+ +-(language::B_set:B)
+ +-(language::N_set:N)
+ `-(language::string_type:string)
)";
CHECK_AST(data, result);
@@ -418,11 +418,11 @@ let t : (B), t = (true, false);
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(B))
- +-(language::tuple_type_specifier:typename(tuple(B)))
- | `-(language::B_set:typename(B))
- +-(language::name:t:tuple(B))
- `-(language::expression_list:list(B*B))
+ +-(language::name:t:(B...))
+ +-(language::tuple_type_specifier:(B...))
+ | `-(language::B_set:B)
+ +-(language::name:t:(B...))
+ `-(language::expression_list:B*B)
+-(language::true_kw:B)
`-(language::false_kw:B)
)";
@@ -439,11 +439,11 @@ let t : (N), t = (1, 2, 3, 5);
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(N))
- +-(language::tuple_type_specifier:typename(tuple(N)))
- | `-(language::N_set:typename(N))
- +-(language::name:t:tuple(N))
- `-(language::expression_list:list(Z*Z*Z*Z))
+ +-(language::name:t:(N...))
+ +-(language::tuple_type_specifier:(N...))
+ | `-(language::N_set:N)
+ +-(language::name:t:(N...))
+ `-(language::expression_list:Z*Z*Z*Z)
+-(language::integer:1:Z)
+-(language::integer:2:Z)
+-(language::integer:3:Z)
@@ -464,15 +464,15 @@ let t : (Z), t = (2, n, true);
(root:void)
+-(language::var_declaration:void)
| +-(language::name:n:N)
- | +-(language::N_set:typename(N))
+ | +-(language::N_set:N)
| +-(language::name:n:N)
| `-(language::integer:3:Z)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(Z))
- +-(language::tuple_type_specifier:typename(tuple(Z)))
- | `-(language::Z_set:typename(Z))
- +-(language::name:t:tuple(Z))
- `-(language::expression_list:list(Z*N*B))
+ +-(language::name:t:(Z...))
+ +-(language::tuple_type_specifier:(Z...))
+ | `-(language::Z_set:Z)
+ +-(language::name:t:(Z...))
+ `-(language::expression_list:Z*N*B)
+-(language::integer:2:Z)
+-(language::name:n:N)
`-(language::true_kw:B)
@@ -490,11 +490,11 @@ let t : (R), t = (2, 3.1, 5);
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(R))
- +-(language::tuple_type_specifier:typename(tuple(R)))
- | `-(language::R_set:typename(R))
- +-(language::name:t:tuple(R))
- `-(language::expression_list:list(Z*R*Z))
+ +-(language::name:t:(R...))
+ +-(language::tuple_type_specifier:(R...))
+ | `-(language::R_set:R)
+ +-(language::name:t:(R...))
+ `-(language::expression_list:Z*R*Z)
+-(language::integer:2:Z)
+-(language::real:3.1:R)
`-(language::integer:5:Z)
@@ -515,34 +515,34 @@ let t2 : (R^3), t2 = (0, 0);
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:R^2)
- | +-(language::vector_type:typename(R^2))
- | | +-(language::R_set:typename(R))
+ | +-(language::vector_type:R^2)
+ | | +-(language::R_set:R)
| | `-(language::integer:2:Z)
| +-(language::name:a:R^2)
- | `-(language::expression_list:list(Z*R))
+ | `-(language::expression_list:Z*R)
| +-(language::integer:2:Z)
| `-(language::real:3.1:R)
+-(language::var_declaration:void)
- | +-(language::name:t1:tuple(R^2))
- | +-(language::tuple_type_specifier:typename(tuple(R^2)))
- | | `-(language::vector_type:typename(R^2))
- | | +-(language::R_set:typename(R))
+ | +-(language::name:t1:(R^2...))
+ | +-(language::tuple_type_specifier:(R^2...))
+ | | `-(language::vector_type:R^2)
+ | | +-(language::R_set:R)
| | `-(language::integer:2:Z)
- | +-(language::name:t1:tuple(R^2))
- | `-(language::expression_list:list(R^2*list(Z*Z)*Z))
+ | +-(language::name:t1:(R^2...))
+ | `-(language::expression_list:R^2*(Z*Z)*Z)
| +-(language::name:a:R^2)
- | +-(language::tuple_expression:list(Z*Z))
+ | +-(language::tuple_expression:Z*Z)
| | +-(language::integer:1:Z)
| | `-(language::integer:2:Z)
| `-(language::integer:0:Z)
`-(language::var_declaration:void)
- +-(language::name:t2:tuple(R^3))
- +-(language::tuple_type_specifier:typename(tuple(R^3)))
- | `-(language::vector_type:typename(R^3))
- | +-(language::R_set:typename(R))
+ +-(language::name:t2:(R^3...))
+ +-(language::tuple_type_specifier:(R^3...))
+ | `-(language::vector_type:R^3)
+ | +-(language::R_set:R)
| `-(language::integer:3:Z)
- +-(language::name:t2:tuple(R^3))
- `-(language::expression_list:list(Z*Z))
+ +-(language::name:t2:(R^3...))
+ `-(language::expression_list:Z*Z)
+-(language::integer:0:Z)
`-(language::integer:0:Z)
)";
@@ -562,42 +562,42 @@ let t2 : (R^3x3), t2 = (0, 0);
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:R^2x2)
- | +-(language::matrix_type:typename(R^2x2))
- | | +-(language::R_set:typename(R))
+ | +-(language::matrix_type:R^2x2)
+ | | +-(language::R_set:R)
| | +-(language::integer:2:Z)
| | `-(language::integer:2:Z)
| +-(language::name:a:R^2x2)
- | `-(language::expression_list:list(Z*R*R*Z))
+ | `-(language::expression_list:Z*R*R*Z)
| +-(language::integer:2:Z)
| +-(language::real:3.1:R)
| +-(language::unary_minus:R)
| | `-(language::real:1.2:R)
| `-(language::integer:4:Z)
+-(language::var_declaration:void)
- | +-(language::name:t1:tuple(R^2x2))
- | +-(language::tuple_type_specifier:typename(tuple(R^2x2)))
- | | `-(language::matrix_type:typename(R^2x2))
- | | +-(language::R_set:typename(R))
+ | +-(language::name:t1:(R^2x2...))
+ | +-(language::tuple_type_specifier:(R^2x2...))
+ | | `-(language::matrix_type:R^2x2)
+ | | +-(language::R_set:R)
| | +-(language::integer:2:Z)
| | `-(language::integer:2:Z)
- | +-(language::name:t1:tuple(R^2x2))
- | `-(language::expression_list:list(R^2x2*list(Z*Z*Z*Z)*Z))
+ | +-(language::name:t1:(R^2x2...))
+ | `-(language::expression_list:R^2x2*(Z*Z*Z*Z)*Z)
| +-(language::name:a:R^2x2)
- | +-(language::tuple_expression:list(Z*Z*Z*Z))
+ | +-(language::tuple_expression:Z*Z*Z*Z)
| | +-(language::integer:1:Z)
| | +-(language::integer:2:Z)
| | +-(language::integer:1:Z)
| | `-(language::integer:3:Z)
| `-(language::integer:0:Z)
`-(language::var_declaration:void)
- +-(language::name:t2:tuple(R^3x3))
- +-(language::tuple_type_specifier:typename(tuple(R^3x3)))
- | `-(language::matrix_type:typename(R^3x3))
- | +-(language::R_set:typename(R))
+ +-(language::name:t2:(R^3x3...))
+ +-(language::tuple_type_specifier:(R^3x3...))
+ | `-(language::matrix_type:R^3x3)
+ | +-(language::R_set:R)
| +-(language::integer:3:Z)
| `-(language::integer:3:Z)
- +-(language::name:t2:tuple(R^3x3))
- `-(language::expression_list:list(Z*Z))
+ +-(language::name:t2:(R^3x3...))
+ `-(language::expression_list:Z*Z)
+-(language::integer:0:Z)
`-(language::integer:0:Z)
)";
@@ -614,11 +614,11 @@ let t : (string), t = ("foo", "bar");
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(string))
- +-(language::tuple_type_specifier:typename(tuple(string)))
- | `-(language::string_type:typename(string))
- +-(language::name:t:tuple(string))
- `-(language::expression_list:list(string*string))
+ +-(language::name:t:(string...))
+ +-(language::tuple_type_specifier:(string...))
+ | `-(language::string_type:string)
+ +-(language::name:t:(string...))
+ `-(language::expression_list:string*string)
+-(language::literal:"foo":string)
`-(language::literal:"bar":string)
)";
@@ -636,11 +636,11 @@ let t : (builtin_t), t= (1,2,3);
std::string_view result = R"(
(root:void)
`-(language::var_declaration:void)
- +-(language::name:t:tuple(builtin_t))
- +-(language::tuple_type_specifier:typename(tuple(builtin_t)))
+ +-(language::name:t:(builtin_t...))
+ +-(language::tuple_type_specifier:(builtin_t...))
| `-(language::type_name_id:builtin_t)
- +-(language::name:t:tuple(builtin_t))
- `-(language::expression_list:list(Z*Z*Z))
+ +-(language::name:t:(builtin_t...))
+ `-(language::expression_list:Z*Z*Z)
+-(language::integer:1:Z)
+-(language::integer:2:Z)
`-(language::integer:3:Z)
@@ -1073,11 +1073,11 @@ x = f(x);
| `-(language::name:f:function)
+-(language::var_declaration:void)
| +-(language::name:x:R^2)
- | +-(language::vector_type:typename(R^2))
- | | +-(language::R_set:typename(R))
+ | +-(language::vector_type:R^2)
+ | | +-(language::R_set:R)
| | `-(language::integer:2:Z)
| +-(language::name:x:R^2)
- | `-(language::expression_list:list(Z*Z))
+ | `-(language::expression_list:Z*Z)
| +-(language::integer:1:Z)
| `-(language::integer:2:Z)
`-(language::eq_op:void)
@@ -1106,7 +1106,7 @@ let x : R, x = incr(3);
| `-(language::name:incr:function)
`-(language::var_declaration:void)
+-(language::name:x:R)
- +-(language::R_set:typename(R))
+ +-(language::R_set:R)
+-(language::name:x:R)
`-(language::function_evaluation:R)
+-(language::name:incr:function)
@@ -1129,11 +1129,11 @@ let diff : R, diff = substract(3,2);
| `-(language::name:substract:function)
`-(language::var_declaration:void)
+-(language::name:diff:R)
- +-(language::R_set:typename(R))
+ +-(language::R_set:R)
+-(language::name:diff:R)
`-(language::function_evaluation:R)
+-(language::name:substract:function)
- `-(language::function_argument_list:list(Z*Z))
+ `-(language::function_argument_list:Z*Z)
+-(language::integer:3:Z)
`-(language::integer:2:Z)
)";
@@ -1155,7 +1155,7 @@ let z : Z, z = incr(3);
| `-(language::name:incr:function)
`-(language::var_declaration:void)
+-(language::name:z:Z)
- +-(language::Z_set:typename(Z))
+ +-(language::Z_set:Z)
+-(language::name:z:Z)
`-(language::function_evaluation:Z)
+-(language::name:incr:function)
@@ -1178,7 +1178,7 @@ let n : N, n = double(3);
| `-(language::name:double:function)
`-(language::var_declaration:void)
+-(language::name:n:N)
- +-(language::N_set:typename(N))
+ +-(language::N_set:N)
+-(language::name:n:N)
`-(language::function_evaluation:N)
+-(language::name:double:function)
@@ -1201,7 +1201,7 @@ let b : B, b = greater_than_2(3);
| `-(language::name:greater_than_2:function)
`-(language::var_declaration:void)
+-(language::name:b:B)
- +-(language::B_set:typename(B))
+ +-(language::B_set:B)
+-(language::name:b:B)
`-(language::function_evaluation:B)
+-(language::name:greater_than_2:function)
@@ -1224,11 +1224,11 @@ let s : string, s = cat("foo", "bar");
| `-(language::name:cat:function)
`-(language::var_declaration:void)
+-(language::name:s:string)
- +-(language::string_type:typename(string))
+ +-(language::string_type:string)
+-(language::name:s:string)
`-(language::function_evaluation:string)
+-(language::name:cat:function)
- `-(language::function_argument_list:list(string*string))
+ `-(language::function_argument_list:string*string)
+-(language::literal:"foo":string)
`-(language::literal:"bar":string)
)";
@@ -1248,16 +1248,16 @@ let (x,x2) : R*R, (x,x2) = x_x2(3);
+-(language::fct_declaration:void)
| `-(language::name:x_x2:function)
`-(language::var_declaration:void)
- +-(language::name_list:list(R*R))
+ +-(language::name_list:R*R)
| +-(language::name:x:R)
| `-(language::name:x2:R)
- +-(language::type_expression:typename(list(typename(R)*typename(R))))
- | +-(language::R_set:typename(R))
- | `-(language::R_set:typename(R))
- +-(language::name_list:list(R*R))
+ +-(language::type_expression:R*R)
+ | +-(language::R_set:R)
+ | `-(language::R_set:R)
+ +-(language::name_list:R*R)
| +-(language::name:x:R)
| `-(language::name:x2:R)
- `-(language::function_evaluation:list(typename(R)*typename(R)))
+ `-(language::function_evaluation:R*R)
+-(language::name:x_x2:function)
`-(language::integer:3:Z)
)";
@@ -1316,7 +1316,7 @@ for (let i : N, i=0; i<3; ++i){
`-(language::for_statement:void)
+-(language::var_declaration:void)
| +-(language::name:i:N)
- | +-(language::N_set:typename(N))
+ | +-(language::N_set:N)
| +-(language::name:i:N)
| `-(language::integer:0:Z)
+-(language::lesser_op:B)
@@ -1342,7 +1342,7 @@ let b:B;
(root:void)
`-(language::var_declaration:void)
+-(language::name:b:B)
- `-(language::B_set:typename(B))
+ `-(language::B_set:B)
)";
CHECK_AST(data, result);
@@ -1358,7 +1358,7 @@ let n :N;
(root:void)
`-(language::var_declaration:void)
+-(language::name:n:N)
- `-(language::N_set:typename(N))
+ `-(language::N_set:N)
)";
CHECK_AST(data, result);
@@ -1374,7 +1374,7 @@ let z:Z;
(root:void)
`-(language::var_declaration:void)
+-(language::name:z:Z)
- `-(language::Z_set:typename(Z))
+ `-(language::Z_set:Z)
)";
CHECK_AST(data, result);
@@ -1390,7 +1390,7 @@ let r:R;
(root:void)
`-(language::var_declaration:void)
+-(language::name:r:R)
- `-(language::R_set:typename(R))
+ `-(language::R_set:R)
)";
CHECK_AST(data, result);
@@ -1406,7 +1406,7 @@ let s: string;
(root:void)
`-(language::var_declaration:void)
+-(language::name:s:string)
- `-(language::string_type:typename(string))
+ `-(language::string_type:string)
)";
CHECK_AST(data, result);
@@ -1423,7 +1423,7 @@ let t : builtin_t, t= 1;
(root:void)
`-(language::var_declaration:void)
+-(language::name:t:builtin_t)
- +-(language::type_name_id:typename(builtin_t))
+ +-(language::type_name_id:builtin_t)
+-(language::name:t:builtin_t)
`-(language::integer:1:Z)
)";
@@ -1470,7 +1470,7 @@ a = 1;
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:N)
- | `-(language::N_set:typename(N))
+ | `-(language::N_set:N)
`-(language::eq_op:void)
+-(language::name:a:N)
`-(language::integer:1:Z)
@@ -1490,7 +1490,7 @@ a *= 1.2;
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:N)
- | +-(language::N_set:typename(N))
+ | +-(language::N_set:N)
| +-(language::name:a:N)
| `-(language::integer:1:Z)
`-(language::multiplyeq_op:void)
@@ -1512,7 +1512,7 @@ a /= 2;
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:R)
- | +-(language::R_set:typename(R))
+ | +-(language::R_set:R)
| +-(language::name:a:R)
| `-(language::integer:3:Z)
`-(language::divideeq_op:void)
@@ -1534,7 +1534,7 @@ a += 2;
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:Z)
- | +-(language::Z_set:typename(Z))
+ | +-(language::Z_set:Z)
| +-(language::name:a:Z)
| `-(language::integer:3:Z)
`-(language::pluseq_op:void)
@@ -1556,7 +1556,7 @@ a -= 2;
(root:void)
+-(language::var_declaration:void)
| +-(language::name:a:Z)
- | +-(language::Z_set:typename(Z))
+ | +-(language::Z_set:Z)
| +-(language::name:a:Z)
| `-(language::integer:1:Z)
`-(language::minuseq_op:void)
@@ -1596,7 +1596,7 @@ for (let i:Z, i=0; i<3; i += 1) { i += 2; }
`-(language::for_statement:void)
+-(language::var_declaration:void)
| +-(language::name:i:Z)
- | +-(language::Z_set:typename(Z))
+ | +-(language::Z_set:Z)
| +-(language::name:i:Z)
| `-(language::integer:0:Z)
+-(language::lesser_op:B)
diff --git a/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp b/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
index 6fbb82cf81db5c9ae7b78d30d17a01864a3e5d57..289eb44be78bc57ed86a03ea308c649b2d17cc87 100644
--- a/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeFunctionEvaluationExpressionBuilder.cpp
@@ -51,7 +51,7 @@ sin(3);
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
- +-(language::name:sin:NameProcessor)
+ +-(language::name:sin:FakeProcessor)
`-(language::integer:3:ValueProcessor)
)";
diff --git a/tests/test_ASTNodeNaturalConversionChecker.cpp b/tests/test_ASTNodeNaturalConversionChecker.cpp
index d03541e6c96c63b70a220ee94f50a858614eab5b..6852222ae307f2cdac86463ecc2b59fde4536618 100644
--- a/tests/test_ASTNodeNaturalConversionChecker.cpp
+++ b/tests/test_ASTNodeNaturalConversionChecker.cpp
@@ -1009,7 +1009,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1,
1)}),
- "invalid implicit conversion: tuple(N) -> R^1x1");
+ "invalid implicit conversion: (N...) -> R^1x1");
}
SECTION("tuple(R) -> R^1x1")
@@ -1018,7 +1018,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1,
1)}),
- "invalid implicit conversion: tuple(R) -> R^1x1");
+ "invalid implicit conversion: (R...) -> R^1x1");
}
SECTION("tuple(R) -> R^2x2")
@@ -1027,7 +1027,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2,
2)}),
- "invalid implicit conversion: tuple(R) -> R^2x2");
+ "invalid implicit conversion: (R...) -> R^2x2");
}
SECTION("tuple(B) -> R^2x2")
@@ -1036,7 +1036,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2,
2)}),
- "invalid implicit conversion: tuple(B) -> R^2x2");
+ "invalid implicit conversion: (B...) -> R^2x2");
}
SECTION("tuple(Z) -> R^3x2")
@@ -1045,7 +1045,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3,
3)}),
- "invalid implicit conversion: tuple(Z) -> R^3x3");
+ "invalid implicit conversion: (Z...) -> R^3x3");
}
SECTION("tuple(R) -> R^3x3")
@@ -1054,7 +1054,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3,
3)}),
- "invalid implicit conversion: tuple(R) -> R^3x3");
+ "invalid implicit conversion: (R...) -> R^3x3");
}
SECTION("tuple(R^1) -> tuple(R^3x3)")
@@ -1419,7 +1419,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)}),
- "invalid implicit conversion: tuple(N) -> R^1");
+ "invalid implicit conversion: (N...) -> R^1");
}
SECTION("tuple(R) -> R^1")
@@ -1427,7 +1427,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)}),
- "invalid implicit conversion: tuple(R) -> R^1");
+ "invalid implicit conversion: (R...) -> R^1");
}
SECTION("tuple(R) -> R^2")
@@ -1435,7 +1435,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)}),
- "invalid implicit conversion: tuple(R) -> R^2");
+ "invalid implicit conversion: (R...) -> R^2");
}
SECTION("tuple(B) -> R^2")
@@ -1443,7 +1443,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(bool_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)}),
- "invalid implicit conversion: tuple(B) -> R^2");
+ "invalid implicit conversion: (B...) -> R^2");
}
SECTION("tuple(Z) -> R^3")
@@ -1451,7 +1451,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)}),
- "invalid implicit conversion: tuple(Z) -> R^3");
+ "invalid implicit conversion: (Z...) -> R^3");
}
SECTION("tuple(R) -> R^3")
@@ -1459,7 +1459,7 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)}),
- "invalid implicit conversion: tuple(R) -> R^3");
+ "invalid implicit conversion: (R...) -> R^3");
}
SECTION("tuple(R^1x1) -> tuple(R^3)")
@@ -1750,14 +1750,14 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, double_dt}),
- "invalid implicit conversion: tuple(N) -> R");
+ "invalid implicit conversion: (N...) -> R");
}
SECTION("tuple(R) -> R")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(double_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, double_dt}),
- "invalid implicit conversion: tuple(R) -> R");
+ "invalid implicit conversion: (R...) -> R");
}
}
@@ -1802,14 +1802,14 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, int_dt}),
- "invalid implicit conversion: tuple(N) -> Z");
+ "invalid implicit conversion: (N...) -> Z");
}
SECTION("tuple(Z) -> Z")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, int_dt}),
- "invalid implicit conversion: tuple(Z) -> Z");
+ "invalid implicit conversion: (Z...) -> Z");
}
}
@@ -1854,14 +1854,14 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, unsigned_int_dt}),
- "invalid implicit conversion: tuple(Z) -> N");
+ "invalid implicit conversion: (Z...) -> N");
}
SECTION("tuple(N) -> N")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(unsigned_int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, unsigned_int_dt}),
- "invalid implicit conversion: tuple(N) -> N");
+ "invalid implicit conversion: (N...) -> N");
}
}
@@ -1920,14 +1920,14 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(int_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, bool_dt}),
- "invalid implicit conversion: tuple(Z) -> B");
+ "invalid implicit conversion: (Z...) -> B");
}
SECTION("tuple(B) -> B")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(bool_dt);
REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node, bool_dt}),
- "invalid implicit conversion: tuple(B) -> B");
+ "invalid implicit conversion: (B...) -> B");
}
}
diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp
index e1b9bb4ed39c39aea07d9d289d8808e8c5a54851..dda3becc1897f2e659ed105256bc0ec09271e46d 100644
--- a/tests/test_BuiltinFunctionProcessor.cpp
+++ b/tests/test_BuiltinFunctionProcessor.cpp
@@ -81,7 +81,7 @@ TEST_CASE("BuiltinFunctionProcessor", "[language]")
std::set<std::string> tested_function_set;
{ // sqrt
- tested_function_set.insert("sqrt");
+ tested_function_set.insert("sqrt:R");
std::string_view data = R"(
import math;
let x:R, x = sqrt(4);
@@ -90,7 +90,7 @@ let x:R, x = sqrt(4);
}
{ // abs
- tested_function_set.insert("abs");
+ tested_function_set.insert("abs:R");
std::string_view data = R"(
import math;
let x:R, x = abs(-3.4);
@@ -99,7 +99,7 @@ let x:R, x = abs(-3.4);
}
{ // sin
- tested_function_set.insert("sin");
+ tested_function_set.insert("sin:R");
std::string_view data = R"(
import math;
let x:R, x = sin(1.3);
@@ -108,7 +108,7 @@ let x:R, x = sin(1.3);
}
{ // cos
- tested_function_set.insert("cos");
+ tested_function_set.insert("cos:R");
std::string_view data = R"(
import math;
let x:R, x = cos(1.3);
@@ -117,7 +117,7 @@ let x:R, x = cos(1.3);
}
{ // tan
- tested_function_set.insert("tan");
+ tested_function_set.insert("tan:R");
std::string_view data = R"(
import math;
let x:R, x = tan(1.3);
@@ -126,7 +126,7 @@ let x:R, x = tan(1.3);
}
{ // asin
- tested_function_set.insert("asin");
+ tested_function_set.insert("asin:R");
std::string_view data = R"(
import math;
let x:R, x = asin(0.7);
@@ -135,7 +135,7 @@ let x:R, x = asin(0.7);
}
{ // acos
- tested_function_set.insert("acos");
+ tested_function_set.insert("acos:R");
std::string_view data = R"(
import math;
let x:R, x = acos(0.7);
@@ -144,7 +144,7 @@ let x:R, x = acos(0.7);
}
{ // atan
- tested_function_set.insert("atan");
+ tested_function_set.insert("atan:R");
std::string_view data = R"(
import math;
let x:R, x = atan(0.7);
@@ -153,7 +153,7 @@ let x:R, x = atan(0.7);
}
{ // atan2
- tested_function_set.insert("atan2");
+ tested_function_set.insert("atan2:R*R");
std::string_view data = R"(
import math;
let x:R, x = atan2(0.7, 0.4);
@@ -162,7 +162,7 @@ let x:R, x = atan2(0.7, 0.4);
}
{ // sinh
- tested_function_set.insert("sinh");
+ tested_function_set.insert("sinh:R");
std::string_view data = R"(
import math;
let x:R, x = sinh(0.6);
@@ -171,7 +171,7 @@ let x:R, x = sinh(0.6);
}
{ // cosh
- tested_function_set.insert("cosh");
+ tested_function_set.insert("cosh:R");
std::string_view data = R"(
import math;
let x:R, x = cosh(1.7);
@@ -180,7 +180,7 @@ let x:R, x = cosh(1.7);
}
{ // tanh
- tested_function_set.insert("tanh");
+ tested_function_set.insert("tanh:R");
std::string_view data = R"(
import math;
let x:R, x = tanh(0.6);
@@ -189,7 +189,7 @@ let x:R, x = tanh(0.6);
}
{ // asinh
- tested_function_set.insert("asinh");
+ tested_function_set.insert("asinh:R");
std::string_view data = R"(
import math;
let x:R, x = asinh(0.6);
@@ -198,7 +198,7 @@ let x:R, x = asinh(0.6);
}
{ // acosh
- tested_function_set.insert("acosh");
+ tested_function_set.insert("acosh:R");
std::string_view data = R"(
import math;
let x:R, x = acosh(1.7);
@@ -207,7 +207,7 @@ let x:R, x = acosh(1.7);
}
{ // tanh
- tested_function_set.insert("atanh");
+ tested_function_set.insert("atanh:R");
std::string_view data = R"(
import math;
let x:R, x = atanh(0.6);
@@ -216,7 +216,7 @@ let x:R, x = atanh(0.6);
}
{ // exp
- tested_function_set.insert("exp");
+ tested_function_set.insert("exp:R");
std::string_view data = R"(
import math;
let x:R, x = exp(1.7);
@@ -225,7 +225,7 @@ let x:R, x = exp(1.7);
}
{ // log
- tested_function_set.insert("log");
+ tested_function_set.insert("log:R");
std::string_view data = R"(
import math;
let x:R, x = log(1.6);
@@ -234,7 +234,7 @@ let x:R, x = log(1.6);
}
{ // pow
- tested_function_set.insert("pow");
+ tested_function_set.insert("pow:R*R");
std::string_view data = R"(
import math;
let x:R, x = pow(1.6, 2.3);
@@ -243,7 +243,7 @@ let x:R, x = pow(1.6, 2.3);
}
{ // ceil
- tested_function_set.insert("ceil");
+ tested_function_set.insert("ceil:R");
std::string_view data = R"(
import math;
let z:Z, z = ceil(-1.2);
@@ -252,7 +252,7 @@ let z:Z, z = ceil(-1.2);
}
{ // floor
- tested_function_set.insert("floor");
+ tested_function_set.insert("floor:R");
std::string_view data = R"(
import math;
let z:Z, z = floor(-1.2);
@@ -261,7 +261,7 @@ let z:Z, z = floor(-1.2);
}
{ // trunc
- tested_function_set.insert("trunc");
+ tested_function_set.insert("trunc:R");
std::string_view data = R"(
import math;
let z:Z, z = trunc(-0.2) + trunc(0.7);
@@ -270,7 +270,7 @@ let z:Z, z = trunc(-0.2) + trunc(0.7);
}
{ // round
- tested_function_set.insert("round");
+ tested_function_set.insert("round:R");
std::string_view data = R"(
import math;
let z:Z, z = round(-1.2);
diff --git a/tests/test_BuiltinFunctionRegister.hpp b/tests/test_BuiltinFunctionRegister.hpp
index bc36e2ea29d37cbcd2464ddc1e080bff9e0dd591..e062fcd92222796da9071243bda7c3e5dd253e32 100644
--- a/tests/test_BuiltinFunctionRegister.hpp
+++ b/tests/test_BuiltinFunctionRegister.hpp
@@ -3,6 +3,7 @@
#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/ParseError.hpp>
#include <language/utils/TypeDescriptor.hpp>
#include <utils/Exceptions.hpp>
@@ -22,135 +23,140 @@ class test_BuiltinFunctionRegister
_populateNameBuiltinFunctionMap()
{
m_name_builtin_function_map.insert(
- std::make_pair("runtimeError", std::make_shared<BuiltinFunctionEmbedder<void(void)>>(
- [](void) -> void { throw NormalError("runtime error"); })));
+ std::make_pair("runtimeError:void", std::make_shared<BuiltinFunctionEmbedder<void(void)>>(
+ [](void) -> void { throw NormalError("runtime error"); })));
- m_name_builtin_function_map.insert(std::make_pair("RtoR", std::make_shared<BuiltinFunctionEmbedder<double(double)>>(
- [](double x) -> double { return x + 1; })));
+ m_name_builtin_function_map.insert(
+ std::make_pair("RtoR:R", std::make_shared<BuiltinFunctionEmbedder<double(double)>>(
+ [](double x) -> double { return x + 1; })));
m_name_builtin_function_map.insert(
- std::make_pair("ZtoR", std::make_shared<BuiltinFunctionEmbedder<double(int64_t)>>(
- [](int64_t z) -> double { return 0.5 * z; })));
+ std::make_pair("ZtoR:Z", std::make_shared<BuiltinFunctionEmbedder<double(int64_t)>>(
+ [](int64_t z) -> double { return 0.5 * z; })));
m_name_builtin_function_map.insert(
- std::make_pair("NtoR", std::make_shared<BuiltinFunctionEmbedder<double(uint64_t)>>(
- [](uint64_t n) -> double { return 0.5 * n; })));
+ std::make_pair("NtoR:N", std::make_shared<BuiltinFunctionEmbedder<double(uint64_t)>>(
+ [](uint64_t n) -> double { return 0.5 * n; })));
- m_name_builtin_function_map.insert(std::make_pair("BtoR", std::make_shared<BuiltinFunctionEmbedder<double(bool)>>(
- [](bool b) -> double { return b; })));
+ m_name_builtin_function_map.insert(std::make_pair("BtoR:B", std::make_shared<BuiltinFunctionEmbedder<double(bool)>>(
+ [](bool b) -> double { return b; })));
m_name_builtin_function_map.insert(
- std::make_pair("RRtoB", std::make_shared<BuiltinFunctionEmbedder<bool(double, double)>>(
- [](double x, double y) -> bool { return x > y; })));
+ std::make_pair("RRtoB:R*R", std::make_shared<BuiltinFunctionEmbedder<bool(double, double)>>(
+ [](double x, double y) -> bool { return x > y; })));
m_name_builtin_function_map.insert(
- std::make_pair("StoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::string)>>(
- [](const std::string& s) -> bool { return s.size() > 0; })));
+ std::make_pair("StoB:string", std::make_shared<BuiltinFunctionEmbedder<bool(std::string)>>(
+ [](const std::string& s) -> bool { return s.size() > 0; })));
m_name_builtin_function_map.insert(
- std::make_pair("RtoR1", std::make_shared<BuiltinFunctionEmbedder<TinyVector<1>(double)>>(
- [](double r) -> TinyVector<1> { return {r}; })));
+ std::make_pair("RtoR1:R", std::make_shared<BuiltinFunctionEmbedder<TinyVector<1>(double)>>(
+ [](double r) -> TinyVector<1> { return {r}; })));
m_name_builtin_function_map.insert(
- std::make_pair("R1toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<1>)>>(
- [](TinyVector<1> x) -> double { return x[0]; })));
+ std::make_pair("R1toR:R^1", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<1>)>>(
+ [](TinyVector<1> x) -> double { return x[0]; })));
m_name_builtin_function_map.insert(
- std::make_pair("R2toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<2>)>>(
- [](TinyVector<2> x) -> double { return x[0] + x[1]; })));
+ std::make_pair("R2toR:R^2", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<2>)>>(
+ [](TinyVector<2> x) -> double { return x[0] + x[1]; })));
m_name_builtin_function_map.insert(
- std::make_pair("R3toR", std::make_shared<BuiltinFunctionEmbedder<double(const TinyVector<3>&)>>(
- [](const TinyVector<3>& x) -> double { return x[0] + x[1] + x[2]; })));
+ std::make_pair("R3toR:R^3", std::make_shared<BuiltinFunctionEmbedder<double(const TinyVector<3>&)>>(
+ [](const TinyVector<3>& x) -> double { return x[0] + x[1] + x[2]; })));
m_name_builtin_function_map.insert(
- std::make_pair("R3R2toR",
+ std::make_pair("R3R2toR:R^3,R^2",
std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<3>, TinyVector<2>)>>(
[](TinyVector<3> x, TinyVector<2> y) -> double { return x[0] * y[1] + (y[0] - x[2]) * x[1]; })));
m_name_builtin_function_map.insert(
- std::make_pair("RtoR11", std::make_shared<BuiltinFunctionEmbedder<TinyMatrix<1>(double)>>(
- [](double r) -> TinyMatrix<1> { return {r}; })));
+ std::make_pair("RtoR11:R", std::make_shared<BuiltinFunctionEmbedder<TinyMatrix<1>(double)>>(
+ [](double r) -> TinyMatrix<1> { return {r}; })));
m_name_builtin_function_map.insert(
- std::make_pair("R11toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<1>)>>(
- [](TinyMatrix<1> x) -> double { return x(0, 0); })));
+ std::make_pair("R11toR:R^1x1", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<1>)>>(
+ [](TinyMatrix<1> x) -> double { return x(0, 0); })));
m_name_builtin_function_map.insert(
- std::make_pair("R22toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<2>)>>(
- [](TinyMatrix<2> x) -> double { return x(0, 0) + x(0, 1) + x(1, 0) + x(1, 1); })));
+ std::make_pair("R22toR:R^2x2",
+ std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<2>)>>(
+ [](TinyMatrix<2> x) -> double { return x(0, 0) + x(0, 1) + x(1, 0) + x(1, 1); })));
m_name_builtin_function_map.insert(
- std::make_pair("R33toR", std::make_shared<BuiltinFunctionEmbedder<double(const TinyMatrix<3>&)>>(
- [](const TinyMatrix<3>& x) -> double { return x(0, 0) + x(1, 1) + x(2, 2); })));
+ std::make_pair("R33toR:R^3x3", std::make_shared<BuiltinFunctionEmbedder<double(const TinyMatrix<3>&)>>(
+ [](const TinyMatrix<3>& x) -> double { return x(0, 0) + x(1, 1) + x(2, 2); })));
m_name_builtin_function_map.insert(
- std::make_pair("R33R22toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<3>, TinyMatrix<2>)>>(
- [](TinyMatrix<3> x, TinyMatrix<2> y) -> double {
- return (x(0, 0) + x(1, 1) + x(2, 2)) * (y(0, 0) + y(0, 1) + y(1, 0) + y(1, 1));
- })));
+ std::make_pair("R33R22toR:R^3x3*R^2x2",
+ std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<3>, TinyMatrix<2>)>>(
+ [](TinyMatrix<3> x, TinyMatrix<2> y) -> double {
+ return (x(0, 0) + x(1, 1) + x(2, 2)) * (y(0, 0) + y(0, 1) + y(1, 0) + y(1, 1));
+ })));
m_name_builtin_function_map.insert(
- std::make_pair("fidToR", std::make_shared<BuiltinFunctionEmbedder<double(const FunctionSymbolId&)>>(
- [](const FunctionSymbolId&) -> double { return 0; })));
+ std::make_pair("fidToR:function", std::make_shared<BuiltinFunctionEmbedder<double(const FunctionSymbolId&)>>(
+ [](const FunctionSymbolId&) -> double { return 0; })));
m_name_builtin_function_map.insert(
- std::make_pair("builtinToBuiltin",
+ std::make_pair("builtinToBuiltin:builtin_t",
std::make_shared<
BuiltinFunctionEmbedder<std::shared_ptr<const double>(std::shared_ptr<const double>)>>(
[](std::shared_ptr<const double> x) -> std::shared_ptr<const double> { return x; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_BtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<bool>)>>(
- [](const std::vector<bool>&) -> double { return 0.5; })));
+ std::make_pair("tuple_BtoR:(B...)", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<bool>)>>(
+ [](const std::vector<bool>&) -> double { return 0.5; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_NtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<uint64_t>)>>(
- [](const std::vector<uint64_t>&) -> double { return 0.5; })));
+ std::make_pair("tuple_NtoR:(N...)", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<uint64_t>)>>(
+ [](const std::vector<uint64_t>&) -> double { return 0.5; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_ZtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<int64_t>)>>(
- [](const std::vector<int64_t>&) -> double { return 0.5; })));
+ std::make_pair("tuple_ZtoR:(Z...)", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<int64_t>)>>(
+ [](const std::vector<int64_t>&) -> double { return 0.5; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_RtoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<double>)>>(
- [](const std::vector<double>&) -> bool { return false; })));
+ std::make_pair("tuple_RtoB:(R...)", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<double>)>>(
+ [](const std::vector<double>&) -> bool { return false; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_stringtoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<std::string>)>>(
- [](const std::vector<std::string>&) -> bool { return true; })));
+ std::make_pair("tuple_stringtoB:(string...)",
+ std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<std::string>)>>(
+ [](const std::vector<std::string>&) -> bool { return true; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_builtinToB",
+ std::make_pair("tuple_builtinToB:(builtin_t...)",
std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<std::shared_ptr<const double>>)>>(
[](const std::vector<std::shared_ptr<const double>>&) -> bool { return true; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R1ToR",
+ std::make_pair("tuple_R1ToR:(R^1...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<1>>&)>>(
[](const std::vector<TinyVector<1>>&) -> double { return 1; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R2ToR",
+ std::make_pair("tuple_R2ToR:(R^2...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<2>>&)>>(
[](const std::vector<TinyVector<2>>&) -> double { return 1; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R3ToR", std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<3>>)>>(
- [](const std::vector<TinyVector<3>>&) -> double { return 0; })));
+ std::make_pair("tuple_R3ToR:(R^3...)",
+ std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<3>>)>>(
+ [](const std::vector<TinyVector<3>>&) -> double { return 0; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R11ToR",
+ std::make_pair("tuple_R11ToR:(R^1x1...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<1>>&)>>(
[](const std::vector<TinyMatrix<1>>&) -> double { return 1; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R22ToR",
+ std::make_pair("tuple_R22ToR:(R^2x2...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<2>>&)>>(
[](const std::vector<TinyMatrix<2>>&) -> double { return 1; })));
m_name_builtin_function_map.insert(
- std::make_pair("tuple_R33ToR",
+ std::make_pair("tuple_R33ToR:(R^3x3...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<3>>)>>(
[](const std::vector<TinyMatrix<3>>&) -> double { return 0; })));
}
diff --git a/tests/test_MathModule.cpp b/tests/test_MathModule.cpp
index 86696dfab3e574b5649c3670689e4c26cd664dbc..e899190bf486ff605c1bd4f8af2ccc232cc806a8 100644
--- a/tests/test_MathModule.cpp
+++ b/tests/test_MathModule.cpp
@@ -23,7 +23,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("sqrt")
{
- auto i_function = name_builtin_function.find("sqrt");
+ auto i_function = name_builtin_function.find("sqrt:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -35,7 +35,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("abs")
{
- auto i_function = name_builtin_function.find("abs");
+ auto i_function = name_builtin_function.find("abs:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -62,7 +62,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("sin")
{
- auto i_function = name_builtin_function.find("sin");
+ auto i_function = name_builtin_function.find("sin:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -74,7 +74,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("cos")
{
- auto i_function = name_builtin_function.find("cos");
+ auto i_function = name_builtin_function.find("cos:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -86,7 +86,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("tan")
{
- auto i_function = name_builtin_function.find("tan");
+ auto i_function = name_builtin_function.find("tan:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -98,7 +98,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("asin")
{
- auto i_function = name_builtin_function.find("asin");
+ auto i_function = name_builtin_function.find("asin:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -110,7 +110,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("acos")
{
- auto i_function = name_builtin_function.find("acos");
+ auto i_function = name_builtin_function.find("acos:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -122,7 +122,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("atan")
{
- auto i_function = name_builtin_function.find("atan");
+ auto i_function = name_builtin_function.find("atan:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -137,7 +137,7 @@ TEST_CASE("MathModule", "[language]")
arg = 1.3;
arg_variant = arg;
- auto i_function = name_builtin_function.find("sinh");
+ auto i_function = name_builtin_function.find("sinh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -149,7 +149,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("cosh")
{
- auto i_function = name_builtin_function.find("cosh");
+ auto i_function = name_builtin_function.find("cosh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -161,7 +161,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("tanh")
{
- auto i_function = name_builtin_function.find("tanh");
+ auto i_function = name_builtin_function.find("tanh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -173,7 +173,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("asinh")
{
- auto i_function = name_builtin_function.find("asinh");
+ auto i_function = name_builtin_function.find("asinh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -188,7 +188,7 @@ TEST_CASE("MathModule", "[language]")
arg = 10;
arg_variant = arg;
- auto i_function = name_builtin_function.find("acosh");
+ auto i_function = name_builtin_function.find("acosh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -200,7 +200,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("atanh")
{
- auto i_function = name_builtin_function.find("atanh");
+ auto i_function = name_builtin_function.find("atanh:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -212,7 +212,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("exp")
{
- auto i_function = name_builtin_function.find("exp");
+ auto i_function = name_builtin_function.find("exp:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -224,7 +224,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("log")
{
- auto i_function = name_builtin_function.find("log");
+ auto i_function = name_builtin_function.find("log:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -243,7 +243,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("ceil")
{
- auto i_function = name_builtin_function.find("ceil");
+ auto i_function = name_builtin_function.find("ceil:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -255,7 +255,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("floor")
{
- auto i_function = name_builtin_function.find("floor");
+ auto i_function = name_builtin_function.find("floor:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -267,7 +267,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("trunc")
{
- auto i_function = name_builtin_function.find("trunc");
+ auto i_function = name_builtin_function.find("trunc:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -279,7 +279,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("round")
{
- auto i_function = name_builtin_function.find("round");
+ auto i_function = name_builtin_function.find("round:R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -300,7 +300,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("atan2")
{
- auto i_function = name_builtin_function.find("atan2");
+ auto i_function = name_builtin_function.find("atan2:R*R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;
@@ -312,7 +312,7 @@ TEST_CASE("MathModule", "[language]")
SECTION("pow")
{
- auto i_function = name_builtin_function.find("pow");
+ auto i_function = name_builtin_function.find("pow:R*R");
REQUIRE(i_function != name_builtin_function.end());
IBuiltinFunctionEmbedder& function_embedder = *i_function->second;