src/compiler.cc

   1 #include <iostream>
   2 #include <fstream>
   3 #include <algorithm>
   4 #include <boost/foreach.hpp>
   5
   6 #include <core/assert.hh>
   7 #include <core/string.hh>
   8 #include <core/process.hh>
   9 #include <ast/ast.hh>
  10 #include <ast/ascii-visitor.hh>
  11 #include <ast/llvm-asm-generator-visitor.hh>
  12 #include <ast/type-checker-visitor.hh>
  13 #include <ast/simplify-visitor.hh>
  14 #include <ast/scope-builder-visitor.hh>
  15 #include <lang/parser-factory.hh>
  16 #include <compiler.hh>
  17 #include <task.hh>
  18 #include <parse-task.hh>
  19
  20 template class core::Singleton<Compiler>;
  21
  22 Compiler::Compiler()
  23   : core::Singleton<Compiler>(),
  24     tasks_(),
  25     astDumpParse_(false),
  26     astDumpTypeCheck_(false),
  27     astDumpSimplify_(false)
  28 {
  29 }
  30
  31 Compiler::~Compiler()
  32 {
  33 }
  34
  35 void
  36 Compiler::addTask(Task * task)
  37 {
  38   assert(task);
  39   std::vector<Task *> * deps = task->dependancies();
  40   if (deps)
  41   {
  42     BOOST_FOREACH(Task * dep, *deps)
  43       addTask(dep);
  44     delete deps;
  45   }
  46   tasks_.push_back(task);
  47 }
  48
  49 void
  50 Compiler::compile()
  51 {
  52   std::sort(tasks_.begin(), tasks_.end());
  53   std::unique(tasks_.begin(), tasks_.end());
  54   BOOST_FOREACH(Task * task, tasks_)
  55   {
  56     assert(task);
  57     task->accept(*this);
  58   }
  59 }
  60
  61 void
  62 Compiler::work(Task & /*task*/)
  63 {
  64   assert(false);
  65 }
  66
  67 void
  68 Compiler::work(ParseTask & task)
  69 {
  70   ast::File * file = lang::ParserFactory::parseFile(task.filename);
  71   file->path = task.filename;
  72   if (astDumpParse_) {
  73     std::cout << "Parsed AST" << std::endl;
  74     ast::AsciiVisitor v;
  75     file->accept(v);
  76   }
  77
  78   ast::ScopeBuilderVisitor sbv;
  79   file->accept(sbv);
  80
  81   ast::TypeCheckerVisitor tcv;
  82   file->accept(tcv);
  83   if (astDumpTypeCheck_) {
  84     std::cout << "TypeChecked AST" << std::endl;
  85     ast::AsciiVisitor v;
  86     file->accept(v);
  87   }
  88
  89   ast::SimplifyVisitor sv;
  90   file->accept(sv);
  91   if (astDumpSimplify_) {
  92     std::cout << "Simplified AST" << std::endl;
  93     ast::AsciiVisitor v;
  94     file->accept(v);
  95   }
  96
  97   std::string asm_filename(task.filename);
  98   core::replace_extention(asm_filename, "ll");
  99   std::ofstream asm_stream(asm_filename.c_str(),
 100                            std::ios_base::out | std::ios_base::trunc);
 101   ast::LLVMAsmGeneratorVisitor lgv(asm_stream);
 102   file->accept(lgv);
 103   asm_stream.close();
 104
 105   core::Process llvm_as;
 106   llvm_as.setBinary("llvm-as");
 107   llvm_as.addArg("-f");
 108   llvm_as.addArg(asm_filename);
 109   llvm_as.run();
 110   assert(!llvm_as.wait());
 111
 112   std::string bc_filename(asm_filename);
 113   core::replace_extention(bc_filename, "bc");
 114   std::string bin_filename(asm_filename);
 115   core::replace_extention(bin_filename, "");
 116   core::Process llvm_ld;
 117   llvm_ld.setBinary("llvm-ld");
 118   llvm_ld.addArg("-native");
 119   llvm_ld.addArg("-o");
 120   llvm_ld.addArg(bin_filename);
 121   llvm_ld.addArg(bc_filename);
 122   llvm_ld.run();
 123   assert(!llvm_ld.wait());
 124 }