aboutsummaryrefslogtreecommitdiff
path: root/build/file.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'build/file.cxx')
-rw-r--r--build/file.cxx169
1 files changed, 167 insertions, 2 deletions
diff --git a/build/file.cxx b/build/file.cxx
index 0b0220d..70a5ed8 100644
--- a/build/file.cxx
+++ b/build/file.cxx
@@ -15,6 +15,19 @@ using namespace std;
namespace build
{
+ bool
+ is_src_root (const path& d)
+ {
+ return file_exists (d / path ("build/bootstrap.build")) ||
+ file_exists (d / path ("build/root.build"));
+ }
+
+ bool
+ is_out_root (const path& d)
+ {
+ return file_exists (d / path ("build/bootstrap/src-root.build"));
+ }
+
void
source (const path& bf, scope& root, scope& base)
{
@@ -146,18 +159,170 @@ namespace build
}
void
- root_pre (scope& root)
+ create_bootstrap_outer (scope& root)
+ {
+ auto v (root.ro_variables ()["amalgamation"]);
+
+ if (!v)
+ return;
+
+ const path& d (v.as<const path&> ());
+ path out_root (root.path () / d);
+ path src_root (root.src_path () / d);
+ out_root.normalize ();
+ src_root.normalize ();
+
+ scope& rs (create_root (out_root, src_root));
+
+ bootstrap_out (rs);
+
+ // Check if the bootstrap process changed src_root.
+ //
+ const path& p (rs.variables["src_root"].as<const path&> ());
+
+ if (src_root != p)
+ fail << "bootstrapped src_root " << p << " does not match "
+ << "amalgamated " << src_root;
+
+ rs.src_path_ = &p;
+
+ bootstrap_src (rs);
+ create_bootstrap_outer (rs);
+ }
+
+ scope&
+ create_bootstrap_inner (scope& root, const path& out_base)
+ {
+ if (auto v = root.ro_variables ()["subprojects"])
+ {
+ for (const name& n: v.as<const list_value&> ())
+ {
+ // Should be a list of directories.
+ //
+ if (!n.type.empty () || !n.value.empty () || n.dir.empty ())
+ fail << "expected directory in subprojects variable "
+ << "instead of " << n;
+
+ path out_root (root.path () / n.dir);
+
+ if (!out_base.sub (out_root))
+ continue;
+
+ path src_root (root.src_path () / n.dir);
+ scope& rs (create_root (out_root, src_root));
+
+ bootstrap_out (rs);
+
+ // Check if the bootstrap process changed src_root.
+ //
+ const path& p (rs.variables["src_root"].as<const path&> ());
+
+ if (src_root != p)
+ fail << "bootstrapped src_root " << p << " does not match "
+ << "subproject " << src_root;
+
+ rs.src_path_ = &p;
+
+ bootstrap_src (rs);
+
+ // See if there are more inner roots.
+ //
+ return create_bootstrap_inner (rs, out_base);
+ }
+ }
+
+ return root;
+ }
+
+ void
+ load_root_pre (scope& root)
{
tracer trace ("root_pre");
// First load outer roots, if any.
//
if (scope* rs = root.parent_scope ()->root_scope ())
- root_pre (*rs);
+ load_root_pre (*rs);
path bf (root.src_path () / path ("build/root.build"));
if (file_exists (bf))
source_once (bf, root, root);
}
+
+ void
+ import (scope& ibase, const name& n, const location& l)
+ {
+ scope& iroot (*ibase.root_scope ());
+
+ // Figure out this project's out_root.
+ //
+ const variable& var (variable_pool.find ("config." + n.value));
+ auto val (iroot[var]);
+
+ if (val)
+ {
+ if (val.scope == global_scope)
+ iroot.variables[var] = val; // Copy into root scope.
+ }
+ else
+ fail (l) << "unable to find out_root for imported " << n <<
+ info << "consider explicitly configuring its out_root via the "
+ << var.name << " command line variable";
+
+ const path& out_root (val.as<const path&> ());
+
+ // 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.
+ //
+ path src_root (is_src_root (out_root) ? out_root : path ());
+ scope& root (create_root (out_root, src_root));
+
+ bootstrap_out (root);
+
+ // Check that the bootstrap process set src_root.
+ //
+ if (auto v = root.ro_variables ()["src_root"])
+ {
+ const path& p (v.as<const path&> ());
+
+ if (!src_root.empty () && p != src_root)
+ fail << "bootstrapped src_root " << p << " does not match "
+ << "discovered " << src_root;
+
+ root.src_path_ = &p;
+ }
+ else
+ fail (l) << "unable to determine src_root for imported " << n <<
+ info << "consider configuring " << out_root;
+
+ bootstrap_src (root);
+
+ // Bootstrap outer roots if any. Loading will be done by
+ // load_root_pre() below.
+ //
+ create_bootstrap_outer (root);
+
+ // Load the imported root scope.
+ //
+ load_root_pre (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.variables["out_root"] = out_root;
+ ts.variables["src_root"] = src_root;
+
+ // 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.
+ //
+ source (root.src_path () / path ("build/export.build"), iroot, ts);
+ }
}