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

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

18
.clang_tidy Normal file
View file

@ -0,0 +1,18 @@
Checks: "*,
-abseil-*,
-altera-*,
-android-*,
-fuchsia-*,
-google-*,
-llvm*,
-modernize-use-trailing-return-type,
-zircon-*,
-readability-else-after-return,
-readability-static-accessed-through-instance,
-readability-avoid-const-params-in-decls,
-cppcoreguidelines-non-private-member-variables-in-classes,
-misc-non-private-member-variables-in-classes,
"
WarningsAsErrors: ''
HeaderFilterRegex: ''
FormatStyle: none

1
.gitignore vendored
View file

@ -13,3 +13,4 @@ _deps
build
build_make

8
.idea/.gitignore generated vendored Normal file
View file

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

1
.idea/.name generated Normal file
View file

@ -0,0 +1 @@
LangInterpreter

5
.idea/codeStyles/codeStyleConfig.xml generated Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectCodeStyleConfiguration">
<state>
<option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
</state>
</component>

2
.idea/lang-interpreter.iml generated Normal file
View file

@ -0,0 +1,2 @@
<?xml version="1.0" encoding="UTF-8"?>
<module classpath="CMake" type="CPP_MODULE" version="4" />

4
.idea/misc.xml generated Normal file
View file

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
</project>

8
.idea/modules.xml generated Normal file
View file

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/lang-interpreter.iml" filepath="$PROJECT_DIR$/.idea/lang-interpreter.iml" />
</modules>
</component>
</project>

7
.idea/vcs.xml generated Normal file
View file

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
<mapping directory="$PROJECT_DIR$/tree-sitter" vcs="Git" />
</component>
</project>

4
include/build_visitor.hpp
View file

@ -8,7 +8,7 @@ namespace interpreter {
class BuildVisitor : public Visitor {
public:
BuildVisitor(const parser::ParseTree& parse_tree) : parse_tree_(parse_tree) {}
explicit BuildVisitor(const parser::ParseTree& parse_tree) : parse_tree_(parse_tree) {}
void VisitSourceFile(SourceFile* source_file) override {
current_node_ = parse_tree_.GetRoot();
@ -23,7 +23,7 @@ private:
void Visit(SourceFile* node) override;
void Visit(Sources* node) override;
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
void Visit(Partition* node) override;
void Visit(Namespace* node) override;

14
include/interpreter_tree.hpp
View file

@ -10,9 +10,7 @@
#include "node.hpp"
namespace interpreter {
namespace tokens {
namespace interpreter::tokens {
// ----------------- Declarations -----------------
@ -30,7 +28,7 @@ using TypeclassIdentifier = std::string;
struct SourceFile;
struct Sources;
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
struct Partition;
struct Namespace;
@ -101,7 +99,7 @@ struct Block;
//
struct NameExpression;
struct NameSuperExpression;
struct ScopedStatement;
enum class LoopControlExpression {
@ -110,7 +108,7 @@ enum class LoopControlExpression {
};
using SubExpressionToken = std::variant<
std::unique_ptr<NameExpression>,
std::unique_ptr<NameSuperExpression>,
std::unique_ptr<ScopedStatement>>;
//
@ -576,6 +574,4 @@ struct CharLiteral : public Node {
char value;
};
} // namespace tokens
} // namespace interpereter
} // namespace interpereter::tokens

16
include/parse_token_types.hpp
View file

@ -2,16 +2,14 @@
#include <string>
namespace parser {
namespace tokens {
namespace parser::tokens {
// Sources -----------------
const std::string SourceFile = "source_file";
const std::string Sources = "sources";
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
const std::string Partition = "partition";
const std::string Namespace = "namespace";
@ -64,7 +62,7 @@ const std::string SubExpressionToken = "subexpression_token";
const std::string SubExpression = "subexpression";
const std::string PrefixedExpression = "prefixed_expression";
const std::string Expression = "expression";
const std::string SuperExpression = "super_expression";
const std::string SuperExpression = "superexpression";
const std::string BlockStatement = "block_statement";
@ -120,9 +118,9 @@ const std::string TypeclassExpression = "typeclass_expression";
const std::string TypeIdentifierDefinition = "type_identifier_definition";
const std::string TypeclassIdentifier = "typeclass_identifer";
const std::string TypeclassIdentifier = "typeclass_identifier";
const std::string NameIdentifier = "name_identifier";
const std::string TypeIdentifier = "type_identifer";
const std::string TypeIdentifier = "type_identifier";
const std::string AbstractTypeIdentifier = "abstract_type_identifier";
const std::string OperatorIdentifier = "operator_identifier";
@ -138,6 +136,4 @@ const std::string Literal = "literal";
const std::string NameSubSuperExpression = "name_subsuperexpression";
} // namespace tokens
} // namespace parser
} // namespace parser::tokens

24
include/parse_tree.hpp
View file

@ -13,8 +13,16 @@ class ParseTree {
public:
class Node {
public:
Node() = default;
Node(const TSNode &node, const std::string* source) : node_(node), source_(source) {}
Node() : uninitialized_(true) {
for (unsigned int& i : node_.context) {
i = 0;
}
node_.id = nullptr;
node_.tree = nullptr;
source_ = nullptr;
};
Node(const TSNode& node, const std::string* source) : uninitialized_(false), node_(node), source_(source) {}
std::string GetType() {
return ts_node_type(node_);
@ -81,8 +89,9 @@ public:
// ?? use field id instaed of name ??
// ?? node equality check needed ??
private:
bool uninitialized_;
TSNode node_;
const std::string* source_ = nullptr;
const std::string* source_;
};
class Cursor { // ?? needed ??
public:
@ -106,15 +115,22 @@ public:
tree_ = ts_parser_parse_string(
parser,
NULL,
nullptr,
source_.c_str(),
source_.size());
ts_parser_delete(parser);
}
ParseTree(const ParseTree& parse_tree) : tree_(ts_tree_copy(parse_tree.tree_)), source_(parse_tree.source_) {}
Node GetRoot() const {
return Node(ts_tree_root_node(tree_), &source_);
}
~ParseTree() {
ts_tree_delete(tree_);
}
private:
TSTree* tree_;
std::string source_; // for token value extraction

4
include/print_visitor.hpp
View file

@ -9,7 +9,7 @@ namespace interpreter {
class PrintVisitor : public Visitor {
public:
PrintVisitor(std::ostream& out) : out_(out) {}
explicit PrintVisitor(std::ostream& out) : out_(out) {}
private:
void Visit(Node* node) override;
@ -19,7 +19,7 @@ private:
void Visit(SourceFile* node) override;
void Visit(Sources* node) override;
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
void Visit(Partition* node) override;
void Visit(Namespace* node) override;

2
include/visitor.hpp
View file

@ -21,7 +21,7 @@ protected:
virtual void Visit(SourceFile* node) {}
virtual void Visit(Sources* node) {}
// Namespaces, partittions -----------------
// Namespaces, partitions -----------------
virtual void Visit(Partition* node) {}
virtual void Visit(Namespace* node) {}

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

Binary file not shown.

96
src/build_visitor.cpp
View file

@ -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

1
tests/default_constructors.lang
View file

@ -1,7 +1,6 @@
namespace Employee {
decl gen_employee : Unit -> Employee
def gen_employee = {
; a = b + c
return
$Employee
& name = "John"

2
tests/functions.lang
View file

@ -18,7 +18,6 @@ def fact : n =
decl find_prefix_hashes ('H : (#AccHash Char)) : String -> Array 'H
def find_prefix_hashes ('H : (#AccHash Char)) : str = {
var hashes = (Array 'H).new (str.size + 1)
; hashes.0 = 'H.of str.0
for i in 1..hashes.size do {
; hashes.i = hashes.(i - 1).clone
@ -68,3 +67,4 @@ decl mul_10 : Int -> Int
def mul_10 = mul 10 // or argument can be used
// ?? is partial application feature needed ??