mirror of
https://codeberg.org/ProgramSnail/lang_2023.git
synced 2025-12-08 16:08:45 +00:00
grammar refactoring: part of build_visitor fixed
This commit is contained in:
ProgramSnail
parent
2d2bb9ec65
commit
64653e6a6a
6 changed files with 245 additions and 404 deletions
|
|
@ -1,6 +1,7 @@
|
|||
#include <iostream>
|
||||
|
||||
#include <memory>
|
||||
#include <sched.h>
|
||||
|
||||
// for clangd
|
||||
#include "../include/build_visitor.hpp"
|
||||
|
|
@ -47,25 +48,28 @@ void BuildVisitor::Visit(Sources* node) {
|
|||
|
||||
// Namespaces, partitions -----------------
|
||||
|
||||
void BuildVisitor::Visit(Partition* node) {
|
||||
void BuildVisitor::Visit(Namespace* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
std::string name = parse_node.ChildByFieldName("name").GetValue();
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (name == "TEST") {
|
||||
node->type = Partition::Test;
|
||||
} else if (name == "INTERFACE") {
|
||||
node->type = Partition::Interface;
|
||||
} else if (name == "CORE") {
|
||||
node->type = Partition::Core;
|
||||
} else if (name == "LIB") {
|
||||
node->type = Partition::Lib;
|
||||
} else if (name == "MODULE") {
|
||||
node->type = Partition::Module;
|
||||
} else if (name == "EXE") {
|
||||
node->type = Partition::Exe;
|
||||
if (child_count > 2) {
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
|
||||
std::string modifier = parse_node.NthChild(1).GetValue();
|
||||
if (modifier == "const") {
|
||||
node->modifier = Namespace::Const;
|
||||
} else if (modifier == "var") {
|
||||
node->modifier = Namespace::Var;
|
||||
}
|
||||
|
||||
node->name = ExtendedName();
|
||||
Visit(&node->name.value());
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
Visit(&node->type);
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("scope");
|
||||
node->scope = std::make_unique<Sources>();
|
||||
Visit(node->scope.get());
|
||||
|
|
@ -73,28 +77,23 @@ void BuildVisitor::Visit(Partition* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(Namespace* node) {
|
||||
void BuildVisitor::Visit(Partition* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
std::string name = parse_node.ChildByFieldName("name").GetValue();
|
||||
|
||||
auto current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::DefinedAnnotatedName) {
|
||||
std::string name_modifier = parse_node.NthChild(1).GetValue(); // TODO
|
||||
if (name_modifier == "const") {
|
||||
node->is_const = true;
|
||||
} else if (name_modifier == "var") {
|
||||
node->is_const = false;
|
||||
}
|
||||
|
||||
node->name = std::make_unique<DefinedAnnotatedName>();
|
||||
Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
|
||||
} else if (current_node_type == parser::tokens::DefinedType) {
|
||||
node->is_const = false; // TODO
|
||||
|
||||
node->name = std::make_unique<DefinedType>();
|
||||
Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
|
||||
if (name == "TEST") {
|
||||
node->name = Partition::Test;
|
||||
} else if (name == "INTERFACE") {
|
||||
node->name = Partition::Interface;
|
||||
} else if (name == "CORE") {
|
||||
node->name = Partition::Core;
|
||||
} else if (name == "LIB") {
|
||||
node->name = Partition::Lib;
|
||||
} else if (name == "MODULE") {
|
||||
node->name = Partition::Module;
|
||||
} else if (name == "EXE") {
|
||||
node->name = Partition::Exe;
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("scope");
|
||||
|
|
@ -109,41 +108,54 @@ void BuildVisitor::Visit(Namespace* node) {
|
|||
void BuildVisitor::Visit(ImportStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t excluded_child_count = 0;
|
||||
|
||||
if (parse_node.NthChild(0).GetValue() == "use") {
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
++excluded_child_count;
|
||||
}
|
||||
|
||||
auto module_name_node = parse_node.ChildByFieldName("module_name");
|
||||
node->module_name = module_name_node.NthChild(1).GetValue(); // open string literal
|
||||
node->module_name = module_name_node.NthChild(1).GetValue();
|
||||
++excluded_child_count;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->symbols.resize(child_count - 1);
|
||||
if (child_count > excluded_child_count) {
|
||||
node->symbols.resize(child_count - excluded_child_count);
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(node->symbols[i]);
|
||||
for (size_t i = 0; i < child_count - excluded_child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + excluded_child_count);
|
||||
Visit(&node->symbols[i]);
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(UsageDefinition* node) {
|
||||
void BuildVisitor::Visit(AliasDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
std::string modifier = parse_node.NthChild(0).GetValue();
|
||||
if (modifier == "alias") {
|
||||
node->modifier = AliasDefinitionStatement::Alias;
|
||||
} else if (modifier == "type") {
|
||||
node->modifier = AliasDefinitionStatement::Type;
|
||||
} else if (modifier == "let") {
|
||||
node->modifier = AliasDefinitionStatement::Let;
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("import_statement");
|
||||
node->import_statement = std::make_unique<ImportStatement>();
|
||||
Visit(node->import_statement.get());
|
||||
node->type = parse_node.ChildByFieldName("type").GetValue();
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
void BuildVisitor::Visit(AliasDefinition* node) {
|
||||
auto parse_node = current_node_;
|
||||
if (child_count > 2) {
|
||||
node->parameters.resize(child_count - 2);
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<DefinedType>();
|
||||
Visit(node->type.get());
|
||||
for (size_t i = 0; i + 2 < child_count; ++i) {
|
||||
node->parameters[i] = parse_node.NthNamedChild(i + 1).GetValue();
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
node->value = std::make_unique<ParametrizedType>();
|
||||
|
|
@ -152,17 +164,18 @@ void BuildVisitor::Visit(AliasDefinition* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(VariableDefinition* node) {
|
||||
void BuildVisitor::Visit(VariableDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
std::string name_modifier = parse_node.NthChild(0).GetValue();
|
||||
if (name_modifier == "const") {
|
||||
node->is_const = true;
|
||||
} else if (name_modifier == "var") {
|
||||
node->is_const = false;
|
||||
std::string modifier = parse_node.NthChild(0).GetValue();
|
||||
if (modifier == "const") {
|
||||
node->modifier = VariableDefinitionStatement::Const;
|
||||
} else if (modifier == "var") {
|
||||
node->modifier = VariableDefinitionStatement::Var;
|
||||
}
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
Visit(node->name);
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
Visit(node->value);
|
||||
|
|
@ -177,35 +190,24 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
|
|||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
bool parameters_ended = false;
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
|
||||
parameters_ended = true;
|
||||
}
|
||||
|
||||
if (!parameters_ended) {
|
||||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
} else {
|
||||
node->argument_types.emplace_back();
|
||||
Visit(node->argument_types.back());
|
||||
}
|
||||
}
|
||||
for (size_t i = 0; i + 2 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
Visit(node->type.get());
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(FunctionDefinition* node) {
|
||||
void BuildVisitor::Visit(FunctionDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
node->name = std::make_unique<DefinedName>();
|
||||
Visit(node->name.get());
|
||||
current_node_ = parse_node.ChildByFieldName("definition");
|
||||
node->definition = std::make_unique<FunctionDefinition>();
|
||||
Visit(node->definition.get());
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
Visit(node->value);
|
||||
|
|
@ -213,33 +215,19 @@ void BuildVisitor::Visit(FunctionDefinition* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(AliasTypeDefinition* node) {
|
||||
void BuildVisitor::Visit(TypeDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<DefinedType>();
|
||||
Visit(node->type.get());
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
node->value = std::make_unique<ParametrizedType>();
|
||||
Visit(node->value.get());
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeDefinition* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
std::string type_modifier = parse_node.NthChild(0).GetValue(); // TODO
|
||||
if (type_modifier == "class") {
|
||||
node->is_class = true;
|
||||
} else if (type_modifier == "struct") {
|
||||
node->is_class = false;
|
||||
std::string modifier = parse_node.NthChild(0).GetValue();
|
||||
if (modifier == "class") {
|
||||
node->modifier = TypeDefinitionStatement::Class;
|
||||
} else if (modifier == "struct") {
|
||||
node->modifier = TypeDefinitionStatement::Struct;
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<DefinedType>();
|
||||
Visit(node->type.get());
|
||||
current_node_ = parse_node.ChildByFieldName("definition");
|
||||
node->definition = std::make_unique<TypeDefinition>();
|
||||
Visit(node->definition.get());
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
Visit(node->value);
|
||||
|
|
@ -247,19 +235,36 @@ void BuildVisitor::Visit(TypeDefinition* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeclassDefinition* node) {
|
||||
void BuildVisitor::Visit(AbstractTypeDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("typeclass");
|
||||
node->typeclass = std::make_unique<DefinedTypeclass>();
|
||||
Visit(node->typeclass.get());
|
||||
std::string modifier = parse_node.NthChild(0).GetValue();
|
||||
if (modifier == "basic") {
|
||||
node->modifier = AbstractTypeDefinitionStatement::Basic;
|
||||
} else if (modifier == "abstract") {
|
||||
node->modifier = AbstractTypeDefinitionStatement::Abstract;
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<AnnotatedType>();
|
||||
Visit(node->type.get());
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeclassDefinitionStatement* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("definition");
|
||||
node->definition = std::make_unique<TypeDefinition>();
|
||||
Visit(node->definition.get());
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->requirements.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
node->requirements[i] = std::make_unique<FunctionDeclaration>();
|
||||
Visit(node->requirements[i].get());
|
||||
|
|
@ -281,30 +286,24 @@ void BuildVisitor::Visit(SourceStatement& node) {
|
|||
if (current_node_type == parser::tokens::ImportStatement) { // optimize ??
|
||||
node = std::make_unique<ImportStatement>();
|
||||
Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::UsageDefinition) {
|
||||
node = std::make_unique<UsageDefinition>();
|
||||
Visit(std::get<std::unique_ptr<UsageDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::AliasDefinition) {
|
||||
node = std::make_unique<AliasDefinition>();
|
||||
Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::VariableDefinition) {
|
||||
node = std::make_unique<VariableDefinition>();
|
||||
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::AliasDefinitionStatement) {
|
||||
node = std::make_unique<AliasDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<AliasDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::FunctionDeclaration) {
|
||||
node = std::make_unique<FunctionDeclaration>();
|
||||
Visit(std::get<std::unique_ptr<FunctionDeclaration>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::FunctionDefinition) {
|
||||
node = std::make_unique<FunctionDefinition>();
|
||||
Visit(std::get<std::unique_ptr<FunctionDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::AliasTypeDefinition) {
|
||||
node = std::make_unique<AliasTypeDefinition>();
|
||||
Visit(std::get<std::unique_ptr<AliasTypeDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TypeDefinition) {
|
||||
node = std::make_unique<TypeDefinition>();
|
||||
Visit(std::get<std::unique_ptr<TypeDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TypeclassDefinition) {
|
||||
node = std::make_unique<TypeclassDefinition>();
|
||||
Visit(std::get<std::unique_ptr<TypeclassDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::FunctionDefinitionStatement) {
|
||||
node = std::make_unique<FunctionDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<FunctionDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TypeDefinitionStatement) {
|
||||
node = std::make_unique<TypeDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<TypeDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::AbstractTypeDefinitionStatement) {
|
||||
node = std::make_unique<AbstractTypeDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<AbstractTypeDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TypeclassDefinitionStatement) {
|
||||
node = std::make_unique<TypeclassDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<TypeclassDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::Namespace) {
|
||||
node = std::make_unique<Namespace>();
|
||||
Visit(std::get<std::unique_ptr<Namespace>>(node).get());
|
||||
|
|
@ -315,44 +314,25 @@ void BuildVisitor::Visit(SourceStatement& node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(ImportSymbol& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
|
||||
node = std::make_unique<TypeclassExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TypeExpression) {
|
||||
node = std::make_unique<TypeExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::NameExpression) {
|
||||
node = std::make_unique<NameExpression>();
|
||||
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
// Definition parts
|
||||
|
||||
void BuildVisitor::Visit(DefinedName* node) {
|
||||
void BuildVisitor::Visit(FunctionDefinition* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue(); // TODO: check on operator
|
||||
|
||||
node->is_operator = (parse_node.NthChild(0).GetValue() == "("); // TODO
|
||||
if (parse_node.NthChild(0).GetValue() == "(") {
|
||||
node->modifier = FunctionDefinition::Operator;
|
||||
} else {
|
||||
node->modifier = FunctionDefinition::Function;
|
||||
}
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
bool parameters_ended = false;
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
|
||||
|
|
@ -363,8 +343,8 @@ void BuildVisitor::Visit(DefinedName* node) {
|
|||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
} else {
|
||||
node->arguments.push_back(std::make_unique<DefinitionArgument>());
|
||||
Visit(node->arguments.back().get());
|
||||
node->arguments.emplace_back();
|
||||
Visit(&node->arguments.back());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -372,30 +352,7 @@ void BuildVisitor::Visit(DefinedName* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(DefinedAnnotatedName* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
current_node_ = parse_node.NthNamedChild(1);
|
||||
|
||||
auto current_node_type = current_node_.GetType();
|
||||
if (current_node_type == parser::tokens::DefinedType) {
|
||||
node->type = std::make_unique<DefinedType>();
|
||||
Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
|
||||
} else if (current_node_type == parser::tokens::DefinedTypeclass) {
|
||||
node->type = std::make_unique<DefinedTypeclass>();
|
||||
Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(DefinedType* node) {
|
||||
void BuildVisitor::Visit(TypeDefinition* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
|
|
@ -405,54 +362,10 @@ void BuildVisitor::Visit(DefinedType* node) {
|
|||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
bool parameters_ended = false;
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
|
||||
parameters_ended = true;
|
||||
}
|
||||
|
||||
if (!parameters_ended) {
|
||||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
} else {
|
||||
node->arguments.push_back(std::make_unique<DefinitionArgument>());
|
||||
Visit(node->arguments.back().get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(DefinedTypeclass* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("typeclass");
|
||||
node->typeclass = std::make_unique<AnnotatedTypeclass>();
|
||||
Visit(node->typeclass.get());
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
bool parameters_ended = false;
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
|
||||
parameters_ended = true;
|
||||
}
|
||||
|
||||
if (!parameters_ended) {
|
||||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
} else {
|
||||
node->arguments.push_back(std::make_unique<DefinitionArgument>());
|
||||
Visit(node->arguments.back().get());
|
||||
}
|
||||
node->parameters.push_back(std::make_unique<DefinitionParameter>());
|
||||
Visit(node->parameters.back().get());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -469,83 +382,16 @@ void BuildVisitor::Visit(DefinitionParameter* node) {
|
|||
if (child_count > 1) {
|
||||
node->typeclasses.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
node->typeclasses[i] = std::make_unique<ParametrizedTypeclass>();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
|
||||
node->typeclasses[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
|
||||
Visit(node->typeclasses[i]->typeclass_expression.get());
|
||||
} else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
|
||||
Visit(node->typeclasses[i].get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
Visit(node->typeclasses[i]);
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(DefinitionArgument* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->types.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
node->types[i] = std::make_unique<ParametrizedType>();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeExpression) { // optimize ??
|
||||
node->types[i]->type_expression = std::make_unique<TypeExpression>();
|
||||
Visit(node->types[i]->type_expression.get());
|
||||
} else if (current_node_type == parser::tokens::ParametrizedType) {
|
||||
Visit(node->types[i].get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(FunctionDeclarationType& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::ParametrizedType) { // optimize ??
|
||||
node = std::make_unique<ParametrizedType>();
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TupleType) {
|
||||
node = std::make_unique<TupleType>();
|
||||
Visit(std::get<std::unique_ptr<TupleType>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::VariantType) {
|
||||
node = std::make_unique<VariantType>();
|
||||
Visit(std::get<std::unique_ptr<VariantType>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
|
||||
node = std::make_unique<ParametrizedTypeclass>();
|
||||
Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
// TODO <-- fixes ended there
|
||||
|
||||
// Flow control -----------------
|
||||
|
||||
|
|
@ -558,7 +404,7 @@ void BuildVisitor::Visit(MatchCase* node) {
|
|||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
std::string prefix = parse_node.NthChild(2).GetValue(); // TODO
|
||||
std::string prefix = parse_node.NthChild(2).GetValue();
|
||||
|
||||
if (child_count > 2 || prefix == "?") {
|
||||
current_node_ = parse_node.ChildByFieldName("condition");
|
||||
|
|
@ -742,9 +588,9 @@ void BuildVisitor::Visit(SubExpressionToken& node) {
|
|||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::NameSuperExpression) { // optimize ??
|
||||
node = std::make_unique<NameSuperExpression>();
|
||||
Visit(std::get<std::unique_ptr<NameSuperExpression>>(node).get());
|
||||
if (current_node_type == parser::tokens::NameExpression) { // optimize ??
|
||||
node = std::make_unique<NameExpression>();
|
||||
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ScopedStatement) {
|
||||
node = std::make_unique<ScopedStatement>();
|
||||
Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
|
||||
|
|
@ -867,12 +713,9 @@ void BuildVisitor::Visit(BlockStatement& node) {
|
|||
if (current_node_type == parser::tokens::Expression) { // optimize ??
|
||||
node = std::make_unique<Expression>();
|
||||
Visit(*std::get<std::unique_ptr<Expression>>(node));
|
||||
} else if (current_node_type == parser::tokens::AliasDefinition) {
|
||||
node = std::make_unique<AliasDefinition>();
|
||||
Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::VariableDefinition) {
|
||||
node = std::make_unique<VariableDefinition>();
|
||||
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::VariableDefinitionStatement) {
|
||||
node = std::make_unique<VariableDefinitionStatement>();
|
||||
Visit(std::get<std::unique_ptr<VariableDefinitionStatement>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::FlowControl) {
|
||||
node = std::make_unique<FlowControl>();
|
||||
Visit(*std::get<std::unique_ptr<FlowControl>>(node));
|
||||
|
|
@ -919,7 +762,7 @@ void BuildVisitor::Visit(FunctionCallExpression* node) {
|
|||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
node->name = std::make_unique<NameSuperExpression>();
|
||||
node->name = std::make_unique<NameExpression>();
|
||||
Visit(node->name.get());
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
|
@ -1032,7 +875,7 @@ void BuildVisitor::Visit(LambdaFunction* node) {
|
|||
|
||||
// Name
|
||||
|
||||
void BuildVisitor::Visit(NameSuperExpression* node) {
|
||||
void BuildVisitor::Visit(NameExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
|
@ -1075,33 +918,6 @@ void BuildVisitor::Visit(NameSuperExpression* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(NameExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
bool types_ended = false;
|
||||
|
||||
for (size_t i = 0; i < child_count - 1; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i);
|
||||
|
||||
if (current_node_.GetType() != parser::tokens::TypeSubExpression) {
|
||||
types_ended = true;
|
||||
}
|
||||
|
||||
if (!types_ended) {
|
||||
node->namespaces.emplace_back();
|
||||
Visit(node->namespaces.back());
|
||||
} else {
|
||||
node->names.push_back(current_node_.GetValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TupleName* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
|
|
@ -1174,27 +990,27 @@ void BuildVisitor::Visit(AnyName& node) {
|
|||
// Type
|
||||
|
||||
void BuildVisitor::Visit(TypeConstructor* node) {
|
||||
// auto parse_node = current_node_;
|
||||
//
|
||||
// current_node_ = parse_node.ChildByFieldName("type");
|
||||
// node->type = std::make_unique<ParametrizedType>();
|
||||
// Visit(node->type.get());
|
||||
//
|
||||
// size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
|
||||
//
|
||||
// node->parameters.resize(parameter_count);
|
||||
//
|
||||
// for (size_t i = 0; i < parameter_count * 2; ++i) {
|
||||
// current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
//
|
||||
// if (i % 2 == 0) {
|
||||
// node->parameters[i / 2].first = current_node_.GetValue();
|
||||
// } else {
|
||||
// Visit(node->parameters[i / 2].second);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// current_node_ = parse_node;
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<ParametrizedType>();
|
||||
Visit(node->type.get());
|
||||
|
||||
size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
|
||||
|
||||
node->parameters.resize(parameter_count);
|
||||
|
||||
for (size_t i = 0; i < parameter_count * 2; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (i % 2 == 0) {
|
||||
node->parameters[i / 2].first = current_node_.GetValue();
|
||||
} else {
|
||||
Visit(node->parameters[i / 2].second);
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TupleType* node) {
|
||||
|
|
@ -1204,7 +1020,7 @@ void BuildVisitor::Visit(TupleType* node) {
|
|||
|
||||
current_node_ = parse_node.NthNamedChild(current_node_n);
|
||||
|
||||
if (current_node_.GetType() == parser::tokens::TypeIdentifierDefinition) {
|
||||
if (current_node_.GetType() == parser::tokens::Constructor) {
|
||||
node->type = current_node_.GetValue(); // TODO check
|
||||
|
||||
++current_node_n;
|
||||
|
|
@ -1237,7 +1053,7 @@ void BuildVisitor::Visit(VariantType* node) {
|
|||
|
||||
current_node_ = parse_node.NthNamedChild(current_node_n);
|
||||
|
||||
if (current_node_.GetType() == parser::tokens::TypeIdentifierDefinition) {
|
||||
if (current_node_.GetType() == parser::tokens::Constructor) {
|
||||
node->type = current_node_.GetValue(); // TODO check
|
||||
|
||||
++current_node_n;
|
||||
|
|
@ -1484,9 +1300,18 @@ void BuildVisitor::Visit(TypeclassExpression* node) {
|
|||
|
||||
// Identifiers, constants, etc. -----------------
|
||||
|
||||
void BuildVisitor::Visit(ExtendedName* node) { // TODO: check
|
||||
size_t child_count = current_node_.NamedChildCount();
|
||||
if (child_count > 1) {
|
||||
node->name = current_node_.GetValue();
|
||||
} else {
|
||||
node->name = current_node_.NthNamedChild(0).GetValue();
|
||||
}
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(AnyIdentifier* node) { // std::string
|
||||
*node = current_node_.GetValue();
|
||||
} // TODO use in other places ??
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(FloatNumberLiteral* node) {
|
||||
node->value = std::stod(current_node_.GetValue());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue