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

extended name removed, dereference added, unary operators removed, fixes

Browse source
This commit is contained in:
ProgramSnail 2023-05-13 13:11:12 +03:00
parent e62144feac
commit 79bd30c1ee
20 changed files with 101 additions and 274 deletions
Download patch file Download diff file Expand all files Collapse all files

85
src/build_visitor.cpp
View file

@ -1,10 +1,12 @@
#include <iostream>
#include <memory>
#include <variant>
// for clangd
#include "../include/build_visitor.hpp"
#include "../include/parse_token_types.hpp"
#include "../include/error_handling.hpp"
namespace interpreter {
@ -178,7 +180,7 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
node->is_in_interface = false;
}
node->name.name = parse_node.ChildByFieldName("name").GetValue();
node->name = parse_node.ChildByFieldName("name").GetValue();
size_t child_count = parse_node.NamedChildCount();
@ -371,21 +373,14 @@ void BuildVisitor::Visit(FunctionDefinition* node) {
auto parse_node = current_node_;
node->name.name = parse_node.ChildByFieldName("name").GetValue();
if (parse_node.NthChild(0).GetValue() == "(") {
node->modifier = utils::FunctionTypeModifier::Operator;
} else {
node->modifier = utils::FunctionTypeModifier::Function;
}
node->name = parse_node.ChildByFieldName("name").GetValue();
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->arguments.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
Visit(&node->arguments[i]);
node->arguments[i] = parse_node.NthNamedChild(i + 1).GetValue();
}
}
@ -446,10 +441,7 @@ void BuildVisitor::Visit(TypeConstructorPatternParameter* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
current_node_ = parse_node.ChildByFieldName("name"),
node->name.emplace();
Visit(&node->name.value());
node->name.value() = parse_node.ChildByFieldName("name").GetValue();
}
current_node_ = parse_node.ChildByFieldName("value"),
@ -489,9 +481,9 @@ void BuildVisitor::Visit(Pattern& node) { // <-> ScopedPattern
std::string current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::ExtendedName) { // optimize ??
node = std::make_unique<ExtendedName>();
Visit(std::get<std::unique_ptr<ExtendedName>>(node).get());
if (current_node_type == parser::tokens::NameIdentifier) { // optimize ??
node = std::make_unique<NameIdentifier>(current_node_.GetValue());
// Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
} else if (current_node_type == parser::tokens::Literal) {
node = std::make_unique<Literal>();
Visit(*std::get<std::unique_ptr<Literal>>(node));
@ -807,9 +799,6 @@ void BuildVisitor::Visit(Expression& node) {
} else if (current_node_type == parser::tokens::PrefixedExpression) {
node = std::make_unique<PrefixedExpression>();
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
} else if (current_node_type == parser::tokens::UnaryOperatorExpression) {
node = std::make_unique<UnaryOperatorExpression>();
Visit(std::get<std::unique_ptr<UnaryOperatorExpression>>(node).get());
} else if (current_node_type == parser::tokens::SubExpression) {
node = std::make_unique<SubExpression>();
Visit(*std::get<std::unique_ptr<SubExpression>>(node));
@ -872,28 +861,29 @@ void BuildVisitor::Visit(BinaryOperatorExpression* node) {
node->operator_name = parse_node.ChildByFieldName("operator_name").GetValue();
{ // remove operator prescendence markers
{ // 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);
}
current_node_ = parse_node.ChildByFieldName("right_expression");
Visit(node->right_expression);
current_node_ = parse_node;
}
// ??
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);
}
void BuildVisitor::Visit(UnaryOperatorExpression* node) {
SetPosition(node->base, current_node_);
auto parse_node = current_node_;
node->operator_name = parse_node.ChildByFieldName("operator_name").GetValue();
current_node_ = parse_node.ChildByFieldName("expression");
Visit(node->expression);
// ??
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);
}
current_node_ = parse_node;
}
@ -909,10 +899,10 @@ void BuildVisitor::Visit(ReferenceExpression* node) {
node->references.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
std::string reference = parse_node.NthChild(i).GetValue();
if (reference == "~") {
if (reference == "^") {
node->references[i] = utils::ReferenceModifier::Reference;
} else if (reference == "@") {
node->references[i] = utils::ReferenceModifier::UniqueReference;
} else if (reference == "~") {
node->references[i] = utils::ReferenceModifier::Dereference;
}
}
}
@ -964,8 +954,7 @@ void BuildVisitor::Visit(FunctionCallExpression* node) {
// no prefix
}
current_node_ = parse_node.ChildByFieldName("name");
Visit(&node->name);
node->name = parse_node.ChildByFieldName("name").GetValue();
++excluded_child_count;
size_t child_count = parse_node.NamedChildCount();
@ -1046,9 +1035,7 @@ void BuildVisitor::Visit(TypeConstructorParameter* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
current_node_ = parse_node.ChildByFieldName("name");
node->name.emplace();
Visit(&node->name.value());
node->name = parse_node.ChildByFieldName("name").GetValue();
std::string assignment_modifier = current_node_.NextSibling().GetValue();
if (assignment_modifier == "=") {
@ -1109,7 +1096,7 @@ void BuildVisitor::Visit(LambdaFunction* node) {
Visit(node->parameters.back().get());
} else {
node->arguments.emplace_back();
Visit(&node->arguments.back());
node->arguments.back() = current_node_.GetValue();
}
}
}
@ -1179,8 +1166,7 @@ void BuildVisitor::Visit(NameExpression* node) {
node->names.resize(child_count);
for (size_t i = 0; i < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(&node->names[i]);
node->names[i] = parse_node.NthNamedChild(i).GetValue();
}
current_node_ = parse_node;
@ -1301,9 +1287,8 @@ void BuildVisitor::Visit(TupleType* node) {
while (current_node_n < parse_node.NamedChildCount()) {
node->entities.emplace_back();
if (current_node_.GetType() == parser::tokens::ExtendedName) {
node->entities.back().first.emplace();
Visit(&node->entities.back().first.value());
if (current_node_.GetType() == parser::tokens::NameIdentifier) {
node->entities.back().first = current_node_.GetValue();
++current_node_n;
current_node_ = parse_node.NthNamedChild(current_node_n);
@ -1432,7 +1417,7 @@ void BuildVisitor::Visit(ExtendedScopedAnyType* node) {
node->references.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
std::string reference = parse_node.NthChild(i).GetValue();
if (reference == "~") {
if (reference == "^") {
node->references[i] = utils::ReferenceModifier::Reference;
} else if (reference == "@") {
node->references[i] = utils::ReferenceModifier::UniqueReference;
@ -1498,12 +1483,6 @@ void BuildVisitor::Visit(ParametrizedType* node) {
// Identifiers, constants, etc. -----------------
void BuildVisitor::Visit(ExtendedName* node) {
SetPosition(node->base, current_node_);
node->name = current_node_.GetValue();
}
// void BuildVisitor::Visit(AnyIdentifier* node) { // std::string
// *node = current_node_.GetValue();
// }