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

print + build partially tested

Browse source
This commit is contained in:
ProgramSnail 2023-04-02 15:10:32 +03:00
parent 0d62ae0814
commit 15e36c203a
22 changed files with 179 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
src/.build_visitor.cpp.kate-swp Normal file
View file

Binary file not shown.

98
src/build_visitor.cpp
View file

@ -2,7 +2,7 @@
#include <memory>
// forclangd
// for clangd
#include "../include/build_visitor.hpp"
#include "../include/parse_token_types.hpp"
@ -45,7 +45,7 @@ void BuildVisitor::Visit(Sources* node) {
current_node_ = parse_node;
}
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
void BuildVisitor::Visit(Partition* node) {
auto parse_node = current_node_;
@ -76,7 +76,7 @@ void BuildVisitor::Visit(Partition* node) {
void BuildVisitor::Visit(Namespace* node) {
auto parse_node = current_node_;
auto current_node_ = parse_node.ChildByFieldName("name");
current_node_ = parse_node.ChildByFieldName("name");
auto current_node_type = current_node_.GetType();
@ -380,7 +380,7 @@ void BuildVisitor::Visit(DefinedAnnotatedName* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
auto current_node_ = parse_node.NthNamedChild(1);
current_node_ = parse_node.NthNamedChild(1);
auto current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::DefinedType) {
@ -558,7 +558,7 @@ void BuildVisitor::Visit(MatchCase* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
std::string prefix = parse_node.NthChild(3).GetValue(); // TODO
std::string prefix = parse_node.NthChild(2).GetValue(); // TODO
if (child_count > 2 || prefix == "?") {
current_node_ = parse_node.ChildByFieldName("condition");
@ -742,9 +742,9 @@ void BuildVisitor::Visit(SubExpressionToken& node) {
std::string current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::NameExpression) { // optimize ??
node = std::make_unique<NameExpression>();
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
if (current_node_type == parser::tokens::NameSuperExpression) { // optimize ??
node = std::make_unique<NameSuperExpression>();
Visit(std::get<std::unique_ptr<NameSuperExpression>>(node).get());
} else if (current_node_type == parser::tokens::ScopedStatement) {
node = std::make_unique<ScopedStatement>();
Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
@ -770,7 +770,7 @@ void BuildVisitor::Visit(SubExpression& node) {
Visit(std::get<std::unique_ptr<BinaryOperatorExpression>>(node).get());
} else if (current_node_type == parser::tokens::SubExpressionToken) {
node = std::make_unique<SubExpressionToken>();
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
} else {
// error
}
@ -790,7 +790,7 @@ void BuildVisitor::Visit(PrefixedExpression& node) {
Visit(std::get<std::unique_ptr<ReturnExpression>>(node).get());
} else if (current_node_type == parser::tokens::LoopControlExpression) {
node = std::make_unique<LoopControlExpression>();
Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node).get());
Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node));
} else if (current_node_type == parser::tokens::Block) {
node = std::make_unique<Block>();
Visit(std::get<std::unique_ptr<Block>>(node).get());
@ -816,13 +816,13 @@ void BuildVisitor::Visit(Expression& node) {
Visit(std::get<std::unique_ptr<TypeConstructor>>(node).get());
} else if (current_node_type == parser::tokens::PrefixedExpression) {
node = std::make_unique<PrefixedExpression>();
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
} else if (current_node_type == parser::tokens::UnaryOperatorExpression) {
node = std::make_unique<UnaryOperatorExpression>();
Visit(std::get<std::unique_ptr<UnaryOperatorExpression>>(node).get());
} else if (current_node_type == parser::tokens::SubExpression) {
node = std::make_unique<SubExpression>();
Visit(*std::get<std::unique_ptr<SubExpression>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpression>>(node));
} else {
// error
}
@ -839,7 +839,7 @@ void BuildVisitor::Visit(SuperExpression& node) {
if (current_node_type == parser::tokens::FlowControl) { // optimize ??
node = std::make_unique<FlowControl>();
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
Visit(*std::get<std::unique_ptr<FlowControl>>(node));
} else if (current_node_type == parser::tokens::TupleExpression) {
node = std::make_unique<TupleExpression>();
Visit(std::get<std::unique_ptr<TupleExpression>>(node).get());
@ -848,7 +848,7 @@ void BuildVisitor::Visit(SuperExpression& node) {
Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
} else if (current_node_type == parser::tokens::Expression) {
node = std::make_unique<Expression>();
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
Visit(*std::get<std::unique_ptr<Expression>>(node));
} else {
// error
}
@ -866,7 +866,7 @@ 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).get());
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());
@ -875,10 +875,10 @@ void BuildVisitor::Visit(BlockStatement& node) {
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
} else if (current_node_type == parser::tokens::FlowControl) {
node = std::make_unique<FlowControl>();
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
Visit(*std::get<std::unique_ptr<FlowControl>>(node));
} else if (current_node_type == parser::tokens::PrefixedExpression) {
node = std::make_unique<PrefixedExpression>();
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
} else {
// error
}
@ -986,10 +986,10 @@ void BuildVisitor::Visit(FunctionArgument& node) {
if (current_node_type == parser::tokens::SubExpressionToken) { // optimize ??
node = std::make_unique<SubExpressionToken>();
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
} else if (current_node_type == parser::tokens::TypeSubExpression) {
node = std::make_unique<TypeSubExpression>();
Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node).get());
Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node));
} else {
// error
}
@ -1043,7 +1043,7 @@ void BuildVisitor::Visit(NameSuperExpression* node) {
current_node_ = parse_node.NthNamedChild(i);
std::string current_node_type = current_node_.GetType();
if (current_node_type != parser::tokens::TypeSubExpression) {
if (current_node_type != parser::tokens::TypeSubExpression && !namespaces_ended) {
namespaces_ended = true;
if (i + 1 == child_count) {
@ -1053,11 +1053,13 @@ void BuildVisitor::Visit(NameSuperExpression* node) {
node->expressions.back() = std::make_unique<NameIdentifier>(current_node_.GetValue());
} else if (current_node_type == parser::tokens::Literal) {
node->expressions.back() = std::make_unique<Literal>();
Visit(*std::get<std::unique_ptr<Literal>>(node->expressions.back()).get());
Visit(*std::get<std::unique_ptr<Literal>>(node->expressions.back()));
} else {
// error
}
break;
} else {
// error
}
}
@ -1172,27 +1174,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) {
@ -1397,7 +1399,7 @@ void BuildVisitor::Visit(TypeParameter& node) {
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
} else if (current_node_type == parser::tokens::Expression) {
node = std::make_unique<Expression>();
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
Visit(*std::get<std::unique_ptr<Expression>>(node));
} else {
// error
}
@ -1487,11 +1489,11 @@ void BuildVisitor::Visit(AnyIdentifier* node) { // std::string
} // TODO use in other places ??
void BuildVisitor::Visit(FloatNumberLiteral* node) {
node->value = std::stod(current_node_.NthChild(0).GetValue());
node->value = std::stod(current_node_.GetValue());
}
void BuildVisitor::Visit(NumberLiteral* node) {
node->value = std::stoll(current_node_.NthChild(0).GetValue());
node->value = std::stoll(current_node_.GetValue());
}
void BuildVisitor::Visit(StringLiteral* node) {
@ -1536,14 +1538,14 @@ void BuildVisitor::Visit(NameSubSuperExpression& node) {
std::string current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::NameIdentifier) { // optimize ??
node = std::make_unique<NameIdentifier>();
// TODO: choose node = std::make_unique<NameIdentifier>(current_node_.GetValue());
Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
} else if (current_node_type == parser::tokens::Literal) {
node = std::make_unique<Literal>();
Visit(*std::get<std::unique_ptr<Literal>>(node).get());
Visit(*std::get<std::unique_ptr<Literal>>(node));
} else if (current_node_type == parser::tokens::SuperExpression) {
node = std::make_unique<SuperExpression>();
Visit(*std::get<std::unique_ptr<SuperExpression>>(node).get());
Visit(*std::get<std::unique_ptr<SuperExpression>>(node));
} else {
// error
}

2
src/main.cpp
View file

@ -36,5 +36,5 @@ int main(int argc, char** argv) { // TODO, only test version
interpreter::PrintVisitor print_visitor(std::cout);
build_visitor.VisitSourceFile(source_file.get());
//print_visitor.VisitSourceFile(source_file.get());
print_visitor.VisitSourceFile(source_file.get());
}

32
src/print_visitor.cpp
View file

@ -30,7 +30,7 @@ void PrintVisitor::Visit(Sources* node) {
out_ << "\n)\n";
}
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
void PrintVisitor::Visit(Partition* node) {
out_ << "(Partition ";
@ -82,7 +82,7 @@ void PrintVisitor::Visit(Namespace* node) {
void PrintVisitor::Visit(ImportStatement* node) {
out_ << "(Import \"" << node->module_name << "\" ";
if (node->symbols.size() > 0) {
if (!node->symbols.empty()) {
out_ << '\n';
}
for (auto& symbol : node->symbols) {
@ -157,7 +157,7 @@ void PrintVisitor::Visit(TypeDefinition* node) {
void PrintVisitor::Visit(TypeclassDefinition* node) {
out_ << "(Typeclass ";
Visit(node->typeclass.get());
if (node->requirements.size() > 0) {
if (!node->requirements.empty()) {
out_ << " : \n";
}
for (auto& requirement : node->requirements) {
@ -172,13 +172,13 @@ void PrintVisitor::Visit(TypeclassDefinition* node) {
void PrintVisitor::Visit(DefinedName* node) {
out_ << "(DefinedName ";
Visit(&node->name);
if (node->parameters.size() > 0) {
if (!node->parameters.empty()) {
out_ << "\n";
}
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
if (node->arguments.size() > 0) {
if (!node->arguments.empty()) {
out_ << " : \n";
}
for (auto& argument : node->arguments) {
@ -204,13 +204,13 @@ void PrintVisitor::Visit(DefinedAnnotatedName* node) {
void PrintVisitor::Visit(DefinedType* node) {
out_ << "(DefinedType ";
Visit(node->type.get());
if (node->parameters.size() > 0) {
if (!node->parameters.empty()) {
out_ << "\n";
}
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
if (node->arguments.size() > 0) {
if (!node->arguments.empty()) {
out_ << " : \n";
}
for (auto& argument : node->arguments) {
@ -222,13 +222,13 @@ void PrintVisitor::Visit(DefinedType* node) {
void PrintVisitor::Visit(DefinedTypeclass* node) {
out_ << "(DefinedTypeclass ";
Visit(node->typeclass.get());
if (node->parameters.size() > 0) {
if (!node->parameters.empty()) {
out_ << "\n";
}
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
if (node->arguments.size() > 0) {
if (!node->arguments.empty()) {
out_ << " : \n";
}
for (auto& argument : node->arguments) {
@ -238,7 +238,7 @@ void PrintVisitor::Visit(DefinedTypeclass* node) {
}
void PrintVisitor::Visit(DefinitionParameter* node) {
out_ << "(DefinitionParameter " << (node->typeclasses.size() > 0 ? "(" : "");
out_ << "(DefinitionParameter " << (!node->typeclasses.empty() > 0 ? "(" : "");
Visit(&node->type);
out_ << ' ';
for (auto& typeclass : node->typeclasses) {
@ -248,7 +248,7 @@ void PrintVisitor::Visit(DefinitionParameter* node) {
}
void PrintVisitor::Visit(DefinitionArgument* node) {
out_ << "(DefinitionArgument " << (node->types.size() > 0 ? "(" : "");
out_ << "(DefinitionArgument " << (!node->types.empty() ? "(" : "");
Visit(&node->name);
out_ << ' ';
for (auto& type : node->types) {
@ -428,7 +428,7 @@ void PrintVisitor::Visit(LambdaFunction* node) {
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
if (node->parameters.size() > 0) {
if (!node->parameters.empty()) {
out_ << " : ";
}
for (auto& argument : node->arguments) {
@ -553,7 +553,7 @@ void PrintVisitor::Visit(VariantType* node) {
void PrintVisitor::Visit(AnnotatedType* node) {
out_ << "(AnnotatedType ";
Visit(node->type_expression.get());
if (node->annotations.size() > 0) {
if (!node->annotations.empty()) {
out_ << " :";
}
for (auto& annotation : node->annotations) {
@ -566,9 +566,9 @@ void PrintVisitor::Visit(AnnotatedType* node) {
void PrintVisitor::Visit(ParametrizedType* node) {
out_ << "(ParametrizedType ";
Visit(node->type_expression.get());
for (auto& paramater : node->parameters) {
for (auto& parameter : node->parameters) {
out_ << ' ';
Visitor::Visit(paramater);
Visitor::Visit(parameter);
}
out_ << " )";
}
@ -588,7 +588,7 @@ void PrintVisitor::Visit(TypeExpression* node) {
void PrintVisitor::Visit(AnnotatedTypeclass* node) {
out_ << "(AnnotatedTypeclass ";
Visit(node->typeclass_expression.get());
if (node->annotations.size() > 0) {
if (!node->annotations.empty()) {
out_ << " :";
}
for (auto& annotation : node->annotations) {

32
src/visitor.cpp
View file

@ -115,7 +115,7 @@ void Visitor::Visit(FlowControl& node) {
void Visitor::Visit(SubExpressionToken& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
Visit(std::get<std::unique_ptr<NameSuperExpression>>(node).get());
break;
case 1:
Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
@ -135,7 +135,7 @@ void Visitor::Visit(SubExpression& node) {
Visit(std::get<std::unique_ptr<BinaryOperatorExpression>>(node).get());
break;
case 2:
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
break;
default:
// error
@ -149,7 +149,7 @@ void Visitor::Visit(PrefixedExpression& node) {
Visit(std::get<std::unique_ptr<ReturnExpression>>(node).get());
break;
case 1:
Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node).get());
Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node));
break;
case 2:
Visit(std::get<std::unique_ptr<Block>>(node).get());
@ -169,13 +169,13 @@ void Visitor::Visit(Expression& node) {
Visit(std::get<std::unique_ptr<TypeConstructor>>(node).get());
break;
case 2:
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
break;
case 3:
Visit(std::get<std::unique_ptr<UnaryOperatorExpression>>(node).get());
break;
case 4:
Visit(*std::get<std::unique_ptr<SubExpression>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpression>>(node));
break;
default:
// error
@ -186,7 +186,7 @@ void Visitor::Visit(Expression& node) {
void Visitor::Visit(SuperExpression& node) {
switch (node.index()) {
case 0:
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
Visit(*std::get<std::unique_ptr<FlowControl>>(node));
break;
case 1:
Visit(std::get<std::unique_ptr<TupleExpression>>(node).get());
@ -195,7 +195,7 @@ void Visitor::Visit(SuperExpression& node) {
Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
break;
case 3:
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
Visit(*std::get<std::unique_ptr<Expression>>(node));
break;
default:
// error
@ -208,7 +208,7 @@ void Visitor::Visit(SuperExpression& node) {
void Visitor::Visit(BlockStatement& node) {
switch (node.index()) {
case 0:
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
Visit(*std::get<std::unique_ptr<Expression>>(node));
break;
case 1:
Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
@ -217,10 +217,10 @@ void Visitor::Visit(BlockStatement& node) {
Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
break;
case 3:
Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
Visit(*std::get<std::unique_ptr<FlowControl>>(node));
break;
case 4:
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
break;
default:
// error
@ -233,10 +233,10 @@ void Visitor::Visit(BlockStatement& node) {
void Visitor::Visit(FunctionArgument& node) {
switch (node.index()) {
case 0:
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
break;
case 1:
Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node).get());
Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node));
break;
default:
// error
@ -307,7 +307,7 @@ void Visitor::Visit(TypeParameter& node) {
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
break;
case 2:
Visit(*std::get<std::unique_ptr<Expression>>(node).get());
Visit(*std::get<std::unique_ptr<Expression>>(node));
break;
default:
// error
@ -345,10 +345,10 @@ void Visitor::Visit(NameSubSuperExpression& node) {
Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
break;
case 1:
Visit(*std::get<std::unique_ptr<Literal>>(node).get());
Visit(*std::get<std::unique_ptr<Literal>>(node));
break;
case 2:
Visit(*std::get<std::unique_ptr<SuperExpression>>(node).get());
Visit(*std::get<std::unique_ptr<SuperExpression>>(node));
break;
default:
// error
@ -356,4 +356,4 @@ void Visitor::Visit(NameSubSuperExpression& node) {
}
}
}; // namespace interpreter
} // namespace interpreter