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

grammar refactoring: part of build_visitor fixed

Browse source
This commit is contained in:
ProgramSnail 2023-04-09 18:49:52 +03:00
parent 2d2bb9ec65
commit 64653e6a6a
6 changed files with 245 additions and 404 deletions
Download patch file Download diff file Expand all files Collapse all files

65
include/build_visitor.hpp
View file

@ -16,8 +16,6 @@ public:
}
private:
// // void Visit(Node* node) override;
// Sources -----------------
void Visit(SourceFile* node) override;
@ -31,28 +29,21 @@ private:
// Definitions -----------------
void Visit(ImportStatement* node) override;
void Visit(UsageDefinition* node) override;
void Visit(AliasDefinition* node) override;
void Visit(VariableDefinition* node) override;
void Visit(AliasDefinitionStatement* node) override;
void Visit(VariableDefinitionStatement* node) override;
void Visit(FunctionDeclaration* node) override;
void Visit(FunctionDefinition* node) override;
void Visit(AliasTypeDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(TypeclassDefinition* node) override;
void Visit(FunctionDefinitionStatement* node) override;
void Visit(TypeDefinitionStatement* node) override;
void Visit(AbstractTypeDefinitionStatement* node) override;
void Visit(TypeclassDefinitionStatement* node) override;
void Visit(SourceStatement& node) override; // variant
void Visit(ImportSymbol& node) override; // variant
// Definition parts
void Visit(DefinedName* node) override;
void Visit(DefinedAnnotatedName* node) override;
void Visit(DefinedType* node) override;
void Visit(DefinedTypeclass* node) override;
void Visit(FunctionDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(DefinitionParameter* node) override;
void Visit(DefinitionArgument* node) override;
void Visit(FunctionDeclarationType& node) override; // variant
// Flow control -----------------
@ -68,10 +59,9 @@ private:
// Statements, expressions, blocks, etc. -----------------
void Visit(Block* node) override;
void Visit(ScopedStatement* node) override;
void Visit(BlockStatement& node) override; // variant
void Visit(LoopControlExpression& node) override; // enum
void Visit(Block* node) override;
void Visit(SubExpressionToken& node) override; // variant
void Visit(SubExpression& node) override; // variant
@ -79,29 +69,31 @@ private:
void Visit(Expression& node) override; // variant
void Visit(SuperExpression& node) override; // variant
void Visit(BlockStatement& node) override; // variant
void Visit(ScopedStatement* node) override;
// Operators
void Visit(BinaryOperatorExpression* node) override;
void Visit(UnaryOperatorExpression* node) override;
void Visit(ReferenceExpression* node) override;
// Simple Expressions
void Visit(FunctionCallExpression* node) override;
void Visit(TupleExpression* node) override;
void Visit(VariantExpression* node) override;
void Visit(ReturnExpression* node) override;
void Visit(FunctionArgument& node) override; // variant
// Lambda
void Visit(TupleExpression* node) override;
void Visit(VariantExpression* node) override;
void Visit(ReturnExpression* node) override;
void Visit(TypeConstructor* node) override;
void Visit(LambdaFunction* node) override;
void Visit(ArrayExpression* node) override;
void Visit(LoopControlExpression& node) override; // enum
// Name
void Visit(NameSuperExpression* node) override;
void Visit(NameExpression* node) override;
void Visit(TupleName* node) override;
void Visit(VariantName* node) override;
@ -109,9 +101,11 @@ private:
void Visit(AnyName& node) override; // variant
// Type, typeclass, etc. -----------------
// Type
void Visit(TypeConstructor* node) override;
void Visit(FunctionType* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(AnnotatedType* node) override;
@ -119,18 +113,25 @@ private:
void Visit(TypeExpression* node) override;
void Visit(AnyType& node) override; // variant
void Visit(TypeSubExpression& node) override; // variant
void Visit(TypeParameter& node) override; // variant
void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
void Visit(AnnotatedTypeclass* node) override;
void Visit(ParametrizedTypeclass* node) override;
void Visit(TypeclassExpression* node) override;
void Visit(TypeclassUsage& node) override; // variant
// Typeclass & Type
void Visit(TypeParameter& node) override; // variant
void Visit(TypeSubExpression& node) override; // variant
// Identifiers, constants, etc. -----------------
void Visit(ExtendedName* node) override;
void Visit(AnyIdentifier* node) override; // std::string
void Visit(FloatNumberLiteral* node) override;
@ -140,7 +141,7 @@ private:
void Visit(Literal& node) override; // variant
void Visit(NameSubSuperExpression& node) override; // variant
void Visit(NameSubExpression& node) override; // variant
private:
const parser::ParseTree& parse_tree_;
parser::ParseTree::Node current_node_;

9
include/interpreter_tree.hpp
View file

@ -215,7 +215,9 @@ using TypeSubExpression = std::variant<
// Comments [IGNORE] -----------------
// Identifiers, constants, etc. -----------------
using ExtendedName = std::string;
struct ExtendedName {
std::string name;
};
struct FloatNumberLiteral;
struct NumberLiteral;
@ -255,7 +257,8 @@ struct Sources {
// ----------------- Namespaces, partittions -----------------
struct Namespace {
enum { Const, Var } modifier;
enum Modifier { Const, Var };
std::optional<Modifier> modifier;
std::optional<ExtendedName> name;
TypeIdentifier type;
std::unique_ptr<Sources> scope;
@ -315,7 +318,7 @@ struct TypeDefinitionStatement {
struct AbstractTypeDefinitionStatement {
enum { Basic, Abstract } modifier;
std::unique_ptr<AnnotatedType> definition;
std::unique_ptr<AnnotatedType> type;
};
struct TypeclassDefinitionStatement {

2
include/print_visitor.hpp
View file

@ -101,6 +101,8 @@ private:
// Identifiers, constants, etc. -----------------
void Visit(ExtendedName* node) override;
void Visit(AnyIdentifier* node) override; // std::string
void Visit(FloatNumberLiteral* node) override;

2
include/visitor.hpp
View file

@ -128,6 +128,8 @@ protected:
// Identifiers, constants, etc. -----------------
virtual void Visit(ExtendedName* node) {}
virtual void Visit(AnyIdentifier* node) {} // std::string
virtual void Visit(FloatNumberLiteral* node) {}

549
src/build_visitor.cpp
View file

@ -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());

22
src/print_visitor.cpp
View file

@ -60,13 +60,17 @@ void PrintVisitor::Visit(Partition* node) {
void PrintVisitor::Visit(Namespace* node) {
out_ << "[Namespace] ";
if (node->name.has_value()) {
switch (node->modifier) {
case Namespace::Const:
out_ << "const ";
break;
case Namespace::Var:
out_ << "var ";
break;
if (node->modifier.has_value()) {
switch (node->modifier.value()) {
case Namespace::Const:
out_ << "const ";
break;
case Namespace::Var:
out_ << "var ";
break;
}
} else {
// error
}
Visit(&node->name.value());
}
@ -647,6 +651,10 @@ void PrintVisitor::Visit(TypeclassExpression* node) {
// Identifiers, constants, etc. -----------------
void PrintVisitor::Visit(ExtendedName* node) {
out_ << "[ExtendedName " << node->name << "] ";
}
void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
out_ << "[Identifier " << *node << "] ";
}