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

printing fixes

Browse source
This commit is contained in:
ProgramSnail 2023-07-25 21:33:57 +03:00
parent 0bb72e0b10
commit 469cb3581f
23 changed files with 318 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/basic_builders.cpp
View file

@ -224,12 +224,14 @@ std::string build_annotation(parser::ParseTree::Node parser_node) {
nodes::Identifier build_operator(parser::ParseTree::Node parser_node) {
std::string identifier = parser_node.get_value();
if (identifier.size() > 0 && identifier.front() != '.') {
// for not point only identifiers
while (identifier.size() > 0 && identifier.back() == '.') {
identifier.pop_back();
}
}
// --- points needed for proper printing
// if (identifier.size() > 0 && identifier.front() != '.') {
// // for not point only identifiers
// while (identifier.size() > 0 && identifier.back() == '.') {
// identifier.pop_back();
// }
// }
// ---
return nodes::Identifier(build_node(parser_node), nodes::Identifier::OPERATOR,
identifier);
@ -240,4 +242,11 @@ nodes::Identifier build_placeholder(parser::ParseTree::Node parser_node) {
nodes::Identifier::PLACEHOLDER, "_");
}
// --- empty lines
nodes::EmptyLines build_empty_lines(parser::ParseTree::Node parser_node) {
return nodes::EmptyLines(build_node(parser_node),
parser_node.get_value_length() - 1);
}
} // namespace builders

6
src/basic_printers.cpp
View file

@ -53,4 +53,10 @@ void print_annotation(const std::string &annotation, Printer &printer) {
printer.print(annotation);
}
void print_empty_lines(const nodes::EmptyLines &empty_lines, Printer &printer) {
for (size_t i = 0; i < empty_lines.size(); ++i) {
printer.new_indent_line();
}
}
} // namespace printers

4
src/doc_builders.cpp
View file

@ -18,8 +18,8 @@ nodes::SymbolDocs build_symbol_docs(
// remove newline delimeters (": " at each new line
size_t j = 0;
for (size_t i = 0; i < description.value().size(); ++i, ++j) {
if (j != i) {
for (size_t i = 2; i < description.value().size(); ++i, ++j) {
if (j != i) { // always true
description.value()[j] = description.value()[i];
}

22
src/doc_printers.cpp
View file

@ -1,4 +1,5 @@
#include "doc_printers.hpp"
#include "basic_printers.hpp"
#include "utils.hpp"
namespace printers {
@ -6,8 +7,27 @@ namespace printers {
// TODO
void print_docs(const nodes::SymbolDocs &docs, Printer &printer) {
auto description = docs.get_description();
error_handling::handle_general_error("Docs printing unimplemented yet");
if (description.has_value()) {
printer.print(": ");
for (auto &ch : *description.value()) {
if (ch == '\n') {
printer.new_indent_line();
printer.print(": ");
} else {
printer.print(std::string(1, ch));
}
}
printer.new_indent_line();
}
for (size_t i = 0; i < docs.get_annotations_info_size(); ++i) {
print_annotation(*docs.get_annotation(i), printer);
printer.space();
printer.print(*docs.get_annotation_info(i));
printer.new_indent_line();
}
} // IN PROGRESS

12
src/expression_builders.cpp
View file

@ -16,9 +16,10 @@ build_expression(parser::ParseTree::Node parser_node,
nodes::TypeStorage &type_storage) {
tokens::Type type = tokens::string_to_type(parser_node.get_type());
auto maybe_parenthesis = parser_node.next_sibling();
auto maybe_parenthesis = parser_node.previous_sibling();
bool is_scoped =
(!maybe_parenthesis.is_null() && maybe_parenthesis.get_value() == "(");
(!maybe_parenthesis.is_null() && !maybe_parenthesis.is_named() &&
maybe_parenthesis.get_value() == "(");
switch (type) {
// --- flow control
@ -119,6 +120,9 @@ build_expression(parser::ParseTree::Node parser_node,
case tokens::Type::NULL_LITERAL:
return expression_storage.add_expression(
nodes::Expression(build_null_literal(parser_node), is_scoped));
case tokens::Type::EMPTY_LINES:
return expression_storage.add_expression(
nodes::Expression(build_empty_lines(parser_node), is_scoped));
default:
error_handling::handle_parsing_error("Unexprected expression node type",
parser_node);
@ -271,7 +275,7 @@ build_comma_expression(parser::ParseTree::Node parser_node,
return nodes::NameExpression(
build_node(parser_node),
nodes::Identifier(
build_node(parser_node), // can't find more precise location'
build_node(parser_node), // can't find more precise location
nodes::Identifier::SIMPLE_NAME, ","),
std::move(arguments), std::nullopt, false, true);
}
@ -308,7 +312,7 @@ build_container(parser::ParseTree::Node parser_node,
nodes::Container::ContainerType container_type) {
std::vector<nodes::ExpressionProxy> expressions;
auto current_node = parser_node.nth_named_child(0).next_named_sibling();
auto current_node = parser_node.nth_named_child(0);
while (!current_node.is_null()) {
expressions.push_back(

62
src/expression_printers.cpp
View file

@ -2,6 +2,7 @@
#include "basic_nodes.hpp"
#include "basic_printers.hpp"
#include "expression_nodes.hpp"
#include "tokens.hpp"
#include "type_printers.hpp"
namespace printers {
@ -60,6 +61,10 @@ void print_expression(const nodes::Expression &expression,
case 12: // Literal
print_literal(*expression.get<nodes::Literal>().value(), printer);
break;
// --- empty lines
case 13: // EmptyLines
print_empty_lines(*expression.get<nodes::EmptyLines>().value(), printer);
break;
}
if (expression.is_scoped()) {
@ -100,9 +105,9 @@ void print_match(const nodes::Match &expression, printers::Printer &printer) {
printer.space();
size_t previous_indentation_level = printer.get_current_indentation_level();
size_t previous_indentation_level = printer.get_indentation_level();
printer.set_current_indentation_level(printer.current_position());
printer.set_indentation_level(printer.current_position());
for (size_t i = 0; i < expression.cases_size(); ++i) {
print_case(*expression.get_case(i), printer);
@ -112,7 +117,7 @@ void print_match(const nodes::Match &expression, printers::Printer &printer) {
}
}
printer.set_current_indentation_level(previous_indentation_level);
printer.set_indentation_level(previous_indentation_level);
} // IN PROGRESS
@ -123,17 +128,19 @@ void print_condition(const nodes::Condition &expression,
if (i == 0) {
printer.print(printer.print_words_instead_of_symbols() ? "if " : "?? ");
} else {
printer.new_indent_line();
printer.print(printer.print_words_instead_of_symbols() ? "elif " : "!! ");
}
print_expression(*expression.get_case(i).first, printer);
printer.print(printer.print_words_instead_of_symbols() ? "do " : "=> ");
printer.print(printer.print_words_instead_of_symbols() ? " do " : " => ");
print_expression(*expression.get_case(i).second, printer);
}
if (expression.get_else_case().has_value()) {
printer.new_indent_line();
printer.print(printer.print_words_instead_of_symbols() ? "else " : "!!=> ");
print_expression(*expression.get_else_case().value(), printer);
}
@ -163,7 +170,6 @@ void print_loop(const nodes::Loop &expression, printers::Printer &printer) {
printer.print(printer.print_words_instead_of_symbols() ? "do " : "=> ");
print_expression(*expression.get_expression(), printer);
printer.print(";");
} // IN PROGRESS
// --- containers
@ -177,16 +183,23 @@ void print_container(const nodes::Container &expression,
} else {
printer.print("{");
printer.indent();
printer.new_indent_line();
}
for (size_t i = 0; i < expression.expressions_size(); ++i) {
bool is_empty_lines_expression = expression.get_expression(i)->get<nodes::EmptyLines>().has_value();
if (!is_array && !is_empty_lines_expression) {
printer.new_indent_line();
}
print_expression(*expression.get_expression(i), printer);
if (is_array) {
printer.space();
if (i + 1 < expression.expressions_size()) {
printer.space();
}
} else {
printer.print(";");
printer.new_indent_line();
if (!is_empty_lines_expression) {
printer.print(";");
}
}
}
@ -194,8 +207,8 @@ void print_container(const nodes::Container &expression,
printer.print("]]");
} else {
printer.deindent();
printer.print("}");
printer.new_indent_line();
printer.print("}");
}
} // IN PROGRESS
@ -234,10 +247,10 @@ void print_name_definition(const nodes::NameDefinition &expression,
} else {
switch (expression.get_modifier()) {
case nodes::NameDefinition::LET:
printer.print("% ");
printer.print("%");
break;
case nodes::NameDefinition::VAR:
printer.print("$ ");
printer.print("$");
break;
default:
break;
@ -343,7 +356,7 @@ void print_name_expression(const nodes::NameExpression &expression,
print_expression(*expression.get_argument_value(0), printer);
if (expression.is_point_call()) {
printer.print(".");
} else {
} else if (*expression.get_name()->get() != ",") {
printer.space();
}
} else if (expression.get_prefix().has_value()) {
@ -351,10 +364,27 @@ void print_name_expression(const nodes::NameExpression &expression,
printer.print(".");
}
// TODO: properly print operator name
//
bool operator_called_as_function =
(!expression.is_operator_call() &&
expression.get_name()->get_type() == nodes::Identifier::OPERATOR);
if (operator_called_as_function) {
printer.print("( ");
}
print_identifier(*expression.get_name(), printer);
for (size_t i = 0; i < expression.arguments_size(); ++i) {
if (operator_called_as_function) {
printer.print(" )");
}
//
for (size_t i =
expression.is_operator_call() || expression.is_point_call() ? 1 : 0;
i < expression.arguments_size(); ++i) {
printer.space();
if (expression.get_argument_annotation(i).has_value()) {
@ -384,7 +414,7 @@ void print_constructor(const nodes::Constructor &expression,
} // IN PROGRESS
void print_lambda(const nodes::Lambda &expression, printers::Printer &printer) {
printer.print(printer.print_words_instead_of_symbols() ? "lambda " : "\\ ");
printer.print(printer.print_words_instead_of_symbols() ? "lambda " : "\\");
for (size_t i = 0; i < expression.arguments_size(); ++i) {
print_identifier(*expression.get_argument(i), printer);

38
src/statement_builders.cpp
View file

@ -2,11 +2,13 @@
#include "basic_builders.hpp"
#include "basic_nodes.hpp"
#include "basic_printers.hpp"
#include "doc_builders.hpp"
#include "doc_nodes.hpp"
#include "error_handling.hpp"
#include "expression_builders.hpp"
#include "statement_nodes.hpp"
#include "statement_printers.hpp"
#include "tokens.hpp"
#include "tree_sitter_wrapper.hpp"
#include "type_builders.hpp"
@ -37,18 +39,42 @@ void build_statement(parser::ParseTree::Node parser_node,
nodes::TypeStorage &type_storage) {
tokens::Type type = tokens::string_to_type(parser_node.get_type());
printers::Printer printer(std::cout, 2, 80, false);
switch (type) {
case tokens::Type::IMPORT:
build_import(parser_node);
printers::print_import(build_import(parser_node),
printer); // TODO TEMPORARY
printer.new_indent_line();
return;
case tokens::Type::TYPE_DEFINITION:
build_type_definition(parser_node, expression_storage, type_storage);
printers::print_type_definition(
build_type_definition(parser_node, expression_storage, type_storage),
printer); // TODO TEMPORARY
printer.new_indent_line();
return;
case tokens::Type::FUNCTION_DEFINITION:
build_function_definition(parser_node, expression_storage, type_storage);
printers::print_function_definition(
build_function_definition(parser_node, expression_storage,
type_storage),
printer); // TODO TEMPORARY
printer.new_indent_line();
return;
case tokens::Type::TYPECLASS_DEFINITION:
build_typeclass_definition(parser_node, expression_storage, type_storage);
printers::print_typeclass_definition(
build_typeclass_definition(parser_node, expression_storage,
type_storage),
printer); // TODO TEMPORARY
printer.new_indent_line();
return;
case tokens::Type::EMPTY_LINES:
build_empty_lines(parser_node);
printers::print_empty_lines(build_empty_lines(parser_node),
printer); // TODO TEMPORARY
return;
default:
error_handling::handle_parsing_error("Unexprected statement node type",
@ -219,7 +245,7 @@ build_function_definition(parser::ParseTree::Node parser_node,
nodes::FunctionDefinition::STATIC;
current_node = name_node.previous_sibling();
if (!current_node.is_null() && current_node.is_named()) {
if (!current_node.is_null() && !current_node.is_named()) {
std::string modifier_str = current_node.get_value();
if (modifier_str == "%" || modifier_str == "let") {
modifier = nodes::FunctionDefinition::LET;
@ -270,11 +296,11 @@ build_function_definition(parser::ParseTree::Node parser_node,
argument_reference_types.push_back(last_reference_type);
arguments.push_back(build_identifier(current_node));
optional_arguments.push_back(!current_node.next_sibling().is_null() &&
current_node.next_sibling().is_named() &&
!current_node.next_sibling().is_named() &&
current_node.next_sibling().get_value() ==
"?");
result_arguments.push_back(!current_node.next_sibling().is_null() &&
current_node.next_sibling().is_named() &&
!current_node.next_sibling().is_named() &&
current_node.next_sibling().get_value() ==
"!");
if (optional_arguments.back() || result_arguments.back()) {
@ -306,7 +332,10 @@ build_function_definition(parser::ParseTree::Node parser_node,
std::vector<std::optional<std::string>> *annotations = nullptr;
std::vector<nodes::Modifier> *reference_types = nullptr;
if (!at_least_one_argument_annotation_found) {
bool is_annotations_same_to_names =
(!at_least_one_argument_annotation_found && types.empty());
if (is_annotations_same_to_names) {
for (size_t i = 0; i < argument_annotations.size(); ++i) {
std::string argument_annotation = *arguments[i].get();
argument_annotations[i] =
@ -346,6 +375,7 @@ build_function_definition(parser::ParseTree::Node parser_node,
std::move(*annotations), std::move(arguments),
std::move(*reference_types), std::move(types),
std::move(optional_arguments), std::move(result_arguments),
is_annotations_same_to_names,
expression_node.has_value()
? build_expression(expression_node.value(), expression_storage,
type_storage)

108
src/statement_printers.cpp
View file

@ -28,9 +28,6 @@ void print_import(const nodes::Import &statement, Printer &printer) {
}
}
printer.print(";");
printer.new_indent_line();
printer.new_indent_line();
} // IN PROGRESS
void print_constraint(const nodes::Constraint &statement, Printer &printer) {
@ -39,6 +36,28 @@ void print_constraint(const nodes::Constraint &statement, Printer &printer) {
printer.print(";");
}
template <typename T>
void print_statement_methods(const T &statement, Printer &printer) {
if (statement.get_methods_size() > 0) {
printer.print(" {");
printer.indent();
for (size_t i = 0; i < statement.get_methods_size(); ++i) {
printer.new_indent_line();
print_function_definition(*statement.get_method(i), printer);
if (i + 1 < statement.get_methods_size()) {
printer.new_indent_line();
}
}
printer.deindent();
printer.new_indent_line();
printer.print("}");
} else {
printer.print(";");
}
}
void print_type_definition(const nodes::TypeDefinition &statement,
Printer &printer) {
print_docs(*statement.get_docs(), printer); // TODO
@ -57,33 +76,16 @@ void print_type_definition(const nodes::TypeDefinition &statement,
if (statement.get_type().has_value()) {
printer.print(" = ");
size_t previous_indentation_level = printer.get_current_indentation_level();
size_t previous_indentation_level = printer.get_indentation_level();
printer.set_current_indentation_level(printer.get_current_position());
printer.set_indentation_level(printer.get_current_position() - 2);
print_variant_type(*statement.get_type().value(), printer);
printer.set_current_indentation_level(previous_indentation_level);
}
// TODO: same to typeclass, make separated function
if (statement.get_methods_size() > 0) {
printer.print(" {");
printer.indent();
for (size_t i = 0; i < statement.get_methods_size(); ++i) {
printer.new_indent_line();
print_function_definition(*statement.get_method(i), printer);
printer.new_indent_line();
}
printer.deindent();
printer.new_indent_line();
printer.print("} ");
} else {
printer.print(";");
printer.set_indentation_level(previous_indentation_level);
}
print_statement_methods(statement, printer);
} // IN PROGRESS
void print_function_definition(const nodes::FunctionDefinition &statement,
@ -99,22 +101,36 @@ void print_function_definition(const nodes::FunctionDefinition &statement,
case nodes::FunctionDefinition::STATIC:
break;
case nodes::FunctionDefinition::LET:
printer.print(printer.print_words_instead_of_symbols() ? "let " : "% ");
printer.print(printer.print_words_instead_of_symbols() ? "let " : "%");
break;
case nodes::FunctionDefinition::VAR:
printer.print(printer.print_words_instead_of_symbols() ? "var " : "$ ");
printer.print(printer.print_words_instead_of_symbols() ? "var " : "$");
break;
default: // remove ??
break;
}
bool operator_called_as_function =
(statement.get_name()->get_type() == nodes::Identifier::OPERATOR);
if (operator_called_as_function) {
printer.print("( ");
}
print_identifier(*statement.get_name(), printer);
if (operator_called_as_function) {
printer.print(" )");
}
// TODO: same fragments with function type, maybe better make separated
// function
for (size_t i = 0; i < statement.get_arguments_size(); ++i) {
printer.space();
if (statement.get_argument_types_size() == 0) {
if (statement.get_argument_annotation(i).has_value()) {
if (!statement.is_annotations_same_to_names() &&
statement.get_argument_annotation(i).has_value()) {
print_annotation(*statement.get_argument_annotation(i).value(),
printer);
printer.space();
@ -154,7 +170,7 @@ void print_function_definition(const nodes::FunctionDefinition &statement,
}
}
if (statement.get_argument_types_size() > 0) { // TODO
if (statement.get_argument_types_size() > 0) {
printer.print(" :");
for (size_t i = 0; i < statement.get_argument_types_size(); ++i) {
printer.space();
@ -183,22 +199,18 @@ void print_function_definition(const nodes::FunctionDefinition &statement,
}
print_type(*statement.get_argument_type(i), printer);
// TODO: can't be optional and result in same time
if (statement.is_argument_optional(i)) {
printer.print("?");
}
if (statement.is_argument_result(i)) {
printer.print("!");
}
}
}
if (statement.get_expression().has_value()) {
printer.print(" = ");
print_expression(*statement.get_expression().value(), printer);
if (!statement.get_expression()
.value()
->get<nodes::Container>()
.has_value()) {
printer.print(";");
}
} else {
printer.print(";");
}
@ -218,25 +230,7 @@ void print_typeclass_definition(const nodes::TypeclassDefinition &statement,
}
}
if (statement.get_methods_size() > 0) {
printer.print(" {");
printer.indent();
for (size_t i = 0; i < statement.get_methods_size(); ++i) {
printer.new_indent_line();
print_function_definition(*statement.get_method(i), printer);
printer.new_indent_line();
}
printer.deindent();
printer.new_indent_line();
printer.print("} ");
} else {
printer.print(";");
}
printer.new_indent_line();
printer.new_indent_line();
print_statement_methods(statement, printer);
} // IN PROGRESS
} // namespace printers

17
src/type_printers.cpp
View file

@ -19,12 +19,16 @@ void print_type(const nodes::Type &type, printers::Printer &printer) {
printer.print("!");
}
printer.print("[");
for (size_t i = 0; i < type.get_parametrs_size(); ++i) {
print_type(*type.get_parameter(i), printer);
printer.space();
if (type.get_parametrs_size() > 0) {
printer.print("[");
for (size_t i = 0; i < type.get_parametrs_size(); ++i) {
print_type(*type.get_parameter(i), printer);
if (i + 1 < type.get_parametrs_size()) {
printer.space();
}
}
printer.print("]");
}
printer.print("]");
}
void print_tuple_type(const nodes::TupleType &type,
@ -37,6 +41,7 @@ void print_tuple_type(const nodes::TupleType &type,
if (annotation.has_value()) {
print_annotation(*annotation.value(), printer);
printer.space();
}
print_type(*type.get(i), printer);
@ -46,7 +51,7 @@ void print_tuple_type(const nodes::TupleType &type,
void print_variant_type(const nodes::VariantType &type,
printers::Printer &printer) {
for (size_t i = 0; i < type.size(); ++i) {
if (type.size() > 1 || i > 0) {
if (i > 0) {
printer.print("| ");
}