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

visitor, print_visitor and build_visitor fixed

Browse source
This commit is contained in:
ProgramSnail 2023-04-29 13:44:34 +03:00
parent 776b6cccc6
commit 4d0b527416
9 changed files with 212 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

162
src/build_visitor.cpp
View file

@ -16,30 +16,8 @@ void BuildVisitor::Visit(SourceFile* node) {
node->statements.resize(statement_count);
for (size_t i = 0; i < statement_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
auto current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::SourceStatement) {
node->statements[i].emplace<SourceStatement>();
Visit(std::get<SourceStatement>(node->statements[i]));
} else if (current_node_type == parser::tokens::Partition) {
node->statements[i].emplace<Partition>();
Visit(&std::get<Partition>(node->statements[i]) );
}
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(Sources* node) {
auto parse_node = current_node_;
size_t statement_count = parse_node.NamedChildCount();
node->statements.resize(statement_count);
for (size_t i = 0; i < statement_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(node->statements[i]);
current_node_ = parse_node.NthNamedChild(i);
Visit(node->statements[i]);
}
current_node_ = parse_node;
@ -47,6 +25,53 @@ void BuildVisitor::Visit(Sources* node) {
// Namespaces, partitions -----------------
void BuildVisitor::Visit(PartitionSources* node) {
auto parse_node = current_node_;
size_t statement_count = parse_node.NamedChildCount();
node->statements.resize(statement_count);
for (size_t i = 0; i < statement_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(node->statements[i]);
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(Partition* node) {
auto parse_node = current_node_;
std::string name = parse_node.ChildByFieldName("name").GetValue();
if (name == "TEST") {
node->name = Partition::Test;
} else if (name == "INTERFACE") {
node->name = Partition::Interface;
} else if (name == "CODE") {
node->name = Partition::Code;
}
current_node_ = parse_node.ChildByFieldName("scope");
Visit(&node->scope);
current_node_ = parse_node;
}
void BuildVisitor::Visit(NamespaceSources* node) {
auto parse_node = current_node_;
size_t statement_count = parse_node.NamedChildCount();
node->statements.resize(statement_count);
for (size_t i = 0; i < statement_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(node->statements[i]);
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(Namespace* node) {
auto parse_node = current_node_;
@ -65,28 +90,7 @@ void BuildVisitor::Visit(Namespace* node) {
Visit(&node->type);
current_node_ = parse_node.ChildByFieldName("scope");
node->scope = std::make_unique<Sources>();
Visit(node->scope.get());
current_node_ = parse_node;
}
void BuildVisitor::Visit(Partition* node) {
auto parse_node = current_node_;
std::string name = parse_node.ChildByFieldName("name").GetValue();
if (name == "TEST") {
node->name = Partition::Test;
} else if (name == "INTERFACE") {
node->name = Partition::Interface;
} else if (name == "CODE") {
node->name = Partition::Code;
}
current_node_ = parse_node.ChildByFieldName("scope");
node->scope = std::make_unique<Sources>();
Visit(node->scope.get());
Visit(&node->scope);
current_node_ = parse_node;
}
@ -279,17 +283,14 @@ void BuildVisitor::Visit(TypeclassDefinitionStatement* node) {
//
void BuildVisitor::Visit(SourceStatement& node) {
void BuildVisitor::Visit(NamespaceStatement& 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::ImportStatement) { // optimize ??
node = std::make_unique<ImportStatement>();
Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
} else if (current_node_type == parser::tokens::AliasDefinitionStatement) {
if (current_node_type == parser::tokens::AliasDefinitionStatement) { // optimize ??
node = std::make_unique<AliasDefinitionStatement>();
Visit(std::get<std::unique_ptr<AliasDefinitionStatement>>(node).get());
} else if (current_node_type == parser::tokens::FunctionDeclaration) {
@ -301,15 +302,55 @@ void BuildVisitor::Visit(SourceStatement& node) {
} 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) {
} else if (current_node_type == parser::tokens::Namespace) {
node = std::make_unique<Namespace>();
Visit(std::get<std::unique_ptr<Namespace>>(node).get());
} else {
// error
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(PartitionStatement& 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::AbstractTypeDefinitionStatement) { // optimize ??
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());
} else if (current_node_type == parser::tokens::NamespaceStatement) {
node = std::make_unique<NamespaceStatement>();
Visit(*std::get<std::unique_ptr<NamespaceStatement>>(node));
} else {
// error
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(SourceStatement& 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::ImportStatement) { // optimize ??
node = std::make_unique<ImportStatement>();
Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
} else if (current_node_type == parser::tokens::Partition) {
node = std::make_unique<Partition>();
Visit(std::get<std::unique_ptr<Partition>>(node).get());
} else if (current_node_type == parser::tokens::PartitionStatement) {
node = std::make_unique<PartitionStatement>();
Visit(*std::get<std::unique_ptr<PartitionStatement>>(node));
} else {
// error
}
@ -1330,17 +1371,6 @@ void BuildVisitor::Visit(ExtendedScopedAnyType* node) {
void BuildVisitor::Visit(TypeclassExpression* node) {
auto parse_node = current_node_;
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->path.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(node->path[i]);
}
}
current_node_ = parse_node.ChildByFieldName("typeclass");
Visit(node->typeclass);