X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Ftarget.cpp;h=055abb56982203e6645873d10b428dae8e3e488f;hb=5e00719d0c63e306786ff36df61797cdbc86f3e9;hp=adde0cd180727b8ceb0a18d46455c60e3cf1f244;hpb=f8961a9113477735724a3a5229b9338bc9c0fe2e;p=builder.git diff --git a/source/target.cpp b/source/target.cpp index adde0cd..055abb5 100644 --- a/source/target.cpp +++ b/source/target.cpp @@ -1,8 +1,9 @@ +#include #include #include #include "builder.h" #include "filetarget.h" -#include "package.h" +#include "sourcepackage.h" #include "target.h" #include "task.h" #include "tool.h" @@ -10,32 +11,63 @@ using namespace std; using namespace Msp; -Target::Target(Builder &b, const Package *p, const string &n): +Target::Target(Builder &b, const string &n): builder(b), - package(p), + package(0), + component(0), name(n), tool(0), - building(false), - rebuild(false), - deps_ready(false), - preparing(false), - prepared(false) + state(INIT), + primary_target(0) { - builder.add_target(this); + builder.get_build_graph().add_target(this); +} + +void Target::add_dependency(Target &dep) +{ + if(&dep==this) + throw invalid_argument("Target::add_depend"); + depends.push_back(&dep); + if(state>PREPARING) + dep.signal_bubble_rebuild.connect(sigc::mem_fun(this, &Target::check_rebuild)); +} + +void Target::add_transitive_dependency(Target &dep) +{ + if(&dep==this) + throw invalid_argument("Target::add_transitive_dependency"); + trans_depends.push_back(&dep); +} + +void Target::add_side_effect(Target &se) +{ + side_effects.push_back(&se); + if(tool) + se.set_tool(*tool); + se.primary_target = this; + /* Side effects are checked for rebuild after the primary target. Recheck + the primary if a side effect is marked for rebuild. */ + se.signal_bubble_rebuild.connect(sigc::mem_fun(this, &Target::check_rebuild)); } Target *Target::get_buildable_target() { - if(!rebuild) + if(primary_target) + return primary_target->get_buildable_target(); + if(!needs_rebuild()) return 0; - bool self_ok = !building; - for(Dependencies::iterator i=depends.begin(); i!=depends.end(); ++i) + bool self_ok = state!=BUILDING; + for(Target *d: depends) { - Target *tgt = (*i)->get_buildable_target(); + // Avoid infinite recursion if a target depends on its own side effect + if(any_equals(side_effects, d)) + continue; + + Target *tgt = d->get_buildable_target(); if(tgt) return tgt; - else if((*i)->get_rebuild()) + else if(d->needs_rebuild()) self_ok = false; } @@ -45,65 +77,116 @@ Target *Target::get_buildable_target() return 0; } -void Target::set_tool(const Tool &t) +void Target::set_tool(Tool &t) { tool = &t; + for(Target *s: side_effects) + s->set_tool(t); } -void Target::add_depend(Target *dep) +void Target::collect_build_info(BuildInfo &binfo) const { - if(dep==this) - throw invalid_argument("Target::add_depend"); - depends.push_back(dep); + if(tool) + binfo.update_from(tool->get_build_info()); + if(component) + binfo.update_from(component->get_build_info()); + else if(package) + binfo.update_from(package->get_build_info()); +} + +void Target::force_rebuild() +{ + if(!is_buildable()) + throw logic_error("Target::force_rebuild"); + mark_rebuild("Forced rebuild"); +} + +void Target::mark_rebuild(const string &reason) +{ + if(reason.empty()) + throw invalid_argument("No reason given for rebuilding "+name); + + state = REBUILD; + rebuild_reason = reason; + + builder.get_logger().log("rebuild", "Rebuilding %s: %s", name, reason); + + signal_bubble_rebuild.emit(); } void Target::prepare() { - if(prepared) + if(state>PREPARING) return; - if(preparing) + if(state==PREPARING) { - builder.problem((package ? package->get_name() : string()), "Dependency cycle detected at "+name); + builder.get_logger().log("problems", "Dependency cycle detected at %s", name); + problems.push_back("Dependency cycle detected"); + state = BROKEN; return; } - preparing = true; - for(Dependencies::iterator i=depends.begin(); i!=depends.end(); ++i) - (*i)->prepare(); + state = PREPARING; + if(tool) + tool->prepare(); + + find_dependencies(); + bool broken = !problems.empty(); + + if(tool) + { + if(FileTarget *tool_exe = tool->get_executable()) + add_dependency(*tool_exe); + broken |= !tool->get_problems().empty(); + + // Only check package and component problems for buildable targets + // XXX How to propagate nested package problems? + broken |= (package && !package->get_problems().empty()); + broken |= (component && !component->get_problems().empty()); + } + + for(Target *d: depends) + { + d->prepare(); + broken |= d->is_broken(); + } + for(Target *d: trans_depends) + d->prepare(); check_rebuild(); - preparing = false; - prepared = true; + if(broken) + state = BROKEN; + else if(state==PREPARING) + state = UPTODATE; + + for(Target *d: depends) + d->signal_bubble_rebuild.connect(sigc::mem_fun(this, &Target::check_rebuild)); } Task *Target::build() { - if(!tool) - { - rebuild = false; - return 0; - } - - // XXX Minor breach of OO here - if(FileTarget *ft = dynamic_cast(this)) - if(!builder.get_dry_run() && FS::exists(ft->get_path())) - FS::unlink(ft->get_path()); + if(primary_target) + return primary_target->build(); Task *task = tool->run(*this); task->signal_finished.connect(sigc::mem_fun(this, &Target::build_finished)); - building = true; + state = BUILDING; - return task; -} + build(*task); + for(Target *s: side_effects) + s->build(*task); -void Target::mark_rebuild(const std::string &reason) -{ - rebuild = true; - rebuild_reason = reason; + return task; } -void Target::build_finished(bool /*success*/) +void Target::build_finished(bool success) { - building = false; - rebuild = false; + state = UPTODATE; + if(success) + { + modified(); + for(Target *s: side_effects) + s->build_finished(success); + signal_modified.emit(); + } }