st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2025-12-09 08:28:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

binary operator expression repalced with function call expression

Browse source
This commit is contained in:
ProgramSnail 2023-05-17 15:49:15 +03:00
parent 5192ffe5f3
commit 94805c8662
15 changed files with 165 additions and 269 deletions
Download patch file Download diff file Expand all files Collapse all files

47
src/build_visitor.cpp
View file

@ -763,8 +763,8 @@ void BuildVisitor::Visit(SubExpression& node) {
node = std::make_unique<FunctionCallExpression>();
Visit(std::get<std::unique_ptr<FunctionCallExpression>>(node).get());
} else if (current_node_type == parser::tokens::BinaryOperatorExpression) {
node = std::make_unique<BinaryOperatorExpression>();
Visit(std::get<std::unique_ptr<BinaryOperatorExpression>>(node).get());
node = std::make_unique<FunctionCallExpression>();
VisitBinaryOperatorExpression(std::get<std::unique_ptr<FunctionCallExpression>>(node).get());
} else if (current_node_type == parser::tokens::SubExpressionToken) {
node = std::make_unique<SubExpressionToken>();
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
@ -869,38 +869,39 @@ void BuildVisitor::Visit(ScopedStatement* node) {
// Operators
void BuildVisitor::Visit(BinaryOperatorExpression* node) {
void BuildVisitor::VisitBinaryOperatorExpression(FunctionCallExpression* node) {
SetPosition(node->base, current_node_);
auto parse_node = current_node_;
current_node_ = parse_node.ChildByFieldName("left_expression");
Visit(node->left_expression);
node->is_binary_operator_expression = true;
node->arguments.resize(2);
node->operator_name = parse_node.ChildByFieldName("operator_name").GetValue();
current_node_ = parse_node.ChildByFieldName("left_expression");
Visit(node->arguments[0]);
node->name = parse_node.ChildByFieldName("operator_name").GetValue();
{ // remove operator precedence markers
size_t operator_size = 0;
for (; operator_size < node->operator_name.size() && node->operator_name[operator_size] != '.'; ++operator_size) {}
node->precedence = utils::MaxOperatorPrecedence - (node->operator_name.size() - operator_size);
node->operator_name = node->operator_name.substr(0, operator_size);
for (; operator_size < node->name.size() && node->name[operator_size] != '.'; ++operator_size) {}
node->precedence = utils::MaxOperatorPrecedence - (node->name.size() - operator_size);
node->name = node->name.substr(0, operator_size);
}
current_node_ = parse_node.ChildByFieldName("right_expression");
Visit(node->right_expression);
Visit(node->arguments[1]);
// ??
if (std::holds_alternative<std::unique_ptr<BinaryOperatorExpression>>(node->left_expression)
&& std::get<std::unique_ptr<BinaryOperatorExpression>>(node->left_expression)->precedence >= node->precedence) {
error_handling::HandleParsingError("Operators can't be chained", node->base.start_position, node->base.end_position);
}
// ??
if (std::holds_alternative<std::unique_ptr<BinaryOperatorExpression>>(node->right_expression)
&& std::get<std::unique_ptr<BinaryOperatorExpression>>(node->right_expression)->precedence >= node->precedence) {
error_handling::HandleParsingError("Operators can't be chained", node->base.start_position, node->base.end_position);
for (size_t i = 0; i < node->arguments.size(); ++i) {
if (std::holds_alternative<std::unique_ptr<FunctionCallExpression>>(node->arguments[i])) {
FunctionCallExpression* argument_node = std::get<std::unique_ptr<FunctionCallExpression>>(node->arguments[i]).get();
if (argument_node->is_binary_operator_expression
&& argument_node->precedence.has_value()
&& argument_node->precedence.value() >= node->precedence.value()) {
error_handling::HandleParsingError("Operators can't be chained (left argument)", node->base.start_position, node->base.end_position);
}
}
}
current_node_ = parse_node;
@ -991,8 +992,8 @@ void BuildVisitor::Visit(FunctionCallExpression* node) {
node->parameters.push_back(std::make_unique<TypeExpression>());
Visit(node->parameters.back().get());
} else {
node->arguments.emplace_back();
Visit(node->arguments.back());
node->arguments.push_back(std::make_unique<SubExpressionToken>());
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->arguments.back()));
}
}
}