Implement clean operation

1 files changed, 190 insertions, 57 deletions

diff --git a/build/rule.cxx b/build/rule.cxx
index f193760..2359445 100644
--- a/build/rule.cxx
+++ b/build/rule.cxx
@@ -10,7 +10,8 @@
 #include <build/algorithm>
 #include <build/diagnostics>
 #include <build/timestamp>
-#include <build/mkdir>
+#include <build/filesystem>
+#include <build/context>
 
 using namespace std;
 
@@ -21,52 +22,94 @@ namespace build
 
   // path_rule
   //
+  // Note that this rule is special. It is the last, fallback rule. If
+  // it doesn't match, then no other rule can possibly match and we have
+  // an error. It also cannot be ambigious with any other rule. As a
+  // result the below implementation bends or ignores quite a few rules
+  // that normal implementations should follow. So you probably shouldn't
+  // use it as a guide to implement your own, normal, rules.
+  //
   void* path_rule::
   match (action a, target& t, const string&) const
   {
-    // @@ TODO:
-    //
-    // - need to try all the target-type-specific extensions, just
-    //   like search_existing_file().
+    // While strictly speaking we should check for the file's existence
+    // for every action (because that's the condition for us matching),
+    // for some actions this is clearly a waste. Say, perform_clean: we
+    // are not doing anything for this action so not checking if the file
+    // exists seems harmless. What about, say, configure_update? Again,
+    // whether we match or not, there is nothing to be done for this
+    // action. And who knows, maybe the file doesn't exist during
+    // configure_update but will magically appear during perform_update.
+    // So the overall guideline seems to be this: if we don't do anything
+    // for the action (other than performing it on the prerequisites),
+    // then we match.
     //
-    path_target& pt (dynamic_cast<path_target&> (t));
-
-    if (pt.path ().empty ())
+    switch (a)
     {
-      path p (t.dir / path (pt.name));
+    case perform_update_id:
+      {
+        // @@ TODO:
+        //
+        // - need to try all the target-type-specific extensions, just
+        //   like search_existing_file().
+        //
+        path_target& pt (dynamic_cast<path_target&> (t));
 
-      // @@ TMP: target name as an extension.
-      //
-      const string& e (pt.ext != nullptr ? *pt.ext : pt.type ().name);
+        if (pt.path ().empty ())
+        {
+          path p (t.dir / path (pt.name));
+
+          // @@ TMP: target name as an extension.
+          //
+          const string& e (pt.ext != nullptr ? *pt.ext : pt.type ().name);
+
+          if (!e.empty ())
+          {
+            p += '.';
+            p += e;
+          }
 
-      if (!e.empty ())
+          // While strictly speaking we shouldn't do this in match(),
+          // no other rule should ever be ambiguous with the fallback
+          // one.
+          //
+          pt.path (move (p));
+        }
+
+        return pt.mtime () != timestamp_nonexistent ? &t : nullptr;
+      }
+    default:
       {
-        p += '.';
-        p += e;
+        return &t;
       }
-
-      // While strictly speaking we shouldn't do this in match(),
-      // no other rule should ever be ambiguous with this fallback
-      // one.
-      //
-      pt.path (move (p));
     }
-
-    return pt.mtime () != timestamp_nonexistent ? &t : nullptr;
   }
 
   recipe path_rule::
   apply (action a, target& t, void*) const
   {
+    // Update triggers the update of this target's prerequisites
+    // so it would seem natural that we should also trigger their
+    // cleanup. However, this possibility is rather theoretical
+    // since such an update would render this target out of date
+    // which in turn would lead to an error. So until we see a
+    // real use-case for this functionality, we simply ignore
+    // the clean operation.
+    //
+    if (a.operation () == clean_id)
+      return noop_recipe;
+
     // Search and match all the prerequisites.
     //
     search_and_match (a, t);
 
-    return &update;
+    return a == perform_update_id
+      ? &perform_update
+      : t.prerequisites.empty () ? noop_recipe : default_recipe;
   }
 
   target_state path_rule::
