source/target.cpp

   1 #include <msp/fs/stat.h>
   2 #include <msp/fs/utils.h>
   3 #include "builder.h"
   4 #include "filetarget.h"
   5 #include "package.h"
   6 #include "target.h"
   7 #include "task.h"
   8 #include "tool.h"
   9
  10 using namespace std;
  11 using namespace Msp;
  12
  13 Target::Target(Builder &b, const Package *p, const string &n):
  14         builder(b),
  15         package(p),
  16         name(n),
  17         tool(0),
  18         buildable(false),
  19         building(false),
  20         rebuild(false),
  21         deps_ready(false),
  22         preparing(false),
  23         prepared(false)
  24 {
  25         builder.add_target(this);
  26 }
  27
  28 Target *Target::get_buildable_target()
  29 {
  30         if(!rebuild)
  31                 return 0;
  32
  33         bool self_ok = !building;
  34         for(TargetList::iterator i=depends.begin(); i!=depends.end(); ++i)
  35         {
  36                 Target *tgt = (*i)->get_buildable_target();
  37                 if(tgt)
  38                         return tgt;
  39                 else if((*i)->get_rebuild())
  40                         self_ok = false;
  41         }
  42
  43         if(self_ok)
  44                 return this;
  45
  46         return 0;
  47 }
  48
  49 void Target::set_tool(const Tool &t)
  50 {
  51         tool = &t;
  52 }
  53
  54 void Target::add_depend(Target *dep)
  55 {
  56         if(dep==this)
  57                 throw invalid_argument("Target::add_depend");
  58         depends.push_back(dep);
  59 }
  60
  61 void Target::prepare()
  62 {
  63         if(prepared)
  64                 return;
  65         if(preparing)
  66         {
  67                 builder.problem((package ? package->get_name() : string()), "Dependency cycle detected at "+name);
  68                 return;
  69         }
  70
  71         preparing = true;
  72         for(TargetList::iterator i=depends.begin(); i!=depends.end(); ++i)
  73                 (*i)->prepare();
  74
  75         check_rebuild();
  76         preparing = false;
  77         prepared = true;
  78 }
  79
  80 Task *Target::build()
  81 {
  82         if(!buildable)
  83         {
  84                 rebuild = false;
  85                 return 0;
  86         }
  87         if(!tool)
  88                 throw logic_error("buildable && !tool");
  89
  90         // XXX Minor breach of OO here
  91         if(FileTarget *ft = dynamic_cast<FileTarget *>(this))
  92                 if(!builder.get_dry_run() && FS::exists(ft->get_path()))
  93                         FS::unlink(ft->get_path());
  94
  95         Task *task = tool->run(*this);
  96         task->signal_finished.connect(sigc::mem_fun(this, &Target::build_finished));
  97         building = true;
  98
  99         return task;
 100 }
 101
 102 void Target::mark_rebuild(const std::string &reason)
 103 {
 104         rebuild = true;
 105         rebuild_reason = reason;
 106 }
 107
 108 void Target::build_finished(bool /*success*/)
 109 {
 110         building = false;
 111         rebuild = false;
 112 }