diff options
Diffstat (limited to 'build')
| -rw-r--r-- | build/algorithm | 18 | ||||
| -rw-r--r-- | build/algorithm.cxx | 40 | ||||
| -rw-r--r-- | build/algorithm.ixx | 27 | ||||
| -rw-r--r-- | build/b.cxx | 9 | ||||
| -rw-r--r-- | build/bin/rule.cxx | 16 | ||||
| -rw-r--r-- | build/cli/rule.cxx | 6 | ||||
| -rw-r--r-- | build/context | 3 | ||||
| -rw-r--r-- | build/context.cxx | 3 | ||||
| -rw-r--r-- | build/cxx/compile.cxx | 5 | ||||
| -rw-r--r-- | build/diagnostics.cxx | 57 | ||||
| -rw-r--r-- | build/rule | 17 | ||||
| -rw-r--r-- | build/rule.cxx | 15 | ||||
| -rw-r--r-- | build/target | 22 | ||||
| -rw-r--r-- | build/target.cxx | 4 | ||||
| -rw-r--r-- | build/test/rule.cxx | 155 |
15 files changed, 273 insertions, 124 deletions
diff --git a/build/algorithm b/build/algorithm index d01614c..3b09d9c 100644 --- a/build/algorithm +++ b/build/algorithm @@ -6,6 +6,7 @@ #define BUILD_ALGORITHM #include <string> +#include <utility> // pair #include <build/types> #include <build/target> @@ -68,6 +69,14 @@ namespace build void match (action, target&); + // Match a "delegate rule" from withing another rules' apply() + // function. Return recipe and recipe action (if any). Note + // that unlike match(), this call doesn't increment the + // dependents count. See also execute_delegate(). + // + std::pair<recipe, action> + match_delegate (action, target&); + // The standard prerequisite search and match implementations. They call // search_and_match_*() versions below passing non-empty directory for // the clean operation. @@ -116,6 +125,15 @@ namespace build target_state execute (action, target&); + // Execute the recipe obtained with match_delegate(). Note that + // the target's state is neither checked nor updated by this + // function. In other words, the appropriate usage is to call + // this function from another recipe and to factor the obtained + // state into the one returned. + // + target_state + execute_delegate (const recipe&, action, target&); + // A special version of the above that should be used for "direct" // and "now" execution, that is, side-stepping the normal target- // prerequisite relationship (so no dependents count is decremented) diff --git a/build/algorithm.cxx b/build/algorithm.cxx index 8893045..615d4b7 100644 --- a/build/algorithm.cxx +++ b/build/algorithm.cxx @@ -55,10 +55,10 @@ namespace build return search (*tt, move (n.dir), move (n.value), e, &s); } - match_result_impl + pair<const rule*, match_result> match_impl (action a, target& t, bool apply) { - match_result_impl r; + pair<const rule*, match_result> r; // Clear the resolved targets list before calling match(). The rule // is free to, say, resize() this list in match() (provided that it @@ -148,6 +148,9 @@ namespace build 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. @@ -187,6 +190,8 @@ namespace build if (!ambig) { + ra = m.recipe_action; // Use custom, if set. + if (apply) { auto g ( @@ -198,13 +203,15 @@ namespace build }, 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.ra = ra; - r.ru = &ru; - r.mr = m; + r.first = &ru; + r.second = move (m); } return r; @@ -235,7 +242,7 @@ namespace build // if (!g.recipe (a)) { - auto mir (match_impl (a, g, false)); + auto rp (match_impl (a, g, false)); r = g.group_members (a); if (r.members != nullptr) @@ -244,7 +251,8 @@ namespace build // That didn't help, so apply the rule and go to the building // phase. // - g.recipe (mir.ra, mir.ru->apply (mir.ra, g, mir.mr)); + const match_result& mr (rp.second); + g.recipe (mr.recipe_action, rp.first->apply (mr.recipe_action, g, mr)); } // Note that we use execute_direct() rather than execute() here to @@ -375,10 +383,7 @@ namespace build if (pt == nullptr) // Skipped. continue; - target_state ts (execute (a, *pt)); - if (ts == target_state::postponed || - (ts == target_state::changed && r == target_state::unchanged)) - r = ts; + r |= execute (a, *pt); } return r; @@ -394,10 +399,7 @@ namespace build if (pt == nullptr) // Skipped. continue; - target_state ts (execute (a, *pt)); - if (ts == target_state::postponed || - (ts == target_state::changed && r == target_state::unchanged)) - r = ts; + r |= execute (a, *pt); } return r; @@ -481,7 +483,9 @@ namespace build // file& ft (dynamic_cast<file&> (t)); - bool r (rmfile (ft.path (), ft)); + target_state r (rmfile (ft.path (), ft) + ? target_state::changed + : target_state::unchanged); // Update timestamp in case there are operations after us that // could use the information. @@ -490,8 +494,8 @@ namespace build // Clean prerequisites. // - target_state ts (reverse_execute_prerequisites (a, t)); + r |= reverse_execute_prerequisites (a, t); - return r && ts != target_state::postponed ? target_state::changed : ts; + return r; } } diff --git a/build/algorithm.ixx b/build/algorithm.ixx index 7849713..26761bf 100644 --- a/build/algorithm.ixx +++ b/build/algorithm.ixx @@ -2,6 +2,8 @@ // copyright : Copyright (c) 2014-2015 Code Synthesis Ltd // license : MIT; see accompanying LICENSE file +#include <utility> // pair + #include <build/rule> #include <build/prerequisite> #include <build/context> @@ -48,15 +50,7 @@ namespace build return static_cast<T&> (search (T::static_type, dir, name, ext, scope)); } - - struct match_result_impl - { - action ra; // Action to set recipe, not to pass to apply(). - const rule* ru; - match_result mr; - }; - - match_result_impl + std::pair<const rule*, match_result> match_impl (action, target&, bool apply); inline void @@ -68,6 +62,15 @@ namespace build t.dependents++; } + inline std::pair<recipe, action> + match_delegate (action a, target& t) + { + auto rp (match_impl (a, t, false)); + const match_result& mr (rp.second); + return std::make_pair (rp.first->apply (mr.recipe_action, t, mr), + mr.recipe_action); + } + group_view resolve_group_members_impl (action, target&); @@ -153,6 +156,12 @@ namespace build } inline target_state + execute_delegate (const recipe& r, action a, target& t) + { + return r (a, t); + } + + inline target_state execute_direct (action a, target& t) { switch (target_state ts = t.state ()) diff --git a/build/b.cxx b/build/b.cxx index 3a6d71f..21e72cf 100644 --- a/build/b.cxx +++ b/build/b.cxx @@ -739,7 +739,8 @@ main (int argc, char* argv[]) if (mif->operation_pre != nullptr) mif->operation_pre (pre_oid); // Cannot be translated. - current_oif = pre_oif; + current_inner_oif = pre_oif; + current_outer_oif = oif; current_mode = pre_oif->mode; action a (mid, pre_oid, oid); @@ -754,7 +755,8 @@ main (int argc, char* argv[]) << ", id " << static_cast<uint16_t> (pre_oid);}); } - current_oif = oif; + current_inner_oif = oif; + current_outer_oif = nullptr; current_mode = oif->mode; action a (mid, oid, 0); @@ -770,7 +772,8 @@ main (int argc, char* argv[]) if (mif->operation_pre != nullptr) mif->operation_pre (post_oid); // Cannot be translated. - current_oif = post_oif; + current_inner_oif = post_oif; + current_outer_oif = oif; current_mode = post_oif->mode; action a (mid, post_oid, oid); diff --git a/build/bin/rule.cxx b/build/bin/rule.cxx index f02029b..0a7f2ee 100644 --- a/build/bin/rule.cxx +++ b/build/bin/rule.cxx @@ -114,23 +114,13 @@ namespace build if (current_mode == execution_mode::last) swap (m1, m2); - target_state r (target_state::unchanged), ts; + target_state r (target_state::unchanged); if (m1 != nullptr) - { - ts = execute (a, *m1); - if (ts == target_state::postponed || - (ts == target_state::changed && r == target_state::unchanged)) - r = ts; - } + r |= execute (a, *m1); if (m2 != nullptr) - { - ts = execute (a, *m2); - if (ts == target_state::postponed || - (ts == target_state::changed && r == target_state::unchanged)) - r = ts; - } + r |= execute (a, *m2); return r; } diff --git a/build/cli/rule.cxx b/build/cli/rule.cxx index dff13f0..d1cb616 100644 --- a/build/cli/rule.cxx +++ b/build/cli/rule.cxx @@ -290,11 +290,13 @@ namespace build t.mtime (timestamp_nonexistent); + target_state ts (r ? target_state::changed : target_state::unchanged); + // Clean prerequisites. // - target_state ts (reverse_execute_prerequisites (a, t)); + ts |= reverse_execute_prerequisites (a, t); - return r && ts != target_state::postponed ? target_state::changed : ts; + return ts; } } } diff --git a/build/context b/build/context index ad9c091..c8200b7 100644 --- a/build/context +++ b/build/context @@ -28,7 +28,8 @@ namespace build // Current action (meta/operation). // extern const meta_operation_info* current_mif; - extern const operation_info* current_oif; + extern const operation_info* current_inner_oif; + extern const operation_info* current_outer_oif; extern execution_mode current_mode; diff --git a/build/context.cxx b/build/context.cxx index 9d9c322..f0e853d 100644 --- a/build/context.cxx +++ b/build/context.cxx @@ -25,7 +25,8 @@ namespace build string_pool project_name_pool; const meta_operation_info* current_mif; - const operation_info* current_oif; + const operation_info* current_inner_oif; + const operation_info* current_outer_oif; execution_mode current_mode; void diff --git a/build/cxx/compile.cxx b/build/cxx/compile.cxx index a12650f..4095598 100644 --- a/build/cxx/compile.cxx +++ b/build/cxx/compile.cxx @@ -642,10 +642,7 @@ namespace build // them is fallback file_rule. So we are going to do a little // fast-path optimization by detecting this common case. // - recipe_function* const* recipe ( - pt.recipe (a).target<recipe_function*> ()); - - if (recipe == nullptr || *recipe != &file_rule::perform_update) + if (!file_rule::uptodate (a, pt)) { // We only want to restart if our call to execute() actually // caused an update. In particular, the target could already diff --git a/build/diagnostics.cxx b/build/diagnostics.cxx index a254860..2f9525b 100644 --- a/build/diagnostics.cxx +++ b/build/diagnostics.cxx @@ -84,24 +84,28 @@ namespace build string diag_do (const action&, const target& t) { - const meta_operation_info& mi (*current_mif); - const operation_info& oi (*current_oif); + const meta_operation_info& m (*current_mif); + const operation_info& io (*current_inner_oif); + const operation_info* oo (current_outer_oif); ostringstream os; // perform(update(x)) -> "update x" // configure(update(x)) -> "configure updating x" // - if (mi.name_do.empty ()) - os << oi.name_do << ' '; + if (m.name_do.empty ()) + os << io.name_do << ' '; else { - os << mi.name_do << ' '; + os << m.name_do << ' '; - if (!oi.name_doing.empty ()) - os << oi.name_doing << ' '; + if (!io.name_doing.empty ()) + os << io.name_doing << ' '; } + if (oo != nullptr) + os << "(for " << oo->name << ") "; + os << t; return os.str (); } @@ -109,19 +113,23 @@ namespace build string diag_doing (const action&, const target& t) { - const meta_operation_info& mi (*current_mif); - const operation_info& oi (*current_oif); + const meta_operation_info& m (*current_mif); + const operation_info& io (*current_inner_oif); + const operation_info* oo (current_outer_oif); ostringstream os; // perform(update(x)) -> "updating x" // configure(update(x)) -> "configuring updating x" // - if (!mi.name_doing.empty ()) - os << mi.name_doing << ' '; + if (!m.name_doing.empty ()) + os << m.name_doing << ' '; + + if (!io.name_doing.empty ()) + os << io.name_doing << ' '; - if (!oi.name_doing.empty ()) - os << oi.name_doing << ' '; + if (oo != nullptr) + os << "(for " << oo->name << ") "; os << t; return os.str (); @@ -130,27 +138,34 @@ namespace build string diag_done (const action&, const target& t) { - const meta_operation_info& mi (*current_mif); - const operation_info& oi (*current_oif); + const meta_operation_info& m (*current_mif); + const operation_info& io (*current_inner_oif); + const operation_info* oo (current_outer_oif); ostringstream os; // perform(update(x)) -> "x is up to date" // configure(update(x)) -> "updating x is configured" // - if (mi.name_done.empty ()) + if (m.name_done.empty ()) { os << t; - if (!oi.name_done.empty ()) - os << " " << oi.name_done; + if (!io.name_done.empty ()) + os << " " << io.name_done; + + if (oo != nullptr) + os << "(for " << oo->name << ") "; } else { - if (!oi.name_doing.empty ()) - os << oi.name_doing << ' '; + if (!io.name_doing.empty ()) + os << io.name_doing << ' '; + + if (oo != nullptr) + os << "(for " << oo->name << ") "; - os << t << " " << mi.name_done; + os << t << " " << m.name_done; } return os.str (); @@ -34,8 +34,9 @@ namespace build target_type* target; - match_result (target_type& t, bool v): value (v), target (&t) {} + action recipe_action = action (); // Used as recipe's action if set. + match_result (target_type& t, bool v): value (v), target (&t) {} match_result (std::nullptr_t v = nullptr): prerequisite (v), target (v) {} match_result (prerequisite_type& p): prerequisite (&p), target (nullptr) {} match_result (prerequisite_type* p): prerequisite (p), target (nullptr) {} @@ -76,6 +77,20 @@ namespace build static target_state perform_update (action, target&); + // Sometimes it is useful, normally as an optimization, to check + // if the file target is up to date. In particular, if the rule + // that matched a target is this fallback rule and the target + // has no prerequisites, then it means it is up to date. + // + static bool + uptodate (action a, target& t) + { + recipe_function* const* r (t.recipe (a).target<recipe_function*> ()); + return r != nullptr && *r == &perform_update && + t.prerequisites.empty () && + (t.group == nullptr || t.group->prerequisites.empty ()); + } + static file_rule instance; }; diff --git a/build/rule.cxx b/build/rule.cxx index f9b9a3c..82ce993 100644 --- a/build/rule.cxx +++ b/build/rule.cxx @@ -213,7 +213,7 @@ namespace build fail << "unable to create directory " << d << ": " << e.what (); } - ts = target_state::changed; + ts |= target_state::changed; } return ts; @@ -229,22 +229,19 @@ namespace build target_state ts (target_state::unchanged); if (t.has_prerequisites ()) - { ts = reverse_execute_prerequisites (a, t); - if (ts == target_state::postponed) - return ts; - } - // If we couldn't remove the directory, return postponed meaning // that the operation could not be performed at this time. // switch (rs) { - case rmdir_status::success: return target_state::changed; - case rmdir_status::not_empty: return target_state::postponed; - default: return ts; + case rmdir_status::success: ts |= target_state::changed; + case rmdir_status::not_empty: ts |= target_state::postponed; + default: break; } + + return ts; } fsdir_rule fsdir_rule::instance; diff --git a/build/target b/build/target index f5a26b4..6ee65f4 100644 --- a/build/target +++ b/build/target @@ -10,6 +10,7 @@ #include <vector> #include <memory> // unique_ptr #include <cstddef> // size_t +#include <cstdint> // uint8_t #include <functional> // reference_wrapper #include <ostream> #include <cassert> @@ -38,19 +39,32 @@ namespace build // Target state. // - enum class target_state + enum class target_state: std::uint8_t { - group, // Target's state is the group's state. + // The order of the enumerators is arranged so that their + // inegral values indicate whether one "overrides" the other + // in the merge operator (see below). + // unknown, - postponed, unchanged, changed, - failed + postponed, + failed, + group // Target's state is the group's state. }; std::ostream& operator<< (std::ostream&, target_state); + inline target_state& + operator |= (target_state& l, target_state r) + { + if (static_cast<std::uint8_t> (r) > static_cast<std::uint8_t> (l)) + l = r; + + return l; + } + // Recipe. // // The returned target state should be changed, unchanged, or diff --git a/build/target.cxx b/build/target.cxx index f6fc5c8..df7e2aa 100644 --- a/build/target.cxx +++ b/build/target.cxx @@ -32,12 +32,12 @@ namespace build // target_state // static const char* target_state_[] = { - "group", "unknown", "postponed", "unchanged", "changed", "failed"}; + "unknown", "unchanged", "changed", "postponed", "failed", "group"}; ostream& operator<< (ostream& os, target_state ts) { - return os << target_state_[static_cast<size_t> (ts)]; + return os << target_state_[static_cast<uint8_t> (ts)]; } // recipe diff --git a/build/test/rule.cxx b/build/test/rule.cxx index b8d7428..da17d61 100644 --- a/build/test/rule.cxx +++ b/build/test/rule.cxx @@ -50,7 +50,7 @@ namespace build // is a test. // if (var.name == "test.input" || - var.name == "test.ouput" || + var.name == "test.output" || var.name == "test.roundtrip" || var.name == "test.options" || var.name == "test.arguments") @@ -68,19 +68,34 @@ namespace build v.rebind (t.base_scope ()[string("test.") + t.type ().name]); r = v && v.as<bool> (); - } - if (!r) - return match_result (t, false); // "Not a test" result. + // If this is the update pre-operation, then all we really need to + // do is say we are not a match and the standard matching machinery + // will (hopefully) find the rule to update this target. + // + // There is one thing that compilates this simple approach: test + // input/output. While normally they will be existing (in src_base) + // files, they could also be auto-generated. In fact, they could + // only be needed for testing, which means the normall update won't + // even know about them (nor clean, for that matter; this is why we + // need cleantest). + // + // To make generated input/output work we will have to cause their + // update ourselves. I other words, we may have to do some actual + // work for (update, test), and not simply "guide" (update, 0) as + // to which targets need updating. For how exactly we are going to + // do it, see apply() below. + // + match_result mr (t, r); - // If this is the update pre-operation, make someone else do - // the job. + // If this is the update pre-operation, change the recipe action + // to (update, 0) (i.e., "unconditional update"). // - if (a.operation () != test_id) - return nullptr; + if (r && a.operation () == update_id) + mr.recipe_action = action (a.meta_operation (), update_id); - return match_result (t, true); + return mr; } recipe rule:: @@ -91,13 +106,24 @@ namespace build if (!mr.value) // Not a test. return noop_recipe; - // Don't do anything for other meta-operations. + // In case of test, we don't do anything for other meta-operations. // - if (a != action (perform_id, test_id)) + if (a.operation () == test_id && a.meta_operation () != perform_id) return noop_recipe; - // See if we have test.{input,output,roundtrip}. First check the - // target-specific vars since they override any scope ones. + // Ok, if we are here, then this means: + // + // 1. This target is a test. + // 2. The action is either + // a. (perform, test, 0) or + // b. (*, update, 0) + // + // In both cases, the next step is to see if we have test.{input, + // output,roundtrip}. + // + + // First check the target-specific vars since they override any + // scope ones. // auto iv (t.vars["test.input"]); auto ov (t.vars["test.output"]); @@ -147,8 +173,8 @@ namespace build } } - const name* i; - const name* o; + const name* in; + const name* on; // Reduce the roundtrip case to input/output. // @@ -158,35 +184,92 @@ namespace build fail << "both test.roundtrip and test.input/output specified " << "for target " << t; - i = o = rv.as<const name*> (); + in = on = rv.as<const name*> (); } else { - i = iv ? iv.as<const name*> () : nullptr; - o = ov ? ov.as<const name*> () : nullptr; + in = iv ? iv.as<const name*> () : nullptr; + on = ov ? ov.as<const name*> () : nullptr; } - // Resolve them to targets (normally just files) and cache in - // our prerequsite targets lists where they can be found by - // perform_test(). If we have either or both, then the first - // entry is input and the second -- output (either can be NULL). + // Resolve them to targets, which normally would be existing files + // but could also be targets that need updating. // - auto& pts (t.prerequisite_targets); + target* it (in != nullptr ? &search (*in, bs) : nullptr); + target* ot (on != nullptr ? in == on ? it : &search (*on, bs) : nullptr); - if (i != nullptr || o != nullptr) - pts.resize (2, nullptr); + if (a.operation () == update_id) + { + // First see if input/output are existing, up-to-date files. This + // is a common case optimization. + // + if (it != nullptr) + { + build::match (a, *it); - //@@ We should match() them, but for update, not test. - //@@ If not doing this for some reason, need to then verify - // path was assigned (i.e., matched an existing file). - // - if (i != nullptr) - pts[0] = &search (*i, bs); + if (file_rule::uptodate (a, *it)) + it = nullptr; + } + + if (ot != nullptr && in == on) + { + build::match (a, *ot); + + if (file_rule::uptodate (a, *ot)) + ot = nullptr; + } + else + ot = it; + + + // Find the "real" update rule, that is, the rule that would + // have been found if we signalled that we do not match from + // match() above. + // + recipe d (match_delegate (a, t).first); + + // If we have no input/output that needs updating, then simply + // redirect to it + // + if (it == nullptr && ot == nullptr) + return d; + + // Ok, time to handle the worst case scenario: we need to + // cause update of input/output targets and also delegate + // to the real update. + // + return [it, ot, dr = move (d)] (action a, target& t) -> target_state + { + // Do the general update first. + // + target_state r (execute_delegate (dr, a, t)); - if (o != nullptr) - pts[1] = i == o ? pts[0] : &search (*o, bs); + if (it != nullptr) + r |= execute (a, *it); - return &perform_test; + if (ot != nullptr) + r |= execute (a, *ot); + + return r; + }; + } + else + { + // Cache the targets in our prerequsite targets lists where they + // can be found by perform_test(). If we have either or both, + // then the first entry is input and the second -- output (either + // can be NULL). + // + if (it != nullptr || ot != nullptr) + { + auto& pts (t.prerequisite_targets); + pts.resize (2, nullptr); + pts[0] = it; + pts[1] = ot; + } + + return &perform_test; + } } static void @@ -310,7 +393,7 @@ namespace build if (pts.size () != 0 && pts[0] != nullptr) { file& it (static_cast<file&> (*pts[0])); - assert (!it.path ().empty ()); // Should have been assigned. + assert (!it.path ().empty ()); // Should have been assigned by update. args.push_back (it.path ().string ().c_str ()); } // Maybe arguments then? @@ -325,7 +408,7 @@ namespace build if (pts.size () != 0 && pts[1] != nullptr) { file& ot (static_cast<file&> (*pts[1])); - assert (!ot.path ().empty ()); // Should have been assigned. + assert (!ot.path ().empty ()); // Should have been assigned by update. args.push_back ("diff"); args.push_back ("-u"); |