aboutsummaryrefslogtreecommitdiff
path: root/build/algorithm.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'build/algorithm.cxx')
-rw-r--r--build/algorithm.cxx197
1 files changed, 158 insertions, 39 deletions
diff --git a/build/algorithm.cxx b/build/algorithm.cxx
index 9f428b3..e6a71df 100644
--- a/build/algorithm.cxx
+++ b/build/algorithm.cxx
@@ -5,6 +5,7 @@
#include <build/algorithm>
#include <memory> // unique_ptr
+#include <cstddef> // size_t
#include <utility> // move
#include <cassert>
@@ -14,6 +15,7 @@
#include <build/prerequisite>
#include <build/rule>
#include <build/search>
+#include <build/context>
#include <build/utility>
#include <build/diagnostics>
@@ -33,6 +35,12 @@ namespace build
void
match_impl (action a, target& t)
{
+ // Clear the resolved targets list before calling match(). The rule
+ // is free to, say, resize() this list in match() (provided that it
+ // matches) in order to, for example, prepare it for apply().
+ //
+ t.prerequisite_targets.clear ();
+
for (auto tt (&t.type ());
tt != nullptr && !t.recipe (a);
tt = tt->base)
@@ -148,30 +156,30 @@ namespace build
void
search_and_match (action a, target& t)
{
- if (t.group != nullptr)
- search_and_match (a, *t.group);
+ group_prerequisites gp (t);
+ t.prerequisite_targets.resize (gp.size ());
- for (prerequisite_target& p: t.prerequisites)
+ size_t i (0);
+ for (prerequisite& p: gp)
{
- p.target = &search (p);
- match (a, *p.target);
+ target& pt (search (p));
+ match (a, pt);
+ t.prerequisite_targets[i++] = &pt;
}
}
void
search_and_match (action a, target& t, const dir_path& d)
{
- if (t.group != nullptr)
- search_and_match (a, *t.group, d);
-
- for (prerequisite_target& p: t.prerequisites)
+ for (prerequisite& p: group_prerequisites (t))
{
- p.target = &search (p);
+ target& pt (search (p));
if (p.target->dir.sub (d))
- match (a, *p.target);
- else
- p.target = nullptr; // Ignore.
+ {
+ match (a, pt);
+ t.prerequisite_targets.push_back (&pt);
+ }
}
}
@@ -181,36 +189,41 @@ namespace build
tracer trace ("inject_parent_fsdir");
scope& s (t.base_scope ());
+ scope* rs (s.root_scope ());
- if (scope* rs = s.root_scope ()) // Could be outside any project.
- {
- const dir_path& out_root (rs->path ());
-
- // If t is a directory (name is empty), say foo/bar/, then
- // t is bar and its parent directory is foo/.
- //
- const dir_path& d (t.name.empty () ? t.dir.directory () : t.dir);
-
- if (d.sub (out_root) && d != out_root)
- {
- level5 ([&]{trace << "injecting prerequisite for " << t;});
-
- prerequisite& p (
- s.prerequisites.insert (
- fsdir::static_type,
- d,
- string (),
- nullptr,
- s,
- trace).first);
+ if (rs == nullptr) // Could be outside any project.
+ return;
- target& pt (search (p));
+ const dir_path& out_root (rs->path ());
- t.prerequisites.emplace_back (p, pt);
+ // If t is a directory (name is empty), say foo/bar/, then
+ // t is bar and its parent directory is foo/.
+ //
+ const dir_path& d (t.name.empty () ? t.dir.directory () : t.dir);
+
+ if (!d.sub (out_root) || d == out_root)
+ return;
+
+ prerequisite& p (
+ s.prerequisites.insert (
+ fsdir::static_type,
+ d,
+ string (),
+ nullptr,
+ s,
+ trace).first);
+
+ // This function is normally called from match() which means
+ // it can be called several times if we are performing several
+ // operations (e.g., clean update). Since it is a fairly common
+ // pattern to add this prerequisite at the end, do a quick check
+ // if the last prerequisite is already what we are about to add.
+ //
+ if (!t.prerequisites.empty () && &t.prerequisites.back ().get () == &p)
+ return;
- match (a, pt);
- }
- }
+ level5 ([&]{trace << "injecting prerequisite for " << t;});
+ t.prerequisites.emplace_back (p);
}
target_state
@@ -250,9 +263,115 @@ namespace build
}
target_state
+ execute_prerequisites (action a, target& t)
+ {
+ target_state ts (target_state::unchanged);
+
+ for (target* pt: t.prerequisite_targets)
+ {
+ if (pt == nullptr) // Skipped.
+ continue;
+
+ if (execute (a, *pt) == target_state::changed)
+ ts = target_state::changed;
+ }
+
+ return ts;
+ }
+
+ target_state
+ reverse_execute_prerequisites (action a, target& t)
+ {
+ target_state ts (target_state::unchanged);
+
+ for (target* pt: reverse_iterate (t.prerequisite_targets))
+ {
+ if (pt == nullptr) // Skipped.
+ continue;
+
+ if (execute (a, *pt) == target_state::changed)
+ ts = target_state::changed;
+ }
+
+ return ts;
+ }
+
+ bool
+ execute_prerequisites (action a, target& t, const timestamp& mt)
+ {
+ bool e (mt == timestamp_nonexistent);
+
+ for (target* pt: t.prerequisite_targets)
+ {
+ if (pt == nullptr) // Skipped.
+ continue;
+
+ target_state ts (execute (a, *pt));
+
+ if (!e)
+ {
+ // If this is an mtime-based target, then compare timestamps.
+ //
+ if (auto mpt = dynamic_cast<const mtime_target*> (pt))
+ {
+ timestamp mp (mpt->mtime ());
+
+ // What do we do if timestamps are equal? This can happen, for
+ // example, on filesystems that don't have subsecond resolution.
+ // There is not much we can do here except detect the case where
+ // the prerequisite was changed in this run which means the
+ // action must be executed on the target as well.
+ //
+ if (mt < mp || (mt == mp && ts == target_state::changed))
+ e = true;
+ }
+ else
+ {
+ // Otherwise we assume the prerequisite is newer if it was changed.
+ //
+ if (ts == target_state::changed)
+ e = true;
+ }
+ }
+ }
+
+ return e;
+ }
+
+ target_state
noop_action (action, target&)
{
assert (false); // We shouldn't be called, see target::recipe().
return target_state::unchanged;
}
+
+ target_state
+ default_action (action a, target& t)
+ {
+ return current_mode == execution_mode::first
+ ? execute_prerequisites (a, t)
+ : reverse_execute_prerequisites (a, t);
+ }
+
+ target_state
+ perform_clean (action a, target& t)
+ {
+ // The reverse order of update: first delete the file, then clean
+ // prerequisites.
+ //
+ file& ft (dynamic_cast<file&> (t));
+
+ bool r (rmfile (ft.path (), ft));
+
+ // Update timestamp in case there are operations after us that
+ // could use the information.
+ //
+ ft.mtime (timestamp_nonexistent);
+
+ // Clean prerequisites.
+ //
+ target_state ts (reverse_execute_prerequisites (a, t));
+
+ return r ? target_state::changed : ts;
+ }
}