mirror of
https://codeberg.org/ProgramSnail/lang_2023.git
synced 2025-12-06 06:58:45 +00:00
grammar refactoring: printer_visitor fixed
This commit is contained in:
ProgramSnail
parent
77c7ac0b2f
commit
2d2bb9ec65
3 changed files with 344 additions and 317 deletions
|
|
@ -1,15 +1,13 @@
|
|||
// for clangd
|
||||
#include "../include/print_visitor.hpp"
|
||||
#include <ctime>
|
||||
|
||||
namespace interpreter {
|
||||
|
||||
void PrintVisitor::Visit(Node* node) {
|
||||
out_ << "[Node]\n";
|
||||
}
|
||||
|
||||
// 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,22 +17,22 @@ void PrintVisitor::Visit(SourceFile* node) {
|
|||
// error
|
||||
}
|
||||
}
|
||||
out_ << "\nSourceFile)\n";
|
||||
out_ << "\n)\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(Sources* node) {
|
||||
out_ << "(Sources\n\n";
|
||||
out_ << "[Sources](\n";
|
||||
for (auto& statement : node->statements) {
|
||||
Visitor::Visit(statement);
|
||||
}
|
||||
out_ << "\n)\n";
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
// Namespaces, partitions -----------------
|
||||
|
||||
void PrintVisitor::Visit(Partition* node) {
|
||||
out_ << "(Partition ";
|
||||
switch (node->type) {
|
||||
out_ << "[Partition] ";
|
||||
switch (node->name) {
|
||||
case Partition::Test:
|
||||
out_ << "TEST";
|
||||
break;
|
||||
|
|
@ -56,211 +54,213 @@ void PrintVisitor::Visit(Partition* node) {
|
|||
}
|
||||
out_ << " {\n";
|
||||
Visit(node->scope.get());
|
||||
out_ << "} )\n";
|
||||
out_ << "}\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(Namespace* node) {
|
||||
out_ << "(Namespace ";
|
||||
if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
|
||||
if (node->is_const) {
|
||||
out_ << "const ";
|
||||
} else {
|
||||
out_ << "var ";
|
||||
out_ << "[Namespace] ";
|
||||
if (node->name.has_value()) {
|
||||
switch (node->modifier) {
|
||||
case Namespace::Const:
|
||||
out_ << "const ";
|
||||
break;
|
||||
case Namespace::Var:
|
||||
out_ << "var ";
|
||||
break;
|
||||
}
|
||||
Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
|
||||
} else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
|
||||
Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
|
||||
} else {
|
||||
// error
|
||||
Visit(&node->name.value());
|
||||
}
|
||||
Visit(&node->type);
|
||||
out_ << "{\n";
|
||||
Visit(node->scope.get());
|
||||
out_ << "} )\n";
|
||||
out_ << "}\n";
|
||||
}
|
||||
|
||||
// Definitions -----------------
|
||||
|
||||
void PrintVisitor::Visit(ImportStatement* node) {
|
||||
out_ << "(Import \"" << node->module_name << "\" ";
|
||||
if (node->name.has_value()) {
|
||||
out_ << "[Use " << node->name.value() << "] = ";
|
||||
}
|
||||
out_ << "[Import " << node->module_name << "]";
|
||||
if (!node->symbols.empty()) {
|
||||
out_ << '\n';
|
||||
out_ << " (\n";
|
||||
for (auto& symbol : node->symbols) {
|
||||
Visitor::Visit(&symbol);
|
||||
out_ << '\n';
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
for (auto& symbol : node->symbols) {
|
||||
Visitor::Visit(symbol);
|
||||
out_ << '\n';
|
||||
}
|
||||
out_ << ")\n";
|
||||
out_ << '\n';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(UsageDefinition* node) {
|
||||
out_ << "(Usage ";
|
||||
Visit(&node->name);
|
||||
out_ << " = ";
|
||||
Visit(node->import_statement.get());
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AliasDefinition* node) {
|
||||
out_ << "(Alias ";
|
||||
Visit(node->type.get());
|
||||
out_ << " = ";
|
||||
void PrintVisitor::Visit(AliasDefinitionStatement* node) {
|
||||
out_ << "[Alias ";
|
||||
switch (node->modifier) {
|
||||
case AliasDefinitionStatement::Alias:
|
||||
out_ << "alias";
|
||||
break;
|
||||
case AliasDefinitionStatement::Type:
|
||||
out_ << "type";
|
||||
break;
|
||||
case AliasDefinitionStatement::Let:
|
||||
out_ << "let";
|
||||
break;
|
||||
}
|
||||
out_ << ' ';
|
||||
Visit(&node->type);
|
||||
out_ << "] = (";
|
||||
Visit(node->value.get());
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(VariableDefinition* node) {
|
||||
out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
|
||||
Visit(&node->name);
|
||||
out_ << " = ";
|
||||
void PrintVisitor::Visit(VariableDefinitionStatement* node) {
|
||||
out_ << "[Variable ";
|
||||
switch (node->modifier) {
|
||||
case VariableDefinitionStatement::Const:
|
||||
out_ << "const";
|
||||
break;
|
||||
case VariableDefinitionStatement::Var:
|
||||
out_ << "var";
|
||||
break;
|
||||
}
|
||||
out_ << ' ';
|
||||
Visitor::Visit(node->name);
|
||||
out_ << "] = (";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FunctionDeclaration* node) {
|
||||
out_ << "(FunctionDeclaration ";
|
||||
out_ << "[FunctionDeclaration ";
|
||||
Visit(&node->name);
|
||||
out_ << "\n";
|
||||
out_ << "] (";
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
out_ << " : \n";
|
||||
for (auto& argument_type : node->argument_types) {
|
||||
Visitor::Visit(argument_type);
|
||||
out_ << ") : (";
|
||||
Visit(node->type.get());
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FunctionDefinitionStatement* node) {
|
||||
out_ << "[Function] (";
|
||||
Visit(node->definition.get());
|
||||
out_ << ") = (";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeDefinitionStatement* node) {
|
||||
out_ << "[Type ";
|
||||
switch (node->modifier) {
|
||||
case TypeDefinitionStatement::Struct:
|
||||
out_ << "struct";
|
||||
break;
|
||||
case TypeDefinitionStatement::Class:
|
||||
out_ << "class";
|
||||
break;
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FunctionDefinition* node) {
|
||||
out_ << "(Function ";
|
||||
Visit(node->name.get());
|
||||
out_ << " = ";
|
||||
out_ << "] (";
|
||||
Visit(node->definition.get());
|
||||
out_ << ") = (";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AliasTypeDefinition* node) {
|
||||
out_ << "(AliasType ";
|
||||
Visit(node->type.get());
|
||||
out_ << " = ";
|
||||
Visit(node->value.get());
|
||||
void PrintVisitor::Visit(AbstractTypeDefinitionStatement* node) {
|
||||
out_ << "[AbstractType ";
|
||||
switch (node->modifier) {
|
||||
case AbstractTypeDefinitionStatement::Basic:
|
||||
out_ << "basic";
|
||||
break;
|
||||
case AbstractTypeDefinitionStatement::Abstract:
|
||||
out_ << "abstract";
|
||||
break;
|
||||
}
|
||||
out_ << "] (";
|
||||
Visit(node->definition.get());
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeDefinition* node) {
|
||||
out_ << "(Type ";
|
||||
Visit(node->type.get());
|
||||
out_ << " = ";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeclassDefinition* node) {
|
||||
out_ << "(Typeclass ";
|
||||
Visit(node->typeclass.get());
|
||||
void PrintVisitor::Visit(TypeclassDefinitionStatement* node) {
|
||||
out_ << "[Typeclass] (";
|
||||
Visit(node->definition.get());
|
||||
if (!node->requirements.empty()) {
|
||||
out_ << " : \n";
|
||||
out_ << ") : (\n";
|
||||
}
|
||||
for (auto& requirement : node->requirements) {
|
||||
out_ << "& ";
|
||||
Visit(requirement.get());
|
||||
out_ << "\n";
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
// Definition parts
|
||||
|
||||
void PrintVisitor::Visit(DefinedName* node) {
|
||||
out_ << "(DefinedName ";
|
||||
Visit(&node->name);
|
||||
if (!node->parameters.empty()) {
|
||||
out_ << "\n";
|
||||
void PrintVisitor::Visit(FunctionDefinition* node) {
|
||||
out_ << "[FunctionDefinition ";
|
||||
switch (node->modifier) {
|
||||
case FunctionDefinition::Operator:
|
||||
out_ << "operator";
|
||||
break;
|
||||
case FunctionDefinition::Function:
|
||||
out_ << "function";
|
||||
break;
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
out_ << ' ';
|
||||
Visit(&node->name);
|
||||
out_ << "]";
|
||||
if (!node->parameters.empty()) {
|
||||
out_ << " (";
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
if (!node->arguments.empty()) {
|
||||
out_ << " : \n";
|
||||
out_ << " : (";
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(&argument);
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ' ';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinedAnnotatedName* node) {
|
||||
out_ << "(DefinedAnnotatedName ";
|
||||
Visit(&node->name);
|
||||
out_ << " : ";
|
||||
if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
|
||||
Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
|
||||
} else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
|
||||
Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
|
||||
} else {
|
||||
// no annotation
|
||||
}
|
||||
out_ << " )";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinedType* node) {
|
||||
out_ << "(DefinedType ";
|
||||
void PrintVisitor::Visit(TypeDefinition* node) {
|
||||
out_ << "[TypeDefinition] (";
|
||||
Visit(node->type.get());
|
||||
out_ << ')';
|
||||
if (!node->parameters.empty()) {
|
||||
out_ << "\n";
|
||||
out_ << '(';
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (!node->arguments.empty()) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinedTypeclass* node) {
|
||||
out_ << "(DefinedTypeclass ";
|
||||
Visit(node->typeclass.get());
|
||||
if (!node->parameters.empty()) {
|
||||
out_ << "\n";
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (!node->arguments.empty()) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ' ';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinitionParameter* node) {
|
||||
out_ << "(DefinitionParameter " << (!node->typeclasses.empty() > 0 ? "(" : "");
|
||||
out_ << "[DefinitionParameter ";
|
||||
Visit(&node->type);
|
||||
out_ << ' ';
|
||||
for (auto& typeclass : node->typeclasses) {
|
||||
Visit(typeclass.get());
|
||||
out_ << ']';
|
||||
if (!node->typeclasses.empty() > 0) {
|
||||
out_ << " (";
|
||||
for (auto& typeclass : node->typeclasses) {
|
||||
Visitor::Visit(typeclass);
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinitionArgument* node) {
|
||||
out_ << "(DefinitionArgument " << (!node->types.empty() ? "(" : "");
|
||||
Visit(&node->name);
|
||||
out_ << ' ';
|
||||
for (auto& type : node->types) {
|
||||
Visit(type.get());
|
||||
}
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
// Flow control -----------------
|
||||
|
||||
void PrintVisitor::Visit(MatchCase* node) {
|
||||
out_ << "(MatchCase | ";
|
||||
out_ << "[MatchCase | ";
|
||||
Visitor::Visit(node->value);
|
||||
if (node->condition.has_value()) {
|
||||
out_ << " ? ";
|
||||
|
|
@ -270,13 +270,13 @@ void PrintVisitor::Visit(MatchCase* node) {
|
|||
out_ << " -> ";
|
||||
Visitor::Visit(node->statement.value());
|
||||
}
|
||||
out_ << ")\n";
|
||||
out_ << "]\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(Match* node) {
|
||||
out_ << "(Match ";
|
||||
out_ << "[Match] (";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << " with\n";
|
||||
out_ << ") [with] (\n";
|
||||
for (auto& match_case : node->matches) {
|
||||
Visit(&match_case);
|
||||
}
|
||||
|
|
@ -284,80 +284,80 @@ void PrintVisitor::Visit(Match* node) {
|
|||
}
|
||||
|
||||
void PrintVisitor::Visit(Condition* node) {
|
||||
out_ << "(If ";
|
||||
out_ << "[If] (";
|
||||
Visitor::Visit(node->conditions[0]);
|
||||
out_ << " then\n";
|
||||
out_ << ") [then] (\n";
|
||||
Visitor::Visit(node->statements[0]);
|
||||
out_ << '\n';
|
||||
out_ << ')';
|
||||
for (size_t i = 1; i < node->conditions.size(); ++i) {
|
||||
out_ << "elif ";
|
||||
out_ << " [elif] (";
|
||||
Visitor::Visit(node->conditions[i]);
|
||||
out_ << " then\n";
|
||||
out_ << ") [then] (\n";
|
||||
Visitor::Visit(node->statements[i]);
|
||||
out_ << '\n';
|
||||
out_ << ')';
|
||||
}
|
||||
if (node->statements.size() > node->conditions.size()) {
|
||||
out_ << "else ";
|
||||
out_ << " [else] (\n";
|
||||
Visitor::Visit(node->statements[node->conditions.size()]);
|
||||
out_ << '\n';
|
||||
out_ << ')';
|
||||
}
|
||||
out_ << ")\n";
|
||||
out_ << '\n';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DoWhileLoop* node) {
|
||||
out_ << "(DoWhile\n";
|
||||
out_ << "[Do] (\n";
|
||||
Visitor::Visit(node->statement);
|
||||
out_ << "\nwhile\n";
|
||||
out_ << ") [while] (";
|
||||
Visitor::Visit(node->condition);
|
||||
out_ << "\n)\n";
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(WhileLoop* node) {
|
||||
out_ << "(While\n";
|
||||
out_ << "[While] (";
|
||||
Visitor::Visit(node->statement);
|
||||
out_ << "\ndo\n";
|
||||
out_ << ") [do] (\n";
|
||||
Visitor::Visit(node->condition);
|
||||
out_ << "\n)\n";
|
||||
out_ << ")\n";
|
||||
}
|
||||
void PrintVisitor::Visit(ForLoop* node) {
|
||||
out_ << "(For\n";
|
||||
out_ << "[For] (";
|
||||
Visitor::Visit(node->variable);
|
||||
out_ << "\nin\n";
|
||||
out_ << ") [in] (";
|
||||
Visitor::Visit(node->interval);
|
||||
out_ << "\ndo\n";
|
||||
out_ << ") [do] (\n";
|
||||
Visitor::Visit(node->statement);
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(LoopLoop* node) {
|
||||
out_ << "(Loop\n";
|
||||
out_ << "[Loop] (\n";
|
||||
Visitor::Visit(node->statement);
|
||||
out_ << "\nLoop)\n";
|
||||
out_ << ")\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_ << "} )\n";
|
||||
out_ << "}\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(ScopedStatement* node) {
|
||||
out_ << "(Scoped ( ";
|
||||
out_ << "[Scoped] ( ";
|
||||
Visitor::Visit(node->statement);
|
||||
out_ << " ) )\n";
|
||||
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,84 +365,119 @@ void PrintVisitor::Visit(LoopControlExpression& node) { // enum
|
|||
// Operators
|
||||
|
||||
void PrintVisitor::Visit(BinaryOperatorExpression* node) {
|
||||
out_ << "(BinaryOperator ";
|
||||
out_ << "[BinaryOperator] (";
|
||||
Visitor::Visit(node->left_expression);
|
||||
out_ << ' ';
|
||||
out_ << ") [";
|
||||
Visit(&node->operator_name);
|
||||
out_ << ' ';
|
||||
out_ << "] (";
|
||||
Visitor::Visit(node->right_expression);
|
||||
out_ << " )";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(UnaryOperatorExpression* node) {
|
||||
out_ << "(UnaryOperator ";
|
||||
out_ << "[UnaryOperator ";
|
||||
Visit(&node->operator_name);
|
||||
out_ << ' ';
|
||||
out_ << "] (";
|
||||
Visitor::Visit(node->expression);
|
||||
out_ << " )";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
// Simple Expressions
|
||||
void PrintVisitor::Visit(ReferenceExpression* node) {
|
||||
out_ << "[ReferenceExpression ";
|
||||
for (auto& reference : node->references) {
|
||||
switch (reference) {
|
||||
case ReferenceType::Reference:
|
||||
out_ << '~';
|
||||
break;
|
||||
case ReferenceType::UniqueReference:
|
||||
out_ << '@';
|
||||
break;
|
||||
}
|
||||
}
|
||||
out_ << "] (";
|
||||
Visit(node->expression.get());
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
// Other Expressions
|
||||
|
||||
void PrintVisitor::Visit(FunctionCallExpression* node) {
|
||||
out_ << "(FunctionCall ";
|
||||
out_ << "[FunctionCall ";
|
||||
Visit(node->name.get());
|
||||
out_ << ' ';
|
||||
out_ << "] (";
|
||||
for (auto& argument : node->arguments) {
|
||||
Visitor::Visit(argument);
|
||||
out_ << ' ';
|
||||
out_ << ", ";
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TupleExpression* node) {
|
||||
out_ << "(TupleExpression ";
|
||||
out_ << ' ';
|
||||
out_ << "[TupleExpression] (";
|
||||
for (auto& expression : node->expressions) {
|
||||
out_ << "& ";
|
||||
out_ << "&";
|
||||
Visitor::Visit(expression);
|
||||
}
|
||||
out_ << " )\n";
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(VariantExpression* node) {
|
||||
out_ << "(VariantExpression ";
|
||||
out_ << ' ';
|
||||
out_ << "[VariantExpression] (";
|
||||
for (auto& expression : node->expressions) {
|
||||
out_ << "& ";
|
||||
out_ << "|";
|
||||
Visitor::Visit(expression);
|
||||
}
|
||||
out_ << " )\n";
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(ReturnExpression* node) {
|
||||
out_ << "(Return ";
|
||||
out_ << "[Return] (";
|
||||
Visitor::Visit(node->expression);
|
||||
out_ << " )\n";
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
// Lambda
|
||||
void PrintVisitor::Visit(TypeConstructor* node) {
|
||||
out_ << "[TypeConstructor ";
|
||||
Visit(node->type.get());
|
||||
out_ << "]\n(";
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(¶meter.first);
|
||||
out_ << " = ";
|
||||
Visitor::Visit(parameter.second);
|
||||
out_ << ")\n(";
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(LambdaFunction* node) {
|
||||
out_ << "(LambdaFunction \\ ";
|
||||
out_ << "[LambdaFunction] (";
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (!node->parameters.empty()) {
|
||||
out_ << " : ";
|
||||
out_ << ") : (";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
Visit(&argument);
|
||||
}
|
||||
out_ << " -> ";
|
||||
out_ << ") -> (\n";
|
||||
Visitor::Visit(node->expression);
|
||||
out_ << " )\n";
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(ArrayExpression* node) {
|
||||
out_ << "[ArrayExpression] ([";
|
||||
for (auto& element : node->elements) {
|
||||
Visitor::Visit(element);
|
||||
out_ << ';';
|
||||
}
|
||||
out_ << "])";
|
||||
}
|
||||
|
||||
// Name
|
||||
|
||||
void PrintVisitor::Visit(NameSuperExpression* node) {
|
||||
out_ << "(NameSuperExpression ";
|
||||
void PrintVisitor::Visit(NameExpression* node) {
|
||||
out_ << "[NameExpression] (";
|
||||
for (auto& variable_namespace : node->namespaces) {
|
||||
Visitor::Visit(variable_namespace);
|
||||
out_ << '.';
|
||||
|
|
@ -453,191 +488,183 @@ void PrintVisitor::Visit(NameSuperExpression* node) {
|
|||
out_ << '.';
|
||||
}
|
||||
}
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(NameExpression* node) {
|
||||
out_ << "(NameExpression ";
|
||||
for (auto& variable_namespace : node->namespaces) {
|
||||
Visitor::Visit(variable_namespace);
|
||||
out_ << '.';
|
||||
}
|
||||
for (size_t i = 0; i < node->names.size(); ++i) {
|
||||
Visit(&node->names[i]);
|
||||
if (i + 1 < node->names.size()) {
|
||||
out_ << '.';
|
||||
}
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TupleName* node) {
|
||||
out_ << "(TupleName ";
|
||||
out_ << "[TupleName] (";
|
||||
for (auto& name : node->names) {
|
||||
out_ << '&';
|
||||
Visit(name.get());
|
||||
out_ << "& ";
|
||||
Visitor::Visit(name);
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(VariantName* node) {
|
||||
out_ << "(VariantName ";
|
||||
out_ << "[VariantName] (";
|
||||
for (auto& name : node->names) {
|
||||
out_ << '|';
|
||||
Visit(name.get());
|
||||
out_ << "| ";
|
||||
Visitor::Visit(name);
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AnnotatedName* node) {
|
||||
out_ << "(AnnotatedName ";
|
||||
out_ << "[AnnotatedName ";
|
||||
Visit(&node->name);
|
||||
out_ << ']';
|
||||
if (node->type.has_value()) {
|
||||
out_ << " : ";
|
||||
Visit(node->type.value().get());
|
||||
out_ << " : (";
|
||||
Visitor::Visit(node->type.value());
|
||||
out_ << ')';
|
||||
}
|
||||
out_ << " )";
|
||||
}
|
||||
|
||||
// Type, typeclass, etc. -----------------
|
||||
|
||||
// Type
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructor* node) {
|
||||
out_ << "(TypeConstructor ";
|
||||
Visit(node->type.get());
|
||||
out_ << '\n';
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(¶meter.first);
|
||||
out_ << " = ";
|
||||
Visitor::Visit(parameter.second);
|
||||
out_ << '\n';
|
||||
void PrintVisitor::Visit(FunctionType* node) {
|
||||
out_ << "[FunctionType] (";
|
||||
bool first = true;
|
||||
for (auto& type : node->types) {
|
||||
if (!first) {
|
||||
out_ << " -> ";
|
||||
}
|
||||
first = false;
|
||||
Visitor::Visit(type);
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TupleType* node) {
|
||||
out_ << "(TupleType ";
|
||||
out_ << "[TupleType ";
|
||||
if (node->type.has_value()) {
|
||||
Visit(&node->type.value());
|
||||
}
|
||||
out_ << ' ';
|
||||
out_ << "] (";
|
||||
for (auto& entity : node->entities) {
|
||||
out_ << "& ";
|
||||
if (entity.first.has_value()) {
|
||||
Visit(&entity.first.value());
|
||||
out_ << " : ";
|
||||
}
|
||||
Visitor::Visit(entity.second);
|
||||
Visit(entity.second.get());
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(VariantType* node) {
|
||||
out_ << "(VariantType ";
|
||||
out_ << "[VariantType ";
|
||||
if (node->type.has_value()) {
|
||||
Visit(&node->type.value());
|
||||
}
|
||||
out_ << ' ';
|
||||
out_ << "] (";
|
||||
for (auto& constructor : node->constructors) {
|
||||
out_ << "| ";
|
||||
if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
|
||||
Visit(&std::get<TypeIdentifierDefinition>(constructor));
|
||||
if (std::holds_alternative<Constructor>(constructor)) {
|
||||
Visit(&std::get<Constructor>(constructor));
|
||||
} else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
|
||||
Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
}
|
||||
out_ << ")";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AnnotatedType* node) {
|
||||
out_ << "(AnnotatedType ";
|
||||
out_ << "[AnnotatedType ";
|
||||
Visit(node->type_expression.get());
|
||||
out_ << ']';
|
||||
if (!node->annotations.empty()) {
|
||||
out_ << " :";
|
||||
out_ << " : (";
|
||||
for (auto& annotation : node->annotations) {
|
||||
Visitor::Visit(annotation);
|
||||
}
|
||||
out_ << ')';
|
||||
}
|
||||
for (auto& annotation : node->annotations) {
|
||||
out_ << " ";
|
||||
Visit(annotation.get());
|
||||
}
|
||||
out_ << ")";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(ParametrizedType* node) {
|
||||
out_ << "(ParametrizedType ";
|
||||
out_ << "[ParametrizedType] (";
|
||||
Visit(node->type_expression.get());
|
||||
for (auto& parameter : node->parameters) {
|
||||
out_ << ' ';
|
||||
Visitor::Visit(parameter);
|
||||
}
|
||||
out_ << " )";
|
||||
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_ << " )";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(ExtendedScopedAnyType* node) {
|
||||
out_ << "[ExtendedScopedAnyType ";
|
||||
for (auto& reference : node->references) {
|
||||
switch (reference) {
|
||||
case ReferenceType::Reference:
|
||||
out_ << '~';
|
||||
break;
|
||||
case ReferenceType::UniqueReference:
|
||||
out_ << '@';
|
||||
break;
|
||||
}
|
||||
}
|
||||
out_ << "] (";
|
||||
Visitor::Visit(node->type);
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
// Typeclass
|
||||
|
||||
void PrintVisitor::Visit(AnnotatedTypeclass* node) {
|
||||
out_ << "(AnnotatedTypeclass ";
|
||||
Visit(node->typeclass_expression.get());
|
||||
if (!node->annotations.empty()) {
|
||||
out_ << " :";
|
||||
}
|
||||
for (auto& annotation : node->annotations) {
|
||||
out_ << " ";
|
||||
Visit(annotation.get());
|
||||
}
|
||||
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_ << " )";
|
||||
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_ << " )";
|
||||
out_ << ')';
|
||||
}
|
||||
|
||||
// Identifiers, constants, etc. -----------------
|
||||
|
||||
void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
|
||||
out_ << "(Identifier " << *node << " )";
|
||||
out_ << "[Identifier " << *node << "] ";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FloatNumberLiteral* node) {
|
||||
out_ << "(FloatNumber " << 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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue