Rework resolved prerequisite targets storage

1 files changed, 7 insertions, 139 deletions

diff --git a/build/algorithm.txx b/build/algorithm.txx
index 4f5f9f3..a62603d 100644
--- a/build/algorithm.txx
+++ b/build/algorithm.txx
@@ -2,126 +2,25 @@
 // copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
 // license   : MIT; see accompanying LICENSE file
 
-#include <build/context>
-#include <build/utility> // reverse_iterate
-
 namespace build
 {
-  template <executor_function* E>
-  target_state
-  execute_prerequisites (action a, target& t)
-  {
-    target_state ts (target_state::unchanged);
-
-    if (t.group != nullptr)
-      ts = execute_prerequisites<E> (a, *t.group);
-
-    for (target* pt: t.prerequisites)
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      if (E (a, *pt) == target_state::changed)
-        ts = target_state::changed;
-    }
-
-    return ts;
-  }
-
-  template <executor_function* E>
-  target_state
-  reverse_execute_prerequisites (action a, target& t)
-  {
-    target_state ts (target_state::unchanged);
-
-    for (target* pt: reverse_iterate (t.prerequisites))
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      if (E (a, *pt) == target_state::changed)
-        ts = target_state::changed;
-    }
-
-    if (t.group != nullptr)
-    {
-      if (reverse_execute_prerequisites<E> (a, *t.group) ==
-            target_state::changed)
-        ts = target_state::changed;
-    }
-
-    return ts;
-  }
-
-  template <executor_function* E>
-  bool
-  execute_prerequisites (action a, target& t, const timestamp& mt)
-  {
-    bool e (mt == timestamp_nonexistent);
-
-    if (t.group != nullptr)
-    {
-      if (execute_prerequisites<E> (a, *t.group, mt))
-        e = true;
-    }
-
-    for (target* pt: t.prerequisites)
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      target_state ts (E (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;
-  }
-
-  template <typename T, executor_function* E>
+  template <typename T>
   T*
-  execute_find_prerequisites (
-    action a, target& t, const timestamp& mt, bool& e)
+  execute_prerequisites (action a, target& t, const timestamp& mt)
   {
     //@@ Can factor the bulk of it into a non-template code. Can
     // either do a function template that will do dynamic_cast check
     // or can scan the target type info myself. I think latter.
     //
+    bool e (mt == timestamp_nonexistent);
     T* r (nullptr);
 
-    if (t.group != nullptr)
-      r = execute_find_prerequisites<T, E> (a, *t.group, mt, e);
-
-    for (target* pt: t.prerequisites)
+    for (target* pt: t.prerequisite_targets)
     {
       if (pt == nullptr) // Skip ignored.
         continue;
 
-      target_state ts (E (a, *pt));
+      target_state ts (execute (a, *pt));
 
       if (!e)
       {
@@ -153,38 +52,7 @@ namespace build
         r = tmp;
     }
 
-    return r;
-  }
-
-  template <executor_function* E = execute>
-  target_state
-  default_action (action a, target& t)
-  {
-    return current_mode == execution_mode::first
-      ? execute_prerequisites<E> (a, t)
-      : reverse_execute_prerequisites<E> (a, t);
-  }
-
-  template <executor_function* E>
-  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<E> (a, t));
-
-    return r ? target_state::changed : ts;
+    assert (r != nullptr);
+    return e ? r : nullptr;
   }
 }