IR canonization implemented, log system added, IR tests added

Author: wh4tsername

.gitignore

@@ -5,6 +5,12 @@ cmake-build-debug/
 
 other/
 
+compiler/tests/logs/*
+!compiler/tests/logs/created_files.txt
+
+compiler/tests_IR/logs/*
+!compiler/tests_IR/logs/created_files.txt
+
 compiler/stack.hh
 
 compiler/scanner.cpp

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.10.2)
 
-set(CMAKE_CXX_STANDARD_REQUIRED 17)
+set(CMAKE_CXX_STANDARD_REQUIRED 20)
 
 set(BISON_EXECUTABLE /usr/local/bin/bison)
 
@@ -164,11 +164,17 @@ set(
         IRVisitors
 
         compiler/IR/visitors/TemplateVisitor.cpp
+        compiler/IR/visitors/PrintVisitor.cpp
+
+        compiler/IR/visitors/Linearizer.cpp
+        compiler/IR/visitors/ESEQEliminator.cpp
+        compiler/IR/visitors/DoubleCallEliminateVisitor.cpp
 )
 
 add_executable(
         Compiler
         main.cpp
+        LogCleaner.cpp
         ${DRIVERS}
         ${NODES}
         ${VISITORS}

LogCleaner.cpp

@@ -0,0 +1,52 @@
+#include <fstream>
+
+#include "LogCleaner.h"
+
+LogCleaner& LogCleaner::GetInstance() {
+  static LogCleaner instance;
+  return instance;
+}
+
+LogCleaner::LogCleaner()
+    : created_files_log_("created_files.txt"), run_is_valid_(false) {}
+
+LogCleaner::~LogCleaner() {
+  if (!run_is_valid_) {
+    for (const auto& file_path : logs_) {
+      std::remove(file_path.c_str());
+    }
+  } else {
+    WriteLogFile();
+  }
+}
+
+void LogCleaner::WriteLogFile() {
+  std::ofstream log;
+  log.open(log_dir_path_ + created_files_log_);
+
+  for (const auto& filename : logs_) {
+    log << filename << std::endl;
+  }
+
+  log.close();
+}
+
+void LogCleaner::AddLogFilePath(const std::string& file_path) {
+  logs_.emplace_back(file_path);
+}
+
+void LogCleaner::ValidateUsage() { run_is_valid_ = true; }
+
+void LogCleaner::ClearLastLogs(const std::string& log_dir_path) {
+  log_dir_path_ = log_dir_path;
+
+  std::ifstream last_log;
+  last_log.open(log_dir_path_ + created_files_log_);
+
+  std::string file_path;
+  while (getline(last_log, file_path)) {
+    std::remove(file_path.c_str());
+  }
+
+  last_log.close();
+}

LogCleaner.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+class LogCleaner {
+ public:
+  void AddLogFilePath(const std::string& file_path);
+  void ClearLastLogs(const std::string& log_dir_path);
+  void ValidateUsage();
+
+  static LogCleaner& GetInstance();
+
+  LogCleaner(const LogCleaner&) = delete;
+  LogCleaner(LogCleaner&&) = delete;
+  LogCleaner& operator=(const LogCleaner&) = delete;
+  LogCleaner&& operator=(LogCleaner&&) = delete;
+
+ private:
+  LogCleaner();
+  ~LogCleaner();
+
+  void WriteLogFile();
+
+ private:
+  std::vector<std::string> logs_;
+  std::string log_dir_path_;
+  std::string created_files_log_;
+  bool run_is_valid_;
+};

compiler/IR/visitors/DoubleCallEliminateVisitor.cpp

@@ -0,0 +1,110 @@
+#include "DoubleCallEliminateVisitor.h"
+#include "IRTNodes.h"
+
+using namespace IRT;
+
+void DoubleCallEliminateVisitor::Visit(ExpStatement *stmt) {
+  IRTStorage elements = Accept(stmt->expression_);
+  tos_value_.statement_ = new ExpStatement(elements.expression_);
+}
+
+void DoubleCallEliminateVisitor::Visit(ConstExpression *const_expression) {
+  tos_value_.expression_ = new ConstExpression(const_expression->Value());
+}
+
+void DoubleCallEliminateVisitor::Visit(JumpConditionalStatement *jump_conditional_statement) {
+  auto lhs = Accept(jump_conditional_statement->left_operand_).expression_;
+  auto rhs = Accept(jump_conditional_statement->right_operand_).expression_;
+
+  tos_value_.statement_ = new JumpConditionalStatement(
+      jump_conditional_statement->operator_type_,
+      lhs,
+      rhs,
+      jump_conditional_statement->label_true_,
+      jump_conditional_statement->label_false_
+  );
+}
+void DoubleCallEliminateVisitor::Visit(MoveStatement *move_statement) {
+  auto source = Accept(move_statement->source_).expression_;
+  auto target = Accept(move_statement->target_).expression_;
+
+  tos_value_.statement_ = new MoveStatement(source, target);
+}
+
+void DoubleCallEliminateVisitor::Visit(SeqStatement *seq_statement) {
+  auto first = Accept(seq_statement->first_statement_).statement_;
+  auto second = Accept(seq_statement->second_statement_).statement_;
+
+  tos_value_.statement_ = new SeqStatement(
+      first,
+      second
+  );
+}
+
+void DoubleCallEliminateVisitor::Visit(LabelStatement *label_statement) {
+  tos_value_.statement_ = new LabelStatement(label_statement->label_);
+}
+
+void DoubleCallEliminateVisitor::Visit(BinopExpression *binop_statement) {
+  tos_value_.expression_ = new BinopExpression(
+      binop_statement->type_,
+      Accept(binop_statement->lhs_).expression_,
+      Accept(binop_statement->rhs_).expression_
+  );
+}
+void DoubleCallEliminateVisitor::Visit(TempExpression *temp_exression) {
+  tos_value_.expression_ = new TempExpression(temp_exression->temporary_);
+}
+
+void DoubleCallEliminateVisitor::Visit(MemExpression *mem_expression) {
+  tos_value_.expression_ = new MemExpression(
+      Accept(mem_expression->expression_).expression_
+  );
+}
+
+void DoubleCallEliminateVisitor::Visit(JumpStatement *jump_statement) {
+  tos_value_.statement_ = new JumpStatement(
+      jump_statement->label_
+  );
+}
+void DoubleCallEliminateVisitor::Visit(CallExpression *call_expression) {
+  auto func = Accept(call_expression->function_name_).expression_;
+  auto args = Accept(call_expression->args_).expression_list_;
+
+  Temporary temp;
+
+  tos_value_.expression_ = new EseqExpression(
+      new MoveStatement(
+          new TempExpression(temp),
+          new CallExpression(
+              func,
+              args
+          )
+      ),
+      new TempExpression(temp)
+  );
+}
+void DoubleCallEliminateVisitor::Visit(ExpressionList *expression_list) {
+  auto expression_list_ = new ExpressionList();
+
+  for (auto expression: expression_list->expressions_) {
+    expression_list_->Add(Accept(expression).expression_);
+  }
+  tos_value_.expression_list_ = expression_list_;
+
+}
+
+void DoubleCallEliminateVisitor::Visit(NameExpression *name_expression) {
+  tos_value_.expression_ = new NameExpression(name_expression->label_);
+}
+
+void DoubleCallEliminateVisitor::Visit(EseqExpression *eseq_expression) {
+  auto stmt = Accept(eseq_expression->statement_).statement_;
+  auto expr = Accept(eseq_expression->expression_).expression_;
+
+  tos_value_.expression_ = new EseqExpression(stmt, expr);
+}
+
+Statement *DoubleCallEliminateVisitor::GetTree() {
+  return tos_value_.statement_;
+}

compiler/IR/visitors/DoubleCallEliminateVisitor.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "IRTStorage.h"
+#include "TemplateVisitor.h"
+
+namespace IRT {
+
+class DoubleCallEliminateVisitor : public TemplateVisitor<IRTStorage> {
+ public:
+  void Visit(ExpStatement *stmt) override;
+  void Visit(ConstExpression *const_expression) override;
+  void Visit(JumpConditionalStatement *jump_conditional_statement) override;
+  void Visit(MoveStatement *move_statement) override;
+  void Visit(SeqStatement *seq_statement) override;
+  void Visit(LabelStatement *label_statement) override;
+  void Visit(BinopExpression *binop_statement) override;
+  void Visit(TempExpression *temp_exression) override;
+  void Visit(MemExpression *mem_expression) override;
+  void Visit(JumpStatement *jump_statement) override;
+  void Visit(CallExpression *call_expression) override;
+  void Visit(ExpressionList *expression_list) override;
+  void Visit(NameExpression *name_expression) override;
+  void Visit(EseqExpression *eseq_expression) override;
+
+  Statement *GetTree();
+};
+
+}  // namespace IRT