diff options
Diffstat (limited to 'libbuild2')
| -rw-r--r-- | libbuild2/dist/init.cxx | 120 | ||||
| -rw-r--r-- | libbuild2/dist/module.hxx | 3 | ||||
| -rw-r--r-- | libbuild2/dist/operation.cxx | 542 | ||||
| -rw-r--r-- | libbuild2/dist/operation.hxx | 3 | ||||
| -rw-r--r-- | libbuild2/version/init.cxx | 83 | ||||
| -rw-r--r-- | libbuild2/version/module.hxx | 2 |
6 files changed, 476 insertions, 277 deletions
diff --git a/libbuild2/dist/init.cxx b/libbuild2/dist/init.cxx index a96d10e..a3d1e3f 100644 --- a/libbuild2/dist/init.cxx +++ b/libbuild2/dist/init.cxx @@ -29,10 +29,6 @@ namespace build2 l5 ([&]{trace << "for " << rs;}); - // Register the meta-operation. - // - rs.insert_meta_operation (dist_id, mo_dist); - // Enter module variables. Do it during boot in case they get assigned // in bootstrap.build (which is customary for, e.g., dist.package). // @@ -59,49 +55,47 @@ namespace build2 // vp.insert<bool> ("config.dist.uncommitted"); + // The bootstrap distribution mode. Note that it can only be specified + // as a global override and is thus marked as unsaved in init(). Unlike + // the normal load distribution mode, we can do in-source and multiple + // projects at once. + // + // Note also that other config.dist.* variables can only be specified as + // overrides (since config.build is not loaded) but do not have to be + // global. + // + auto& v_d_b (vp.insert<bool> ("config.dist.bootstrap")); + vp.insert<dir_path> ("dist.root"); vp.insert<process_path> ("dist.cmd"); vp.insert<paths> ("dist.archives"); vp.insert<paths> ("dist.checksums"); - vp.insert<paths> ("dist.uncommitted"); vp.insert<bool> ("dist", variable_visibility::target); // Flag. - // Project's package name. + // Project's package name. Note: if set, must be in bootstrap.build. // auto& v_d_p (vp.insert<string> ("dist.package")); + // See if we need to use the bootstrap mode. + // + bool bm (cast_false<bool> (rs.global_scope ()[v_d_b])); + + // Register the meta-operation. + // + rs.insert_meta_operation (dist_id, + bm ? mo_dist_bootstrap : mo_dist_load); + // Create the module. // extra.set_module (new module (v_d_p)); } - bool - init (scope& rs, - scope&, - const location& l, - bool first, - bool, - module_init_extra&) + // This code is reused by the bootstrap mode. + // + void + init_config (scope& rs) { - tracer trace ("dist::init"); - - if (!first) - { - warn (l) << "multiple dist module initializations"; - return true; - } - - l5 ([&]{trace << "for " << rs;}); - - // Register our wildcard rule. Do it explicitly for the alias to prevent - // something like insert<target>(dist_id, test_id) taking precedence. - // - rs.insert_rule<target> (dist_id, 0, "dist", rule_); - rs.insert_rule<alias> (dist_id, 0, "dist.alias", rule_); //@@ outer? - - // Configuration. - // // Note that we don't use any defaults for root -- the location // must be explicitly specified or we will complain if and when // we try to dist. @@ -109,13 +103,9 @@ namespace build2 using config::lookup_config; using config::specified_config; - bool s (specified_config (rs, "dist")); - - // Adjust module priority so that the config.dist.* values are saved at - // the end of config.build. + // Note: ignore config.dist.bootstrap. // - if (s) - config::save_module (rs, "dist", INT32_MAX); + bool s (specified_config (rs, "dist", {"bootstrap"})); // dist.root // @@ -172,6 +162,62 @@ namespace build2 // Omit it from the configuration unless specified. // lookup_config (rs, "config.dist.uncommitted"); + } + + bool + init (scope& rs, + scope&, + const location& l, + bool first, + bool, + module_init_extra&) + { + tracer trace ("dist::init"); + + if (!first) + { + warn (l) << "multiple dist module initializations"; + return true; + } + + l5 ([&]{trace << "for " << rs;}); + + auto& vp (rs.var_pool ()); + + // Register our wildcard rule. Do it explicitly for the alias to prevent + // something like insert<target>(dist_id, test_id) taking precedence. + // + rs.insert_rule<target> (dist_id, 0, "dist", rule_); + rs.insert_rule<alias> (dist_id, 0, "dist.alias", rule_); //@@ outer? + + // Configuration. + // + // Adjust module priority so that the config.dist.* values are saved at + // the end of config.build. + // + // Note: must be done regardless of specified_config() result due to + // the unsave_variable() call below. + // + config::save_module (rs, "dist", INT32_MAX); + + init_config (rs); + + // dist.bootstrap + // + { + auto& v (*vp.find ("config.dist.bootstrap")); + + // If specified, verify it is a global override. + // + if (lookup l = rs[v]) + { + if (!l.belongs (rs.global_scope ())) + fail << "config.dist.bootstrap must be a global override" << + info << "specify !config.dist.bootstrap=..."; + } + + config::unsave_variable (rs, v); + } return true; } diff --git a/libbuild2/dist/module.hxx b/libbuild2/dist/module.hxx index 95dbc53..e445d4a 100644 --- a/libbuild2/dist/module.hxx +++ b/libbuild2/dist/module.hxx @@ -40,6 +40,9 @@ namespace build2 // Note that if registered, the callbacks are also called (recursively) // in subprojects. // + // Note also that in the bootstrap distribution mode only callbacks + // registered during bootstrap will be called. + // using callback_func = void (const path&, const scope&, void*); void diff --git a/libbuild2/dist/operation.cxx b/libbuild2/dist/operation.cxx index cce2239..a5dfba0 100644 --- a/libbuild2/dist/operation.cxx +++ b/libbuild2/dist/operation.cxx @@ -61,38 +61,101 @@ namespace build2 dist_operation_pre (const values&, operation_id o) { if (o != default_id) - fail << "explicit operation specified for meta-operation dist"; + fail << "explicit operation specified for dist meta-operation"; return o; } + // Enter the specified source file as a target of type T. The path is + // expected to be normalized and relative to src_root. If the third + // argument is false, then first check if the file exists. If the fourth + // argument is true, then set the target's path. + // + template <typename T> + static const T* + add_target (const scope& rs, const path& f, bool e = false, bool s = false) + { + tracer trace ("dist::add_target"); + + path p (rs.src_path () / f); + if (e || exists (p)) + { + dir_path d (p.directory ()); + + // Figure out if we need out. + // + dir_path out (rs.src_path () != rs.out_path () + ? out_src (d, rs) + : dir_path ()); + + const T& t (rs.ctx.targets.insert<T> ( + move (d), + move (out), + p.leaf ().base ().string (), + p.extension (), // Specified. + trace)); + + if (s) + t.path (move (p)); + + return &t; + } + + return nullptr; + } + + // Recursively traverse an src_root subdirectory entering/collecting the + // contained files and file symlinks as the file targets and skipping + // entries that start with a dot. Follow directory symlinks (preserving + // their names) and fail on dangling symlinks. + // static void - dist_execute (const values&, action, action_targets& ts, - uint16_t, bool prog) + add_subdir (const scope& rs, const dir_path& sd, action_targets& files) { - tracer trace ("dist_execute"); + dir_path d (rs.src_path () / sd); - // For now we assume all the targets are from the same project. - // - const target& t (ts[0].as<target> ()); - const scope* rs (t.base_scope ().root_scope ()); + try + { + for (const dir_entry& e: dir_iterator (d, false /* ignore_dangling */)) + { + const path& n (e.path ()); - if (rs == nullptr) - fail << "out of project target " << t; + if (n.string ()[0] != '.') + try + { + if (e.type () == entry_type::directory) // Can throw. + add_subdir (rs, sd / path_cast<dir_path> (n), files); + else + files.push_back (add_target<file> (rs, sd / n, true, true)); + } + catch (const system_error& e) + { + fail << "unable to stat " << (d / n) << ": " << e; + } + } + } + catch (const system_error& e) + { + fail << "unable to iterate over " << d << ": " << e; + } + } - context& ctx (rs->ctx); + // If tgt is NULL, then this is the bootstrap mode. + // + static void + dist_project (const scope& rs, const target* tgt, bool prog) + { + tracer trace ("dist::dist_project"); - const dir_path& out_root (rs->out_path ()); - const dir_path& src_root (rs->src_path ()); + context& ctx (rs.ctx); - if (out_root == src_root) - fail << "in-tree distribution of target " << t << - info << "distribution requires out-of-tree build"; + const dir_path& out_root (rs.out_path ()); + const dir_path& src_root (rs.src_path ()); // Make sure we have the necessary configuration before we get down to // business. // - auto l (rs->vars["dist.root"]); + auto l (rs.vars["dist.root"]); if (!l || l->empty ()) fail << "unknown root distribution directory" << @@ -104,26 +167,14 @@ namespace build2 // const dir_path& dist_root (cast<dir_path> (l)); - l = rs->vars["dist.package"]; + l = rs.vars["dist.package"]; if (!l || l->empty ()) fail << "unknown distribution package name" << info << "did you forget to set dist.package?"; const string& dist_package (cast<string> (l)); - const process_path& dist_cmd (cast<process_path> (rs->vars["dist.cmd"])); - - // Verify all the targets are from the same project. - // - for (const action_target& at: ts) - { - const target& t (at.as<target> ()); - - if (rs != t.base_scope ().root_scope ()) - fail << "target " << t << " is from a different project" << - info << "one dist meta-operation can handle one project" << - info << "consider using several dist meta-operations"; - } + const process_path& dist_cmd (cast<process_path> (rs.vars["dist.cmd"])); // We used to print 'dist <target>' at verbosity level 1 but that has // proven to be just noise. Though we still want to print something @@ -136,204 +187,211 @@ namespace build2 if (verb == 1) text << "dist " << dist_package; - // Match a rule for every operation supported by this project. Skip - // default_id. - // - // Note that we are not calling operation_pre/post() callbacks here - // since the meta operation is dist and we know what we are doing. + // Get the list of files to distribute. // - values params; - path_name pn ("<dist>"); - const location loc (pn); // Dummy location. + action_targets files; + + if (tgt != nullptr) { - auto mog = make_guard ([&ctx] () {ctx.match_only = false;}); - ctx.match_only = true; + l5 ([&]{trace << "load dist " << rs;}); - const operations& ops (rs->root_extra->operations); - for (operations::size_type id (default_id + 1); // Skip default_id. - id < ops.size (); - ++id) + // Match a rule for every operation supported by this project. Skip + // default_id. + // + // Note that we are not calling operation_pre/post() callbacks here + // since the meta operation is dist and we know what we are doing. + // + values params; + path_name pn ("<dist>"); + const location loc (pn); // Dummy location. { - if (const operation_info* oif = ops[id]) - { - // Skip aliases (e.g., update-for-install). In fact, one can argue - // the default update should be sufficient since it is assumed to - // update all prerequisites and we no longer support ad hoc stuff - // like test.input. Though here we are using the dist meta- - // operation, not perform. - // - if (oif->id != id) - continue; + action_targets ts {tgt}; - // Use standard (perform) match. - // - if (oif->pre != nullptr) + auto mog = make_guard ([&ctx] () {ctx.match_only = false;}); + ctx.match_only = true; + + const operations& ops (rs.root_extra->operations); + for (operations::size_type id (default_id + 1); // Skip default_id. + id < ops.size (); + ++id) + { + if (const operation_info* oif = ops[id]) { - if (operation_id pid = oif->pre (params, dist_id, loc)) + // Skip aliases (e.g., update-for-install). In fact, one can + // argue the default update should be sufficient since it is + // assumed to update all prerequisites and we no longer support + // ad hoc stuff like test.input. Though here we are using the + // dist meta-operation, not perform. + // + if (oif->id != id) + continue; + + // Use standard (perform) match. + // + if (oif->pre != nullptr) { - const operation_info* poif (ops[pid]); - ctx.current_operation (*poif, oif, false /* diag_noise */); - action a (dist_id, poif->id, oif->id); - match (params, a, ts, - 1 /* diag (failures only) */, - false /* progress */); + if (operation_id pid = oif->pre (params, dist_id, loc)) + { + const operation_info* poif (ops[pid]); + ctx.current_operation (*poif, oif, false /* diag_noise */); + action a (dist_id, poif->id, oif->id); + match (params, a, ts, + 1 /* diag (failures only) */, + false /* progress */); + } } - } - ctx.current_operation (*oif, nullptr, false /* diag_noise */); - action a (dist_id, oif->id); - match (params, a, ts, - 1 /* diag (failures only) */, - false /* progress */); + ctx.current_operation (*oif, nullptr, false /* diag_noise */); + action a (dist_id, oif->id); + match (params, a, ts, + 1 /* diag (failures only) */, + false /* progress */); - if (oif->post != nullptr) - { - if (operation_id pid = oif->post (params, dist_id)) + if (oif->post != nullptr) { - const operation_info* poif (ops[pid]); - ctx.current_operation (*poif, oif, false /* diag_noise */); - action a (dist_id, poif->id, oif->id); - match (params, a, ts, - 1 /* diag (failures only) */, - false /* progress */); + if (operation_id pid = oif->post (params, dist_id)) + { + const operation_info* poif (ops[pid]); + ctx.current_operation (*poif, oif, false /* diag_noise */); + action a (dist_id, poif->id, oif->id); + match (params, a, ts, + 1 /* diag (failures only) */, + false /* progress */); + } } } } } - } - // Add buildfiles that are not normally loaded as part of the project, - // for example, the export stub. They will still be ignored on the next - // step if the user explicitly marked them dist=false. - // - auto add_adhoc = [&trace] (const scope& rs, const path& f) - { - path p (rs.src_path () / f); - if (exists (p)) + // Add buildfiles that are not normally loaded as part of the project, + // for example, the export stub. They will still be ignored on the + // next step if the user explicitly marked them dist=false. + // + add_target<buildfile> (rs, rs.root_extra->export_file); + + // The same for subprojects that have been loaded. + // + if (const subprojects* ps = *rs.root_extra->subprojects) { - dir_path d (p.directory ()); + for (auto p: *ps) + { + const dir_path& pd (p.second); + dir_path out_nroot (out_root / pd); + const scope& nrs (ctx.scopes.find (out_nroot)); - // Figure out if we need out. - // - dir_path out (rs.src_path () != rs.out_path () - ? out_src (d, rs) - : dir_path ()); - - rs.ctx.targets.insert<buildfile> ( - move (d), - move (out), - p.leaf ().base ().string (), - p.extension (), // Specified. - trace); + if (nrs.out_path () != out_nroot) // This subproject not loaded. + continue; + + if (!nrs.src_path ().sub (src_root)) // Not a strong amalgamation. + continue; + + add_target<buildfile> (nrs, nrs.root_extra->export_file); + } } - }; - add_adhoc (*rs, rs->root_extra->export_file); + // Collect the files. We want to take the snapshot of targets since + // updating some of them may result in more targets being entered. + // + // Note that we are not showing progress here (e.g., "N targets to + // distribute") since it will be useless (too fast). + // + const variable& dist_var (ctx.var_pool["dist"]); - // The same for subprojects that have been loaded. - // - if (const subprojects* ps = *rs->root_extra->subprojects) - { - for (auto p: *ps) + for (const auto& pt: ctx.targets) { - const dir_path& pd (p.second); - dir_path out_nroot (out_root / pd); - const scope& nrs (ctx.scopes.find (out_nroot)); + file* ft (pt->is_a<file> ()); - if (nrs.out_path () != out_nroot) // This subproject not loaded. + if (ft == nullptr) // Not a file. continue; - if (!nrs.src_path ().sub (src_root)) // Not a strong amalgamation. - continue; - - add_adhoc (nrs, nrs.root_extra->export_file); - } - } - - // Collect the files. We want to take the snapshot of targets since - // updating some of them may result in more targets being entered. - // - // Note that we are not showing progress here (e.g., "N targets to - // distribute") since it will be useless (too fast). - // - action_targets files; - const variable& dist_var (ctx.var_pool["dist"]); + if (ft->dir.sub (src_root)) + { + // Include unless explicitly excluded. + // + auto l ((*ft)[dist_var]); - for (const auto& pt: ctx.targets) - { - file* ft (pt->is_a<file> ()); + if (l && !cast<bool> (l)) + l5 ([&]{trace << "excluding " << *ft;}); + else + files.push_back (ft); - if (ft == nullptr) // Not a file. - continue; + continue; + } - if (ft->dir.sub (src_root)) - { - // Include unless explicitly excluded. - // - auto l ((*ft)[dist_var]); + if (ft->dir.sub (out_root)) + { + // Exclude unless explicitly included. + // + auto l ((*ft)[dist_var]); - if (l && !cast<bool> (l)) - l5 ([&]{trace << "excluding " << *ft;}); - else - files.push_back (ft); + if (l && cast<bool> (l)) + { + l5 ([&]{trace << "including " << *ft;}); + files.push_back (ft); + } - continue; + continue; + } } - if (ft->dir.sub (out_root)) + // Make sure what we need to distribute is up to date. + // { - // Exclude unless explicitly included. + if (mo_perform.meta_operation_pre != nullptr) + mo_perform.meta_operation_pre (params, loc); + + // This is a hack since according to the rules we need to completely + // reset the state. We could have done that (i.e., saved target + // names and then re-searched them in the new tree) but that would + // just slow things down while this little cheat seems harmless + // (i.e., assume the dist mete-opreation is "compatible" with + // perform). // - auto l ((*ft)[dist_var]); - - if (l && cast<bool> (l)) - { - l5 ([&]{trace << "including " << *ft;}); - files.push_back (ft); - } - - continue; - } - } + // Note also that we don't do any structured result printing. + // + size_t on (ctx.current_on); + ctx.current_meta_operation (mo_perform); + ctx.current_on = on + 1; - // Make sure what we need to distribute is up to date. - // - { - if (mo_perform.meta_operation_pre != nullptr) - mo_perform.meta_operation_pre (params, loc); - - // This is a hack since according to the rules we need to completely - // reset the state. We could have done that (i.e., saved target names - // and then re-searched them in the new tree) but that would just slow - // things down while this little cheat seems harmless (i.e., assume - // the dist mete-opreation is "compatible" with perform). - // - // Note also that we don't do any structured result printing. - // - size_t on (ctx.current_on); - ctx.current_meta_operation (mo_perform); - ctx.current_on = on + 1; + if (mo_perform.operation_pre != nullptr) + mo_perform.operation_pre (params, update_id); - if (mo_perform.operation_pre != nullptr) - mo_perform.operation_pre (params, update_id); + ctx.current_operation (op_update, nullptr, false /* diag_noise */); - ctx.current_operation (op_update, nullptr, false /* diag_noise */); + action a (perform_update_id); - action a (perform_update_id); + mo_perform.match (params, a, files, + 1 /* diag (failures only) */, + prog /* progress */); - mo_perform.match (params, a, files, - 1 /* diag (failures only) */, - prog /* progress */); + mo_perform.execute (params, a, files, + 1 /* diag (failures only) */, + prog /* progress */); - mo_perform.execute (params, a, files, - 1 /* diag (failures only) */, - prog /* progress */); + if (mo_perform.operation_post != nullptr) + mo_perform.operation_post (params, update_id); - if (mo_perform.operation_post != nullptr) - mo_perform.operation_post (params, update_id); + if (mo_perform.meta_operation_post != nullptr) + mo_perform.meta_operation_post (params); + } + } + else + { + l5 ([&]{trace << "bootstrap dist " << rs;}); - if (mo_perform.meta_operation_post != nullptr) - mo_perform.meta_operation_post (params); + // Recursively enter/collect file targets in src_root ignoring those + // that start with a dot. + // + // Note that, in particular, we also collect the symlinks which point + // outside src_root (think of third-party project packaging with the + // upstream git submodule at the root of the git project). Also note + // that we could probably exclude symlinks which point outside the VCS + // project (e.g., backlinks in a forwarded configuration) but that + // would require the user to supply this boundary (since we don't have + // the notion of VCS root at this level). So let's keep it simple for + // now. + // + add_subdir (rs, dir_path (), files); } dir_path td (dist_root / dir_path (dist_package)); @@ -348,7 +406,7 @@ namespace build2 // Copy over all the files. Apply post-processing callbacks. // - module& mod (*rs->find_module<module> (module::name)); + module& mod (*rs.find_module<module> (module::name)); prog = prog && show_progress (1 /* max_verb */); size_t prog_percent (0); @@ -370,10 +428,10 @@ namespace build2 // See if this file is in a subproject. // - const scope* srs (rs); + const scope* srs (&rs); const module::callbacks* cbs (&mod.callbacks_); - if (const subprojects* ps = *rs->root_extra->subprojects) + if (const subprojects* ps = *rs.root_extra->subprojects) { for (auto p: *ps) { @@ -446,9 +504,9 @@ namespace build2 // Archive and checksum if requested. // - if (lookup as = rs->vars["dist.archives"]) + if (lookup as = rs.vars["dist.archives"]) { - lookup cs (rs->vars["dist.checksums"]); + lookup cs (rs.vars["dist.checksums"]); // Split the dist.{archives,checksums} value into a directory and // extension. @@ -487,6 +545,33 @@ namespace build2 } } + static void + dist_load_execute (const values&, action, action_targets& ts, + uint16_t, bool prog) + { + // We cannot do multiple projects because we need to start with a clean + // set of targets. + // + if (ts.size () != 1) + fail << "multiple targets in dist meta-operation" << + info << "one dist meta-operation can handle one project" << + info << "consider using several dist meta-operations"; + + const target& t (ts[0].as<target> ()); + const scope* rs (t.base_scope ().root_scope ()); + + if (rs == nullptr || + !t.is_a<dir> () || + (rs->out_path () != t.dir && rs->src_path () != t.dir)) + fail << "dist meta-operation target must be project root directory"; + + if (rs->out_path () == rs->src_path ()) + fail << "in-tree distribution of target " << t << + info << "distribution requires out-of-tree build"; + + dist_project (*rs, &t, prog); + } + // install -d <dir> // static void @@ -838,7 +923,7 @@ namespace build2 const prerequisite_member& p, include_type i) { - tracer trace ("dist_include"); + tracer trace ("dist::dist_include"); // Override excluded to adhoc so that every source is included into the // distribution. Note that this should be harmless to a custom rule @@ -854,7 +939,7 @@ namespace build2 return i; } - const meta_operation_info mo_dist { + const meta_operation_info mo_dist_load { dist_id, "dist", "distribute", @@ -867,10 +952,77 @@ namespace build2 &load, // normal load &search, // normal search nullptr, // no match (see dist_execute()). - &dist_execute, + &dist_load_execute, nullptr, // operation post nullptr, // meta-operation post &dist_include }; + + // The bootstrap distribution mode. + // + // Note: pretty similar overall idea as the info meta-operation. + // + void + init_config (scope&); // init.cxx + + static void + dist_bootstrap_load (const values&, + scope& rs, + const path&, + const dir_path& out_base, + const dir_path& src_base, + const location& l) + { + if (rs.out_path () != out_base || rs.src_path () != src_base) + fail (l) << "dist meta-operation target must be project root directory"; + + setup_base (rs.ctx.scopes.rw (rs).insert (out_base), out_base, src_base); + + // Also initialize the dist.* variables (needed in dist_project()). + // + init_config (rs); + } + + void + dist_bootstrap_search (const values&, + const scope& rs, + const scope&, + const path&, + const target_key& tk, + const location& l, + action_targets& ts) + { + if (!tk.type->is_a<dir> ()) + fail (l) << "dist meta-operation target must be project root directory"; + + ts.push_back (&rs); + } + + static void + dist_bootstrap_execute (const values&, action, action_targets& ts, + uint16_t, bool prog) + { + for (const action_target& at: ts) + dist_project (at.as<scope> (), nullptr, prog); + } + + const meta_operation_info mo_dist_bootstrap { + dist_id, + "dist", + "distribute", + "distributing", + "distributed", + "has nothing to distribute", + true, // bootstrap_outer //@@ Maybe not? (But will overrides work)? + nullptr, // meta-operation pre + &dist_operation_pre, + &dist_bootstrap_load, + &dist_bootstrap_search, + nullptr, // no match (see dist_bootstrap_execute()). + &dist_bootstrap_execute, + nullptr, // operation post + nullptr, // meta-operation post + nullptr // include + }; } } diff --git a/libbuild2/dist/operation.hxx b/libbuild2/dist/operation.hxx index 8030590..b6730f4 100644 --- a/libbuild2/dist/operation.hxx +++ b/libbuild2/dist/operation.hxx @@ -13,7 +13,8 @@ namespace build2 { namespace dist { - extern const meta_operation_info mo_dist; + extern const meta_operation_info mo_dist_load; + extern const meta_operation_info mo_dist_bootstrap; } } diff --git a/libbuild2/version/init.cxx b/libbuild2/version/init.cxx index d11b2f3..ced9c68 100644 --- a/libbuild2/version/init.cxx +++ b/libbuild2/version/init.cxx @@ -30,6 +30,44 @@ namespace build2 static const in_rule in_rule_; static const manifest_install_rule manifest_install_rule_; + static void + dist_callback (const path&, const scope&, void*); + + void + boot_post (scope& rs, const location&, module_boot_post_extra& extra) + { + // If the dist module is used, set its dist.package and register the + // post-processing callback. + // + if (auto* dm = rs.find_module<dist::module> (dist::module::name)) + { + // Don't touch if dist.package was set by the user. + // + value& val (rs.assign (dm->var_dist_package)); + + if (!val) + { + auto& m (extra.module_as<module> ()); + const standard_version& v (m.version); + + // We've already verified in boot() it is named. + // + string p (project (rs).string ()); + p += '-'; + p += v.string (); + val = move (p); + + // Only register the post-processing callback if this is a rewritten + // snapshot. + // + if (m.rewritten) + dm->register_callback (dir_path (".") / manifest_file, + &dist_callback, + &m); + } + } + } + void boot (scope& rs, const location& l, module_boot_extra& extra) { @@ -281,19 +319,17 @@ namespace build2 // Initialize second (dist.package, etc). // + extra.post = &boot_post; extra.init = module_boot_init::before_second; } - static void - dist_callback (const path&, const scope&, void*); - bool init (scope& rs, scope&, const location& l, bool first, bool, - module_init_extra& extra) + module_init_extra&) { tracer trace ("version::init"); @@ -304,43 +340,6 @@ namespace build2 // load_module (rs, rs, "in.base", l); - auto& m (extra.module_as<module> ()); - const standard_version& v (m.version); - - // If the dist module is used, set its dist.package and register the - // post-processing callback. - // - if (auto* dm = rs.find_module<dist::module> (dist::module::name)) - { - // Make sure dist is init'ed, not just boot'ed. - // - load_module (rs, rs, "dist", l); - - m.dist_uncommitted = cast_false<bool> (rs["config.dist.uncommitted"]); - - // Don't touch if dist.package was set by the user. - // - value& val (rs.assign (dm->var_dist_package)); - - if (!val) - { - // We've already verified in boot() it is named. - // - string p (project (rs).string ()); - p += '-'; - p += v.string (); - val = move (p); - - // Only register the post-processing callback if this is a rewritten - // snapshot. - // - if (m.rewritten) - dm->register_callback (dir_path (".") / manifest_file, - &dist_callback, - &m); - } - } - // Register rules. // rs.insert_rule<file> (perform_update_id, "version.in", in_rule_); @@ -363,7 +362,7 @@ namespace build2 // Complain if this is an uncommitted snapshot. // - if (!m.committed && !m.dist_uncommitted) + if (!m.committed && !cast_false<bool> (rs["config.dist.uncommitted"])) fail << "distribution of uncommitted project " << rs.src_path () << info << "specify config.dist.uncommitted=true to force"; diff --git a/libbuild2/version/module.hxx b/libbuild2/version/module.hxx index bfa7d8c..26bd48a 100644 --- a/libbuild2/version/module.hxx +++ b/libbuild2/version/module.hxx @@ -44,8 +44,6 @@ namespace build2 dependencies_type dependencies; - bool dist_uncommitted = false; - module (const project_name& p, butl::standard_version v, bool c, |