basic printers, type printers, some fixes, part of expression printers

src/expression_printers.cpp

@@ -0,0 +1,225 @@
+#include "expression_printers.hpp"
+#include "basic_nodes.hpp"
+#include "basic_printers.hpp"
+#include "expression_nodes.hpp"
+#include "type_printers.hpp"
+
+namespace printers {
+
+void print_expression(const nodes::Expression &expression,
+                      printers::Printer &printer) {} // IN PROGRESS
+
+// --- flow control
+
+void print_match(const nodes::Match &expression, printers::Printer &printer) {
+} // IN PROGRESS
+
+void print_condition(const nodes::Condition &expression,
+                     printers::Printer &printer) {} // IN PROGRESS
+
+void print_loop(const nodes::Loop &expression, printers::Printer &printer) {
+} // IN PROGRESS
+
+// --- containers
+
+void print_container(const nodes::Container &expression,
+                     printers::Printer &printer) {} // IN PROGRESS
+
+// --- modifiers
+
+void print_return(const nodes::Return &expression, printers::Printer &printer) {
+
+  switch (expression.get_type()) {
+  case nodes::Return::RETURN:
+    printer.print("return ");
+    break;
+  case nodes::Return::BRING:
+    printer.print("bring ");
+    break;
+  default:
+    break;
+  }
+
+  print_expression(*expression.get_expression(), printer);
+}
+
+void print_name_definition(const nodes::NameDefinition &expression,
+                           printers::Printer &printer) {
+
+  if (printer.print_words_instead_of_symbols()) {
+    switch (expression.get_modifier()) {
+    case nodes::NameDefinition::LET:
+      printer.print("let ");
+      break;
+    case nodes::NameDefinition::VAR:
+      printer.print("var ");
+      break;
+    default:
+      break;
+    }
+  } else {
+    switch (expression.get_modifier()) {
+    case nodes::NameDefinition::LET:
+      printer.print("% ");
+      break;
+    case nodes::NameDefinition::VAR:
+      printer.print("$ ");
+      break;
+    default:
+      break;
+    }
+  }
+
+  print_identifier(*expression.get_name(), printer);
+}
+
+void print_access(const nodes::Access &expression, printers::Printer &printer) {
+  print_expression(*expression.get_value(), printer);
+
+  switch (expression.get_type()) {
+  case nodes::Access::ARRAY:
+    printer.print('[');
+    break;
+  case nodes::Access::TUPLE:
+    printer.print('.');
+    break;
+  default:
+    break;
+  }
+
+  print_expression(*expression.get_index(), printer);
+
+  switch (expression.get_type()) {
+  case nodes::Access::ARRAY:
+    printer.print(']');
+    break;
+  case nodes::Access::TUPLE:
+    break;
+  default:
+    break;
+  }
+}
+
+void print_loop_control(const nodes::LoopControl &expression,
+                        printers::Printer &printer) {
+  switch (expression.get_type()) {
+  case nodes::LoopControl::BREAK:
+    printer.print("break");
+    break;
+  case nodes::LoopControl::CONTINUE:
+    printer.print("continue");
+    break;
+  default:
+    break;
+  }
+}
+
+void print_modifier_expression(const nodes::ModifierExpression &expression,
+                               printers::Printer &printer) {
+
+  if (printer.print_words_instead_of_symbols()) {
+    switch (expression.get_modifier()) {
+    case nodes::Modifier::OUT:
+      printer.print("out ");
+      break;
+    case nodes::Modifier::IN:
+      printer.print("in ");
+      break;
+    case nodes::Modifier::REF:
+      printer.print("ref ");
+      break;
+    default:
+      break;
+    }
+  } else {
+    switch (expression.get_modifier()) {
+    case nodes::Modifier::OUT:
+      printer.print("-> ");
+      break;
+    case nodes::Modifier::IN:
+      printer.print("<- ");
+      break;
+    case nodes::Modifier::REF:
+      printer.print("<> ");
+      break;
+    default:
+      break;
+    }
+  }
+
+  print_expression(*expression.get_expression(), printer);
+
+  switch (expression.get_modifier()) {
+  case nodes::Modifier::OR_FALSE:
+    printer.print('?');
+    break;
+  case nodes::Modifier::OR_RETURN:
+    printer.print('!');
+    break;
+  default:
+    break;
+  }
+}
+
+// --- other
+
+void print_name_expression(const nodes::NameExpression &expression,
+                           printers::Printer &printer) {
+  if (expression.is_operator_call() || expression.is_point_call()) {
+    print_expression(*expression.get_argument_value(0), printer);
+    if (expression.is_point_call()) {
+      printer.print('.');
+    } else {
+      printer.space();
+    }
+  } else if (expression.get_prefix().has_value()) {
+    print_type(*expression.get_prefix().value(), printer);
+    printer.print('.');
+  }
+
+  print_identifier(*expression.get_name(), printer);
+
+  for (size_t i = 0; i < expression.arguments_size(); ++i) {
+    printer.space();
+
+    if (expression.get_argument_annotation(i).has_value()) {
+      print_annotation(*expression.get_argument_annotation(i).value(), printer);
+      printer.space();
+    }
+    print_expression(*expression.get_argument_value(i), printer);
+  }
+
+} // IN PROGRESS
+
+void print_constructor(const nodes::Constructor &expression,
+                       printers::Printer &printer) {
+  print_type(*expression.get_type(), printer);
+
+  for (size_t i = 0; i < expression.arguments_size(); ++i) {
+    printer.space();
+
+    if (expression.get_argument_annotation(i).has_value()) {
+      print_annotation(*expression.get_argument_annotation(i).value(), printer);
+      printer.space();
+    }
+
+    print_expression(*expression.get_argument_value(i), printer);
+  }
+
+} // IN PROGRESS
+
+void print_lambda(const nodes::Lambda &expression, printers::Printer &printer) {
+  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);
+    printer.space();
+  }
+
+  printer.print(printer.print_words_instead_of_symbols() ? "do " : "-> ");
+
+  print_expression(*expression.get_expression(), printer);
+
+} // IN PROGRESS
+
+} // namespace printers