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

debug

Browse source
This commit is contained in:
ProgramSnail 2023-03-31 12:10:12 +03:00
parent 582ad5668e
commit 0d62ae0814
29 changed files with 99479 additions and 1166 deletions
Download patch file Download diff file Expand all files Collapse all files

133
src/build_visitor.cpp
View file

@ -1,8 +1,10 @@
#include <iostream>
#include <memory>
// forclangd
#include "../include/build_visitor.hpp"
#include "../include/parse_token_types.hpp"
#include <bits/utility.h>
#include <memory>
namespace interpreter {
@ -77,6 +79,7 @@ void BuildVisitor::Visit(Namespace* node) {
auto current_node_ = parse_node.ChildByFieldName("name");
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") {
@ -254,10 +257,11 @@ void BuildVisitor::Visit(TypeclassDefinition* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->requirements.resize(child_count - 1, std::make_unique<FunctionDeclaration>());
node->requirements.resize(child_count - 1);
for (size_t i = 0; i < child_count - 1; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->requirements[i] = std::make_unique<FunctionDeclaration>();
Visit(node->requirements[i].get());
}
}
@ -463,12 +467,23 @@ void BuildVisitor::Visit(DefinitionParameter* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->typeclasses.resize(child_count - 1, std::make_unique<ParametrizedTypeclass>());
node->typeclasses.resize(child_count - 1);
for (size_t i = 0; i < child_count - 1; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
Visit(node->typeclasses[i].get());
// choose between typeclass_expression and parametrized_typeclass
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
}
}
}
@ -483,12 +498,23 @@ void BuildVisitor::Visit(DefinitionArgument* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->types.resize(child_count - 1, std::make_unique<ParametrizedType>());
node->types.resize(child_count - 1);
for (size_t i = 0; i < child_count - 1; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
Visit(node->types[i].get());
// choose between type_expression and parametrized_type
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
}
}
}
@ -1079,10 +1105,11 @@ void BuildVisitor::Visit(TupleName* node) {
size_t names_count = parse_node.NamedChildCount();
node->names.resize(names_count, std::make_unique<AnnotatedName>());
node->names.resize(names_count);
for (size_t i = 0; i < names_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
node->names[i] = std::make_unique<AnnotatedName>();
Visit(node->names[i].get());
}
@ -1094,10 +1121,11 @@ void BuildVisitor::Visit(VariantName* node) {
size_t names_count = parse_node.NamedChildCount();
node->names.resize(names_count, std::make_unique<AnnotatedName>());
node->names.resize(names_count);
for (size_t i = 0; i < names_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
node->names[i] =std::make_unique<AnnotatedName>();
Visit(node->names[i].get());
}
@ -1109,7 +1137,7 @@ void BuildVisitor::Visit(AnnotatedName* node) {
node->name = parse_node.ChildByFieldName("name").GetValue();
if (parse_node.ChildCount() > 1) {
if (parse_node.NamedChildCount() > 1) {
current_node_ = parse_node.ChildByFieldName("type");
node->type = std::make_unique<ParametrizedType>();
Visit(node->type.value().get());
@ -1144,27 +1172,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) {
@ -1245,11 +1273,23 @@ void BuildVisitor::Visit(AnnotatedType* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->annotations.resize(child_count - 1, std::make_unique<ParametrizedTypeclass>());
node->annotations.resize(child_count - 1);
for (size_t i = 0; i < child_count - 1; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
current_node_ = parse_node.NthNamedChild(i + 1);
std::string current_node_type = current_node_.GetType();
node->annotations[i] = std::make_unique<ParametrizedTypeclass>();
if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
node->annotations[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
Visit(node->annotations[i]->typeclass_expression.get());
} else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
Visit(node->annotations[i].get());
} else {
// error
}
}
}
@ -1296,7 +1336,7 @@ void BuildVisitor::Visit(TypeExpression* node) {
current_node_ = parse_node;
}
void BuildVisitor::Visit(AnyType& node) {
void BuildVisitor::Visit(AnyType& node) { // Or ScopedAnyType
auto parse_node = current_node_;
current_node_ = parse_node.NthNamedChild(0);
@ -1349,7 +1389,10 @@ void BuildVisitor::Visit(TypeParameter& node) {
std::string current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::ParametrizedType) { // optimize ??
if (current_node_type == parser::tokens::TypeExpression) { // optimize ??
node = std::make_unique<TypeExpression>();
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
} else if (current_node_type == parser::tokens::ParametrizedType) {
node = std::make_unique<ParametrizedType>();
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
} else if (current_node_type == parser::tokens::Expression) {
@ -1374,11 +1417,23 @@ void BuildVisitor::Visit(AnnotatedTypeclass* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->annotations.resize(child_count - 1, std::make_unique<ParametrizedTypeclass>());
node->annotations.resize(child_count - 1);
for (size_t i = 0; i < child_count - 1; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
Visit(node->annotations[i].get());
std::string current_node_type = current_node_.GetType();
node->annotations[i] = std::make_unique<ParametrizedTypeclass>();
if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
node->annotations[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
Visit(node->annotations[i]->typeclass_expression.get());
} else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
Visit(node->annotations[i].get());
} else {
// error
}
}
}

40
src/main.cpp Normal file
View file

@ -0,0 +1,40 @@
#include <fstream>
#include <iostream>
#include <sstream>
// for clangd
#include "../include/parse_tree.hpp"
#include "../include/interpreter_tree.hpp"
#include "../include/build_visitor.hpp"
#include "../include/print_visitor.hpp"
int main(int argc, char** argv) { // TODO, only test version
if (argc < 2 || argc > 2) {
std::cout << "Wrong argument count (provide one argument - source file)\n";
return 0;
}
std::string filename = argv[1];
std::ifstream in;
in.open(filename); // TODO handle errors
std::stringstream source_stream;
source_stream << in.rdbuf();
in.close();
std::string source = source_stream.str();
parser::ParseTree parse_tree(source);
std::unique_ptr<interpreter::tokens::SourceFile> source_file =
std::make_unique<interpreter::tokens::SourceFile>();
interpreter::BuildVisitor build_visitor(parse_tree);
interpreter::PrintVisitor print_visitor(std::cout);
build_visitor.VisitSourceFile(source_file.get());
//print_visitor.VisitSourceFile(source_file.get());
}

12
src/node.cpp
View file

@ -1,12 +0,0 @@
// for clangd
#include "../include/node.hpp"
#include "../include/visitor.hpp"
namespace interpreter {
/*void Node::Accept(Visitor* visitor) {
visitor->Visit(this);
}*/
} // namespace interpreter

98452
src/parser.c Normal file
View file

File diff suppressed because it is too large Load diff

218
src/print_visitor.cpp
View file

@ -9,7 +9,7 @@ void PrintVisitor::Visit(Node* node) {
// Sources -----------------
void PrintVisitor::Visit(SourceFile* node) {
out_ << "<SourceFile>\n\n";
out_ << "(SourceFile\n\n";
for (auto& statement : node->statements) {
if (std::holds_alternative<Partition>(statement)) {
Visit(&std::get<Partition>(statement));
@ -19,21 +19,21 @@ void PrintVisitor::Visit(SourceFile* node) {
// error
}
}
out_ << "\n<SourceFile/>";
out_ << "\nSourceFile)\n";
}
void PrintVisitor::Visit(Sources* node) {
out_ << "<Sources>\n\n";
out_ << "(Sources\n\n";
for (auto& statement : node->statements) {
Visitor::Visit(statement);
}
out_ << "\n</Sources>";
out_ << "\n)\n";
}
// Namespaces, partittions -----------------
void PrintVisitor::Visit(Partition* node) {
out_ << "<Partition> ";
out_ << "(Partition ";
switch (node->type) {
case Partition::Test:
out_ << "TEST";
@ -56,11 +56,11 @@ void PrintVisitor::Visit(Partition* node) {
}
out_ << " {\n";
Visit(node->scope.get());
out_ << "} </Partition>\n";
out_ << "} )\n";
}
void PrintVisitor::Visit(Namespace* node) {
out_ << "<Namespace> ";
out_ << "(Namespace ";
if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
if (node->is_const) {
out_ << "const ";
@ -75,13 +75,13 @@ void PrintVisitor::Visit(Namespace* node) {
}
out_ << "{\n";
Visit(node->scope.get());
out_ << "} </Namespace>\n";
out_ << "} )\n";
}
// Definitions -----------------
void PrintVisitor::Visit(ImportStatement* node) {
out_ << "<Import> \"" << node->module_name << "\" ";
out_ << "(Import \"" << node->module_name << "\" ";
if (node->symbols.size() > 0) {
out_ << '\n';
}
@ -89,35 +89,35 @@ void PrintVisitor::Visit(ImportStatement* node) {
Visitor::Visit(symbol);
out_ << '\n';
}
out_ << "</Import>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(UsageDefinition* node) {
out_ << "<Usage> ";
out_ << "(Usage ";
Visit(&node->name);
out_ << " = ";
Visit(node->import_statement.get());
out_ << "</Usage>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(AliasDefinition* node) {
out_ << "<Alias> ";
out_ << "(Alias ";
Visit(node->type.get());
out_ << " = ";
Visit(node->value.get());
out_ << "</Alias>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(VariableDefinition* node) {
out_ << "<Variable> " << (node->is_const ? "const" : "var") << ' ';
out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
Visit(&node->name);
out_ << " = ";
Visitor::Visit(node->value);
out_ << "</Variable>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(FunctionDeclaration* node) {
out_ << "<FunctionDeclaration> ";
out_ << "(FunctionDeclaration ";
Visit(&node->name);
out_ << "\n";
for (auto& parameter : node->parameters) {
@ -127,35 +127,35 @@ void PrintVisitor::Visit(FunctionDeclaration* node) {
for (auto& argument_type : node->argument_types) {
Visitor::Visit(argument_type);
}
out_ << "</FunctionDeclaration>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(FunctionDefinition* node) {
out_ << "<Function> ";
out_ << "(Function ";
Visit(node->name.get());
out_ << " = ";
Visitor::Visit(node->value);
out_ << "</Function>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(AliasTypeDefinition* node) {
out_ << "<AliasType> ";
out_ << "(AliasType ";
Visit(node->type.get());
out_ << " = ";
Visit(node->value.get());
out_ << "</AliasType>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(TypeDefinition* node) {
out_ << "<Type> ";
out_ << "(Type ";
Visit(node->type.get());
out_ << " = ";
Visitor::Visit(node->value);
out_ << "</Type>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(TypeclassDefinition* node) {
out_ << "<Typeclass> ";
out_ << "(Typeclass ";
Visit(node->typeclass.get());
if (node->requirements.size() > 0) {
out_ << " : \n";
@ -164,13 +164,13 @@ void PrintVisitor::Visit(TypeclassDefinition* node) {
out_ << "& ";
Visit(requirement.get());
}
out_ << "</Typeclass>\n";
out_ << ")\n";
}
// Definition parts
void PrintVisitor::Visit(DefinedName* node) {
out_ << "<DefinedName> ";
out_ << "(DefinedName ";
Visit(&node->name);
if (node->parameters.size() > 0) {
out_ << "\n";
@ -184,11 +184,11 @@ void PrintVisitor::Visit(DefinedName* node) {
for (auto& argument : node->arguments) {
Visit(argument.get());
}
out_ << "</DefinedName>\n";
out_ << ")";
}
void PrintVisitor::Visit(DefinedAnnotatedName* node) {
out_ << "<DefinedAnnotatedName> ";
out_ << "(DefinedAnnotatedName ";
Visit(&node->name);
out_ << " : ";
if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
@ -198,11 +198,11 @@ void PrintVisitor::Visit(DefinedAnnotatedName* node) {
} else {
// no annotation
}
out_ << " </DefinedAnnotatedName>";
out_ << " )";
}
void PrintVisitor::Visit(DefinedType* node) {
out_ << "<DefinedType> ";
out_ << "(DefinedType ";
Visit(node->type.get());
if (node->parameters.size() > 0) {
out_ << "\n";
@ -216,11 +216,11 @@ void PrintVisitor::Visit(DefinedType* node) {
for (auto& argument : node->arguments) {
Visit(argument.get());
}
out_ << "</DefinedType>\n";
out_ << ")";
}
void PrintVisitor::Visit(DefinedTypeclass* node) {
out_ << "<DefinedTypeclass> ";
out_ << "(DefinedTypeclass ";
Visit(node->typeclass.get());
if (node->parameters.size() > 0) {
out_ << "\n";
@ -234,33 +234,33 @@ void PrintVisitor::Visit(DefinedTypeclass* node) {
for (auto& argument : node->arguments) {
Visit(argument.get());
}
out_ << "</DefinedTypeclass>\n";
out_ << ")";
}
void PrintVisitor::Visit(DefinitionParameter* node) {
out_ << "<DefinitionParameter> " << (node->typeclasses.size() > 0 ? "(" : "");
out_ << "(DefinitionParameter " << (node->typeclasses.size() > 0 ? "(" : "");
Visit(&node->type);
out_ << ' ';
for (auto& typeclass : node->typeclasses) {
Visit(typeclass.get());
}
out_ << "</DefinitionParamater>\n";
out_ << ")";
}
void PrintVisitor::Visit(DefinitionArgument* node) {
out_ << "<DefinitionArgument> " << (node->types.size() > 0 ? "(" : "");
out_ << "(DefinitionArgument " << (node->types.size() > 0 ? "(" : "");
Visit(&node->name);
out_ << ' ';
for (auto& type : node->types) {
Visit(type.get());
}
out_ << "</DefinitionArgument>\n";
out_ << ")";
}
// Flow control -----------------
void PrintVisitor::Visit(MatchCase* node) {
out_ << "<MatchCase> | ";
out_ << "(MatchCase | ";
Visitor::Visit(node->value);
if (node->condition.has_value()) {
out_ << " ? ";
@ -270,21 +270,21 @@ void PrintVisitor::Visit(MatchCase* node) {
out_ << " -> ";
Visitor::Visit(node->statement.value());
}
out_ << "</MatchCase>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(Match* node) {
out_ << "<Match> ";
out_ << "(Match ";
Visitor::Visit(node->value);
out_ << " with\n";
for (auto& match_case : node->matches) {
Visit(&match_case);
}
out_ << "</Match>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(Condition* node) {
out_ << "<If> ";
out_ << "(If ";
Visitor::Visit(node->conditions[0]);
out_ << " then\n";
Visitor::Visit(node->statements[0]);
@ -301,63 +301,63 @@ void PrintVisitor::Visit(Condition* node) {
Visitor::Visit(node->statements[node->conditions.size()]);
out_ << '\n';
}
out_ << "</If>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(DoWhileLoop* node) {
out_ << "<DoWhile>\n";
out_ << "(DoWhile\n";
Visitor::Visit(node->statement);
out_ << "\nwhile\n";
Visitor::Visit(node->condition);
out_ << "\n</DoWhile>\n";
out_ << "\n)\n";
}
void PrintVisitor::Visit(WhileLoop* node) {
out_ << "<While>\n";
out_ << "(While\n";
Visitor::Visit(node->statement);
out_ << "\ndo\n";
Visitor::Visit(node->condition);
out_ << "\n</While>\n";
out_ << "\n)\n";
}
void PrintVisitor::Visit(ForLoop* node) {
out_ << "<For>\n";
out_ << "(For\n";
Visitor::Visit(node->variable);
out_ << "\nin\n";
Visitor::Visit(node->interval);
out_ << "\ndo\n";
Visitor::Visit(node->statement);
out_ << "</For>\n";
out_ << ")\n";
}
void PrintVisitor::Visit(LoopLoop* node) {
out_ << "<Loop>\n";
out_ << "(Loop\n";
Visitor::Visit(node->statement);
out_ << "<\n/Loop>\n";
out_ << "\nLoop)\n";
}
// Statements, expressions, blocks, etc. -----------------
void PrintVisitor::Visit(Block* node) {
out_ << "<Block> {\n";
out_ << "(Block {\n";
for (auto& statement : node->statements) {
Visitor::Visit(statement);
}
out_ << "} </Block>\n";
out_ << "} )\n";
}
void PrintVisitor::Visit(ScopedStatement* node) {
out_ << "<Scoped> ( ";
out_ << "(Scoped ( ";
Visitor::Visit(node->statement);
out_ << " ) </Scoped>";
out_ << " ) )\n";
}
void PrintVisitor::Visit(LoopControlExpression& node) { // enum
switch (node) {
case LoopControlExpression::Break:
out_ << "<Break/>\n";
out_ << "(Break/>\n";
break;
case LoopControlExpression::Continue:
out_ << "<Continue/>\n";
out_ << "(Continue/>\n";
break;
}
}
@ -365,66 +365,66 @@ void PrintVisitor::Visit(LoopControlExpression& node) { // enum
// Operators
void PrintVisitor::Visit(BinaryOperatorExpression* node) {
out_ << "<BinaryOperator> ";
out_ << "(BinaryOperator ";
Visitor::Visit(node->left_expression);
out_ << ' ';
Visit(&node->operator_name);
out_ << ' ';
Visitor::Visit(node->right_expression);
out_ << " </BinaryOperator>";
out_ << " )";
}
void PrintVisitor::Visit(UnaryOperatorExpression* node) {
out_ << "<UnaryOperator> ";
out_ << "(UnaryOperator ";
Visit(&node->operator_name);
out_ << ' ';
Visitor::Visit(node->expression);
out_ << " </UnaryOperator>";
out_ << " )";
}
// Simple Expressions
void PrintVisitor::Visit(FunctionCallExpression* node) {
out_ << "<FunctionCall> ";
out_ << "(FunctionCall ";
Visit(node->name.get());
out_ << ' ';
for (auto& argument : node->arguments) {
Visitor::Visit(argument);
out_ << ' ';
}
out_ << "</FunctionCall>";
out_ << ")\n";
}
void PrintVisitor::Visit(TupleExpression* node) {
out_ << "<TupleExpression> ";
out_ << "(TupleExpression ";
out_ << ' ';
for (auto& expression : node->expressions) {
out_ << "& ";
Visitor::Visit(expression);
}
out_ << " </TupleExpression>";
out_ << " )\n";
}
void PrintVisitor::Visit(VariantExpression* node) {
out_ << "<VariantExpression> ";
out_ << "(VariantExpression ";
out_ << ' ';
for (auto& expression : node->expressions) {
out_ << "& ";
Visitor::Visit(expression);
}
out_ << " </VariantExpression>";
out_ << " )\n";
}
void PrintVisitor::Visit(ReturnExpression* node) {
out_ << "<Return> ";
out_ << "(Return ";
Visitor::Visit(node->expression);
out_ << " </Return>";
out_ << " )\n";
}
// Lambda
void PrintVisitor::Visit(LambdaFunction* node) {
out_ << "<LambdaFunction> \\ ";
out_ << "(LambdaFunction \\ ";
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
@ -436,73 +436,73 @@ void PrintVisitor::Visit(LambdaFunction* node) {
}
out_ << " -> ";
Visitor::Visit(node->expression);
out_ << " </LambdaFunction>";
out_ << " )\n";
}
// Name
void PrintVisitor::Visit(NameSuperExpression* node) {
out_ << "<NameSuperExpression> ";
out_ << "(NameSuperExpression ";
for (auto& variable_namespace : node->namespaces) {
Visitor::Visit(variable_namespace);
out_ << '.';
}
for (int i = 0; i < node->expressions.size(); ++i) {
for (size_t i = 0; i < node->expressions.size(); ++i) {
Visitor::Visit(node->expressions[i]);
if (i + 1 < node->expressions.size()) {
out_ << '.';
}
}
out_ << "</NameSupperExpression>\n";
out_ << ")";
}
void PrintVisitor::Visit(NameExpression* node) {
out_ << "<NameExpression> ";
out_ << "(NameExpression ";
for (auto& variable_namespace : node->namespaces) {
Visitor::Visit(variable_namespace);
out_ << '.';
}
for (int i = 0; i < node->names.size(); ++i) {
for (size_t i = 0; i < node->names.size(); ++i) {
Visit(&node->names[i]);
if (i + 1 < node->names.size()) {
out_ << '.';
}
}
out_ << "</NameExpression>\n";
out_ << ")";
}
void PrintVisitor::Visit(TupleName* node) {
out_ << "<TupleName> ";
out_ << "(TupleName ";
for (auto& name : node->names) {
out_ << '&';
Visit(name.get());
}
out_ << "</TupleName>\n";
out_ << ")";
}
void PrintVisitor::Visit(VariantName* node) {
out_ << "<VariantName> ";
out_ << "(VariantName ";
for (auto& name : node->names) {
out_ << '|';
Visit(name.get());
}
out_ << "</VariantName>\n";
out_ << ")";
}
void PrintVisitor::Visit(AnnotatedName* node) {
out_ << "<AnnotatedName> ";
out_ << "(AnnotatedName ";
Visit(&node->name);
if (node->type.has_value()) {
out_ << " : ";
Visit(node->type.value().get());
}
out_ << " </AnnotatedName>";
out_ << " )";
}
// Type
void PrintVisitor::Visit(TypeConstructor* node) {
out_ << "<TypeConstructor> ";
out_ << "(TypeConstructor ";
Visit(node->type.get());
out_ << '\n';
for (auto& parameter : node->parameters) {
@ -511,13 +511,13 @@ void PrintVisitor::Visit(TypeConstructor* node) {
Visitor::Visit(parameter.second);
out_ << '\n';
}
out_ << "</TypeConstructor>\n";
out_ << ")";
}
void PrintVisitor::Visit(TupleType* node) {
out_ << "<TupleType> ";
out_ << "(TupleType ";
if (node->type.has_value()) {
Visit(&node->type.value()); // optional
Visit(&node->type.value());
}
out_ << ' ';
for (auto& entity : node->entities) {
@ -528,11 +528,11 @@ void PrintVisitor::Visit(TupleType* node) {
}
Visitor::Visit(entity.second);
}
out_ << "</TupleType>";
out_ << ")";
}
void PrintVisitor::Visit(VariantType* node) {
out_ << "<VariantType> ";
out_ << "(VariantType ";
if (node->type.has_value()) {
Visit(&node->type.value());
}
@ -540,18 +540,18 @@ void PrintVisitor::Visit(VariantType* node) {
for (auto& constructor : node->constructors) {
out_ << "| ";
if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
Visit(&std::get<TypeIdentifierDefinition>(constructor));
Visit(&std::get<TypeIdentifierDefinition>(constructor));
} else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
} else {
// error
}
}
out_ << "</VariantType>";
out_ << ")";
}
void PrintVisitor::Visit(AnnotatedType* node) {
out_ << "<AnnotatedType> ";
out_ << "(AnnotatedType ";
Visit(node->type_expression.get());
if (node->annotations.size() > 0) {
out_ << " :";
@ -560,33 +560,33 @@ void PrintVisitor::Visit(AnnotatedType* node) {
out_ << " ";
Visit(annotation.get());
}
out_ << "</AnnotatedType>";
out_ << ")";
}
void PrintVisitor::Visit(ParametrizedType* node) {
out_ << "<ParametrizedType> ";
out_ << "(ParametrizedType ";
Visit(node->type_expression.get());
for (auto& paramater : node->parameters) {
out_ << ' ';
Visitor::Visit(paramater);
}
out_ << " </ParamtrizedType>";
out_ << " )";
}
void PrintVisitor::Visit(TypeExpression* node) {
out_ << "<TypeExpression> ";
out_ << "(TypeExpression ";
for (auto& type_namespace : node->namespaces) {
Visitor::Visit(type_namespace);
out_ << '.';
}
Visit(&node->type);
out_ << " </TypeExpression>";
out_ << " )";
}
// Typeclass
void PrintVisitor::Visit(AnnotatedTypeclass* node) {
out_ << "<AnnotatedTypeclass> ";
out_ << "(AnnotatedTypeclass ";
Visit(node->typeclass_expression.get());
if (node->annotations.size() > 0) {
out_ << " :";
@ -595,49 +595,49 @@ void PrintVisitor::Visit(AnnotatedTypeclass* node) {
out_ << " ";
Visit(annotation.get());
}
out_ << "</AnnotatedTypeclass>";
out_ << ")";
}
void PrintVisitor::Visit(ParametrizedTypeclass* node) {
out_ << "<ParametrizedTypeclass> ";
out_ << "(ParametrizedTypeclass ";
Visit(node->typeclass_expression.get());
for (auto& paramater : node->parameters) {
out_ << ' ';
Visitor::Visit(paramater);
}
out_ << " </ParamtrizedTypeclass>";
out_ << " )";
}
void PrintVisitor::Visit(TypeclassExpression* node) {
out_ << "<TypeclassExpression> ";
out_ << "(TypeclassExpression ";
for (auto& typeclass_namespace : node->namespaces) {
Visitor::Visit(typeclass_namespace);
out_ << '.';
}
Visit(&node->typeclass);
out_ << " </TypeclassExpression>";
out_ << " )";
}
// Identifiers, constants, etc. -----------------
void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
out_ << "<Identifier " << *node << " />";
out_ << "(Identifier " << *node << " )";
}
void PrintVisitor::Visit(FloatNumberLiteral* node) {
out_ << "<Identifier " << node->value << " />";
out_ << "(FloatNumber " << node->value << " )";
}
void PrintVisitor::Visit(NumberLiteral* node) {
out_ << "<Number " << node->value << " />";
out_ << "(Number " << node->value << " )";
}
void PrintVisitor::Visit(StringLiteral* node) {
out_ << "<String " << node->value << " />";
out_ << "(String " << node->value << " )";
}
void PrintVisitor::Visit(CharLiteral* node) {
out_ << "<Char " << node->value << " />";
out_ << "(Char " << node->value << " )";
}
} // namespace interpreter

7
src/visitor.cpp
View file

@ -265,7 +265,7 @@ void Visitor::Visit(AnyName& node) {
// Type
void Visitor::Visit(AnyType& node) {
void Visitor::Visit(AnyType& node) { // Or ScopedAnyType
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
@ -301,9 +301,12 @@ void Visitor::Visit(TypeSubExpression& node) {
void Visitor::Visit(TypeParameter& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
break;
case 1:
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
break;
case 2:
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
break;
default: