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

print & build visitor fixed and tested

Browse source
This commit is contained in:
ProgramSnail 2023-04-26 01:02:53 +03:00
parent c34523bd4f
commit 66a5dcfb4a
14 changed files with 91 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

1
include/build_visitor.hpp
View file

@ -144,6 +144,7 @@ private:
void Visit(NumberLiteral* node) override;
void Visit(StringLiteral* node) override;
void Visit(CharLiteral* node) override;
void Visit(UnitLiteral* node) override;
void Visit(Literal& node) override; // variant
private:

21
include/find_symbols_visitor.hpp
View file

@ -44,6 +44,8 @@ private:
// Flow control -----------------
// // void Visit(TypeConstructorPatternParameter* node) override;
// // void Visit(TypeConstructorPattern* node) override;
// // void Visit(MatchCase* node) override;
// // void Visit(Match* node) override;
// // void Visit(Condition* node) override;
@ -68,14 +70,15 @@ private:
// Simple Expressions
// // void Visit(FunctionCallExpression* node) override;
// //
// // void Visit(TupleExpression* node) override;
// // void Visit(VariantExpression* node) override;
// // void Visit(ReturnExpression* node) override;
// // void Visit(TypeConstructorParameter* node) override;
// // void Visit(TypeConstructor* node) override;
// // void Visit(LambdaFunction* node) override;
// // void Visit(ArrayExpression* node) override;
// //
// // void Visit(LoopControlExpression& node) override; // enum
// Name
@ -92,26 +95,30 @@ private:
// // void Visit(FunctionType* node) override;
// // void Visit(TupleType* node) override;
// // void Visit(VariantType* node) override;
// // void Visit(ParametrizedType* node) override;
// // void Visit(TypeExpression* node) override;
// //
// // void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
// // void Visit(ParametrizedTypeclass* node) override;
// // void Visit(TypeclassExpression* node) override;
// // void Visit(ParametrizedTypeclass* node) override;
// Typeclass & Type
// // void Visit(ParametrizedType* node) override;
// Identifiers, constants, etc. -----------------
// // void Visit(ExtendedName* node) override;
// //
// // void Visit(std::string* node) override; // std::string
// //
// // void Visit(FloatNumberLiteral* node) override;
// // void Visit(NumberLiteral* node) override;
// // void Visit(StringLiteral* node) override;
// // void Visit(CharLiteral* node) override;
// // void Visit(UnitLiteral* node) override;
private:
info::GlobalInfo::NamespaceVisitor namespace_visitor_;

13
include/interpreter_tree.hpp
View file

@ -94,12 +94,14 @@ struct FloatNumberLiteral;
struct NumberLiteral;
struct StringLiteral;
struct CharLiteral;
struct UnitLiteral;
using Literal = std::variant<
std::unique_ptr<FloatNumberLiteral>,
std::unique_ptr<NumberLiteral>,
std::unique_ptr<StringLiteral>,
std::unique_ptr<CharLiteral>>;
std::unique_ptr<CharLiteral>,
std::unique_ptr<UnitLiteral>>;
//
struct NameExpression;
@ -278,10 +280,7 @@ struct Partition {
enum PartitionName {
Test,
Interface,
Core,
Lib,
Module,
Exe,
Code,
};
PartitionName name;
@ -487,7 +486,7 @@ struct TypeConstructorParameter {
enum AssignmentModifier { Move, Assign };
std::optional<ExtendedName> name;
std::optional<AssignmentModifier> asignment_modifier;
PatternToken value;
SubExpression value;
};
struct TypeConstructor {
@ -599,4 +598,6 @@ struct CharLiteral {
char value;
};
struct UnitLiteral {};
} // namespace interpereter::tokens

12
include/link_symbols_visitor.hpp
View file

@ -45,6 +45,8 @@ private:
// Flow control -----------------
// // void Visit(TypeConstructorPatternParameter* node) override;
// // void Visit(TypeConstructorPattern* node) override;
// // void Visit(MatchCase* node) override;
// // void Visit(Match* node) override;
// // void Visit(Condition* node) override;
@ -72,6 +74,7 @@ private:
// // void Visit(TupleExpression* node) override;
// // void Visit(VariantExpression* node) override;
// // void Visit(ReturnExpression* node) override;
// // void Visit(TypeConstructorParameter* node) override;
// // void Visit(TypeConstructor* node) override;
void Visit(LambdaFunction* node) override;
// // void Visit(ArrayExpression* node) override;
@ -92,15 +95,18 @@ private:
// // void Visit(FunctionType* node) override;
// // void Visit(TupleType* node) override;
// // void Visit(VariantType* node) override;
// // void Visit(ParametrizedType* node) override;
void Visit(TypeExpression* node) override;
void Visit(TypeExpression* node) override; // TODO
// // void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
void Visit(TypeclassExpression* node) override; // TODO
// // void Visit(ParametrizedTypeclass* node) override;
void Visit(TypeclassExpression* node) override;
// Typeclass & Type
// // void Visit(ParametrizedType* node) override;
// Identifiers, constants, etc. -----------------

1
include/parse_token_types.hpp
View file

@ -129,6 +129,7 @@ const std::string FloatNumberLiteral = "float_number_literal";
const std::string NumberLiteral = "number_literal";
const std::string StringLiteral = "string_literal";
const std::string CharLiteral = "char_literal";
const std::string UnitLiteral = "unit_literal";
const std::string Literal = "literal";

1
include/print_visitor.hpp
View file

@ -115,6 +115,7 @@ private:
void Visit(NumberLiteral* node) override;
void Visit(StringLiteral* node) override;
void Visit(CharLiteral* node) override;
void Visit(UnitLiteral* node) override;
private:
std::ostream& out_;

11
include/type_check_visitor.hpp
View file

@ -43,6 +43,8 @@ private:
// Flow control -----------------
void Visit(TypeConstructorPatternParameter* node) override;
void Visit(TypeConstructorPattern* node) override;
void Visit(MatchCase* node) override;
void Visit(Match* node) override;
void Visit(Condition* node) override;
@ -71,6 +73,7 @@ private:
void Visit(TupleExpression* node) override;
void Visit(VariantExpression* node) override;
void Visit(ReturnExpression* node) override;
void Visit(TypeConstructorParameter* node) override;
void Visit(TypeConstructor* node) override;
void Visit(LambdaFunction* node) override;
void Visit(ArrayExpression* node) override;
@ -91,15 +94,18 @@ private:
void Visit(FunctionType* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(ParametrizedType* node) override;
void Visit(TypeExpression* node) override;
void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
void Visit(ParametrizedTypeclass* node) override;
void Visit(TypeclassExpression* node) override;
void Visit(ParametrizedTypeclass* node) override;
// Typeclass & Type
void Visit(ParametrizedType* node) override;
// Identifiers, constants, etc. -----------------
@ -111,6 +117,7 @@ private:
void Visit(NumberLiteral* node) override;
void Visit(StringLiteral* node) override;
void Visit(CharLiteral* node) override;
void Visit(UnitLiteral* node) override;
private:
info::GlobalInfo::NamespaceVisitor namespace_visitor_;

1
include/visitor.hpp
View file

@ -141,6 +141,7 @@ protected:
virtual void Visit(NumberLiteral* node);
virtual void Visit(StringLiteral* node);
virtual void Visit(CharLiteral* node);
virtual void Visit(UnitLiteral* node);
virtual void Visit(Literal& node); // variant
};

54
src/build_visitor.cpp
View file

@ -85,14 +85,8 @@ void BuildVisitor::Visit(Partition* node) {
node->name = Partition::Test;
} else if (name == "INTERFACE") {
node->name = Partition::Interface;
} else if (name == "CORE") {
node->name = Partition::Core;
} else if (name == "LIB") {
node->name = Partition::Lib;
} else if (name == "MODULE") {
node->name = Partition::Module;
} else if (name == "EXE") {
node->name = Partition::Exe;
} else if (name == "CODE") {
node->name = Partition::Code;
}
current_node_ = parse_node.ChildByFieldName("scope");
@ -198,10 +192,13 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
size_t child_count = parse_node.NamedChildCount();
for (size_t i = 0; i + 2 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
Visit(node->parameters.back().get());
if (child_count > 2) {
node->parameters.resize(child_count - 2);
for (size_t i = 0; i + 2 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->parameters[i] = std::make_unique<AnnotatedAbstractType>();
Visit(node->parameters.back().get());
}
}
current_node_ = parse_node.ChildByFieldName("type");
@ -395,6 +392,7 @@ void BuildVisitor::Visit(AnyAnnotatedType* node) {
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->typeclasses[i] = std::make_unique<TypeclassExpression>();
Visit(node->typeclasses[i].get());
}
}
@ -871,6 +869,7 @@ void BuildVisitor::Visit(AccessExpression* node) {
auto parse_node = current_node_;
current_node_ = parse_node.ChildByFieldName("name");
node->name = std::make_unique<NameExpression>();
Visit(node->name.get());
current_node_ = parse_node.ChildByFieldName("id");
@ -1300,7 +1299,7 @@ void BuildVisitor::Visit(AnyType& node) {
std::string current_node_type = current_node_.GetType();
if (current_node_type == parser::tokens::ParametrizedType) {
if (current_node_type == parser::tokens::TypeExpression) {
node = std::make_unique<TypeExpression>();
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
} else if (current_node_type == parser::tokens::TupleType) {
@ -1346,21 +1345,21 @@ void BuildVisitor::Visit(ExtendedScopedAnyType* node) {
void BuildVisitor::Visit(TypeclassExpression* node) {
auto parse_node = current_node_;
//
size_t child_count = parse_node.NamedChildCount();
//
// if (child_count > 1) {
// node->path.resize(child_count - 1);
//
// for (size_t i = 0; i + 1 < child_count; ++i) {
// current_node_ = parse_node.NthNamedChild(i);
// Visit(node->path[i]);
// }
// }
//
if (child_count > 1) {
node->path.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
Visit(node->path[i]);
}
}
current_node_ = parse_node.ChildByFieldName("typeclass");
Visit(node->typeclass);
//
current_node_ = parse_node;
}
@ -1482,6 +1481,8 @@ void BuildVisitor::Visit(CharLiteral* node) {
node->value = literal.substr(1, literal.size() - 2).back(); // TODO: special symbols, etc.
}
void BuildVisitor::Visit(UnitLiteral* node) {}
void BuildVisitor::Visit(Literal& node) {
auto parse_node = current_node_;
@ -1501,6 +1502,9 @@ void BuildVisitor::Visit(Literal& node) {
} else if (current_node_type == parser::tokens::CharLiteral) {
node = std::make_unique<CharLiteral>();
Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
} else if (current_node_type == parser::tokens::UnitLiteral) {
node = std::make_unique<UnitLiteral>();
Visit(std::get<std::unique_ptr<UnitLiteral>>(node).get());
} else {
// error
}

4
src/main.cpp
View file

@ -33,8 +33,8 @@ int main(int argc, char** argv) { // TODO, only test version
std::make_unique<interpreter::tokens::SourceFile>();
interpreter::BuildVisitor build_visitor(parse_tree);
// interpreter::PrintVisitor print_visitor(std::cout);
interpreter::PrintVisitor print_visitor(std::cout);
build_visitor.VisitSourceFile(source_file.get());
// print_visitor.VisitSourceFile(source_file.get());
print_visitor.VisitSourceFile(source_file.get());
}

21
src/print_visitor.cpp
View file

@ -38,17 +38,8 @@ void PrintVisitor::Visit(Partition* node) {
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";
case Partition::Code:
out_ << "CODE";
break;
}
out_ << " {\n";
@ -281,8 +272,8 @@ void PrintVisitor::Visit(TypeConstructorPattern* node) {
for (auto& parameter : node->parameters) {
if (!is_first) {
out_ << ")\n";
is_first = false;
}
is_first = false;
out_ << '(';
Visit(&parameter);
}
@ -514,8 +505,8 @@ void PrintVisitor::Visit(TypeConstructor* node) {
for (auto& parameter : node->parameters) {
if (!is_first) {
out_ << ")\n";
is_first = false;
}
is_first = false;
out_ << '(';
Visit(&parameter);
}
@ -735,4 +726,8 @@ void PrintVisitor::Visit(CharLiteral* node) {
out_ << "[Char " << node->value << "] ";
}
void PrintVisitor::Visit(UnitLiteral* node) {
out_ << "[Unit ()] ";
}
} // namespace interpreter

5
src/visitor.cpp
View file

@ -330,6 +330,9 @@ void Visitor::Visit(Literal& node) {
case 3:
Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
break;
case 4:
Visit(std::get<std::unique_ptr<UnitLiteral>>(node).get());
break;
default:
// error
break;
@ -723,5 +726,7 @@ void Visitor::Visit(StringLiteral* node) {}
void Visitor::Visit(CharLiteral* node) {}
void Visitor::Visit(UnitLiteral* node) {}
} // namespace interpreter

2
tests/match.lang
View file

@ -5,7 +5,7 @@ def fruit_cost : fruit = {
}
def amount_to_string : x is_zero_separated = {
const ans = match x with
const ans = match x with
| 0 ? is_zero_separated () -> "Zero"
| 0 | 1 | 2 | 3 | 4 -> "Few"
| x ? (5..9).contains x -> "Several"

6
tests/types.lang
View file

@ -3,6 +3,6 @@ alias T1 = Int
abstract (T2 : #A #B #C)
// Used to pre-compile module for some types
// let T2 = Int
// let T2 = Float
// let T2 = Complex
let T2 = Int
let T2 = Float
let T2 = Complex