diff options
Diffstat (limited to 'libbuild2')
| -rw-r--r-- | libbuild2/config/operation.cxx | 6 | ||||
| -rw-r--r-- | libbuild2/dump.cxx | 5 | ||||
| -rw-r--r-- | libbuild2/file.cxx | 150 | ||||
| -rw-r--r-- | libbuild2/file.hxx | 17 | ||||
| -rw-r--r-- | libbuild2/operation.cxx | 2 | ||||
| -rw-r--r-- | libbuild2/scope.hxx | 26 | ||||
| -rw-r--r-- | libbuild2/scope.ixx | 56 |
7 files changed, 198 insertions, 64 deletions
diff --git a/libbuild2/config/operation.cxx b/libbuild2/config/operation.cxx index 37ff1a3..17eb99a 100644 --- a/libbuild2/config/operation.cxx +++ b/libbuild2/config/operation.cxx @@ -202,12 +202,10 @@ namespace build2 if (inherit) { - if (auto l = rs.vars[ctx.var_amalgamation]) + if (const dir_path* a = *rs.root_extra->amalgamation) { - const dir_path& d (cast<dir_path> (l)); - os << endl - << "# Base configuration inherited from " << d << endl + << "# Base configuration inherited from " << *a << endl << "#" << endl; } } diff --git a/libbuild2/dump.cxx b/libbuild2/dump.cxx index e253988..8ee68b7 100644 --- a/libbuild2/dump.cxx +++ b/libbuild2/dump.cxx @@ -400,6 +400,11 @@ namespace build2 // Nested scopes of which we are an immediate parent. // + // Note that because we use the logical (rather than physical) parent, we + // will be printing the logical scope hierarchy (i.e., a project with + // disabled amalgamation will be printed directly inside the global + // scope). + // for (auto e (p.ctx.scopes.end ()); i != e && i->second.parent_scope () == &p; ) { diff --git a/libbuild2/file.cxx b/libbuild2/file.cxx index 3e0d1c1..0bcb198 100644 --- a/libbuild2/file.cxx +++ b/libbuild2/file.cxx @@ -494,6 +494,7 @@ namespace build2 root.root_extra.reset ( new scope::root_extra_type { + nullopt /* amalgamation */, a, a ? alt_build_ext : std_build_ext, a ? alt_build_dir : std_build_dir, @@ -567,15 +568,29 @@ namespace build2 } pair<value, bool> - extract_variable (context& ctx, lexer& l, const variable& var) + extract_variable (context& ctx, lexer& l, const variable& var, size_t n) { const path_name& fn (l.name ()); try { token t (l.next ()); - token_type tt; + // Skip the requested number of lines. + // + while (--n != 0) + { + for (; t.type != token_type::eos; t = l.next ()) + { + if (t.type == token_type::newline) + { + t = l.next (); + break; + } + } + } + + token_type tt; if (t.type != token_type::word || t.value != var.name || ((tt = l.next ().type) != token_type::assign && tt != token_type::prepend && @@ -603,22 +618,23 @@ namespace build2 pair<value, bool> extract_variable (context& ctx, - istream& is, - const path& bf, - const variable& var) + istream& is, const path& bf, + const variable& var, size_t n) { path_name in (bf); lexer l (is, in); - return extract_variable (ctx, l, var); + return extract_variable (ctx, l, var, n); } pair<value, bool> - extract_variable (context& ctx, const path& bf, const variable& var) + extract_variable (context& ctx, + const path& bf, + const variable& var, size_t n) { try { ifdstream ifs (bf); - return extract_variable (ctx, ifs, bf, var); + return extract_variable (ctx, ifs, bf, var, n); } catch (const io_error& e) { @@ -715,8 +731,8 @@ namespace build2 auto p (extract_variable (ctx, f, *ctx.var_project)); if (!p.second) - fail << "variable " << ctx.var_project->name << " expected " - << "as a first line in " << f; + fail << "variable " << *ctx.var_project << " expected as a first " + << "line in " << f; name = cast<project_name> (move (p.first)); } @@ -817,44 +833,68 @@ namespace build2 context& ctx (rs.ctx); - bool r (false); - const dir_path& out_root (rs.out_path ()); const dir_path& src_root (rs.src_path ()); + path bf (exists (src_root, std_bootstrap_file, alt_bootstrap_file, altn)); + + if (rs.root_extra == nullptr) { - path f (exists (src_root, std_bootstrap_file, alt_bootstrap_file, altn)); + // If nothing so far has indicated the naming, assume standard. + // + if (!altn) + altn = false; - if (rs.root_extra == nullptr) - { - // If nothing so far has indicated the naming, assume standard. - // - if (!altn) - altn = false; + setup_root_extra (rs, altn); + } - setup_root_extra (rs, altn); - } + bool r (true); + if (bf.empty ()) + { + r = false; + } + // 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. + // + else if (rs.buildfiles.insert (bf).second) + { + // Deal with the empty amalgamation variable (which indicates that + // amalgamating this project is disabled). We go through all this + // trouble of extracting its value manually (and thus requiring its + // assignment, if any, to be the second line in bootstrap.build, after + // project assignment) in order to have the logical amalgamation view + // during bootstrap (note that the bootstrap pre hooks will still see + // physical amalgamation). + // + auto ap (extract_variable (ctx, bf, *ctx.var_amalgamation, 2)); + + if (ap.second && (ap.first.null || ap.first.empty ())) + rs.root_extra->amalgamation = nullptr; - 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 (rs.buildfiles.insert (f).second) - { - parser p (rs.ctx, load_stage::boot); - source (p, rs, rs, f); - } - else - l5 ([&]{trace << "skipping already sourced " << f;}); + parser p (rs.ctx, load_stage::boot); + source (p, rs, rs, bf); + } - r = true; + // Detect and diagnose the case where the amalgamation variable is not + // the second line. + // + if (!ap.second && rs.vars[ctx.var_amalgamation].defined ()) + { + fail << "variable " << *ctx.var_amalgamation << " expected as a " + << "second line in " << bf; } } + else + { + // Here we assume amalgamation has been dealt with. + // + l5 ([&]{trace << "skipping already sourced " << bf;}); + } - // See if we are a part of an amalgamation. There are two key players: the + // Finish dealing with the 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 @@ -877,17 +917,20 @@ namespace build2 const dir_path& ad (ars->out_path ()); dir_path rd (ad.relative (out_root)); - // If we already have the amalgamation variable set, verify - // that aroot matches its value. + // If we already have the amalgamation variable set, verify that aroot + // matches its value. // if (!rp.second) { + /* @@ TMP if (!v) { fail << out_root << " cannot be amalgamated" << info << "amalgamated by " << ad; } else + */ + if (v) { const dir_path& vd (cast<dir_path> (v)); @@ -909,10 +952,9 @@ namespace build2 } 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. + // 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); @@ -923,7 +965,18 @@ namespace build2 l5 ([&]{trace << out_root << " amalgamated as " << rd;}); v = move (rd); } + //@@ else: the value will be NULL and amalgamation will be disabled. + // We could omit setting it in root_extra... But maybe this is + // correct: we don't want to load half of the project as + // amalgamated and the other half as not, would we now? + } + // @@ else if (v): shouldn't we try to bootstrap a project in the + // user-specified directory? Though this case is not + // used outside of some controlled cases (like module + // sidebuilds). + + rs.root_extra->amalgamation = cast_null<dir_path> (v); } // See if we have any subprojects. In a sense, this is the other @@ -1198,6 +1251,8 @@ namespace build2 // Check if we are strongly amalgamated by this outer root scope. // + // Note that we won't end up here if we are not amalgamatable. + // if (root.src_path ().sub (rs.src_path ())) root.strong_ = rs.strong_scope (); // Itself or some outer scope. } @@ -1248,10 +1303,17 @@ namespace build2 rs.assign (ctx.var_forwarded) = true; // Only upgrade (see main()). } + //@@ TODO: what if subproject has amalgamation disabled? Can we have a + // subproject that disables our attempt to amalgamate it (see + // amalgamatable() call below). + // 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. + if (rs.amalgamatable ()) + { + 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. // diff --git a/libbuild2/file.hxx b/libbuild2/file.hxx index 8af408e..0123591 100644 --- a/libbuild2/file.hxx +++ b/libbuild2/file.hxx @@ -213,24 +213,27 @@ namespace build2 load_root (scope& root); // Extract the specified variable value from a buildfile. It is expected to - // be the first non-comment line and not to rely on any variable expansion - // other than those from the global scope or any variable overrides. Return - // an indication of whether the variable was found. + // be the n'th non-blank/comment line and not to rely on any variable + // expansions other than those from the global scope or any variable + // overrides. Return in second an indication of whether the variable was + // found. // LIBBUILD2_SYMEXPORT pair<value, bool> - extract_variable (context&, const path&, const variable&); + extract_variable (context&, const path&, const variable&, size_t n = 1); - // As above, but extract from a stream. The name argument is used for + // As above, but extract from a stream. The path argument is used for // diagnostics. // LIBBUILD2_SYMEXPORT pair<value, bool> - extract_variable (context&, istream&, const path& name, const variable&); + extract_variable (context&, + istream&, const path&, + const variable&, size_t = 1); // As above, but extract from a lexer (this could be useful for extracting // from stdin). // LIBBUILD2_SYMEXPORT pair<value, bool> - extract_variable (context&, lexer&, const variable&); + extract_variable (context&, lexer&, const variable&, size_t = 1); // Import has two phases: the first is triggered by the import directive in // the buildfile. It will try to find and load the project. Failed that, it diff --git a/libbuild2/operation.cxx b/libbuild2/operation.cxx index 5b549a4..d56e416 100644 --- a/libbuild2/operation.cxx +++ b/libbuild2/operation.cxx @@ -549,7 +549,7 @@ namespace build2 << "url: " << cast_empty<string> (rs[ctx.var_project_url]) << endl << "src_root: " << cast<dir_path> (rs[ctx.var_src_root]) << endl << "out_root: " << cast<dir_path> (rs[ctx.var_out_root]) << endl - << "amalgamation: " << cast_empty<dir_path> (rs[ctx.var_amalgamation]) << endl + << "amalgamation: " << (*rs.root_extra->amalgamation != nullptr ? **rs.root_extra->amalgamation : empty_dir_path) << endl << "subprojects: " << cast_empty<subprojects> (rs[ctx.var_subprojects]) << endl << "operations:"; print_ops (rs.root_extra->operations, ctx.operation_table); cout << endl << "meta-operations:"; print_ops (rs.root_extra->meta_operations, ctx.meta_operation_table); cout << endl; diff --git a/libbuild2/scope.hxx b/libbuild2/scope.hxx index e7c2db7..473dde8 100644 --- a/libbuild2/scope.hxx +++ b/libbuild2/scope.hxx @@ -46,18 +46,21 @@ namespace build2 const dir_path* src_path_ = nullptr; bool - root () const {return root_ == this;} + root () const; - scope* parent_scope () {return parent_;} - const scope* parent_scope () const {return parent_;} + // Note that the *_scope() functions reaturn "logical" parent/root/etc + // scopes, taking into account the project's var_amalgamation value. + + scope* parent_scope (); + const scope* parent_scope () const; // Root scope of this scope or NULL if this scope is not (yet) in any // (known) project. Note that if the scope itself is root, then this // function return this. To get to the outer root, query the root scope of // the parent. // - scope* root_scope () {return root_;} - const scope* root_scope () const {return root_;} + scope* root_scope (); + const scope* root_scope () const; // Root scope of the outermost "strong" (source-based) amalgamation of // this scope or NULL if this scope is not (yet) in any (known) project. @@ -413,6 +416,11 @@ namespace build2 public: struct root_extra_type { + // This project's amalgamation (var_amalgamation value). Absent means it + // is not yet determined. NULL means amalgamation is disabled. + // + optional<const dir_path*> amalgamation; + bool altn; // True if using alternative build file/directory naming. // Build file/directory naming scheme used by this project. @@ -506,6 +514,14 @@ namespace build2 scope (context& c, bool global) : ctx (c), vars (c, global), target_vars (c, global) {} + // Return true if this root scope can be amalgamated. + // + bool + amalgamatable () const; + + // Note that these values represent "physical" scoping relationships not + // taking into account the project's var_amalgamation value. + // scope* parent_; scope* root_; scope* strong_ = nullptr; // Only set on root scopes. diff --git a/libbuild2/scope.ixx b/libbuild2/scope.ixx index 9aecd48..a3a417f 100644 --- a/libbuild2/scope.ixx +++ b/libbuild2/scope.ixx @@ -5,9 +5,52 @@ namespace build2 { // scope // + inline bool scope:: + root () const + { + return root_ == this; + } + + inline bool scope:: + amalgamatable () const + { + return (root_extra == nullptr || + !root_extra->amalgamation || + *root_extra->amalgamation != nullptr); + } + + inline scope* scope:: + parent_scope () + { + // If this is a root scope and amalgamation is disabled, "jump" straight + // to the global scope. + // + return root () && !amalgamatable () ? &global_scope () : parent_; + } + + inline const scope* scope:: + parent_scope () const + { + return root () && !amalgamatable () ? &global_scope () : parent_; + } + + inline scope* scope:: + root_scope () + { + return root_; + } + + inline const scope* scope:: + root_scope () const + { + return root_; + } + inline scope* scope:: strong_scope () { + // We naturally assume strong_ is not set for non-amalgamatable projects. + // return root_ != nullptr ? root_->strong_ != nullptr ? root_->strong_ : root_ : nullptr; @@ -26,7 +69,9 @@ namespace build2 { scope* r (root_); if (r != nullptr) - for (; r->parent_->root_ != nullptr; r = r->parent_->root_) ; + for (; + r->amalgamatable () && r->parent_->root_ != nullptr; + r = r->parent_->root_) ; return r; } @@ -35,7 +80,9 @@ namespace build2 { const scope* r (root_); if (r != nullptr) - for (; r->parent_->root_ != nullptr; r = r->parent_->root_) ; + for (; + r->amalgamatable () && r->parent_->root_ != nullptr; + r = r->parent_->root_) ; return r; } @@ -44,9 +91,12 @@ namespace build2 { // Scan the parent root scope chain looking for this scope. // - for (const scope* pr (&r); (pr = pr->parent_->root_) != nullptr; ) + for (const scope* pr (&r); + pr->amalgamatable () && (pr = pr->parent_->root_) != nullptr; ) + { if (pr == this) return true; + } return false; } |