mirror of
https://codeberg.org/ProgramSnail/lang_2023.git
synced 2025-12-07 23:48:43 +00:00
visitor improvements, part of print_visitor
This commit is contained in:
ProgramSnail
parent
41330c5dee
commit
f0a95ee2df
2 changed files with 686 additions and 0 deletions
330
src/print_visitor.cpp
Normal file
330
src/print_visitor.cpp
Normal file
|
|
@ -0,0 +1,330 @@
|
|||
// for clangd
|
||||
#include "../include/print_visitor.hpp"
|
||||
|
||||
namespace interpreter {
|
||||
|
||||
void PrintVisitor::Visit(Node* node) {
|
||||
out_ << "[Node]\n";
|
||||
}
|
||||
|
||||
// Sources -----------------
|
||||
void PrintVisitor::Visit(SourceFile* node) {
|
||||
out_ << "<SourceFile>\n\n";
|
||||
for (auto& statement : node->statements) {
|
||||
if (std::holds_alternative<Partition>(statement)) {
|
||||
Visit(&std::get<Partition>(statement));
|
||||
} else if (std::holds_alternative<SourceStatement>(statement)) {
|
||||
Visitor::Visit(std::get<SourceStatement>(statement));
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
}
|
||||
out_ << "\n<SourceFile/>";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(Sources* node) {
|
||||
out_ << "<Sources>\n\n";
|
||||
for (auto& source_statement : node->statements) {
|
||||
Visitor::Visit(source_statement);
|
||||
}
|
||||
out_ << "\n</Sources>";
|
||||
}
|
||||
|
||||
// Namespaces, partittions -----------------
|
||||
|
||||
void PrintVisitor::Visit(Partition* node) {
|
||||
out_ << "<Partition> ";
|
||||
switch (node->type) {
|
||||
case Partition::Test:
|
||||
out_ << "TEST";
|
||||
break;
|
||||
case Partition::Interface:
|
||||
out_ << "INTERFACE";
|
||||
break;
|
||||
case Partition::Core:
|
||||
out_ << "CORE";
|
||||
break;
|
||||
case Partition::Lib:
|
||||
out_ << "LIB";
|
||||
break;
|
||||
case Partition::Module:
|
||||
out_ << "MODULE";
|
||||
break;
|
||||
case Partition::Exe:
|
||||
out_ << "EXE";
|
||||
break;
|
||||
}
|
||||
out_ << " {\n";
|
||||
Visit(node->scope.get());
|
||||
out_ << "} </Partition>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(Namespace* node) {
|
||||
out_ << "<Namespace> ";
|
||||
if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
|
||||
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
|
||||
}
|
||||
out_ << "{\n";
|
||||
Visit(node->scope.get());
|
||||
out_ << "} </Namespace>\n";
|
||||
}
|
||||
|
||||
// Definitions -----------------
|
||||
|
||||
void PrintVisitor::Visit(ImportStatement* node) {
|
||||
out_ << "<Import> \"" << node->module_name << "\" ";
|
||||
if (node->symbols.size() > 0) {
|
||||
out_ << '\n';
|
||||
}
|
||||
for (auto& symbol : node->symbols) {
|
||||
Visitor::Visit(symbol);
|
||||
out_ << '\n';
|
||||
}
|
||||
out_ << "</Import>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(UsageDefinition* node) {
|
||||
out_ << "<Usage> ";
|
||||
Visit(&node->name);
|
||||
out_ << " = ";
|
||||
Visit(node->import_statement.get());
|
||||
out_ << "</Usage>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AliasDefinition* node) {
|
||||
out_ << "<Alias> ";
|
||||
Visit(node->type.get());
|
||||
out_ << " = ";
|
||||
Visit(node->value.get());
|
||||
out_ << "</Alias>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(VariableDefinition* node) {
|
||||
out_ << "<Variable> " << (node->is_const ? "const" : "var") << ' ';
|
||||
Visit(&node->name);
|
||||
out_ << " = ";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << "</Variable>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FunctionDeclaration* node) {
|
||||
out_ << "<FunctionDeclaration> ";
|
||||
Visit(&node->name);
|
||||
out_ << "\n";
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
out_ << " : \n";
|
||||
for (auto& argument_type : node->argument_types) {
|
||||
Visitor::Visit(argument_type);
|
||||
}
|
||||
out_ << "</FunctionDeclaration>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FunctionDefinition* node) {
|
||||
out_ << "<Function> ";
|
||||
Visit(node->name.get());
|
||||
out_ << " = ";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << "</Function>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(AliasTypeDefinition* node) {
|
||||
out_ << "<AliasType> ";
|
||||
Visit(node->name.get());
|
||||
out_ << " = ";
|
||||
Visit(node->value.get());
|
||||
out_ << "</AliasType>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeDefinition* node) {
|
||||
out_ << "<Type> ";
|
||||
Visit(node->name.get());
|
||||
out_ << " = ";
|
||||
Visitor::Visit(node->value);
|
||||
out_ << "</Type>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeclassDefinition* node) {
|
||||
out_ << "<Typeclass> ";
|
||||
Visit(node->name.get());
|
||||
if (node->requirements.size() > 0) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& requirement : node->requirements) {
|
||||
out_ << "& ";
|
||||
Visit(requirement.get());
|
||||
}
|
||||
out_ << "</Typeclass>\n";
|
||||
}
|
||||
|
||||
// Definition parts
|
||||
|
||||
void PrintVisitor::Visit(DefinedName* node) {
|
||||
out_ << "<DefinedName> ";
|
||||
Visit(&node->name);
|
||||
if (node->parameters.size() > 0) {
|
||||
out_ << "\n";
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (node->arguments.size() > 0) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << "</DefinedName>\n";
|
||||
}
|
||||
|
||||
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_ << " </DefinedAnnotatedName>";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinedType* node) {
|
||||
out_ << "<DefinedType> ";
|
||||
Visit(node->type.get());
|
||||
if (node->parameters.size() > 0) {
|
||||
out_ << "\n";
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (node->arguments.size() > 0) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << "</DefinedType>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinedTypeclass* node) {
|
||||
out_ << "<DefinedTypeclass> ";
|
||||
Visit(node->typeclass.get());
|
||||
if (node->parameters.size() > 0) {
|
||||
out_ << "\n";
|
||||
}
|
||||
for (auto& parameter : node->parameters) {
|
||||
Visit(parameter.get());
|
||||
}
|
||||
if (node->arguments.size() > 0) {
|
||||
out_ << " : \n";
|
||||
}
|
||||
for (auto& argument : node->arguments) {
|
||||
Visit(argument.get());
|
||||
}
|
||||
out_ << "</DefinedTypeclass>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinitionParameter* node) {
|
||||
out_ << "<DefinitionParameter> " << (node->typeclasses.size() > 0 ? "(" : "");
|
||||
Visit(&node->type);
|
||||
out_ << ' ';
|
||||
for (auto& typeclass : node->typeclasses) {
|
||||
Visit(typeclass.get());
|
||||
}
|
||||
out_ << "</DefinitionParamater>\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(DefinitionArgument* node) {
|
||||
out_ << "<DefinitionArgument> " << (node->types.size() > 0 ? "(" : "");
|
||||
Visit(&node->name);
|
||||
out_ << ' ';
|
||||
for (auto& type : node->types) {
|
||||
Visit(type.get());
|
||||
}
|
||||
out_ << "</DefinitionArgument>\n";
|
||||
}
|
||||
|
||||
// Flow control -----------------
|
||||
|
||||
void PrintVisitor::Visit(Match* node) {}
|
||||
void PrintVisitor::Visit(Condition* node) {}
|
||||
void PrintVisitor::Visit(DoWhileLoop* node) {}
|
||||
void PrintVisitor::Visit(WhileLoop* node) {};
|
||||
void PrintVisitor::Visit(ForLoop* node) {};
|
||||
void PrintVisitor::Visit(LoopLoop* node) {};
|
||||
|
||||
// Statements, expressions, blocks, etc. -----------------
|
||||
|
||||
void PrintVisitor::Visit(Block* node) {}
|
||||
void PrintVisitor::Visit(ScopedStatement* node) {}
|
||||
|
||||
// Operators
|
||||
|
||||
void PrintVisitor::Visit(BinaryOperatorExpression* node) {}
|
||||
void PrintVisitor::Visit(UnaryOperatorExpression* node) {}
|
||||
|
||||
// Simple Expressions
|
||||
|
||||
void PrintVisitor::Visit(FunctionCallExpression* node) {}
|
||||
void PrintVisitor::Visit(TupleExpression* node) {}
|
||||
void PrintVisitor::Visit(VariantExpression* node) {}
|
||||
void PrintVisitor::Visit(ReturnExpression* node) {}
|
||||
|
||||
// Lambda
|
||||
|
||||
void PrintVisitor::Visit(LambdaFunction* node) {}
|
||||
|
||||
// Name
|
||||
|
||||
void PrintVisitor::Visit(NameSuperExpression* node) {}
|
||||
void PrintVisitor::Visit(NameExpression* node) {}
|
||||
void PrintVisitor::Visit(TupleName* node) {}
|
||||
void PrintVisitor::Visit(VariantName* node) {}
|
||||
void PrintVisitor::Visit(AnnotatedName* node) {}
|
||||
|
||||
// Type
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructor* node) {}
|
||||
void PrintVisitor::Visit(TupleType* node) {}
|
||||
void PrintVisitor::Visit(VariantType* node) {}
|
||||
void PrintVisitor::Visit(AnnotatedType* node) {}
|
||||
void PrintVisitor::Visit(ParametrizedType* node) {}
|
||||
void PrintVisitor::Visit(TypeExpression* node) {}
|
||||
|
||||
// Typeclass
|
||||
|
||||
void PrintVisitor::Visit(AnnotatedTypeclass* node) {}
|
||||
void PrintVisitor::Visit(ParametrizedTypeclass* node) {}
|
||||
void PrintVisitor::Visit(TypeclassExpression* node) {}
|
||||
|
||||
// Identifiers, constants, etc. -----------------
|
||||
|
||||
void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
|
||||
out_ << "<Identifier " << *node << " />";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(FloatNumberLiteral* node) {
|
||||
out_ << "<Identifier " << node->value << " />";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(NumberLiteral* node) {
|
||||
out_ << "<Number " << node->value << " />";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(StringLiteral* node) {
|
||||
out_ << "<String " << node->value << " />";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(CharLiteral* node) {
|
||||
out_ << "<Char " << node->value << " />";
|
||||
}
|
||||
|
||||
} // namespace interpreter
|
||||
356
src/visitor.cpp
Normal file
356
src/visitor.cpp
Normal file
|
|
@ -0,0 +1,356 @@
|
|||
// for clangd
|
||||
#include "../include/visitor.hpp"
|
||||
|
||||
namespace interpreter {
|
||||
|
||||
// Definitions -----------------
|
||||
|
||||
void Visitor::Visit(SourceStatement& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<UsageDefinition>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
|
||||
break;
|
||||
case 4:
|
||||
Visit(std::get<std::unique_ptr<FunctionDeclaration>>(node).get());
|
||||
break;
|
||||
case 5:
|
||||
Visit(std::get<std::unique_ptr<FunctionDefinition>>(node).get());
|
||||
break;
|
||||
case 6:
|
||||
Visit(std::get<std::unique_ptr<AliasTypeDefinition>>(node).get());
|
||||
break;
|
||||
case 7:
|
||||
Visit(std::get<std::unique_ptr<TypeDefinition>>(node).get());
|
||||
break;
|
||||
case 8:
|
||||
Visit(std::get<std::unique_ptr<TypeclassDefinition>>(node).get());
|
||||
break;
|
||||
case 9:
|
||||
Visit(std::get<std::unique_ptr<Namespace>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(ImportSymbol& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Definition parts
|
||||
|
||||
void Visitor::Visit(FunctionDeclarationType& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TupleType>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<VariantType>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Flow control -----------------
|
||||
|
||||
void Visitor::Visit(FlowControl& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<Match>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<Condition>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<DoWhileLoop>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(std::get<std::unique_ptr<WhileLoop>>(node).get());
|
||||
break;
|
||||
case 4:
|
||||
Visit(std::get<std::unique_ptr<ForLoop>>(node).get());
|
||||
break;
|
||||
case 5:
|
||||
Visit(std::get<std::unique_ptr<LoopLoop>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Statements, expressions, blocks, etc. -----------------
|
||||
|
||||
void Visitor::Visit(SubExpressionToken& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(SubExpression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<FunctionCallExpression>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<BinaryOperatorExpression>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(PrefixedExpression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<ReturnExpression>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<Block>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(Expression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<LambdaFunction>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TypeConstructor>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(std::get<std::unique_ptr<UnaryOperatorExpression>>(node).get());
|
||||
break;
|
||||
case 4:
|
||||
Visit(*std::get<std::unique_ptr<SubExpression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(SuperExpression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TupleExpression>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
void Visitor::Visit(BlockStatement& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
|
||||
break;
|
||||
case 4:
|
||||
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Simple Expressions
|
||||
|
||||
void Visitor::Visit(FunctionArgument& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Name
|
||||
|
||||
void Visitor::Visit(AnyName& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<AnnotatedName>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TupleName>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<VariantName>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Type
|
||||
|
||||
void Visitor::Visit(AnyType& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<TupleType>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<VariantType>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Visitor::Visit(TypeSubExpression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<AnyTypeIdentifier>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
void Visitor::Visit(TypeParameter& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Identifiers, constants, etc. -----------------
|
||||
|
||||
void Visitor::Visit(Literal& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<FloatNumberLiteral>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(std::get<std::unique_ptr<NumberLiteral>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(std::get<std::unique_ptr<StringLiteral>>(node).get());
|
||||
break;
|
||||
case 3:
|
||||
Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
void Visitor::Visit(NameSubSuperExpression& node) {
|
||||
switch (node.index()) {
|
||||
case 0:
|
||||
Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
|
||||
break;
|
||||
case 1:
|
||||
Visit(*std::get<std::unique_ptr<Literal>>(node).get());
|
||||
break;
|
||||
case 2:
|
||||
Visit(*std::get<std::unique_ptr<SuperExpression>>(node).get());
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}; // namespace interpreter
|
||||
Loading…
Add table
Add a link
Reference in a new issue