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

partition syntax changed, interface modifier added

Browse source
This commit is contained in:
ProgramSnail 2023-05-07 22:58:15 +03:00
parent 3fca384446
commit b1aff1935d
22 changed files with 299 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

136
src/build_visitor.cpp
View file

@ -32,43 +32,6 @@ void BuildVisitor::Visit(SourceFile* node) {
// Namespaces, partitions -----------------
void BuildVisitor::Visit(PartitionSources* node) {
SetPosition(node->base, current_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) {
SetPosition(node->base, current_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) {
SetPosition(node->base, current_node_);
@ -208,6 +171,13 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
auto parse_node = current_node_;
// ['decl'] ['interface'] name
if (parse_node.NthChild(0).GetValue() == "decl") {
node->is_in_interface = (parse_node.NthChild(1).GetValue() == "interface");
} else {
node->is_in_interface = false;
}
node->name.name = parse_node.ChildByFieldName("name").GetValue();
size_t child_count = parse_node.NamedChildCount();
@ -233,8 +203,6 @@ void BuildVisitor::Visit(FunctionDefinitionStatement* node) {
auto parse_node = current_node_;
node->is_inline = (parse_node.NthChild(1).GetValue() == "inline");
current_node_ = parse_node.ChildByFieldName("definition");
node->definition = std::make_unique<FunctionDefinition>();
Visit(node->definition.get());
@ -257,6 +225,8 @@ void BuildVisitor::Visit(TypeDefinitionStatement* node) {
node->modifier = utils::ClassModifier::Struct;
}
node->is_in_interface = (parse_node.NthChild(1).GetValue() == "interface");
current_node_ = parse_node.ChildByFieldName("definition");
node->definition = std::make_unique<TypeDefinition>();
Visit(node->definition.get());
@ -310,6 +280,30 @@ void BuildVisitor::Visit(TypeclassDefinitionStatement* node) {
current_node_ = parse_node;
}
void BuildVisitor::Visit(PartitionStatement* node) {
SetPosition(node->base, current_node_);
auto parse_node = current_node_;
std::string partition_modifier = parse_node.NthChild(0).GetValue();
if (partition_modifier == "exec") {
node->modifier = utils::PartitionModifier::Exec;
} else if (partition_modifier == "test") {
node->modifier = utils::PartitionModifier::Test;
} else {
// error
}
current_node_ = parse_node.ChildByFieldName("name");
Visit(&node->name);
current_node_ = parse_node.ChildByFieldName("value");
Visit(node->value);
current_node_ = parse_node;
}
//
void BuildVisitor::Visit(NamespaceStatement& node) {
@ -331,6 +325,9 @@ void BuildVisitor::Visit(NamespaceStatement& 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::PartitionStatement) {
node = std::make_unique<PartitionStatement>();
Visit(std::get<std::unique_ptr<PartitionStatement>>(node).get());
} else if (current_node_type == parser::tokens::Namespace) {
node = std::make_unique<Namespace>();
Visit(std::get<std::unique_ptr<Namespace>>(node).get());
@ -341,29 +338,6 @@ void BuildVisitor::Visit(NamespaceStatement& node) {
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::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_;
@ -374,12 +348,15 @@ 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::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 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::NamespaceStatement) {
node = std::make_unique<NamespaceStatement>();
Visit(*std::get<std::unique_ptr<NamespaceStatement>>(node));
} else {
// error
}
@ -1167,6 +1144,25 @@ void BuildVisitor::Visit(LoopControlExpression& node) {
// Name
void BuildVisitor::Visit(PartitionName* node) {
SetPosition(node->base, current_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) {
node->path[i] = parse_node.NthNamedChild(i).GetValue();
}
}
node->name = parse_node.ChildByFieldName("name").GetValue();
current_node_ = parse_node;
}
void BuildVisitor::Visit(NameExpression* node) {
SetPosition(node->base, current_node_);
@ -1176,8 +1172,8 @@ 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]);
current_node_ = parse_node.NthNamedChild(i);
Visit(&node->names[i]);
}
current_node_ = parse_node;