-  update (action a, target& t)
+  perform_update (action a, target& t)
   {
     // Make sure the target is not older than any of its prerequisites.
     //
@@ -75,7 +118,7 @@ namespace build
     for (const prerequisite& p: t.prerequisites)
     {
       target& pt (*p.target);
-      target_state ts (update (a, pt));
+      target_state ts (execute (a, pt));
 
       // If this is an mtime-based target, then compare timestamps.
       //
@@ -113,17 +156,17 @@ namespace build
   recipe dir_rule::
   apply (action a, target& t, void*) const
   {
-    search_and_match (a, t);
-    return &update;
-  }
-
-  target_state dir_rule::
-  update (action a, target& t)
-  {
-    // Return changed if any of our prerequsites were updated and
-    // unchanged otherwise.
+    // When cleaning, ignore prerequisites that are not in the same
+    // or a subdirectory of ours.
     //
-    return execute_prerequisites (a, t);
+    switch (a.operation ())
+    {
+    case update_id: search_and_match (a, t); break;
+    case clean_id:  search_and_match (a, t, t.dir); break;
+    default:        assert (false);
+    }
+
+    return default_recipe;
   }
 
   // fsdir_rule
@@ -137,47 +180,137 @@ namespace build
   recipe fsdir_rule::
   apply (action a, target& t, void*) const
   {
-    // Let's not allow any prerequisites for this target since it
-    // doesn't make much sense. The sole purpose of this target type
-    // is to create a directory.
-    //
-    if (!t.prerequisites.empty ())
-      fail << "no prerequisites allowed for target " << t;
+    switch (a.operation ())
+    {
+    case update_id:
+      {
+        search_and_match (a, t);
+        break;
+      }
+    case clean_id:
+      {
+        // Ignore prerequisites that are not in the same or a subdirectory
+        // of ours (if t.dir is foo/bar/, then "we" are bar and our directory
+        // is foo/). Just meditate on it a bit and you will see the light.
+        //
+        search_and_match (a, t, t.dir.root () ? t.dir : t.dir.directory ());
+        break;
+      }
+    default:
+      assert (false);
+    }
 
-    return &update;
+    switch (a)
+    {
+    case perform_update_id: return &perform_update;
+    case perform_clean_id: return &perform_clean;
+    default: return noop_recipe;
+    }
   }
 
   target_state fsdir_rule::
-  update (action a, target& t)
+  perform_update (action a, target& t)
   {
-    path d (t.dir / path (t.name));
+    target_state ts (target_state::unchanged);
 
-    // Add the extension back if it was specified.
+    // First update prerequisites (e.g. create parent directories)
+    // then create this directory.
     //
-    if (t.ext != nullptr)
+    if (!t.prerequisites.empty ())
+      ts = execute_prerequisites (a, t);
+
+    const path& d (t.dir); // Everything is in t.dir.
+
+    if (path_mtime (d) == timestamp_nonexistent)
     {
-      d += '.';
-      d += *t.ext;
+      if (verb >= 1)
+        text << "mkdir " << d.string ();
+      else
+        text << "mkdir " << t;
+
+      try
+      {
+        mkdir (d);
+      }
+      catch (const system_error& e)
+      {
+        fail << "unable to create directory " << d.string () << ": "
+             << e.what ();
+      }
+
+      ts = target_state::changed;
     }
 
-    if (path_mtime (d) != timestamp_nonexistent)
+    return ts;
+  }
+
+  target_state fsdir_rule::
+  perform_clean (action a, target& t)
+  {
+    // Wait until the last dependent to get an empty directory.
+    //
+    if (t.dependents != 0)
+    {
+      t.state = target_state::unknown;
       return target_state::unchanged;
+    }
 
-    if (verb >= 1)
-      text << "mkdir " << d.string ();
-    else
-      text << "mkdir " << t; //@@ Probably only show if [show]?
+    // The reverse order of update: first delete this directory,
+    // then clean prerequisites (e.g., delete parent directories).
+    //
+    const path& d (t.dir); // Everything is in t.dir.
+    bool w (d == work); // Don't try to delete working directory.
+
+    rmdir_status rs;
 
+    // We don't want to print the command if we couldn't delete the
+    // directory because it does not exist (just like we don't print
+    // mkdir if it already exists) or if it is not empty. This makes
+    // the below code a bit ugly.
+    //
     try
     {
-      mkdir (d);
+      rs = !w ? try_rmdir (d) : rmdir_status::not_empty;
     }
     catch (const system_error& e)
     {
-      fail << "unable to create directory " << d.string () << ": "
+      if (verb >= 1)
+        text << "rmdir " << d.string ();
+      else
+        text << "rmdir " << t;
+
+      fail << "unable to delete directory " << d.string () << ": "
            << e.what ();
     }
 
-    return target_state::changed;
+    switch (rs)
+    {
+    case rmdir_status::success:
+      {
+        if (verb >= 1)
+          text << "rmdir " << d.string ();
+        else
+          text << "rmdir " << t;
+
+        break;
+      }
+    case rmdir_status::not_empty:
+      {
+        if (verb >= 1)
+          text << "directory " << d.string () << " is "
+               << (w ? "cwd" : "not empty") << ", not removing";
+
+        break;
+      }
+    case rmdir_status::not_exist:
+      break;
+    }
+
+    target_state ts (target_state::unchanged);
+
+    if (!t.prerequisites.empty ())
+      ts = execute_prerequisites (a, t);
+
+    return rs == rmdir_status::success ? target_state::changed : ts;
   }
 }