diff options
Diffstat (limited to 'build')
34 files changed, 1093 insertions, 229 deletions
diff --git a/build/algorithm b/build/algorithm index af461dc..375cebb 100644 --- a/build/algorithm +++ b/build/algorithm @@ -73,6 +73,9 @@ namespace build void match (action, target&); + // Note that calling this function only makes sense if the + // target itself doesn't have its own dependents. + // void unmatch (action, target&); diff --git a/build/algorithm.cxx b/build/algorithm.cxx index e09d125..f462bb8 100644 --- a/build/algorithm.cxx +++ b/build/algorithm.cxx @@ -83,7 +83,6 @@ namespace build // action ra (a.meta_operation (), io, o != oo ? 0 : oo); - size_t oi (o - 1); // Operation index in rule_map. scope& bs (t.base_scope ()); for (auto tt (&t.type ()); tt != nullptr; tt = tt->base) @@ -94,129 +93,139 @@ namespace build s != nullptr; s = s->root () ? global_scope : s->parent_scope ()) { - const rule_map& om (s->rules); + const operation_rule_map* om (s->rules[a.meta_operation ()]); - if (om.size () <= oi) - continue; // No entry for this operation id. + if (om == nullptr) + continue; // No entry for this meta-operation id. - const target_type_rule_map& ttm (om[oi]); + // First try the map for the actual operation. If that + // doesn't yeld anything, try the wildcard map. + // + for (size_t oi (o), oip (o); oip != 0; oip = oi, oi = 0) + { + const target_type_rule_map* ttm ((*om)[oi]); - if (ttm.empty ()) - continue; // Empty map for this operation id. + if (ttm == nullptr) + continue; // No entry for this operation id. - auto i (ttm.find (tt->id)); + if (ttm->empty ()) + continue; // Empty map for this operation id. - if (i == ttm.end () || i->second.empty ()) - continue; // No rules registered for this target type. + auto i (ttm->find (tt->id)); - const auto& rules (i->second); // Hint map. + if (i == ttm->end () || i->second.empty ()) + continue; // No rules registered for this target type. - // @@ TODO - // - // Different rules can be used for different operations (update - // vs test is a good example). So, at some point, we will probably - // have to support a list of hints or even an operation-hint map - // (e.g., 'hint=cxx test=foo' if cxx supports the test operation - // but we want the foo rule instead). This is also the place where - // the '{build clean}=cxx' construct (which we currently do not - // support) can come handy. - // - // Also, ignore the hint (that is most likely ment for a different - // operation) if this is a unique match. - // - string hint; - auto rs (rules.size () == 1 - ? make_pair (rules.begin (), rules.end ()) - : rules.find_prefix (hint)); + const auto& rules (i->second); // Hint map. - for (auto i (rs.first); i != rs.second; ++i) - { - const string& n (i->first); - const rule& ru (i->second); - - match_result m; - { - auto g ( - make_exception_guard ( - [](action a, target& t, const string& n) - { - info << "while matching rule " << n << " to " - << diag_do (a, t); - }, - ra, t, n)); - - if (!(m = ru.match (ra, t, hint))) - continue; - - if (!m.recipe_action.valid ()) - m.recipe_action = ra; // Default, if not set. - } - - // Do the ambiguity test. + // @@ TODO // - bool ambig (false); - - diag_record dr; + // Different rules can be used for different operations (update + // vs test is a good example). So, at some point, we will probably + // have to support a list of hints or even an operation-hint map + // (e.g., 'hint=cxx test=foo' if cxx supports the test operation + // but we want the foo rule instead). This is also the place where + // the '{build clean}=cxx' construct (which we currently do not + // support) can come handy. + // + // Also, ignore the hint (that is most likely ment for a different + // operation) if this is a unique match. + // + string hint; + auto rs (rules.size () == 1 + ? make_pair (rules.begin (), rules.end ()) + : rules.find_prefix (hint)); - for (++i; i != rs.second; ++i) + for (auto i (rs.first); i != rs.second; ++i) { - const string& n1 (i->first); - const rule& ru1 (i->second); + const string& n (i->first); + const rule& ru (i->second); + match_result m; { auto g ( make_exception_guard ( - [](action a, target& t, const string& n1) + [](action a, target& t, const string& n) { - info << "while matching rule " << n1 << " to " + info << "while matching rule " << n << " to " << diag_do (a, t); }, - ra, t, n1)); + ra, t, n)); - if (!ru1.match (ra, t, hint)) + if (!(m = ru.match (ra, t, hint))) continue; - } - if (!ambig) - { - dr << fail << "multiple rules matching " << diag_doing (ra, t) - << info << "rule " << n << " matches"; - ambig = true; + if (!m.recipe_action.valid ()) + m.recipe_action = ra; // Default, if not set. } - dr << info << "rule " << n1 << " also matches"; - } + // Do the ambiguity test. + // + bool ambig (false); - if (!ambig) - { - ra = m.recipe_action; // Use custom, if set. + diag_record dr; - if (apply) + for (++i; i != rs.second; ++i) { - auto g ( - make_exception_guard ( - [](action a, target& t, const string& n) - { - info << "while applying rule " << n << " to " - << diag_do (a, t); - }, - ra, t, n)); - - // @@ We could also allow the rule to change the recipe - // action in apply(). Could be useful with delegates. - // - t.recipe (ra, ru.apply (ra, t, m)); + const string& n1 (i->first); + const rule& ru1 (i->second); + + { + auto g ( + make_exception_guard ( + [](action a, target& t, const string& n1) + { + info << "while matching rule " << n1 << " to " + << diag_do (a, t); + }, + ra, t, n1)); + + if (!ru1.match (ra, t, hint)) + continue; + } + + if (!ambig) + { + dr << fail << "multiple rules matching " + << diag_doing (ra, t) + << info << "rule " << n << " matches"; + ambig = true; + } + + dr << info << "rule " << n1 << " also matches"; } - else + + if (!ambig) { - r.first = &ru; - r.second = move (m); + ra = m.recipe_action; // Use custom, if set. + + if (apply) + { + auto g ( + make_exception_guard ( + [](action a, target& t, const string& n) + { + info << "while applying rule " << n << " to " + << diag_do (a, t); + }, + ra, t, n)); + + // @@ We could also allow the rule to change the recipe + // action in apply(). Could be useful with delegates. + // + t.recipe (ra, ru.apply (ra, t, m)); + } + else + { + r.first = &ru; + r.second = move (m); + } + + return r; } - - return r; + else + dr << info << "use rule hint to disambiguate this match"; } - else - dr << info << "use rule hint to disambiguate this match"; } } } diff --git a/build/b.cxx b/build/b.cxx index 412fb12..38a944c 100644 --- a/build/b.cxx +++ b/build/b.cxx @@ -42,6 +42,7 @@ using namespace std; #include <build/config/module> +#include <build/dist/module> #include <build/bin/module> #include <build/cxx/module> #include <build/cli/module> @@ -94,6 +95,7 @@ main (int argc, char* argv[]) // Register builtin modules. // builtin_modules["config"] = &config::config_init; + builtin_modules["dist"] = &dist::dist_init; builtin_modules["bin"] = &bin::bin_init; builtin_modules["cxx"] = &cxx::cxx_init; builtin_modules["cli"] = &cli::cli_init; @@ -771,7 +773,7 @@ main (int argc, char* argv[]) action a (mid, pre_oid, oid); mif->match (a, tgs); - mif->execute (a, tgs); + mif->execute (a, tgs, true); // Run quiet. if (mif->operation_post != nullptr) mif->operation_post (pre_oid); @@ -788,7 +790,7 @@ main (int argc, char* argv[]) action a (mid, oid, 0); mif->match (a, tgs); - mif->execute (a, tgs); + mif->execute (a, tgs, false); if (post_oid != 0) { @@ -806,7 +808,7 @@ main (int argc, char* argv[]) action a (mid, post_oid, oid); mif->match (a, tgs); - mif->execute (a, tgs); + mif->execute (a, tgs, true); // Run quiet. if (mif->operation_post != nullptr) mif->operation_post (post_oid); diff --git a/build/bin/module.cxx b/build/bin/module.cxx index 4c5cca5..63f602c 100644 --- a/build/bin/module.cxx +++ b/build/bin/module.cxx @@ -57,13 +57,11 @@ namespace build { auto& rs (b.rules); - rs.insert<obj> (default_id, "bin.obj", obj_); - rs.insert<obj> (update_id, "bin.obj", obj_); - rs.insert<obj> (clean_id, "bin.obj", obj_); + rs.insert<obj> (perform_id, update_id, "bin.obj", obj_); + rs.insert<obj> (perform_id, clean_id, "bin.obj", obj_); - rs.insert<lib> (default_id, "bin.lib", lib_); - rs.insert<lib> (update_id, "bin.lib", lib_); - rs.insert<lib> (clean_id, "bin.lib", lib_); + rs.insert<lib> (perform_id, update_id, "bin.lib", lib_); + rs.insert<lib> (perform_id, clean_id, "bin.lib", lib_); //@@ Should we check if the install module was loaded // (by checking if install operation is registered @@ -72,7 +70,7 @@ namespace build // should enforce loading of all operation-defining // modules before all others? // - rs.insert<lib> (install_id, "bin.lib", lib_); + rs.insert<lib> (perform_id, install_id, "bin.lib", lib_); } // Enter module variables. diff --git a/build/buildfile b/build/buildfile index ce917f6..0da8d8e 100644 --- a/build/buildfile +++ b/build/buildfile @@ -5,6 +5,7 @@ import libs += libbutl%lib{butl} config = config/{operation module utility} +dist = dist/{operation rule module} bin = bin/{target rule module} cxx = cxx/{target compile link install module utility} cli = cli/{target rule module} @@ -13,8 +14,8 @@ install1 = install/{operation rule module} exe{b}: cxx{b algorithm name operation spec scope variable target \ prerequisite rule file module context search diagnostics token \ - lexer parser path-io utility dump options $config $bin $cxx $cli \ - $test1 $install1} $libs + lexer parser path-io utility dump options $config $dist $bin $cxx \ + $cli $test1 $install1} $libs #@@ TODO # diff --git a/build/cli/module.cxx b/build/cli/module.cxx index 7702589..efc9ff2 100644 --- a/build/cli/module.cxx +++ b/build/cli/module.cxx @@ -61,21 +61,17 @@ namespace build { auto& rs (base.rules); - rs.insert<cli_cxx> (default_id, "cli.compile", compile_); - rs.insert<cli_cxx> (update_id, "cli.compile", compile_); - rs.insert<cli_cxx> (clean_id, "cli.compile", compile_); + rs.insert<cli_cxx> (perform_id, update_id, "cli", compile_); + rs.insert<cli_cxx> (perform_id, clean_id, "cli", compile_); - rs.insert<cxx::hxx> (default_id, "cli.compile", compile_); - rs.insert<cxx::hxx> (update_id, "cli.compile", compile_); - rs.insert<cxx::hxx> (clean_id, "cli.compile", compile_); + rs.insert<cxx::hxx> (perform_id, update_id, "cli", compile_); + rs.insert<cxx::hxx> (perform_id, clean_id, "cli", compile_); - rs.insert<cxx::cxx> (default_id, "cli.compile", compile_); - rs.insert<cxx::cxx> (update_id, "cli.compile", compile_); - rs.insert<cxx::cxx> (clean_id, "cli.compile", compile_); + rs.insert<cxx::cxx> (perform_id, update_id, "cli", compile_); + rs.insert<cxx::cxx> (perform_id, clean_id, "cli", compile_); - rs.insert<cxx::ixx> (default_id, "cli.compile", compile_); - rs.insert<cxx::ixx> (update_id, "cli.compile", compile_); - rs.insert<cxx::ixx> (clean_id, "cli.compile", compile_); + rs.insert<cxx::ixx> (perform_id, update_id, "cli", compile_); + rs.insert<cxx::ixx> (perform_id, clean_id, "cli", compile_); } // Enter module variables. diff --git a/build/cli/rule.cxx b/build/cli/rule.cxx index a892d7c..b3c57f1 100644 --- a/build/cli/rule.cxx +++ b/build/cli/rule.cxx @@ -172,7 +172,7 @@ namespace build { case perform_update_id: return &perform_update; case perform_clean_id: return &perform_clean; - default: return default_recipe; // Forward to prerequisites. + default: assert (false); return default_recipe; } } else diff --git a/build/config/operation.cxx b/build/config/operation.cxx index 913ae29..80b92dc 100644 --- a/build/config/operation.cxx +++ b/build/config/operation.cxx @@ -187,17 +187,26 @@ namespace build } static void - configure_execute (action a, const action_targets& ts) + configure_search (scope& root, + const target_key&, + const location&, + action_targets& ts) { - for (void* v: ts) - { - target& t (*static_cast<target*> (v)); - scope* rs (t.base_scope ().root_scope ()); + tracer trace ("configure_search"); + level5 ([&]{trace << "collecting " << root.path ();}); + ts.push_back (&root); + } - if (rs == nullptr) - fail << "out of project target " << t; + static void + configure_match (action, action_targets&) {} - configure_project (a, *rs); + static void + configure_execute (action a, const action_targets& ts, bool) + { + for (void* v: ts) + { + scope& root (*static_cast<scope*> (v)); + configure_project (a, root); } } @@ -209,8 +218,8 @@ namespace build nullptr, // meta-operation pre &configure_operation_pre, &load, // normal load - &search, // normal search - &match, // normal match + &configure_search, + &configure_match, &configure_execute, nullptr, // operation post nullptr // meta-operation post @@ -355,7 +364,7 @@ namespace build } static void - disfigure_execute (action a, const action_targets& ts) + disfigure_execute (action a, const action_targets& ts, bool quiet) { tracer trace ("disfigure_execute"); @@ -372,7 +381,8 @@ namespace build targets.insert ( dir::static_type, root.path (), "", nullptr, trace).first); - info << diag_done (a, t); + if (!quiet) + info << diag_done (a, t); } } } diff --git a/build/config/utility b/build/config/utility index 82f71fe..406c271 100644 --- a/build/config/utility +++ b/build/config/utility @@ -49,12 +49,25 @@ namespace build // Return the value, which can be NULL. // const value& - optional (scope& root, const variable& var); + optional (scope& root, const variable&); inline const value& - optional (scope& root, const std::string& name) + optional (scope& root, const std::string& var) { - return optional (root, variable_pool.find (name)); + return optional (root, variable_pool.find (var)); + } + + // As above but assumes the value is dir_path and makes it + // absolute if the value specified on the command line is + // relative. + // + const value& + optional_absolute (scope& root, const variable&); + + inline const value& + optional_absolute (scope& root, const std::string& var) + { + return optional_absolute (root, variable_pool.find (var)); } // Check whether there are any variables specified from the diff --git a/build/config/utility.cxx b/build/config/utility.cxx index ce723fe..c9d7c66 100644 --- a/build/config/utility.cxx +++ b/build/config/utility.cxx @@ -4,6 +4,8 @@ #include <build/config/utility> +#include <build/context> + using namespace std; namespace build @@ -20,6 +22,37 @@ namespace build : root.assign (var); // NULL } + const value& + optional_absolute (scope& root, const variable& var) + { + auto l (root[var]); + + if (!l.defined ()) + return root.assign (var); // NULL + + if (!l.belongs (*global_scope)) // Value from (some) root scope. + return *l; + + // Make the command-line value absolute. This is necessary to avoid + // a warning issued by the config module about global/root scope + // value mismatch. + // + value& v (const_cast<value&> (*l)); + + if (v && !v.empty ()) + { + dir_path& d (as<dir_path> (v)); + + if (d.relative ()) + { + d = work / d; + d.normalize (); + } + } + + return root.assign (var) = v; + } + bool specified (scope& r, const string& ns) { diff --git a/build/context b/build/context index b8d178b..920ad1f 100644 --- a/build/context +++ b/build/context @@ -93,6 +93,12 @@ namespace build inline fs_status<butl::rmdir_status> rmdir (const dir_path& d) {return rmdir (d, d);} + // Note that this function returns not_empty if we try to remove + // a working directory. + // + fs_status<butl::rmdir_status> + rmdir_r (const dir_path&); + // Return the src/out directory corresponding to the given out/src. The // passed directory should be a sub-directory of out/src_root. // diff --git a/build/context.cxx b/build/context.cxx index 3e3d0c3..aaeb426 100644 --- a/build/context.cxx +++ b/build/context.cxx @@ -47,6 +47,7 @@ namespace build meta_operation_table.insert ("perform"); meta_operation_table.insert ("configure"); meta_operation_table.insert ("disfigure"); + meta_operation_table.insert ("dist"); operation_table.clear (); operation_table.insert ("default"); @@ -100,17 +101,13 @@ namespace build { rule_map& rs (global_scope->rules); - rs.insert<alias> (default_id, "alias", alias_rule::instance); - rs.insert<alias> (update_id, "alias", alias_rule::instance); - rs.insert<alias> (clean_id, "alias", alias_rule::instance); + rs.insert<alias> (perform_id, 0, "alias", alias_rule::instance); - rs.insert<fsdir> (default_id, "fsdir", fsdir_rule::instance); - rs.insert<fsdir> (update_id, "fsdir", fsdir_rule::instance); - rs.insert<fsdir> (clean_id, "fsdir", fsdir_rule::instance); + rs.insert<fsdir> (perform_id, update_id, "fsdir", fsdir_rule::instance); + rs.insert<fsdir> (perform_id, clean_id, "fsdir", fsdir_rule::instance); - rs.insert<file> (default_id, "file", file_rule::instance); - rs.insert<file> (update_id, "file", file_rule::instance); - rs.insert<file> (clean_id, "file", file_rule::instance); + rs.insert<file> (perform_id, update_id, "file", file_rule::instance); + rs.insert<file> (perform_id, clean_id, "file", file_rule::instance); } } @@ -162,6 +159,31 @@ namespace build return ms; } + fs_status<butl::rmdir_status> + rmdir_r (const dir_path& d) + { + using namespace butl; + + if (work.sub (d)) // Don't try to remove working directory. + return rmdir_status::not_empty; + + if (!dir_exists (d)) + return rmdir_status::not_exist; + + text << "rmdir -r " << d; + + try + { + butl::rmdir_r (d); + } + catch (const std::system_error& e) + { + fail << "unable to remove directory " << d << ": " << e.what (); + } + + return rmdir_status::success; + } + dir_path src_out (const dir_path& out, scope& s) { diff --git a/build/cxx/compile.cxx b/build/cxx/compile.cxx index ce921d2..bb42c30 100644 --- a/build/cxx/compile.cxx +++ b/build/cxx/compile.cxx @@ -151,7 +151,7 @@ namespace build { case perform_update_id: return &perform_update; case perform_clean_id: return &perform_clean; - default: return default_recipe; // Forward to prerequisites. + default: assert (false); return default_recipe; } } diff --git a/build/cxx/link.cxx b/build/cxx/link.cxx index 4023105..9602e75 100644 --- a/build/cxx/link.cxx +++ b/build/cxx/link.cxx @@ -722,7 +722,7 @@ namespace build { case perform_update_id: return &perform_update; case perform_clean_id: return &perform_clean; - default: return default_recipe; // Forward to prerequisites. + default: assert (false); return default_recipe; } } diff --git a/build/cxx/module.cxx b/build/cxx/module.cxx index 7f200cd..c2469d9 100644 --- a/build/cxx/module.cxx +++ b/build/cxx/module.cxx @@ -64,31 +64,26 @@ namespace build auto& rs (b.rules); - rs.insert<obja> (default_id, "cxx.compile", compile::instance); - rs.insert<obja> (update_id, "cxx.compile", compile::instance); - rs.insert<obja> (clean_id, "cxx.compile", compile::instance); + rs.insert<obja> (perform_id, update_id, "cxx", compile::instance); + rs.insert<obja> (perform_id, clean_id, "cxx", compile::instance); - rs.insert<objso> (default_id, "cxx.compile", compile::instance); - rs.insert<objso> (update_id, "cxx.compile", compile::instance); - rs.insert<objso> (clean_id, "cxx.compile", compile::instance); + rs.insert<objso> (perform_id, update_id, "cxx", compile::instance); + rs.insert<objso> (perform_id, clean_id, "cxx", compile::instance); - rs.insert<exe> (default_id, "cxx.link", link::instance); - rs.insert<exe> (update_id, "cxx.link", link::instance); - rs.insert<exe> (clean_id, "cxx.link", link::instance); + rs.insert<exe> (perform_id, update_id, "cxx", link::instance); + rs.insert<exe> (perform_id, clean_id, "cxx", link::instance); - rs.insert<liba> (default_id, "cxx.link", link::instance); - rs.insert<liba> (update_id, "cxx.link", link::instance); - rs.insert<liba> (clean_id, "cxx.link", link::instance); + rs.insert<liba> (perform_id, update_id, "cxx", link::instance); + rs.insert<liba> (perform_id, clean_id, "cxx", link::instance); - rs.insert<libso> (default_id, "cxx.link", link::instance); - rs.insert<libso> (update_id, "cxx.link", link::instance); - rs.insert<libso> (clean_id, "cxx.link", link::instance); + rs.insert<libso> (perform_id, update_id, "cxx", link::instance); + rs.insert<libso> (perform_id, clean_id, "cxx", link::instance); //@@ Should we check if install module was loaded (see bin)? // - rs.insert<exe> (install_id, "cxx.install", install::instance); - rs.insert<liba> (install_id, "cxx.install", install::instance); - rs.insert<libso> (install_id, "cxx.install", install::instance); + rs.insert<exe> (perform_id, install_id, "cxx", install::instance); + rs.insert<liba> (perform_id, install_id, "cxx", install::instance); + rs.insert<libso> (perform_id, install_id, "cxx", install::instance); } // Enter module variables. diff --git a/build/dist/module b/build/dist/module new file mode 100644 index 0000000..9fad86f --- /dev/null +++ b/build/dist/module @@ -0,0 +1,21 @@ +// file : build/dist/module -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef BUILD_DIST_MODULE +#define BUILD_DIST_MODULE + +#include <build/types> +#include <build/module> + +namespace build +{ + namespace dist + { + extern "C" void + dist_init ( + scope&, scope&, const location&, std::unique_ptr<module>&, bool); + } +} + +#endif // BUILD_DIST_MODULE diff --git a/build/dist/module.cxx b/build/dist/module.cxx new file mode 100644 index 0000000..7b9b340 --- /dev/null +++ b/build/dist/module.cxx @@ -0,0 +1,130 @@ +// file : build/dist/module.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <build/dist/module> + +#include <build/scope> +#include <build/file> +#include <build/diagnostics> + +#include <build/config/utility> + +#include <build/dist/rule> +#include <build/dist/operation> + +using namespace std; +using namespace butl; + +namespace build +{ + namespace dist + { + static rule rule_; + + extern "C" void + dist_init (scope& r, + scope& b, + const location& l, + std::unique_ptr<module>&, + bool first) + { + tracer trace ("dist::init"); + + if (&r != &b) + fail (l) << "dist module must be initialized in bootstrap.build"; + + if (!first) + { + warn (l) << "multiple dist module initializations"; + return; + } + + const dir_path& out_root (r.path ()); + level4 ([&]{trace << "for " << out_root;}); + + // Register meta-operation. + // + r.meta_operations.insert (dist_id, dist); + + // Register our wildcard rule. Do it explicitly for the alias + // to prevent something like insert<target>(dist_id, test_id) + // taking precedence. + // + r.rules.insert<target> (dist_id, 0, "dist", rule_); + r.rules.insert<alias> (dist_id, 0, "dist", rule_); + + // Enter module variables. + // + if (first) + { + variable_pool.find ("dist.package", string_type); + + variable_pool.find ("dist.root", dir_path_type); + variable_pool.find ("config.dist.root", dir_path_type); + + //@@ VAR type + // + variable_pool.find ("dist.cmd", string_type); + variable_pool.find ("config.dist.cmd", string_type); + + variable_pool.find ("dist.archives", strings_type); + variable_pool.find ("config.dist.archives", strings_type); + } + + // 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. + // + using namespace config; + + bool s (specified (r, "config.dist")); + + // dist.root + // + { + value& v (r.assign ("dist.root")); + + if (s) + { + const value& cv (optional_absolute (r, "config.dist.root")); + + if (cv && !cv.empty ()) + v = cv; + } + } + + // dist.cmd + // + { + value& v (r.assign ("dist.cmd")); + + if (s) + { + const value& cv (required (r, "config.dist.cmd", "install").first); + + if (cv && !cv.empty ()) + v = cv; + } + else + v = "install"; + } + + // dist.archives + // + { + value& v (r.assign ("dist.archives")); + + if (s) + { + const value& cv (optional (r, "config.dist.archives")); + + if (cv && !cv.empty ()) + v = cv; + } + } + } + } +} diff --git a/build/dist/operation b/build/dist/operation new file mode 100644 index 0000000..c7aa014 --- /dev/null +++ b/build/dist/operation @@ -0,0 +1,18 @@ +// file : build/dist/operation -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef BUILD_DIST_OPERATION +#define BUILD_DIST_OPERATION + +#include <build/operation> + +namespace build +{ + namespace dist + { + extern meta_operation_info dist; + } +} + +#endif // BUILD_DIST_OPERATION diff --git a/build/dist/operation.cxx b/build/dist/operation.cxx new file mode 100644 index 0000000..3c6ec98 --- /dev/null +++ b/build/dist/operation.cxx @@ -0,0 +1,423 @@ +// file : build/dist/operation.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <build/dist/operation> + +#include <cassert> + +#include <butl/process> +#include <butl/filesystem> + +#include <build/file> +#include <build/dump> +#include <build/scope> +#include <build/target> +#include <build/context> +#include <build/algorithm> +#include <build/diagnostics> + +using namespace std; +using namespace butl; + +namespace build +{ + namespace dist + { + static void + dist_meta_operation_pre () + { + // Reset the dependency state so that we don't end up with stray + // files from previous batches. + // + // @@ This is called too late, after we have bootstrapped the + // project. + // + //reset (); + } + + static operation_id + dist_operation_pre (operation_id o) + { + if (o != default_id) + fail << "explicit operation specified for dist meta-operation"; + + return o; + } + + static void + dist_match (action, action_targets&) + { + // Don't match anything -- see execute (). + } + + // install -d <dir> + // + static void + install (const string& cmd, const dir_path&); + + // install <file> <dir> + // + static void + install (const string& cmd, file&, const dir_path&); + + // cd <root> && tar|zip ... <pkg>.<ext> <pkg> + // + static void + archive (const dir_path& root, const string& pkg, const string& ext); + + static void + dist_execute (action, const action_targets& ts, bool) + { + tracer trace ("dist_execute"); + + // For now we assume all the targets are from the same project. + // + target& t (*static_cast<target*> (ts[0])); + scope* rs (t.base_scope ().root_scope ()); + + if (rs == nullptr) + fail << "out of project target " << t; + + const dir_path& out_root (rs->path ()); + const dir_path& src_root (rs->src_path ()); + + if (out_root == src_root) + fail << "in-tree distribution of target " << t << + info << "distribution requires out-of-tree build"; + + // Make sure we have the necessary configuration before + // we get down to business. + // + auto l (rs->vars["dist.root"]); + + if (!l || l->empty ()) + fail << "unknown root distribution directory" << + info << "did you forget to specify config.dist.root?"; + + const dir_path& dist_root (as<dir_path> (*l)); + + if (!dir_exists (dist_root)) + fail << "root distribution directory " << dist_root + << " does not exist"; + + 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 (as<string> (*l)); + const string& dist_cmd (as<string> (*rs->vars["dist.cmd"])); + + // Get the list of operations supported by this project. Skip + // default_id. + // + for (operations::size_type id (default_id + 1); + id < rs->operations.size (); + ++id) + { + const operation_info* oi (rs->operations[id]); + if (oi == nullptr) + continue; + + // Note that we are not calling operation_pre/post() callbacks + // here since the meta operation is dist and we know what we + // are doing. + // + current_inner_oif = oi; + current_outer_oif = nullptr; + current_mode = oi->mode; + dependency_count = 0; + + action a (dist_id, id); + + if (verb >= 5) + dump (a); + + for (void* v: ts) + { + target& t (*static_cast<target*> (v)); + + if (rs != t.base_scope ().root_scope ()) + fail << "out of project target " << t; + + level4 ([&]{trace << diag_doing (a, t);}); + + match (a, t); + } + + if (verb >= 5) + dump (a); + } + + // 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 + // nodist. + // + auto add_adhoc = [&src_root, &trace] (const char* f) + { + path p (src_root / path (f)); + if (file_exists (p)) + { + const char* e (p.extension ()); + targets.insert<buildfile> ( + p.directory (), + p.leaf ().base ().string (), + &extension_pool.find (e == nullptr ? "" : e), // Specified. + trace); + } + }; + + add_adhoc ("build/export.build"); + + // Collect the files. We want to take the snapshot of targets + // since updating some of them may result in more targets being + // entered. + // + action_targets files; + + for (const auto& pt: targets) + { + file* ft (pt->is_a<file> ()); + + if (ft == nullptr) // Not a file. + continue; + + if (ft->dir.sub (src_root)) + { + // Include unless explicitly excluded. + // + files.push_back (ft); + continue; + } + + if (ft->dir.sub (out_root)) + { + // Exclude unless explicitly included. + // + //files.push_back (*ft); + continue; + } + } + + // Make sure what we need to distribute is up to date. + // + { + if (perform.meta_operation_pre != nullptr) + perform.meta_operation_pre (); + + current_mif = &perform; + + if (perform.operation_pre != nullptr) + perform.operation_pre (update_id); + + current_inner_oif = &update; + current_outer_oif = nullptr; + current_mode = update.mode; + dependency_count = 0; + + action a (perform_id, update_id); + + perform.match (a, files); + perform.execute (a, files, true); // Run quiet. + + if (perform.operation_post != nullptr) + perform.operation_post (update_id); + + if (perform.meta_operation_post != nullptr) + perform.meta_operation_post (); + } + + dir_path td (dist_root / dir_path (dist_package)); + + // Clean up the target directory. + // + // @@ Not for incremental dist? + // + if (build::rmdir_r (td) == rmdir_status::not_empty) + fail << "unable to clean target directory " << td; + + install (dist_cmd, td); + + // Copy over all the files. + // + for (void* v: files) + { + file& t (*static_cast<file*> (v)); + + // Figure out where this file is inside the target directory. + // + dir_path d (td); + d /= t.dir.sub (src_root) + ? t.dir.leaf (src_root) + : t.dir.leaf (out_root); + + if (!dir_exists (d)) + install (dist_cmd, d); + + install (dist_cmd, t, d); + } + + // Archive if requested. + // + if (auto l = rs->vars["dist.archives"]) + { + for (const string& e: as<strings> (*l)) + archive (dist_root, dist_package, e); + } + } + + // install -d <dir> + // + static void + install (const string& cmd, const dir_path& d) + { + path reld (relative (d)); + + cstrings args {cmd.c_str (), "-d"}; + + args.push_back ("-m"); + args.push_back ("755"); + args.push_back (reld.string ().c_str ()); + args.push_back (nullptr); + + if (verb) + print_process (args); + else + text << "dist -d " << d; + + try + { + process pr (args.data ()); + + if (!pr.wait ()) + throw failed (); + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e.what (); + + if (e.child ()) + exit (1); + + throw failed (); + } + } + + // install <file> <dir> + // + static void + install (const string& cmd, file& t, const dir_path& d) + { + path reld (relative (d)); + path relf (relative (t.path ())); + + cstrings args {cmd.c_str ()}; + + // Preserve timestamps. This could becomes important if, for + // example, we have pre-generated sources. Note that the + // install-sh script doesn't support this option, while both + // Linux and BSD install's do. + // + args.push_back ("-p"); + + // Assume the file is executable if the owner has execute + // permission, in which case we make it executable for + // everyone. + // + args.push_back ("-m"); + args.push_back ( + (path_permissions (t.path ()) & permissions::xu) == permissions::xu + ? "755" + : "644"); + + args.push_back (relf.string ().c_str ()); + args.push_back (reld.string ().c_str ()); + args.push_back (nullptr); + + if (verb) + print_process (args); + else + text << "dist " << t; + + try + { + process pr (args.data ()); + + if (!pr.wait ()) + throw failed (); + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e.what (); + + if (e.child ()) + exit (1); + + throw failed (); + } + } + + static void + archive (const dir_path& root, const string& pkg, const string& e) + { + string a (pkg + '.' + e); + + // Delete old archive for good measure. + // + path ap (root / path (a)); + if (file_exists (ap)) + rmfile (ap); + + // Use zip for .zip archives. Everything else goes to tar in the + // auto-compress mode (-a). + // + cstrings args; + if (e == "zip") + args = {"zip", "-rq", a.c_str (), pkg.c_str (), nullptr}; + else + args = {"tar", "-a", "-cf", a.c_str (), pkg.c_str (), nullptr}; + + if (verb) + print_process (args); + else + text << args[0] << " " << ap; + + try + { + // Change child's working directory to dist_root. + // + process pr (root.string ().c_str (), args.data ()); + + if (!pr.wait ()) + throw failed (); + } + catch (const process_error& e) + { + error << "unable to execute " << args[0] << ": " << e.what (); + + if (e.child ()) + exit (1); + + throw failed (); + } + } + + meta_operation_info dist { + "dist", + "distribute", + "distributing", + "has nothing to distribute", // We cannot "be distributed". + &dist_meta_operation_pre, + &dist_operation_pre, + &load, // normal load + &search, // normal search + &dist_match, + &dist_execute, + nullptr, // operation post + nullptr // meta-operation post + }; + } +} diff --git a/build/dist/rule b/build/dist/rule new file mode 100644 index 0000000..ffb2227 --- /dev/null +++ b/build/dist/rule @@ -0,0 +1,29 @@ +// file : build/dist/rule -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef BUILD_DIST_RULE +#define BUILD_DIST_RULE + +#include <build/rule> +#include <build/types> +#include <build/target> +#include <build/operation> + +namespace build +{ + namespace dist + { + class rule: public build::rule + { + public: + virtual match_result + match (action, target&, const std::string&) const; + + virtual recipe + apply (action, target&, const match_result&) const; + }; + } +} + +#endif // BUILD_DIST_RULE diff --git a/build/dist/rule.cxx b/build/dist/rule.cxx new file mode 100644 index 0000000..bda2ef7 --- /dev/null +++ b/build/dist/rule.cxx @@ -0,0 +1,49 @@ +// file : build/dist/rule.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <build/dist/rule> + +#include <build/scope> +#include <build/target> +#include <build/algorithm> +#include <build/diagnostics> + +using namespace std; + +namespace build +{ + namespace dist + { + match_result rule:: + match (action, target& t, const std::string&) const + { + return t; // We always match. + } + + recipe rule:: + apply (action a, target& t, const match_result&) const + { + const dir_path& out_root (t.root_scope ().path ()); + + for (prerequisite_member p: group_prerequisite_members (a, t)) + { + // Skip prerequisites imported from other projects. + // + if (p.proj () != nullptr) + continue; + + // @@ This is where we will handle dist/nodist. + + target& pt (p.search ()); + + // Don't match targets that are outside our project. + // + if (pt.dir.sub (out_root)) + build::match (a, pt); + } + + return noop_recipe; // We will never be executed. + } + } +} diff --git a/build/install/module.cxx b/build/install/module.cxx index 610154a..5bf2876 100644 --- a/build/install/module.cxx +++ b/build/install/module.cxx @@ -63,7 +63,7 @@ namespace build if (spec) { - if (cv != nullptr && *cv && !cv->empty ()) + if (*cv && !cv->empty ()) v = *cv; } else @@ -116,19 +116,9 @@ namespace build // r.operations.insert (install_id, install); - // Register rules. + // Register our file installer rule. // - { - auto& rs (b.rules); - - // Register the standard alias rule for the install operation. - // - rs.insert<alias> (install_id, "alias", alias_rule::instance); - - // Register our file installer rule. - // - rs.insert<file> (install_id, "install", rule_); - } + b.rules.insert<file> (perform_id, install_id, "install", rule_); // Enter module variables. // diff --git a/build/install/rule.cxx b/build/install/rule.cxx index 8f67001..b1627be 100644 --- a/build/install/rule.cxx +++ b/build/install/rule.cxx @@ -61,11 +61,6 @@ namespace build if (!mr.bvalue) // Not installable. return noop_recipe; - // In case of install, we don't do anything for other meta-operations. - // - if (a.operation () == install_id && a.meta_operation () != perform_id) - return noop_recipe; - // Ok, if we are here, then this means: // // 1. This target is installable. diff --git a/build/lexer.cxx b/build/lexer.cxx index 9dce949..fb4d9ea 100644 --- a/build/lexer.cxx +++ b/build/lexer.cxx @@ -48,10 +48,6 @@ namespace build } case '$': { - // The following name is lexed in the variable mode. - // - next_mode_ = lexer_mode::variable; - return token (token_type::dollar, sep, ln, cn); } case '(': @@ -147,6 +143,7 @@ namespace build switch (c) { case '/': + case '-': { done = true; break; diff --git a/build/operation b/build/operation index 286e003..8aeede6 100644 --- a/build/operation +++ b/build/operation @@ -109,10 +109,12 @@ namespace build const meta_operation_id configure_id = 2; const meta_operation_id disfigure_id = 3; + const meta_operation_id dist_id = 4; + // The default operation is a special marker that can be used to // indicate that no operation was explicitly specified by the user. // - const operation_id default_id = 1; + const operation_id default_id = 1; // Shall be first. const operation_id update_id = 2; const operation_id clean_id = 3; @@ -210,7 +212,7 @@ namespace build void (*match) (action, action_targets&); - void (*execute) (action, const action_targets&); + void (*execute) (action, const action_targets&, bool quiet); void (*operation_post) (operation_id); // End of operation batch. void (*meta_operation_post) (); // End of meta-operation batch. @@ -245,10 +247,10 @@ namespace build // Execute the action on the list of targets. This is the default // implementation that does just that while issuing appropriate - // diagnostics. + // diagnostics (unless quiet). // void - execute (action, const action_targets&); + execute (action, const action_targets&, bool quiet); extern meta_operation_info perform; @@ -342,6 +344,11 @@ namespace build bool empty () const {return v_.empty ();} + // Note that this is more of a "max index" rather than size. + // + size_type + size () const {return v_.size ();} + private: base_type v_; }; diff --git a/build/operation.cxx b/build/operation.cxx index a92c912..55a926a 100644 --- a/build/operation.cxx +++ b/build/operation.cxx @@ -4,6 +4,7 @@ #include <build/operation> +#include <vector> #include <ostream> #include <cassert> #include <functional> // reference_wrapper @@ -109,7 +110,7 @@ namespace build } void - execute (action a, const action_targets& ts) + execute (action a, const action_targets& ts, bool quiet) { tracer trace ("execute"); @@ -119,7 +120,7 @@ namespace build vector<reference_wrapper<target>> psp; auto body ( - [a, &psp, &trace] (void* v) + [a, quiet, &psp, &trace] (void* v) { target& t (*static_cast<target*> (v)); @@ -129,9 +130,7 @@ namespace build { case target_state::unchanged: { - // Be quiet in pre/post operations. - // - if (a.outer_operation () == 0) + if (!quiet) info << diag_done (a, t); break; } @@ -165,7 +164,7 @@ namespace build { case target_state::unchanged: { - if (a.outer_operation () == 0) + if (!quiet) info << diag_done (a, t); break; } diff --git a/build/parser b/build/parser index c6d275b..3374ac0 100644 --- a/build/parser +++ b/build/parser @@ -108,6 +108,11 @@ namespace build void process_default_target (token&); + // Enter buildfile as a target. + // + void + enter_buildfile (const path&); + // Lexer. // private: diff --git a/build/parser.cxx b/build/parser.cxx index 03c20d0..9c50d17 100644 --- a/build/parser.cxx +++ b/build/parser.cxx @@ -36,6 +36,8 @@ namespace build void parser:: parse_buildfile (istream& is, const path& p, scope& root, scope& base) { + enter_buildfile (p); + string rw (diag_relative (p)); // Relative to work. path_ = &rw; @@ -446,6 +448,8 @@ namespace build level4 ([&]{trace (t) << "entering " << p;}); + enter_buildfile (p); + string rw (diag_relative (p)); // Relative to work. const string* op (path_); path_ = &rw; @@ -585,6 +589,8 @@ namespace build level4 ([&]{trace (t) << "entering " << p;}); + enter_buildfile (p); + string rw (diag_relative (p)); // Relative to work. const string* op (path_); path_ = &rw; @@ -1015,11 +1021,23 @@ namespace build // if (tt == type::dollar) { + // Switch to the variable name mode. We want to use this + // mode for $foo but not for $(foo). Since we don't know + // whether the next token is a paren or a name, we turn + // it on and turn it off if what we get next is a paren + // so that the following name is scanned in the normal + // mode. + // + lexer_->mode (lexer_mode::variable); + next (t, tt); bool paren (tt == type::lparen); if (paren) + { + lexer_->mode (lexer_mode::normal); next (t, tt); + } if (tt != type::name) fail (t) << "variable name expected instead of " << t; @@ -1499,6 +1517,19 @@ namespace build ct.prerequisites.emplace_back (p); } + void parser:: + enter_buildfile (const path& p) + { + tracer trace ("parser::enter_buildfile", &path_); + + const char* e (p.extension ()); + targets.insert<buildfile> ( + p.directory (), + p.leaf ().base ().string (), + &extension_pool.find (e == nullptr ? "" : e), // Always specified. + trace); + } + token_type parser:: next (token& t, token_type& tt) { diff --git a/build/rule-map b/build/rule-map index 883800b..0ef0036 100644 --- a/build/rule-map +++ b/build/rule-map @@ -8,8 +8,9 @@ #include <map> #include <vector> #include <string> +#include <memory> // unique_ptr #include <typeindex> -#include <functional> // reference_wrapper +#include <functional> // reference_wrapper #include <butl/prefix-map> @@ -25,21 +26,76 @@ namespace build butl::prefix_map<std::string, // Rule hint. std::reference_wrapper<rule>, '.'>>; - // This is an "indexed map" with (operation_id - 1) being the - // index. + // This is an "indexed map" with operation_id being the index. Entry + // with id 0 is a wildcard. // - class rule_map: public std::vector<target_type_rule_map> + class operation_rule_map { public: template <typename T> void insert (operation_id oid, const char* hint, rule& r) { - if (oid > size ()) - resize (oid < 3 ? 3 : oid); // 3 is the number of builtin operations. + // 3 is the number of builtin operations. + // + if (oid >= map_.size ()) + map_.resize ((oid < 3 ? 3 : oid) + 1); - (*this)[oid - 1][typeid (T)].emplace (hint, r); + map_[oid][typeid (T)].emplace (hint, r); } + + // Return NULL if not found. + // + const target_type_rule_map* + operator[] (operation_id oid) const + { + return map_.size () > oid ? &map_[oid] : nullptr; + } + + private: + std::vector<target_type_rule_map> map_; + }; + + // This is another indexed map but this time meta_operation_id is the + // index. The implementation is different, however: here we use a linked + // list with the first, statically-allocated node corresponding to the + // perform meta-operation. The idea is to try and get away with a dynamic + // allocation for the common cases since most rules will be registered + // for perform, at least on non-root scopes. + // + class rule_map + { + public: + template <typename T> + void + insert (meta_operation_id mid, operation_id oid, const char* hint, rule& r) + { + if (mid_ == mid) + map_.insert<T> (oid, hint, r); + else + { + if (next_ == nullptr) + next_.reset (new rule_map (mid)); + + next_->insert<T> (mid, oid, hint, r); + } + } + + // Return NULL if not found. + // + const operation_rule_map* + operator[] (meta_operation_id mid) const + { + return mid == mid_ ? &map_ : next_ == nullptr ? nullptr : (*next_)[mid]; + } + + explicit + rule_map (meta_operation_id mid = perform_id): mid_ (mid) {} + + private: + meta_operation_id mid_; + operation_rule_map map_; + std::unique_ptr<rule_map> next_; }; } diff --git a/build/rule.cxx b/build/rule.cxx index 7bf030d..b9a989b 100644 --- a/build/rule.cxx +++ b/build/rule.cxx @@ -38,13 +38,9 @@ namespace build // for every action (because that's the condition for us matching), // for some actions this is clearly a waste. Say, perform_clean: we // are not doing anything for this action so not checking if the file - // exists seems harmless. What about, say, configure_update? Again, - // whether we match or not, there is nothing to be done for this - // action. And, who knows, maybe the file doesn't exist during - // configure_update but will magically appear during perform_update. - // So the overall guideline seems to be this: if we don't do anything - // for the action (other than performing it on the prerequisites), - // then we match. + // exists seems harmless. So the overall guideline seems to be this: + // if we don't do anything for the action (other than performing it + // on the prerequisites), then we match. // switch (a) { @@ -181,7 +177,7 @@ namespace build { case perform_update_id: return &perform_update; case perform_clean_id: return &perform_clean; - default: return default_recipe; // Forward to prerequisites. + default: assert (false); return default_recipe; } } @@ -196,7 +192,7 @@ namespace build if (!t.prerequisite_targets.empty ()) ts = execute_prerequisites (a, t); - const path& d (t.dir); // Everything is in t.dir. + const dir_path& d (t.dir); // Everything is in t.dir. // Generally, it is probably correct to assume that in the majority // of cases the directory will already exist. If so, then we are diff --git a/build/target b/build/target index 2c05ea1..f2b093e 100644 --- a/build/target +++ b/build/target @@ -925,6 +925,16 @@ namespace build static const target_type static_type; }; + class buildfile: public file + { + public: + using file::file; + + public: + virtual const target_type& type () const {return static_type;} + static const target_type static_type; + }; + // Common documentation file targets. // // @@ Maybe these should be in the built-in doc module? diff --git a/build/target.cxx b/build/target.cxx index 6315d04..669ff7a 100644 --- a/build/target.cxx +++ b/build/target.cxx @@ -493,6 +493,26 @@ namespace build false }; + static const std::string& + buildfile_target_extension (const target_key& tk, scope&) + { + // If the name is special 'buildfile', then there is no extension, + // otherwise it is .build. + // + return extension_pool.find (*tk.name == "buildfile" ? "" : "build"); + } + + const target_type buildfile::static_type + { + typeid (buildfile), + "buildfile", + &file::static_type, + &file_factory<buildfile>, + &buildfile_target_extension, + &search_file, + false + }; + constexpr const char doc_ext[] = ""; const target_type doc::static_type { diff --git a/build/test/module.cxx b/build/test/module.cxx index 9495275..8c0df38 100644 --- a/build/test/module.cxx +++ b/build/test/module.cxx @@ -51,18 +51,20 @@ namespace build { auto& rs (r.rules); - // Register the standard alias rule for the test operation. + // Register our test running rule. // - rs.insert<alias> (test_id, "alias", alias_rule::instance); + rs.insert<target> (perform_id, test_id, "test", rule_); - // Register our test running rule. + // Register our rule for the dist meta-operation. We need + // to do this because we have "ad-hoc prerequisites", test + // input/output files, that need to be entered into the + // target list. // - rs.insert<target> (test_id, "test", rule_); + rs.insert<target> (dist_id, test_id, "test", rule_); } // Enter module variables. // - if (first) { variable_pool.find ("test", bool_type); variable_pool.find ("test.input", name_type); diff --git a/build/test/rule.cxx b/build/test/rule.cxx index eecd613..25baaa7 100644 --- a/build/test/rule.cxx +++ b/build/test/rule.cxx @@ -113,11 +113,6 @@ namespace build if (!mr.bvalue) // Not a test. return noop_recipe; - // In case of test, we don't do anything for other meta-operations. - // - if (a.operation () == test_id && a.meta_operation () != perform_id) - return noop_recipe; - // Ok, if we are here, then this means: // // 1. This target is a test. @@ -218,18 +213,21 @@ namespace build } } - if (ot != nullptr && in == on) + if (ot != nullptr) { - build::match (a, *ot); - - if (ot->state () == target_state::unchanged) + if (in != on) { - unmatch (a, *ot); - ot = nullptr; + build::match (a, *ot); + + if (ot->state () == target_state::unchanged) + { + unmatch (a, *ot); + ot = nullptr; + } } + else + ot = it; } - else - ot = it; // Find the "real" update rule, that is, the rule that would |