aboutsummaryrefslogtreecommitdiff
path: root/build2/algorithm.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'build2/algorithm.cxx')
-rw-r--r--build2/algorithm.cxx334
1 files changed, 323 insertions, 11 deletions
diff --git a/build2/algorithm.cxx b/build2/algorithm.cxx
index fc7ef88..a3f4d0a 100644
--- a/build2/algorithm.cxx
+++ b/build2/algorithm.cxx
@@ -205,21 +205,19 @@ namespace build2
}
target_lock
- add_adhoc_member (action a, target& t, const target_type& tt, const char* s)
+ add_adhoc_member (action a,
+ target& t,
+ const target_type& tt,
+ const dir_path& dir,
+ const dir_path& out,
+ const string& n)
{
- string n (t.name);
- if (s != nullptr)
- {
- n += '.';
- n += s;
- }
-
const_ptr<target>* mp (&t.member);
for (; *mp != nullptr && !(*mp)->is_a (tt); mp = &(*mp)->member) ;
const target& m (*mp != nullptr // Might already be there.
? **mp
- : search (t, tt, t.dir, t.out, n));
+ : search (t, tt, dir, out, n));
target_lock l (lock (a, m));
assert (l.target != nullptr); // Someone messing with ad hoc members?
@@ -227,7 +225,7 @@ namespace build2
if (*mp == nullptr)
*mp = l.target;
else
- assert ((*mp)->name == n); // Basic sanity check.
+ assert ((*mp)->dir == dir && (*mp)->name == n); // Basic sanity check.
return l;
};
@@ -896,6 +894,286 @@ namespace build2
return ts;
}
+ void
+ update_backlink (const file& f, const path& l, bool changed)
+ {
+ const path& p (f.path ());
+ dir_path d (l.directory ());
+
+ // At low verbosity levels we print the command if the target changed or
+ // the link does not exist (we also treat errors as "not exist" and let
+ // the link update code below handle it).
+ //
+ // Note that in the changed case we print it even if the link is not
+ // actually updated to signal to the user that the updated out target is
+ // now available in src.
+ //
+ if (verb <= 2)
+ {
+ if (changed || !butl::entry_exists (l,
+ false /* follow_symlinks */,
+ true /* ignore_errors */))
+ {
+ if (verb >= 2)
+ text << "ln -s " << p << ' ' << l;
+ else
+ text << "ln " << f << " -> " << d;
+ }
+ }
+
+ // What if there is no such subdirectory in src (some like to stash their
+ // executables in bin/ or some such). The easiest is probably just to
+ // create it even though we won't be cleaning it up.
+ //
+ if (!exists (d))
+ mkdir_p (d, 2 /* verbosity */);
+
+ update_backlink (p, l);
+ }
+
+ void
+ update_backlink (const path& p, const path& l, bool changed)
+ {
+ // As above but with a slightly different diagnostics.
+
+ dir_path d (l.directory ());
+
+ if (verb <= 2)
+ {
+ if (changed || !butl::entry_exists (l,
+ false /* follow_symlinks */,
+ true /* ignore_errors */))
+ {
+ if (verb >= 2)
+ text << "ln -s " << p.string () << ' ' << l.string ();
+ else
+ text << "ln " << p.string () << " -> " << d;
+ }
+ }
+
+ if (!exists (d))
+ mkdir_p (d, 2 /* verbosity */);
+
+ update_backlink (p, l);
+ }
+
+ void
+ update_backlink (const path& p, const path& l)
+ {
+ bool d (l.to_directory ());
+
+ bool sym (true);
+ auto print = [&sym, &p, &l] ()
+ {
+ if (verb >= 3)
+ text << (sym ? "ln -sf" : "ln -f")
+ << ' ' << p.string ()
+ << ' ' << l.string (); // 'ln foo/ bar/' means different thing.
+ };
+
+ try
+ {
+ try_rmfile (l); // Normally will be there.
+
+ // Skip (ad hoc) targets that don't exist.
+ //
+ if (!(d ? dir_exists (p) : file_exists (p)))
+ return;
+
+ try
+ {
+ mksymlink (p, l, d);
+ }
+ catch (const system_error& e)
+ {
+ // If symlinks not supported, try a hardlink.
+ //
+ // Note that we are not guaranteed that the system_error exception is
+ // of the generic category.
+ //
+ int c (e.code ().value ());
+ if (!(e.code ().category () == generic_category () &&
+ (c == ENOSYS || // Not implemented.
+ c == EPERM))) // Not supported by the filesystem(s).
+ throw;
+
+ sym = false;
+ mkhardlink (p, l, d);
+ }
+ }
+ catch (const system_error& e)
+ {
+ print ();
+ fail << "unable to create " << (sym ? "symlink " : " hardlink ") << l
+ << ": " << e;
+ }
+
+ print ();
+ }
+
+ void
+ clean_backlink (const path& l, uint16_t verbosity)
+ {
+ // Assuming this works for directories (which can only be symlinked). See
+ // also try_rmfile() calls in ~backlink() and update_backlink().
+ //
+ rmfile (l, verbosity);
+ }
+
+ // If target/link path are syntactically to a directory, then the backlink
+ // is assumed to be to a directory, otherwise -- to a file.
+ //
+ struct backlink: auto_rm<path>
+ {
+ using path_type = build2::path;
+
+ reference_wrapper<const path_type> target;
+
+ backlink (const path_type& t, path_type&& l)
+ : auto_rm<path_type> (move (l)), target (t)
+ {
+ assert (t.to_directory () == path.to_directory ());
+ }
+
+ ~backlink ()
+ {
+ if (active)
+ {
+ // Assuming this works for both file and directory (sym)links.
+ //
+ try_rmfile (path, true /* ignore_errors */);
+ active = false;
+ }
+ }
+
+ backlink (backlink&&) = default;
+ backlink& operator= (backlink&&) = default;
+ };
+
+ // Normally (i.e., on sane platforms that don't have things like PDBs, etc)
+ // there will be just one backlink so optimize for that.
+ //
+ using backlinks = small_vector<backlink, 1>;
+
+ static bool
+ backlink_test (action a, target& t)
+ {
+ // Note: the order of these checks is from the least to most expensive.
+
+ // Only for plain update/clean.
+ //
+ if (a.outer () || (a != perform_update_id && a != perform_clean_id))
+ return false;
+
+ // Only file-based targets in the out tree can be backlinked.
+ //
+ if (!t.out.empty () || !t.is_a<file> ())
+ return false;
+
+ // An in-src configuration cannot be forwarded.
+ //
+ const scope& bs (t.base_scope ());
+ if (bs.src_path () == bs.out_path ())
+ return false;
+
+ // Only for forwarded configurations.
+ //
+ if (!cast_false<bool> (bs.root_scope ()->vars[var_forwarded]))
+ return false;
+
+ lookup l (t[var_backlink]);
+
+ // If not found, check for some defaults in the global scope (this does
+ // not happen automatically since target type/pattern-specific lookup
+ // stops at the project boundary).
+ //
+ if (!l.defined ())
+ l = global_scope->find (*var_backlink, t.key ());
+
+ return cast_false<bool> (l);
+ }
+
+ static backlinks
+ backlink_collect (target& t)
+ {
+ const scope& s (t.base_scope ());
+
+ backlinks bls;
+ auto add = [&bls, &s] (const path& p)
+ {
+ bls.emplace_back (p, s.src_path () / p.leaf (s.out_path ()));
+ };
+
+ // First the target itself.
+ //
+ add (t.as<file> ().path ());
+
+ // Then ad hoc group file/fsdir members, if any.
+ //
+ for (const target* m (t.member); m != nullptr; m = m->member)
+ {
+ if (const file* f = m->is_a<file> ())
+ {
+ const path& p (f->path ());
+
+ if (!p.empty ()) // The "trust me, it's somewhere" case.
+ add (p);
+ }
+ else if (const fsdir* d = m->is_a<fsdir> ())
+ add (d->dir);
+ }
+
+ return bls;
+ }
+
+ static inline backlinks
+ backlink_update_pre (target& t)
+ {
+ return backlink_collect (t);
+ }
+
+ static void
+ backlink_update_post (target& t, target_state ts, backlinks& bls)
+ {
+ if (ts == target_state::failed)
+ return; // Let auto rm clean things up.
+
+ // Make backlinks.
+ //
+ for (auto b (bls.begin ()), i (b); i != bls.end (); ++i)
+ {
+ const backlink& bl (*i);
+
+ if (i == b)
+ update_backlink (t.as<file> (), bl.path, ts == target_state::changed);
+ else
+ update_backlink (bl.target, bl.path);
+ }
+
+ // Cancel removal.
+ //
+ for (backlink& bl: bls)
+ bl.cancel ();
+ }
+
+ static void
+ backlink_clean_pre (target& t)
+ {
+ backlinks bls (backlink_collect (t));
+
+ for (auto b (bls.begin ()), i (b); i != bls.end (); ++i)
+ {
+ backlink& bl (*i);
+ const path& l (bl.path);
+
+ bl.cancel ();
+
+ // Printing anything at level 1 will probably just add more noise.
+ //
+ clean_backlink (l, i == b ? 2 : 3 /* verbosity */);
+ }
+ }
+
static target_state
execute_impl (action a, target& t)
{
@@ -904,7 +1182,41 @@ namespace build2
assert (s.task_count.load (memory_order_consume) == target::count_busy ()
&& s.state == target_state::unknown);
- target_state ts (execute_recipe (a, t, s.recipe));
+ target_state ts;
+ try
+ {
+ // Handle target backlinking to forwarded configurations.
+ //
+ // Note that this function will never be called if the recipe is noop
+ // which is ok since such targets are probably not interesting for
+ // backlinking.
+ //
+ backlinks bls;
+ bool bl (backlink_test (a, t));
+
+ if (bl)
+ {
+ if (a == perform_update_id)
+ bls = backlink_update_pre (t);
+ else
+ backlink_clean_pre (t);
+ }
+
+ ts = execute_recipe (a, t, s.recipe);
+
+ if (bl)
+ {
+ if (a == perform_update_id)
+ backlink_update_post (t, ts, bls);
+ }
+ }
+ catch (const failed&)
+ {
+ // If we could not backlink the target, then the best way to signal the
+ // failure seems to be to mark the target as failed.
+ //
+ ts = s.state = target_state::failed;
+ }
// Decrement the target count (see set_recipe() for details).
//