Split build system into library and driver

1 files changed, 1660 insertions, 0 deletions

diff --git a/libbuild2/file.cxx b/libbuild2/file.cxx
new file mode 100644
index 0000000..5966168
--- /dev/null
+++ b/libbuild2/file.cxx
@@ -0,0 +1,1660 @@
+// file      : libbuild2/file.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <libbuild2/file.hxx>
+
+#include <iostream> // cin
+
+#include <libbuild2/scope.hxx>
+#include <libbuild2/target.hxx>
+#include <libbuild2/context.hxx>
+#include <libbuild2/filesystem.hxx>   // exists()
+#include <libbuild2/prerequisite.hxx>
+#include <libbuild2/diagnostics.hxx>
+
+#include <libbuild2/token.hxx>
+#include <libbuild2/lexer.hxx>
+#include <libbuild2/parser.hxx>
+
+using namespace std;
+using namespace butl;
+
+namespace build2
+{
+  // Standard and alternative build file/directory naming schemes.
+  //
+  const dir_path std_build_dir     ("build");
+  const dir_path std_root_dir      (dir_path (std_build_dir) /= "root");
+  const dir_path std_bootstrap_dir (dir_path (std_build_dir) /= "bootstrap");
+
+  const path std_root_file      (std_build_dir     / "root.build");
+  const path std_bootstrap_file (std_build_dir     / "bootstrap.build");
+  const path std_src_root_file  (std_bootstrap_dir / "src-root.build");
+  const path std_out_root_file  (std_bootstrap_dir / "out-root.build");
+  const path std_export_file    (std_build_dir     / "export.build");
+
+  const string std_build_ext        ("build");
+  const path   std_buildfile_file   ("buildfile");
+  const path   std_buildignore_file (".buildignore");
+
+  //
+
+  const dir_path alt_build_dir     ("build2");
+  const dir_path alt_root_dir      (dir_path (alt_build_dir) /= "root");
+  const dir_path alt_bootstrap_dir (dir_path (alt_build_dir) /= "bootstrap");
+
+  const path alt_root_file      (alt_build_dir     / "root.build2");
+  const path alt_bootstrap_file (alt_build_dir     / "bootstrap.build2");
+  const path alt_src_root_file  (alt_bootstrap_dir / "src-root.build2");
+  const path alt_out_root_file  (alt_bootstrap_dir / "out-root.build2");
+  const path alt_export_file    (alt_build_dir     / "export.build2");
+
+  const string alt_build_ext        ("build2");
+  const path   alt_buildfile_file   ("build2file");
+  const path   alt_buildignore_file (".build2ignore");
+
+  ostream&
+  operator<< (ostream& os, const subprojects& sps)
+  {
+    for (auto b (sps.begin ()), i (b); os && i != sps.end (); ++i)
+    {
+      // See find_subprojects() for details.
+      //
+      const project_name& n (
+        path::traits_type::is_separator (i->first.string ().back ())
+        ? empty_project_name
+        : i->first);
+
+      os << (i != b ? " " : "") << n << '@' << i->second;
+    }
+
+    return os;
+  }
+
+  // Check if the standard/alternative file/directory exists, returning empty
+  // path if it does not.
+  //
+  template <typename T>
+  static T
+  exists (const dir_path& d, const T& s, const T& a, optional<bool>& altn)
+  {
+    T p;
+    bool e;
+
+    if (altn)
+    {
+      p = d / (*altn ? a : s);
+      e = exists (p);
+    }
+    else
+    {
+      // Check the alternative name first since it is more specific.
+      //
+      p = d / a;
+
+      if ((e = exists (p)))
+        altn = true;
+      else
+      {
+        p = d / s;
+
+        if ((e = exists (p)))
+          altn = false;
+      }
+    }
+
+    return e ? p : T ();
+  }
+
+  bool
+  is_src_root (const dir_path& d, optional<bool>& altn)
+  {
+    // We can't have root without bootstrap.build.
+    //
+    return !exists (d, std_bootstrap_file, alt_bootstrap_file, altn).empty ();
+  }
+
+  bool
+  is_out_root (const dir_path& d, optional<bool>& altn)
+  {
+    return !exists (d, std_src_root_file, alt_src_root_file, altn).empty ();
+  }
+
+  dir_path
+  find_src_root (const dir_path& b, optional<bool>& altn)
+  {
+    for (dir_path d (b); !d.root () && d != home; d = d.directory ())
+    {
+      if (is_src_root (d, altn))
+        return d;
+    }
+
+    return dir_path ();
+  }
+
+  pair<dir_path, bool>
+  find_out_root (const dir_path& b, optional<bool>& altn)
+  {
+    for (dir_path d (b); !d.root () && d != home; d = d.directory ())
+    {
+      bool s;
+      if ((s = is_src_root (d, altn)) || is_out_root (d, altn))
+        return make_pair (move (d), s);
+    }
+
+    return make_pair (dir_path (), false);
+  }
+
+  dir_path old_src_root;
+  dir_path new_src_root;
+
+  // Remap the src_root variable value if it is inside old_src_root.
+  //
+  static inline void
+  remap_src_root (value& v)
+  {
+    if (!old_src_root.empty ())
+    {
+      dir_path& d (cast<dir_path> (v));
+
+      if (d.sub (old_src_root))
+        d = new_src_root / d.leaf (old_src_root);
+    }
+  }
+
+  static void
+  source (scope& root, scope& base, const path& bf, bool boot)
+  {
+    tracer trace ("source");
+
+    try
+    {
+      bool sin (bf.string () == "-");
+
+      ifdstream ifs;
+
+      if (!sin)
+        ifs.open (bf);
+      else
+        cin.exceptions (ifdstream::failbit | ifdstream::badbit);
+
+      istream& is (sin ? cin : ifs);
+
+      l5 ([&]{trace << "sourcing " << bf;});
+
+      parser p (boot);
+      p.parse_buildfile (is, bf, root, base);
+    }
+    catch (const io_error& e)
+    {
+      fail << "unable to read buildfile " << bf << ": " << e;
+    }
+  }
+
+  void
+  source (scope& root, scope& base, const path& bf)
+  {
+    source (root, base, bf, false);
+  }
+
+  bool
+  source_once (scope& root, scope& base, const path& bf, scope& once)
+  {
+    tracer trace ("source_once");
+
+    if (!once.buildfiles.insert (bf).second)
+    {
+      l5 ([&]{trace << "skipping already sourced " << bf;});
+      return false;
+    }
+
+    source (root, base, bf);
+    return true;
+  }
+
+  // Source (once) pre-*.build (pre is true) or post-*.build (otherwise) hooks
+  // from the specified directory (build/{bootstrap,root}/ of out_root) which
+  // must exist.
+  //
+  static void
+  source_hooks (scope& root, const dir_path& d, bool pre)
+  {
+    // While we could have used the wildcard pattern matching functionality,
+    // our needs are pretty basic and performance is quite important, so let's
+    // handle this ourselves.
+    //
+    try
+    {
+      for (const dir_entry& de: dir_iterator (d, false /* ignore_dangling */))
+      {
+        // If this is a link, then type() will try to stat() it. And if the
+        // link is dangling or points to something inaccessible, it will fail.
+        // So let's first check that the name matches and only then check the
+        // type.
+        //
+        const path& n (de.path ());
+
+        if (n.string ().compare (0,
+                                 pre ? 4 : 5,
+                                 pre ? "pre-" : "post-") != 0 ||
+            n.extension () != root.root_extra->build_ext)
+          continue;
+
+        path f (d / n);
+
+        try
+        {
+          if (de.type () != entry_type::regular)
+            continue;
+        }
+        catch (const system_error& e)
+        {
+          fail << "unable to read buildfile " << f << ": " << e;
+        }
+
+        source_once (root, root, f);
+      }
+    }
+    catch (const system_error& e)
+    {
+      fail << "unable to iterate over " << d << ": " << e;
+    }
+  }
+
+  scope_map::iterator
+  create_root (scope& l, const dir_path& out_root, const dir_path& src_root)
+  {
+    auto i (scopes.rw (l).insert (out_root, true /* root */));
+    scope& rs (i->second);
+
+    // Set out_path. Note that src_path is set in setup_root() below.
+    //
+    if (rs.out_path_ != &i->first)
+    {
+      assert (rs.out_path_ == nullptr);
+      rs.out_path_ = &i->first;
+    }
+
+    // If this is already a root scope, verify that things are consistent.
+    //
+    {
+      value& v (rs.assign (var_out_root));
+
+      if (!v)
+        v = out_root;
+      else
+      {
+        const dir_path& p (cast<dir_path> (v));
+
+        if (p != out_root)
+          fail << "new out_root " << out_root << " does not match "
+               << "existing " << p;
+      }
+    }
+
+    if (!src_root.empty ())
+    {
+      value& v (rs.assign (var_src_root));
+
+      if (!v)
+        v = src_root;
+      else
+      {
+        const dir_path& p (cast<dir_path> (v));
+
+        if (p != src_root)
+          fail << "new src_root " << src_root << " does not match "
+               << "existing " << p;
+      }
+    }
+
+    return i;
+  }
+
+  void
+  setup_root (scope& s, bool forwarded)
+  {
+    // The caller must have made sure src_root is set on this scope.
+    //
+    value& v (s.assign (var_src_root));
+    assert (v);
+    const dir_path& d (cast<dir_path> (v));
+
+    if (s.src_path_ == nullptr)
+      s.src_path_ = &d;
+    else
+      assert (s.src_path_ == &d);
+
+    s.assign (var_forwarded) = forwarded;
+  }
+
+  scope&
+  setup_base (scope_map::iterator i,
+              const dir_path& out_base,
+              const dir_path& src_base)
+  {
+    scope& s (i->second);
+
+    // Set src/out_base variables.
+    //
+    value& ov (s.assign (var_out_base));
+
+    if (!ov)
+      ov = out_base;
+    else
+      assert (cast<dir_path> (ov) == out_base);
+
+    value& sv (s.assign (var_src_base));
+
+    if (!sv)
+      sv = src_base;
+    else
+      assert (cast<dir_path> (sv) == src_base);
+
+    // Set src/out_path. The key (i->first) is out_base.
+    //
+    if (s.out_path_ == nullptr)
+      s.out_path_ = &i->first;
+    else
+      assert (*s.out_path_ == out_base);
+
+    if (s.src_path_ == nullptr)
+      s.src_path_ = &cast<dir_path> (sv);
+    else
+      assert (*s.src_path_ == src_base);
+
+    return s;
+  }
+
+  pair<scope&, scope*>
+  switch_scope (scope& root, const dir_path& p)
+  {
+    // First, enter the scope into the map and see if it is in any project. If
+    // it is not, then there is nothing else to do.
+    //
+    auto i (scopes.rw (root).insert (p));
+    scope& base (i->second);
+    scope* rs (base.root_scope ());
+
+    if (rs != nullptr)
+    {
+      // Path p can be src_base or out_base. Figure out which one it is.
+      //
+      dir_path out_base (p.sub (rs->out_path ()) ? p : src_out (p, *rs));
+
+      // Create and bootstrap root scope(s) of subproject(s) that this scope
+      // may belong to. If any were created, load them. Note that we need to
+      // do this before figuring out src_base since we may switch the root
+      // project (and src_root with it).
+      //
+      {
+        scope* nrs (&create_bootstrap_inner (*rs, out_base));
+
+        if (rs != nrs)
+          rs = nrs;
+      }
+
+      // Switch to the new root scope.
+      //
+      if (rs != &root)
+        load_root (*rs); // Load new root(s) recursively.
+
+      // Now we can figure out src_base and finish setting the scope.
+      //
+      dir_path src_base (src_out (out_base, *rs));
+      setup_base (i, move (out_base), move (src_base));
+    }
+
+    return pair<scope&, scope*> (base, rs);
+  }
+
+  dir_path
+  bootstrap_fwd (const dir_path& src_root, optional<bool>& altn)
+  {
+    path f (exists (src_root, std_out_root_file, alt_out_root_file, altn));
+
+    if (f.empty ())
+      return src_root;
+
+    // We cannot just source the buildfile since there is no scope to do
+    // this on yet.
+    //
+    auto p (extract_variable (f, *var_out_root));
+
+    if (!p.second)
+      fail << "variable out_root expected as first line in " << f;
+
+    try
+    {
+      return convert<dir_path> (move (p.first));
+    }
+    catch (const invalid_argument& e)
+    {
+      fail << "invalid out_root value in " << f << ": " << e << endf;
+    }
+  }
+
+  static void
+  setup_root_extra (scope& root, optional<bool>& altn)
+  {
+    assert (altn && root.root_extra == nullptr);
+    bool a (*altn);
+
+    root.root_extra = unique_ptr<scope::root_data> (
+      new scope::root_data {
+        a,
+        a ? alt_build_ext        : std_build_ext,
+        a ? alt_build_dir        : std_build_dir,
+        a ? alt_buildfile_file   : std_buildfile_file,
+        a ? alt_buildignore_file : std_buildignore_file,
+        a ? alt_root_dir         : std_root_dir,
+        a ? alt_bootstrap_dir    : std_bootstrap_dir,
+        a ? alt_bootstrap_file   : std_bootstrap_file,
+        a ? alt_root_file        : std_root_file,
+        a ? alt_export_file      : std_export_file,
+        a ? alt_src_root_file    : std_src_root_file,
+        a ? alt_out_root_file    : std_out_root_file,
+        {}, /* meta_operations */
+        {}, /* operations */
+        {}, /* modules */
+        {}  /* override_cache */});
+
+    // Enter built-in meta-operation and operation names. Loading of
+    // modules (via the src bootstrap; see below) can result in
+    // additional meta/operations being added.
+    //
+    root.insert_meta_operation (noop_id,    mo_noop);
+    root.insert_meta_operation (perform_id, mo_perform);
+    root.insert_meta_operation (info_id,    mo_info);
+
+    root.insert_operation (default_id, op_default);
+    root.insert_operation (update_id,  op_update);
+    root.insert_operation (clean_id,   op_clean);
+  }
+
+  void
+  bootstrap_out (scope& root, optional<bool>& altn)
+  {
+    const dir_path& out_root (root.out_path ());
+
+    path f (exists (out_root, std_src_root_file, alt_src_root_file, altn));
+
+    if (f.empty ())
+      return;
+
+    if (root.root_extra == nullptr)
+      setup_root_extra (root, altn);
+
+    //@@ TODO: if bootstrap files can source other bootstrap files (for
+    //   example, as a way to express dependecies), then we need a way to
+    //   prevent multiple sourcing. We handle it here but we still need
+    //   something like source_once (once [scope] source) in buildfiles.
+    //
+    source_once (root, root, f);
+  }
+
+  pair<value, bool>
+  extract_variable (const path& bf, const variable& var)
+  {
+    try
+    {
+      ifdstream ifs (bf);
+
+      lexer lex (ifs, bf);
+      token t (lex.next ());
+      token_type tt;
+
+      if (t.type != token_type::word || t.value != var.name ||
+          ((tt = lex.next ().type) != token_type::assign &&
+           tt != token_type::prepend &&
+           tt != token_type::append))
+      {
+        return make_pair (value (), false);
+      }
+
+      parser p;
+      temp_scope tmp (global_scope->rw ());
+      p.parse_variable (lex, tmp, var, tt);
+
+      value* v (tmp.vars.find_to_modify (var).first);
+      assert (v != nullptr);
+
+      // Steal the value, the scope is going away.
+      //
+      return make_pair (move (*v), true);
+    }
+    catch (const io_error& e)
+    {
+      fail << "unable to read buildfile " << bf << ": " << e << endf;
+    }
+  }
+
+  // Extract the project name from bootstrap.build.
+  //
+  static project_name
+  find_project_name (const dir_path& out_root,
+                     const dir_path& fallback_src_root,
+                     optional<bool> out_src, // True if out_root is src_root.
+                     optional<bool>& altn)
+  {
+    tracer trace ("find_project_name");
+
+    // First check if the root scope for this project has already been setup
+    // in which case we will have src_root and maybe even the name.
+    //
+    const dir_path* src_root (nullptr);
+    const scope& s (scopes.find (out_root));
+
+    if (s.root_scope () == &s && s.out_path () == out_root)
+    {
+      if (s.root_extra != nullptr)
+      {
+        if (!altn)
+          altn = s.root_extra->altn;
+        else
+          assert (*altn == s.root_extra->altn);
+      }
+
+      if (lookup l = s.vars[var_project])
+        return cast<project_name> (l);
+
+      src_root = s.src_path_;
+    }
+
+    // Load the project name. If this subdirectory is the subproject's
+    // src_root, then we can get directly to that. Otherwise, we first have to
+    // discover its src_root.
+    //
+    value src_root_v; // Need it to live until the end.
+
+    if (src_root == nullptr)
+    {
+      if (out_src ? *out_src : is_src_root (out_root, altn))
+        src_root = &out_root;
+      else
+      {
+        path f (exists (out_root, std_src_root_file, alt_src_root_file, altn));
+
+        if (f.empty ())
+        {
+          // Note: the same diagnostics as in main().
+          //
+          if (fallback_src_root.empty ())
+            fail << "no bootstrapped src_root for " << out_root <<
+              info << "consider reconfiguring this out_root";
+
+          src_root = &fallback_src_root;
+        }
+        else
+        {
+          auto p (extract_variable (f, *var_src_root));
+
+          if (!p.second)
+            fail << "variable src_root expected as first line in " << f;
+
+          src_root_v = move (p.first);
+          remap_src_root (src_root_v); // Remap if inside old_src_root.
+          src_root = &cast<dir_path> (src_root_v);
+
+          l5 ([&]{trace << "extracted src_root " << *src_root
+                        << " for " << out_root;});
+        }
+      }
+    }
+
+    project_name name;
+    {
+      path f (exists (*src_root, std_bootstrap_file, alt_bootstrap_file, altn));
+
+      if (f.empty ())
+        fail << "no build/bootstrap.build in " << *src_root;
+
+      auto p (extract_variable (f, *var_project));
+
+      if (!p.second)
+        fail << "variable " << var_project->name << " expected "
+             << "as a first line in " << f;
+
+      name = cast<project_name> (move (p.first));
+    }
+
+    l5 ([&]{trace << "extracted project name '" << name << "' for "
+                  << *src_root;});
+    return name;
+  }
+
+  // Scan the specified directory for any subprojects. If a subdirectory
+  // is a subproject, then enter it into the map, handling the duplicates.
+  //
+  static void
+  find_subprojects (subprojects& sps,
+                    const dir_path& d,
+                    const dir_path& root,
+                    bool out)
+  {
+    tracer trace ("find_subprojects");
+
+    try
+    {
+      for (const dir_entry& de: dir_iterator (d, true /* ignore_dangling */))
+      {
+        if (de.type () != entry_type::directory)
+          continue;
+
+        dir_path sd (d / path_cast<dir_path> (de.path ()));
+
+        bool src (false);
+        optional<bool> altn;
+
+        if (!((out && is_out_root (sd, altn)) ||
+              (src =  is_src_root (sd, altn))))
+        {
+          // We used to scan for subproject recursively but this is probably
+          // too loose (think of some tests laying around). In the future we
+          // should probably allow specifying something like extra/* or
+          // extra/** in subprojects.
+          //
+          //find_subprojects (sps, sd, root, out);
+          //
+          continue;
+        }
+
+        // Calculate relative subdirectory for this subproject.
+        //
+        dir_path dir (sd.leaf (root));
+        l5 ([&]{trace << "subproject " << sd << " as " << dir;});
+
+        // Load its name. Note that here we don't use fallback src_root
+        // since this function is used to scan both out_root and src_root.
+        //
+        project_name name (find_project_name (sd, dir_path (), src, altn));
+
+        // If the name is empty, then is is an unnamed project. While the
+        // 'project' variable stays empty, here we come up with a surrogate
+        // name for a key. The idea is that such a key should never conflict
+        // with a real project name. We ensure this by using the project's
+        // sub-directory and appending a trailing directory separator to it.
+        //
+        if (name.empty ())
+          name = project_name (dir.posix_string () + '/',
+                               project_name::raw_string);
+
+        // @@ Can't use move() because we may need the values in diagnostics
+        // below. Looks like C++17 try_emplace() is what we need.
+        //
+        auto rp (sps.emplace (name, dir));
+
+        // Handle duplicates.
+        //
+        if (!rp.second)
+        {
+          const dir_path& dir1 (rp.first->second);
+
+          if (dir != dir1)
+            fail << "inconsistent subproject directories for " << name <<
+              info << "first alternative: " << dir1 <<
+              info << "second alternative: " << dir;
+
+          l6 ([&]{trace << "skipping duplicate";});
+        }
+      }
+    }
+    catch (const system_error& e)
+    {
+      fail << "unable to iterate over " << d << ": " << e;
+    }
+  }
+
+  bool
+  bootstrap_src (scope& root, optional<bool>& altn)
+  {
+    tracer trace ("bootstrap_src");
+
+    bool r (false);
+
+    const dir_path& out_root (root.out_path ());
+    const dir_path& src_root (root.src_path ());
+
+    {
+      path f (exists (src_root, std_bootstrap_file, alt_bootstrap_file, altn));
+
+      if (root.root_extra == nullptr)
+      {
+        // If nothing so far has indicated the naming, assume standard.
+        //
+        if (!altn)
+          altn = false;
+
+        setup_root_extra (root, altn);
+      }
+
+      if (!f.empty ())
+      {
+        // We assume that bootstrap out cannot load this file explicitly. It
+        // feels wrong to allow this since that makes the whole bootstrap
+        // process hard to reason about. But we may try to bootstrap the same
+        // root scope multiple time.
+        //
+        if (root.buildfiles.insert (f).second)
+          source (root, root, f, true);
+        else
+          l5 ([&]{trace << "skipping already sourced " << f;});
+
+        r = true;
+      }
+    }
+
+    // See if we are a part of an amalgamation. There are two key players: the
+    // outer root scope which may already be present (i.e., we were loaded as
+    // part of an amalgamation) and the amalgamation variable that may or may
+    // not be set by the user (in bootstrap.build) or by an earlier call to
+    // this function for the same scope. When set by the user, the empty
+    // special value means that the project shall not be amalgamated (and
+    // which we convert to NULL below). When calculated, the NULL value
+    // indicates that we are not amalgamated.
+    //
+    // Note: the amalgamation variable value is always a relative directory.
+    //
+    {
+      auto rp (root.vars.insert (*var_amalgamation)); // Set NULL by default.
+      value& v (rp.first);
+
+      if (v && v.empty ()) // Convert empty to NULL.
+        v = nullptr;
+
+      if (scope* aroot = root.parent_scope ()->root_scope ())
+      {
+        const dir_path& ad (aroot->out_path ());
+        dir_path rd (ad.relative (out_root));
+
+        // If we already have the amalgamation variable set, verify
+        // that aroot matches its value.
+        //
+        if (!rp.second)
+        {
+          if (!v)
+          {
+            fail << out_root << " cannot be amalgamated" <<
+              info << "amalgamated by " << ad;
+          }
+          else
+          {
+            const dir_path& vd (cast<dir_path> (v));
+
+            if (vd != rd)
+            {
+              fail << "inconsistent amalgamation of " << out_root <<
+                info << "specified: " << vd <<
+                info << "actual: " << rd << " by " << ad;
+            }
+          }
+        }
+        else
+        {
+          // Otherwise, use the outer root as our amalgamation.
+          //
+          l5 ([&]{trace << out_root << " amalgamated as " << rd;});
+          v = move (rd);
+        }
+      }
+      else if (rp.second)
+      {
+        // If there is no outer root and the amalgamation variable
+        // hasn't been set, then we need to check if any of the
+        // outer directories is a project's out_root. If so, then
+        // that's our amalgamation.
+        //
+        optional<bool> altn;
+        const dir_path& ad (find_out_root (out_root.directory (), altn).first);
+
+        if (!ad.empty ())
+        {
+          dir_path rd (ad.relative (out_root));
+          l5 ([&]{trace << out_root << " amalgamated as " << rd;});
+          v = move (rd);
+        }
+      }
+    }
+
+    // See if we have any subprojects. In a sense, this is the other
+    // side/direction of the amalgamation logic above. Here, the subprojects
+    // variable may or may not be set by the user (in bootstrap.build) or by
+    // an earlier call to this function for the same scope. When set by the
+    // user, the empty special value means that there are no subproject and
+    // none should be searched for (and which we convert to NULL below).
+    // Otherwise, it is a list of [project@]directory pairs. The directory
+    // must be relative to our out_root. If the project name is not specified,
+    // then we have to figure it out. When subprojects are calculated, the
+    // NULL value indicates that we found no subprojects.
+    //
+    {
+      auto rp (root.vars.insert (*var_subprojects)); // Set NULL by default.
+      value& v (rp.first);
+
+      if (rp.second)
+      {
+        // No subprojects set so we need to figure out if there are any.
+        //
+        // First we are going to scan our out_root and find all the
+        // pre-configured subprojects. Then, if out_root != src_root,
+        // we are going to do the same for src_root. Here, however,
+        // we need to watch out for duplicates.
+        //
+        subprojects sps;
+
+        if (exists (out_root))
+        {
+          l5 ([&]{trace << "looking for subprojects in " << out_root;});
+          find_subprojects (sps, out_root, out_root, true);
+        }
+
+        if (out_root != src_root)
+        {
+          l5 ([&]{trace << "looking for subprojects in " << src_root;});
+          find_subprojects (sps, src_root, src_root, false);
+        }
+
+        if (!sps.empty ()) // Keep it NULL if no subprojects.
+          v = move (sps);
+      }
+      else if (v)
+      {
+        // Convert empty to NULL.
+        //
+        if (v.empty ())
+          v = nullptr;
+        else
+        {
+          // Scan the (untyped) value and convert it to the "canonical" form,
+          // that is, a list of name@dir pairs.
+          //
+          subprojects sps;
+          names& ns (cast<names> (v));
+
+          for (auto i (ns.begin ()); i != ns.end (); ++i)
+          {
+            // Project name.
+            //
+            project_name n;
+            if (i->pair)
+            {
+              if (i->pair != '@')
+                fail << "unexpected pair style in variable subprojects";
+
+              try
+              {
+                n = convert<project_name> (move (*i));
+
+                if (n.empty ())
+                  fail << "empty project name in variable subprojects";
+              }
+              catch (const invalid_argument&)
+              {
+                fail << "expected project name instead of '" << *i << "' in "
+                     << "variable subprojects";
+              }
+
+              ++i; // Got to have the second half of the pair.
+            }
+
+            // Directory.
+            //
+            dir_path d;
+            try
+            {
+              d = convert<dir_path> (move (*i));
+
+              if (d.empty ())
+                fail << "empty directory in variable subprojects";
+            }
+            catch (const invalid_argument&)
+            {
+              fail << "expected directory instead of '" << *i << "' in "
+                   << "variable subprojects";
+            }
+
+            // Figure out the project name if the user didn't specify one.
+            //
+            if (n.empty ())
+            {
+              optional<bool> altn;
+
+              // Pass fallback src_root since this is a subproject that was
+              // specified by the user so it is most likely in our src.
+              //
+              n = find_project_name (out_root / d,
+                                     src_root / d,
+                                     nullopt /* out_src */,
+                                     altn);
+
+              // See find_subprojects() for details on unnamed projects.
+              //
+              if (n.empty ())
+                n = project_name (d.posix_string () + '/',
+                                  project_name::raw_string);
+            }
+
+            sps.emplace (move (n), move (d));
+          }
+
+          // Change the value to the typed map.
+          //
+          v = move (sps);
+        }
+      }
+    }
+
+    return r;
+  }
+
+  void
+  bootstrap_pre (scope& root, optional<bool>& altn)
+  {
+    const dir_path& out_root (root.out_path ());
+
+    // This test is a bit loose in a sense that there can be a stray
+    // build/bootstrap/ directory that will make us mis-treat a project as
+    // following the standard naming scheme (the other way, while also
+    // possible, is a lot less likely). If this does becomes a problem, we can
+    // always tighten the test by also looking for a hook file with the
+    // correct extension.
+    //
+    dir_path d (exists (out_root, std_bootstrap_dir, alt_bootstrap_dir, altn));
+
+    if (!d.empty ())
+    {
+      if (root.root_extra == nullptr)
+        setup_root_extra (root, altn);
+
+      source_hooks (root, d, true /* pre */);
+    }
+  }
+
+  void
+  bootstrap_post (scope& root)
+  {
+    const dir_path& out_root (root.out_path ());
+
+    dir_path d (out_root / root.root_extra->bootstrap_dir);
+
+    if (exists (d))
+      source_hooks (root, d, false /* pre */);
+  }
+
+  bool
+  bootstrapped (scope& root)
+  {
+    // Use the subprojects variable set by bootstrap_src() as an indicator.
+    // It should either be NULL or typed (so we assume that the user will
+    // never set it to NULL).
+    //
+    auto l (root.vars[var_subprojects]);
+    return l.defined () && (l->null || l->type != nullptr);
+  }
+
+  // Return true if the inner/outer project (identified by out/src_root) of
+  // the 'origin' project (identified by orig) should be forwarded.
+  //
+  static inline bool
+  forwarded (const scope& orig,
+             const dir_path& out_root,
+             const dir_path& src_root,
+             optional<bool>& altn)
+  {
+    // The conditions are:
+    //
+    // 1. Origin is itself forwarded.
+    //
+    // 2. Inner/outer src_root != out_root.
+    //
+    // 3. Inner/outer out-root.build exists in src_root and refers out_root.
+    //
+    return (out_root != src_root                        &&
+            cast_false<bool> (orig.vars[var_forwarded]) &&
+            bootstrap_fwd (src_root, altn) == out_root);
+  }
+
+  void
+  create_bootstrap_outer (scope& root)
+  {
+    auto l (root.vars[var_amalgamation]);
+
+    if (!l)
+      return;
+
+    const dir_path& d (cast<dir_path> (l));
+    dir_path out_root (root.out_path () / d);
+    out_root.normalize (); // No need to actualize (d is a bunch of ..)
+
+    // src_root is a bit more complicated. Here we have three cases:
+    //
+    // 1. Amalgamation's src_root is "parallel" to the sub-project's.
+    // 2. Amalgamation's src_root is the same as its out_root.
+    // 3. Some other pre-configured (via src-root.build) src_root.
+    //
+    // So we need to try all these cases in some sensible order. #3 should
+    // probably be tried first since that src_root was explicitly configured
+    // by the user. After that, #2 followed by #1 seems reasonable.
+    //
+    scope& rs (create_root (root, out_root, dir_path ())->second);
+
+    bool bstrapped (bootstrapped (rs));
+
+    optional<bool> altn;
+    if (!bstrapped)
+    {
+      bootstrap_out (rs, altn); // #3 happens here (or it can be #1).
+
+      value& v (rs.assign (var_src_root));
+
+      if (!v)
+      {
+        if (is_src_root (out_root, altn)) // #2
+          v = out_root;
+        else // #1
+        {
+          dir_path src_root (root.src_path () / d);
+          src_root.normalize (); // No need to actualize (as above).
+          v = move (src_root);
+        }
+      }
+      else
+        remap_src_root (v); // Remap if inside old_src_root.
+
+      setup_root (rs, forwarded (root, out_root, v.as<dir_path> (), altn));
+      bootstrap_pre (rs, altn);
+      bootstrap_src (rs, altn);
+      // bootstrap_post() delayed until after create_bootstrap_outer().
+    }
+    else
+    {
+      altn = rs.root_extra->altn;
+
+      if (forwarded (root, rs.out_path (), rs.src_path (), altn))
+        rs.assign (var_forwarded) = true; // Only upgrade (see main()).
+    }
+
+    create_bootstrap_outer (rs);
+
+    if (!bstrapped)
+      bootstrap_post (rs);
+
+    // Check if we are strongly amalgamated by this outer root scope.
+    //
+    if (root.src_path ().sub (rs.src_path ()))
+      root.strong_ = rs.strong_scope (); // Itself or some outer scope.
+  }
+
+  scope&
+  create_bootstrap_inner (scope& root, const dir_path& out_base)
+  {
+    scope* r (&root);
+
+    if (auto l = root.vars[var_subprojects])
+    {
+      for (const auto& p: cast<subprojects> (l))
+      {
+        dir_path out_root (root.out_path () / p.second);
+
+        if (!out_base.empty () && !out_base.sub (out_root))
+          continue;
+
+        // The same logic to src_root as in create_bootstrap_outer().
+        //
+        scope& rs (create_root (root, out_root, dir_path ())->second);
+
+        optional<bool> altn;
+        if (!bootstrapped (rs))
+        {
+          bootstrap_out (rs, altn);
+
+          value& v (rs.assign (var_src_root));
+
+          if (!v)
+          {
+            v = is_src_root (out_root, altn)
+              ? out_root
+              : (root.src_path () / p.second);
+          }
+          else
+            remap_src_root (v); // Remap if inside old_src_root.
+
+          setup_root (rs, forwarded (root, out_root, v.as<dir_path> (), altn));
+          bootstrap_pre (rs, altn);
+          bootstrap_src (rs, altn);
+          bootstrap_post (rs);
+        }
+        else
+        {
+          altn = rs.root_extra->altn;
+          if (forwarded (root, rs.out_path (), rs.src_path (), altn))
+            rs.assign (var_forwarded) = true; // Only upgrade (see main()).
+        }
+
+        // Check if we strongly amalgamated this inner root scope.
+        //
+        if (rs.src_path ().sub (root.src_path ()))
+          rs.strong_ = root.strong_scope (); // Itself or some outer scope.
+
+        // See if there are more inner roots.
+        //
+        r = &create_bootstrap_inner (rs, out_base);
+
+        if (!out_base.empty ())
+          break; // We have found our subproject.
+      }
+    }
+
+    return *r;
+  }
+
+  void
+  load_root (scope& root)
+  {
+    tracer trace ("load_root");
+
+    const dir_path& out_root (root.out_path ());
+    const dir_path& src_root (root.src_path ());
+
+    // As an optimization, check if we have already loaded root.build. If
+    // that's the case, then we have already been called for this project.
+    //
+    path f (src_root / root.root_extra->root_file);
+
+    if (root.buildfiles.find (f) != root.buildfiles.end ())
+      return;
+
+    // First load outer roots, if any.
+    //
+    if (scope* rs = root.parent_scope ()->root_scope ())
+      load_root (*rs);
+
+    // Finish off loading bootstrapped modules.
+    //
+    for (auto& p: root.root_extra->modules)
+    {
+      module_state& s (p.second);
+
+      if (s.boot && s.first)
+        load_module (root, root, p.first, s.loc);
+    }
+
+    for (auto& p: root.root_extra->modules)
+    {
+      module_state& s (p.second);
+
+      if (s.boot && !s.first)
+        load_module (root, root, p.first, s.loc);
+    }
+
+    // Load hooks and root.build.
+    //
+    // We can load the pre hooks before finishing off loading the bootstrapped
+    // modules (which, in case of config would load config.build) or after and
+    // one can come up with a plausible use-case for either approach. Note,
+    // however, that one can probably achieve adequate pre-modules behavior
+    // with a post-bootstrap hook.
+    //
+    dir_path hd (out_root / root.root_extra->root_dir);
+    bool he (exists (hd));
+
+    if (he)         source_hooks (root, hd, true /* pre */);
+    if (exists (f)) source_once  (root, root, f);
+    if (he)         source_hooks (root, hd, false /* pre */);
+  }
+
+  scope&
+  load_project (scope& lock,
+                const dir_path& out_root,
+                const dir_path& src_root,
+                bool forwarded,
+                bool load)
+  {
+    assert (!forwarded || out_root != src_root);
+
+    auto i (create_root (lock, out_root, src_root));
+    scope& rs (i->second);
+
+    if (!bootstrapped (rs))
+    {
+      optional<bool> altn;
+      bootstrap_out (rs, altn);
+      setup_root (rs, forwarded);
+      bootstrap_pre (rs, altn);
+      bootstrap_src (rs, altn);
+      bootstrap_post (rs);
+    }
+    else
+    {
+      if (forwarded)
+        rs.assign (var_forwarded) = true; // Only upgrade (see main()).
+    }
+
+    if (load)
+    {
+      load_root (rs);
+      setup_base (i, out_root, src_root); // Setup as base.
+    }
+
+    return rs;
+  }
+
+  names
+  import (scope& ibase, name target, const location& loc)
+  {
+    tracer trace ("import");
+
+    l5 ([&]{trace << target << " from " << ibase;});
+
+    // If there is no project specified for this target, then our run will be
+    // short and sweet: we simply return it as empty-project-qualified and
+    // let someone else (e.g., a rule) take a stab at it.
+    //
+    if (target.unqualified ())
+    {
+      target.proj = project_name ();
+      return names {move (target)};
+    }
+
+    // Otherwise, get the project name and convert the target to unqualified.
+    //
+    project_name proj (move (*target.proj));
+    target.proj = nullopt;
+
+    scope& iroot (*ibase.root_scope ());
+
+    // Figure out this project's out_root.
+    //
+    dir_path out_root;
+
+    // First try the config.import.* mechanism. The idea is that if the user
+    // explicitly told us the project's location, then we should prefer that
+    // over anything that we may discover. In particular, we will prefer it
+    // over any bundled subprojects.
+    //
+    auto& vp (var_pool.rw (iroot));
+
+    for (;;) // Break-out loop.
+    {
+      string n ("config.import." + proj.variable ());
+
+      // config.import.<proj>
+      //
+      {
+        // Note: pattern-typed in context.cxx:reset() as an overridable
+        // variable of type abs_dir_path (path auto-completion).
+        //
+        const variable& var (vp.insert (n));
+
+        if (auto l = iroot[var])
+        {
+          out_root = cast<dir_path> (l);      // Normalized and actualized.
+
+          // Mark as part of config.
+          //
+          if (config_save_variable != nullptr)
+            config_save_variable (iroot, var, 0 /* flags */);
+
+          // Empty config.import.* value means don't look in subprojects or
+          // amalgamations and go straight to the rule-specific import (e.g.,
+          // to use system-installed).
+          //
+          if (out_root.empty ())
+          {
+            target.proj = move (proj);
+            l5 ([&]{trace << "skipping " << target;});
+            return names {move (target)};
+          }
+
+          break;
+        }
+      }
+
+      // config.import.<proj>.<name>.<type>
+      // config.import.<proj>.<name>
+      //
+      // For example: config.import.build2.b.exe=/opt/build2/bin/b
+      //
+      if (!target.value.empty ())
+      {
+        auto lookup = [&iroot, &vp, &loc] (string name) -> path
+        {
+          // Note: pattern-typed in context.cxx:reset() as an overridable
+          // variable of type path.
+          //
+          const variable& var (vp.insert (move (name)));
+
+          path r;
+          if (auto l = iroot[var])
+          {
+            r = cast<path> (l);
+
+            if (r.empty ())
+              fail (loc) << "empty path in " << var.name;
+
+            if (config_save_variable != nullptr)
+              config_save_variable (iroot, var, 0 /* flags */);
+          }
+
+          return r;
+        };
+
+        // First try .<name>.<type>, then just .<name>.
+        //
+        path p;
+        if (target.typed ())
+          p = lookup (n + '.' + target.value + '.' + target.type);
+
+        if (p.empty ())
+          p = lookup (n + '.' + target.value);
+
+        if (!p.empty ())
+        {
+          // If the path is relative, then keep it project-qualified assuming
+          // import phase 2 knows what to do with it. Think:
+          //
+          // config.import.build2.b=b-boot
+          //
+          if (p.relative ())
+            target.proj = move (proj);
+
+          target.dir = p.directory ();
+          target.value = p.leaf ().string ();
+
+          return names {move (target)};
+        }
+      }
+
+      // Otherwise search subprojects, starting with our root and then trying
+      // outer roots for as long as we are inside an amalgamation.
+      //
+      for (scope* r (&iroot);; r = r->parent_scope ()->root_scope ())
+      {
+        l5 ([&]{trace << "looking in " << *r;});
+
+        // First check the amalgamation itself.
+        //
+        if (r != &iroot && cast<project_name> (r->vars[var_project]) == proj)
+        {
+          out_root = r->out_path ();
+          break;
+        }
+
+        if (auto l = r->vars[var_subprojects])
+        {
+          const auto& m (cast<subprojects> (l));
+          auto i (m.find (proj));
+
+          if (i != m.end ())
+          {
+            const dir_path& d ((*i).second);
+            out_root = r->out_path () / d;
+            break;
+          }
+        }
+
+        if (!r->vars[var_amalgamation])
+          break;
+      }
+
+      break;
+    }
+
+    // If we couldn't find the project, convert it back into qualified target
+    // and return to let someone else (e.g., a rule) take a stab at it.
+    //
+    if (out_root.empty ())
+    {
+      target.proj = move (proj);
+      l5 ([&]{trace << "postponing " << target;});
+      return names {move (target)};
+    }
+
+    // Bootstrap the imported root scope. This is pretty similar to what we do
+    // in main() except that here we don't try to guess src_root.
+    //
+    // The user can also specify the out_root of the amalgamation that contains
+    // our project. For now we only consider top-level sub-projects.
+    //
+    scope* root;
+    dir_path src_root;
+
+    // See if this is a forwarded configuration. For top-level project we want
+    // to use the same logic as in main() while for inner subprojects -- as in
+    // create_bootstrap_inner().
+    //
+    bool fwd (false);
+    optional<bool> altn;
+    if (is_src_root (out_root, altn))
+    {
+      src_root = move (out_root);
+      out_root = bootstrap_fwd (src_root, altn);
+      fwd = (src_root != out_root);
+    }
+
+    for (const scope* proot (nullptr); ; proot = root)
+    {
+      bool top (proot == nullptr);
+
+      root = &create_root (iroot, out_root, src_root)->second;
+
+      bool bstrapped (bootstrapped (*root));
+
+      if (!bstrapped)
+      {
+        bootstrap_out (*root, altn);
+
+        // Check that the bootstrap process set src_root.
+        //
+        auto l (root->vars[*var_src_root]);
+        if (l)
+        {
+          // Note that unlike main() here we fail hard. The idea is that if
+          // the project we are importing is misconfigured, then it should be
+          // fixed first.
+          //
+          const dir_path& p (cast<dir_path> (l));
+
+          if (!src_root.empty () && p != src_root)
+            fail (loc) << "configured src_root " << p << " does not match "
+                       << "discovered " << src_root;
+        }
+        else
+          fail (loc) << "unable to determine src_root for imported " << proj <<
+            info << "consider configuring " << out_root;
+
+        setup_root (*root,
+                    (top
+                     ? fwd
+                     : forwarded (*proot, out_root, l->as<dir_path> (), altn)));
+
+        bootstrap_pre (*root, altn);
+        bootstrap_src (*root, altn);
+        if (!top)
+          bootstrap_post (*root);
+      }
+      else
+      {
+        altn = root->root_extra->altn;
+
+        if (src_root.empty ())
+          src_root = root->src_path ();
+
+        if (top ? fwd : forwarded (*proot, out_root, src_root, altn))
+          root->assign (var_forwarded) = true; // Only upgrade (see main()).
+      }
+
+      if (top)
+      {
+        create_bootstrap_outer (*root);
+
+        if (!bstrapped)
+          bootstrap_post (*root);
+      }
+
+      // Now we know this project's name as well as all its subprojects.
+      //
+      if (cast<project_name> (root->vars[var_project]) == proj)
+        break;
+
+      if (auto l = root->vars[var_subprojects])
+      {
+        const auto& m (cast<subprojects> (l));
+        auto i (m.find (proj));
+
+        if (i != m.end ())
+        {
+          const dir_path& d ((*i).second);
+          altn = nullopt;
+          out_root = root->out_path () / d;
+          src_root = is_src_root (out_root, altn) ? out_root : dir_path ();
+          continue;
+        }
+      }
+
+      fail (loc) << out_root << " is not out_root for " << proj;
+    }
+
+    // Load the imported root scope.
+    //
+    load_root (*root);
+
+    // Create a temporary scope so that the export stub does not mess
+    // up any of our variables.
+    //
+    temp_scope ts (ibase);
+
+    // "Pass" the imported project's roots to the stub.
+    //
+    ts.assign (var_out_root) = move (out_root);
+    ts.assign (var_src_root) = move (src_root);
+
+    // Also pass the target being imported in the import.target variable.
+    //
+    {
+      value& v (ts.assign (var_import_target));
+
+      if (!target.empty ()) // Otherwise leave NULL.
+        v = target; // Can't move (need for diagnostics below).
+    }
+
+    // Load the export stub. Note that it is loaded in the context
+    // of the importing project, not the imported one. The export
+    // stub will normally switch to the imported root scope at some
+    // point.
+    //
+    path es (root->src_path () / root->root_extra->export_file);
+
+    try
+    {
+      ifdstream ifs (es);
+
+      l5 ([&]{trace << "importing " << es;});
+
+      // @@ Should we verify these are all unqualified names? Or maybe
+      // there is a use-case for the export stub to return a qualified
+      // name?
+      //
+      parser p;
+      names v (p.parse_export_stub (ifs, es, iroot, ts));
+
+      // If there were no export directive executed in an export stub, assume
+      // the target is not exported.
+      //
+      if (v.empty () && !target.empty ())
+        fail (loc) << "target " << target << " is not exported by project "
+                   << proj;
+
+      return v;
+    }
+    catch (const io_error& e)
+    {
+      fail (loc) << "unable to read buildfile " << es << ": " << e;
+    }
+
+    return names (); // Never reached.
+  }
+
+  const target*
+  import (const prerequisite_key& pk, bool existing)
+  {
+    tracer trace ("import");
+
+    assert (pk.proj);
+    const project_name& proj (*pk.proj);
+
+    // Target type-specific search.
+    //
+    const target_key& tk (pk.tk);
+    const target_type& tt (*tk.type);
+
+    // Try to find the executable in PATH (or CWD if relative).
+    //
+    if (tt.is_a<exe> ())
+    {
+      path n (*tk.dir);
+      n /= *tk.name;
+      if (tk.ext)
+      {
+        n += '.';
+        n += *tk.ext;
+      }
+
+      // Only search in PATH (or CWD).
+      //
+      process_path pp (process::try_path_search (n, true, dir_path (), true));
+
+      if (!pp.empty ())
+      {
+        path& p (pp.effect);
+        assert (!p.empty ()); // We searched for a simple name.
+
+        const exe* t (
+          !existing
+          ? &targets.insert<exe> (tt,
+                                  p.directory (),
+                                  dir_path (),    // No out (out of project).
+                                  p.leaf ().base ().string (),
+                                  p.extension (), // Always specified.
+                                  trace)
+          : targets.find<exe> (tt,
+                               p.directory (),
+                               dir_path (),
+                               p.leaf ().base ().string (),
+                               p.extension (),
+                               trace));
+
+        if (t != nullptr)
+        {
+          if (!existing)
+            t->path (move (p));
+          else
+            assert (t->path () == p);
+
+          return t;
+        }
+      }
+    }
+
+    if (existing)
+      return nullptr;
+
+    // @@ We no longer have location. This is especially bad for the
+    //    empty case, i.e., where do I need to specify the project
+    //    name)? Looks like the only way to do this is to keep location
+    //    in name and then in prerequisite. Perhaps one day...
+    //
+    diag_record dr;
+    dr << fail << "unable to import target " << pk;
+
+    if (proj.empty ())
+      dr << info << "consider adding its installation location" <<
+        info << "or explicitly specify its project name";
+    else
+      dr << info << "use config.import." << proj.variable ()
+         << " command line variable to specify its project out_root";
+
+    dr << endf;
+  }
+}