diff options
| -rw-r--r-- | build2/parser.cxx | 599 | ||||
| -rw-r--r-- | build2/parser.hxx | 8 | ||||
| -rw-r--r-- | build2/prerequisite.hxx | 1 | ||||
| -rw-r--r-- | build2/target.hxx | 1 | ||||
| -rw-r--r-- | build2/variable.hxx | 3 | ||||
| -rw-r--r-- | tests/directive/run.testscript | 2 | ||||
| -rw-r--r-- | tests/name/pattern.testscript | 6 | ||||
| -rw-r--r-- | tests/variable/prerequisite-specific/testscript | 52 | ||||
| -rw-r--r-- | tests/variable/scope-specific/testscript | 2 | ||||
| -rw-r--r-- | tests/variable/target-specific/testscript | 36 | ||||
| -rw-r--r-- | tests/variable/target-type-pattern-specific/buildfile | 5 | ||||
| -rw-r--r-- | tests/variable/target-type-pattern-specific/testscript | 58 |
12 files changed, 553 insertions, 220 deletions
diff --git a/build2/parser.cxx b/build2/parser.cxx index 1658623..c0b0936 100644 --- a/build2/parser.cxx +++ b/build2/parser.cxx @@ -161,7 +161,7 @@ namespace build2 assert (n.pair == '@'); if (!o.directory ()) - p.fail (loc) << "directory expected after @"; + p.fail (loc) << "expected directory after @"; } dir_path& d (n.dir); @@ -465,10 +465,81 @@ namespace build2 // means empty list. // if (ns.empty ()) - fail (t) << "target expected before :"; + fail (t) << "expected target before :"; - next (t, tt); + // Call the specified parsing function (either variable or block) for + // each target. We handle multiple targets by replaying the tokens. + // since the value/block may contain variable expansions that would be + // sensitive to the target context in which they are evaluated. The + // function signature is: + // + // void (token& t, type& tt, const target_type* type, string pat) + // + auto for_each = [this, &trace, &t, &tt, &ns, &nloc] (auto&& f) + { + // Note: watch out for an out-qualified single target (two names). + // + replay_guard rg (*this, + ns.size () > 2 || (ns.size () == 2 && !ns[0].pair)); + + for (auto i (ns.begin ()), e (ns.end ()); i != e; ) + { + name& n (*i); + if (n.qualified ()) + fail (nloc) << "project name in target " << n; + + // Figure out if this is a target or a target type/pattern (yeah, + // it can be a mixture). + // + if (n.value.find_first_of ("*?") == string::npos) + { + name o (n.pair ? move (*++i) : name ()); + enter_target tg (*this, + move (n), + move (o), + true /* implied */, + nloc, + trace); + + f (t, tt, nullptr, string ()); + } + else + { + if (n.pair) + fail (nloc) << "out-qualified target type/pattern-specific " + << "variable"; + + // If we have the directory, then it is the scope. + // + enter_scope sg; + if (!n.dir.empty ()) + sg = enter_scope (*this, move (n.dir)); + + // Resolve target type. If none is specified or if it is '*', + // use the root of the hierarchy. So these are all equivalent: + // + // *: foo = bar + // {*}: foo = bar + // *{*}: foo = bar + // + const target_type* ti ( + n.untyped () || n.type == "*" + ? &target::static_type + : scope_->find_target_type (n.type)); + + if (ti == nullptr) + fail (nloc) << "unknown target type " << n.type; + + f (t, tt, ti, move (n.value)); + } + + if (++i != e) + rg.play (); // Replay. + } + }; + + next (t, tt); if (tt == type::newline) { // See if this is a target block. @@ -487,13 +558,18 @@ namespace build2 else attributes_pop (); - // @@ TODO: target block (also prerequisite block below). + // Parse the block for each target. // - fail (nloc) << "target blocks are not yet supported" << - info << "if migrating, remove ':'"; + for_each ([this] (token& t, type& tt, + const target_type* type, string pat) + { + next (t, tt); // First token inside the block. + + parse_variable_block (t, tt, type, move (pat)); - if (tt != type::rcbrace) - fail (t) << "expected } instead of " << t; + if (tt != type::rcbrace) + fail (t) << "expected } instead of " << t; + }); // Should be on its own line. // @@ -505,7 +581,7 @@ namespace build2 continue; } - // If this is not a scope, then it is a target without any + // If this is not a block, then it is a target without any // prerequisites. Fall through. } @@ -539,171 +615,31 @@ namespace build2 // if (tt == type::assign || tt == type::prepend || tt == type::append) { - token at (t); - type att (tt); + type akind (tt); + const location aloc (get_location (t)); const variable& var (parse_variable_name (move (pns), ploc)); apply_variable_attributes (var); - if (var.visibility >= variable_visibility::prereq) + if (var.visibility > variable_visibility::target) { fail (nloc) << "variable " << var << " has " << var.visibility - << " visibility but is assigned in a target"; + << " visibility but is assigned on a target"; } - // If we have multiple targets, then we save the value tokens when - // parsing the first one and then replay them for the subsequent. - // We have to do it this way because the value may contain - // variable expansions that would be sensitive to the target/scope - // context in which they are evaluated. + // Parse the assignment for each target. // - // Note: watch out for an out-qualified single target (two names). - // - replay_guard rg ( - *this, ns.size () > 2 || (ns.size () == 2 && !ns[0].pair)); - - for (auto i (ns.begin ()), e (ns.end ()); i != e; ) - { - name& n (*i); - - if (n.qualified ()) - fail (nloc) << "project name in target " << n; - - // Figure out if this is a target or type/pattern-specific - // variable. - // - size_t p (n.value.find ('*')); - - if (p == string::npos) - { - name o (n.pair ? move (*++i) : name ()); - enter_target tg ( - *this, move (n), move (o), true, nloc, trace); - parse_variable (t, tt, var, att); - } - else - { - // See tests/variable/type-pattern. - // - if (n.pair) - fail (nloc) << "out-qualified target type/pattern-" - << "specific variable"; - - if (n.value.find ('*', p + 1) != string::npos) - fail (nloc) << "multiple wildcards in target type/pattern " - << n; - - // If we have the directory, then it is the scope. - // - enter_scope sg; - if (!n.dir.empty ()) - sg = enter_scope (*this, move (n.dir)); - - // Resolve target type. If none is specified or if it is '*', - // use the root of the hierarchy. So these are all equivalent: - // - // *: foo = bar - // {*}: foo = bar - // *{*}: foo = bar - // - const target_type* ti ( - n.untyped () || n.type == "*" - ? &target::static_type - : scope_->find_target_type (n.type)); - - if (ti == nullptr) - fail (nloc) << "unknown target type " << n.type; - - // Note: expanding the value in the context of the scope. - // - value rhs (parse_variable_value (t, tt)); - - // Leave the value untyped unless we are assigning. - // - pair<reference_wrapper<value>, bool> p ( - scope_->target_vars[*ti][move (n.value)].insert ( - var, att == type::assign)); - - value& lhs (p.first); - - // We store prepend/append values untyped (similar to - // overrides). - // - if (rhs.type != nullptr && att != type::assign) - untypify (rhs); - - if (p.second) - { - // Note: we are always using assign and we don't pass the - // variable in case of prepend/append in order to keep the - // value untyped. - // - apply_value_attributes ( - att == type::assign ? &var : nullptr, - lhs, - move (rhs), - type::assign); - - // Map assignment type to value::extra constant. - // - lhs.extra = - att == type::prepend ? 1 : - att == type::append ? 2 : - 0; - } - else - { - // Existing value. What happens next depends on what we are - // trying to do and what's already there. - // - // Assignment is the easy one: we simply overwrite what's - // already there. Also, if we are appending/prepending to a - // previously assigned value, then we simply append or - // prepend normally. - // - if (att == type::assign || lhs.extra == 0) - { - // Above we instructed insert() not to type the value so - // we have to compensate for that now. - // - if (att != type::assign) - { - if (var.type != nullptr && lhs.type != var.type) - typify (lhs, *var.type, &var); - } - else - lhs.extra = 0; // Change to assignment. - - apply_value_attributes (&var, lhs, move (rhs), att); - } - else - { - // This is an append/prepent to a previously appended or - // prepended value. We can handle it as long as things are - // consistent. - // - if (att == type::prepend && lhs.extra == 2) - fail (at) << "prepend to a previously appended target " - << "type/pattern-specific variable " << var; - - if (att == type::append && lhs.extra == 1) - fail (at) << "append to a previously prepended target " - << "type/pattern-specific variable " << var; - - // Do untyped prepend/append. - // - apply_value_attributes (nullptr, lhs, move (rhs), att); - } - } - - if (lhs.extra != 0 && lhs.type != nullptr) - fail (at) << "typed prepend/append to target type/pattern-" - << "specific variable " << var; - } - - if (++i != e) - rg.play (); // Replay. - } + for_each ([this, &var, akind, &aloc] (token& t, type& tt, + const target_type* type, + string pat) + { + if (type == nullptr) + parse_variable (t, tt, var, akind); + else + parse_type_pattern_variable (t, tt, + *type, move (pat), + var, akind, aloc); + }); } // Dependency declaration potentially followed by a chain and/or // a prerequisite-specific variable assignment. @@ -772,7 +708,7 @@ namespace build2 if (tt != type::assign && tt != type::prepend && tt != type::append) - fail (t) << "variable assignment expected instead of " << t; + fail (t) << "expected variable assignment instead of " << t; } else { @@ -791,7 +727,7 @@ namespace build2 diag_record dr (fail (nloc)); dr << "variable " << var << " has " << var.visibility - << " visibility but is assigned in a scope"; + << " visibility but is assigned on a scope"; if (var.visibility == variable_visibility::target) dr << info << "consider changing it to '*: " << var << "'"; @@ -825,7 +761,7 @@ namespace build2 name& n (ns[0]); if (!n.directory ()) - fail (nloc) << "scope directory expected"; + fail (nloc) << "expected scope directory"; next (t, tt); @@ -868,10 +804,70 @@ namespace build2 } void parser:: + parse_variable_block (token& t, type& tt, + const target_type* type, string pat) + { + // Parse a target or prerequisite-specific variable block. If type is not + // NULL, then this is a target type/pattern-specific block. + // + // enter: first token of first line in the block + // leave: rcbrace + // + // This is a more restricted variant of parse_clause() that only allows + // variable assignments. + // + tracer trace ("parser::parse_variable_block", &path_); + + while (tt != type::rcbrace && tt != type::eos) + { + attributes_push (t, tt); + + location nloc (get_location (t)); + names ns (parse_names (t, tt, + pattern_mode::ignore, + false /* chunk */, + "variable name")); + + if (tt != type::assign && + tt != type::prepend && + tt != type::append) + fail (t) << "expected variable assignment instead of " << t; + + const variable& var (parse_variable_name (move (ns), nloc)); + apply_variable_attributes (var); + + if (prerequisite_ != nullptr && + var.visibility > variable_visibility::target) + { + fail (t) << "variable " << var << " has " << var.visibility + << " visibility but is assigned on a target"; + } + + if (type == nullptr) + parse_variable (t, tt, var, tt); + else + parse_type_pattern_variable (t, tt, + *type, pat, // Note: can't move. + var, tt, get_location (t)); + + if (tt != type::newline) + fail (t) << "expected newline instead of " << t; + + next (t, tt); + } + } + + void parser:: parse_dependency (token& t, token_type& tt, names&& tns, const location& tloc, // Target names. names&& pns, const location& ploc) // Prereq names. { + // Parse a dependency chain and/or a prerequisite-specific variable + // assignment. + // + // enter: colon (anything else is not handled) + // leave: newline + // tracer trace ("parser::parse_dependency", &path_); // First enter all the targets (normally we will have just one). @@ -960,33 +956,15 @@ namespace build2 fail (ploc) << "no prerequisites in dependency chain or prerequisite-" << "specific variable assignment"; - next (t, tt); - auto at (attributes_push (t, tt)); - - // @@ PAT: currently we pattern-expand prerequisite-specific vars. + // Call the specified parsing function (either variable or block) for the + // last pns.size() prerequisites of each target. We handle multiple + // targets and/or prerequisites by replaying the tokens (see the target- + // specific case above for details). The function signature is: // - const location loc (get_location (t)); - names ns (tt != type::newline && tt != type::eos - ? parse_names (t, tt, pattern_mode::expand) - : names ()); - - // Prerequisite-specific variable assignment. + // void (token& t, type& tt) // - if (tt == type::assign || tt == type::prepend || tt == type::append) + auto for_each = [this, &t, &tt, &tgs, &pns] (auto&& f) { - // Set the variable in the last pns.size() prerequisites of each target. - // This code is similar to the target-specific variable case. - // - // @@ TODO prerequisite block (also target block above). - // - type at (tt); - - const variable& var (parse_variable_name (move (ns), loc)); - apply_variable_attributes (var); - - // We handle multiple targets and/or prerequisites by replaying the - // tokens (see the target-specific case above for details). - // replay_guard rg (*this, tgs.size () > 1 || pns.size () > 1); for (auto ti (tgs.begin ()), te (tgs.end ()); ti != te; ) @@ -998,7 +976,8 @@ namespace build2 pi != pn; ) { enter_prerequisite pg (*this, tg.prerequisites_[pi]); - parse_variable (t, tt, var, at); + + f (t, tt); if (++pi != pn) rg.play (); // Replay. @@ -1007,6 +986,65 @@ namespace build2 if (++ti != te) rg.play (); // Replay. } + }; + + next (t, tt); + auto at (attributes_push (t, tt)); + + // See if this is a prerequisite block. + // + if (tt == type::newline && peek () == type::lcbrace) + { + next (t, tt); + + // Should be on its own line. + // + if (next (t, tt) != type::newline) + fail (t) << "expected newline after {"; + + if (at.first) + fail (at.second) << "attributes before prerequisite block"; + else + attributes_pop (); + + // Parse the block for each prerequisites of each target. + // + for_each ([this] (token& t, token_type& tt) + { + next (t, tt); // First token of first line in the block. + + parse_variable_block (t, tt, nullptr, string ()); + + if (tt != type::rcbrace) + fail (t) << "expected } instead of " << t; + }); + + next (t, tt); // Presumably newline after '}'. + return; + } + + // @@ PAT: currently we pattern-expand prerequisite-specific vars. + // + const location loc (get_location (t)); + names ns (tt != type::newline && tt != type::eos + ? parse_names (t, tt, pattern_mode::expand) + : names ()); + + // Prerequisite-specific variable assignment. + // + if (tt == type::assign || tt == type::prepend || tt == type::append) + { + type at (tt); + + const variable& var (parse_variable_name (move (ns), loc)); + apply_variable_attributes (var); + + // Parse the assignment for each prerequisites of each target. + // + for_each ([this, &var, at] (token& t, token_type& tt) + { + parse_variable (t, tt, var, at); + }); } // // Dependency chain. @@ -1283,7 +1321,7 @@ namespace build2 } if (args.empty () || args[0].empty ()) - fail (l) << "executable name expected after run"; + fail (l) << "expected executable name after run"; cstrings cargs; cargs.reserve (args.size () + 1); @@ -1591,7 +1629,7 @@ namespace build2 standard_version v; if (!i->simple ()) - fail (l) << "module name expected instead of " << *i; + fail (l) << "expected module name instead of " << *i; n = move (i->value); @@ -1603,7 +1641,7 @@ namespace build2 ++i; if (!i->simple ()) - fail (l) << "module version expected instead of " << *i; + fail (l) << "expected module version instead of " << *i; v = standard_version (i->value, standard_version::allow_earliest); } @@ -2132,7 +2170,7 @@ namespace build2 // The list should contain a single, simple name. // if (ns.size () != 1 || !ns[0].simple () || ns[0].empty ()) - fail (l) << "variable name expected instead of " << ns; + fail (l) << "expected variable name instead of " << ns; string& n (ns[0].value); @@ -2166,6 +2204,97 @@ namespace build2 apply_value_attributes (&var, lhs, move (rhs), kind); } + void parser:: + parse_type_pattern_variable (token& t, token_type& tt, + const target_type& type, string pat, + const variable& var, token_type kind, + const location& loc) + { + // Parse target type/pattern-specific variable assignment. + // + // See old-tests/variable/type-pattern. + + // Note: expanding the value in the current scope context. + // + value rhs (parse_variable_value (t, tt)); + + // Leave the value untyped unless we are assigning. + // + pair<reference_wrapper<value>, bool> p ( + scope_->target_vars[type][move (pat)].insert ( + var, kind == type::assign)); + + value& lhs (p.first); + + // We store prepend/append values untyped (similar to overrides). + // + if (rhs.type != nullptr && kind != type::assign) + untypify (rhs); + + if (p.second) + { + // Note: we are always using assign and we don't pass the variable in + // case of prepend/append in order to keep the value untyped. + // + apply_value_attributes (kind == type::assign ? &var : nullptr, + lhs, + move (rhs), + type::assign); + + // Map assignment type to the value::extra constant. + // + lhs.extra = (kind == type::prepend ? 1 : + kind == type::append ? 2 : + 0); + } + else + { + // Existing value. What happens next depends on what we are trying to do + // and what's already there. + // + // Assignment is the easy one: we simply overwrite what's already + // there. Also, if we are appending/prepending to a previously assigned + // value, then we simply append or prepend normally. + // + if (kind == type::assign || lhs.extra == 0) + { + // Above we've instructed insert() not to type the value so we have to + // compensate for that now. + // + if (kind != type::assign) + { + if (var.type != nullptr && lhs.type != var.type) + typify (lhs, *var.type, &var); + } + else + lhs.extra = 0; // Change to assignment. + + apply_value_attributes (&var, lhs, move (rhs), kind); + } + else + { + // This is an append/prepent to a previously appended or prepended + // value. We can handle it as long as things are consistent. + // + if (kind == type::prepend && lhs.extra == 2) + fail (loc) << "prepend to a previously appended target type/pattern-" + << "specific variable " << var; + + if (kind == type::append && lhs.extra == 1) + fail (loc) << "append to a previously prepended target type/pattern-" + << "specific variable " << var; + + // Do untyped prepend/append. + // + apply_value_attributes (nullptr, lhs, move (rhs), kind); + } + } + + if (lhs.extra != 0 && lhs.type != nullptr) + fail (loc) << "typed prepend/append to target type/pattern-specific " + << "variable " << var; + } + value parser:: parse_variable_value (token& t, type& tt) { @@ -3394,6 +3523,11 @@ namespace build2 continue; } + //@@ This can be a nested replay (which we don't support), for example, + // via target-specific var assignment. Add support for nested (2-level + // replay)? Why not use replay_guard for storage? Alternatively, don't + // use it here (see parse_for() for an alternative approach). + // replay_guard rg (*this, ln.size () > 1); for (auto i (ln.begin ()), e (ln.end ()); i != e; ) { @@ -3789,7 +3923,7 @@ namespace build2 // must start inclusions or exclusions (see above). // if (rpat && t.separated && tt != type::rcbrace && !pattern_prefix (t)) - fail (t) << "name pattern inclusion or exclusion expected"; + fail (t) << "expected name pattern inclusion or exclusion"; } // Name. @@ -4633,7 +4767,7 @@ namespace build2 : buildspec ()); if (tt != type::eos) - fail (t) << "operation or target expected instead of " << t; + fail (t) << "expected operation or target instead of " << t; return r; } @@ -4675,7 +4809,7 @@ namespace build2 tt != type::pair_separator) // Empty pair LHS: '@foo ...' { if (first) - fail (t) << "operation or target expected instead of " << t; + fail (t) << "expected operation or target instead of " << t; break; } @@ -4688,7 +4822,7 @@ namespace build2 names ns (parse_names (t, tt, pattern_mode::expand, depth < 2)); if (ns.empty ()) // Can happen if pattern expansion. - fail (l) << "operation or target expected"; + fail (l) << "expected operation or target"; // What these names mean depends on what's next. If it is an opening // paren, then they are operation/meta-operation names. Otherwise they @@ -4697,11 +4831,11 @@ namespace build2 if (tt == type::lparen) // Got by parse_names(). { if (ns.empty ()) - fail (t) << "operation name expected before '('"; + fail (t) << "expected operation name before '('"; for (const name& n: ns) if (!opname (n)) - fail (l) << "operation name expected instead of '" << n << "'"; + fail (l) << "expected operation name instead of '" << n << "'"; // Inside '(' and ')' we have another, nested, buildspec. Push another // mode to keep track of the depth (used in the lexer implementation @@ -4730,7 +4864,7 @@ namespace build2 } if (tt != type::rparen) - fail (t) << "')' expected instead of " << t; + fail (t) << "expected ')' instead of " << t; expire_mode (); next (t, tt); // Get what's after ')'. @@ -4811,7 +4945,7 @@ namespace build2 // @@ We may actually want to support this at some point. // if (i->qualified ()) - fail (l) << "target name expected instead of " << *i; + fail (l) << "expected target name instead of " << *i; if (opname (*i)) ms.push_back (opspec (move (i->value))); @@ -4864,12 +4998,22 @@ namespace build2 //@@ TODO : append namespace if any. } + const scope* s (nullptr); + const target* t (nullptr); + const prerequisite* p (nullptr); + // If we are qualified, it can be a scope or a target. // enter_scope sg; enter_target tg; - if (!qual.empty ()) + if (qual.empty ()) + { + s = scope_; + t = target_; + p = prerequisite_; + } + else { switch (qual.pair) { @@ -4877,6 +5021,7 @@ namespace build2 { assert (qual.directory ()); sg = enter_scope (*this, move (qual.dir)); + s = scope_; break; } case ':': @@ -4887,6 +5032,7 @@ namespace build2 // tg = enter_target ( *this, move (qual), build2::name (), true, loc, trace); + t = target_; break; } default: assert (false); @@ -4897,15 +5043,42 @@ namespace build2 // const auto& var (var_pool.rw (*scope_).insert (move (name), true)); - if ((var.visibility == variable_visibility::prereq) || - (var.visibility == variable_visibility::target && target_ == nullptr)) + if (p != nullptr) + { + // The lookup depth is a bit of a hack but should be harmless since + // unused. + // + pair<lookup, size_t> r (p->vars[var], 1); + + if (!r.first.defined ()) + r = t->find_original (var); + + return var.override == nullptr + ? r.first + : t->base_scope ().find_override (var, move (r), true).first; + } + + if (t != nullptr) { - fail (loc) << "variable " << var << " has " << var.visibility - << " visibility but is expanded in a " - << (target_ != nullptr ? "target" : "scope"); + if (var.visibility > variable_visibility::target) + { + fail (loc) << "variable " << var << " has " << var.visibility + << " visibility but is expanded in target context"; + } + + return (*t)[var]; } - return target_ != nullptr ? (*target_)[var] : (*scope_)[var]; + if (s != nullptr) + { + if (var.visibility > variable_visibility::scope) + { + fail (loc) << "variable " << var << " has " << var.visibility + << " visibility but is expanded in scope context"; + } + + return (*s)[var]; + } // Undefined/NULL namespace variables are not allowed. // @@ -4916,6 +5089,8 @@ namespace build2 // if (var.name.find ('.') != string::npos) // fail (loc) << "undefined/null namespace variable " << var; // } + + return lookup (); } void parser:: diff --git a/build2/parser.hxx b/build2/parser.hxx index 582f925..e877422 100644 --- a/build2/parser.hxx +++ b/build2/parser.hxx @@ -76,6 +76,9 @@ namespace build2 parse_clause (token&, token_type&, bool one = false); void + parse_variable_block (token&, token_type&, const target_type*, string); + + void parse_dependency (token&, token_type&, names&&, const location&, names&&, const location&); @@ -122,6 +125,11 @@ namespace build2 void parse_variable (token&, token_type&, const variable&, token_type); + void + parse_type_pattern_variable (token&, token_type&, + const target_type&, string, + const variable&, token_type, const location&); + const variable& parse_variable_name (names&&, const location&); diff --git a/build2/prerequisite.hxx b/build2/prerequisite.hxx index 0f9a9cd..c584e19 100644 --- a/build2/prerequisite.hxx +++ b/build2/prerequisite.hxx @@ -83,6 +83,7 @@ namespace build2 // Prerequisite-specific variables. // // Note that the lookup is often ad hoc (see bin.whole as an example). + // But see also parser::lookup_variable() if adding something here. // public: variable_map vars; diff --git a/build2/target.hxx b/build2/target.hxx index ca93b24..b1bd16a 100644 --- a/build2/target.hxx +++ b/build2/target.hxx @@ -395,7 +395,6 @@ namespace build2 // that given two lookups from the same target, we can say which one came // earlier. If no value is found, then the depth is set to ~0. // - // pair<lookup, size_t> find (const variable& var) const { diff --git a/build2/variable.hxx b/build2/variable.hxx index e45914a..9688944 100644 --- a/build2/variable.hxx +++ b/build2/variable.hxx @@ -1227,6 +1227,9 @@ namespace build2 size_t version = 0; // Incremented on each modification (variable_cache). }; + // Note that we guarantee ascending iteration order (e.g., for predictable + // dump output in tests). + // using map_type = butl::prefix_map<reference_wrapper<const variable>, value_data, '.'>; diff --git a/tests/directive/run.testscript b/tests/directive/run.testscript index ba4a413..88ea909 100644 --- a/tests/directive/run.testscript +++ b/tests/directive/run.testscript @@ -32,6 +32,6 @@ EOE : cat <'print run' >=buildfile; $* <"run '$0' noop" 2>>"EOE" != 0 -<stdout>:1:4: error: executable name expected after run +<stdout>:1:4: error: expected executable name after run <stdin>:1:5: info: while parsing $0 output EOE diff --git a/tests/name/pattern.testscript b/tests/name/pattern.testscript index 1c9d6f5..07ff863 100644 --- a/tests/name/pattern.testscript +++ b/tests/name/pattern.testscript @@ -45,19 +45,19 @@ EOI : simple : $* <'print {*.txt +foo file{bar}}' 2>>EOE != 0 - <stdin>:1:19: error: name pattern inclusion or exclusion expected + <stdin>:1:19: error: expected name pattern inclusion or exclusion EOE : inclusion-exclusion-sign : $* <'print {*.txt -foo bar}' 2>>EOE != 0 - <stdin>:1:19: error: name pattern inclusion or exclusion expected + <stdin>:1:19: error: expected name pattern inclusion or exclusion EOE : inclusion-quoted : $* <'print {*.txt -foo "+bar"}' 2>>EOE != 0 - <stdin>:1:19: error: name pattern inclusion or exclusion expected + <stdin>:1:19: error: expected name pattern inclusion or exclusion EOE : empty-inclusion-exclusion diff --git a/tests/variable/prerequisite-specific/testscript b/tests/variable/prerequisite-specific/testscript index ef14cfc..ed7c60b 100644 --- a/tests/variable/prerequisite-specific/testscript +++ b/tests/variable/prerequisite-specific/testscript @@ -62,6 +62,58 @@ EOI } EOE +: block +: +$* <<EOI 2>>/~%EOE% +foo = COX +dir{x}: foo = FOX +dir{x}: dir{a}: +{ + foo = FOO + bar = BAR +} +dump dir{x} +EOI +<stdin>:8:1: dump: +% .+/dir\{x/\}:% + { + foo = FOX + } +% .+/dir\{x/\}: .+:dir\{a/\}:% + { + bar = BAR + foo = FOO + } +EOE + +: block-multiple +: +$* <<EOI 2>>/~%EOE% +dir{y}: foo = FOX +dir{x} dir{y}: dir{a} dir{b}: +{ + foo += FOO + bar = BAR $foo +} +dump dir{y} +EOI +<stdin>:7:1: dump: +% .+/dir\{y/\}:% + { + foo = FOX + } +% .+/dir\{y/\}: .+:dir\{a/\}:% + { + bar = BAR FOX FOO + foo = FOX FOO + } +% .+/dir\{y/\}: .+:dir\{b/\}:% + { + bar = BAR FOX FOO + foo = FOX FOO + } +EOE + : chain : $* <<EOI 2>>/~%EOE% diff --git a/tests/variable/scope-specific/testscript b/tests/variable/scope-specific/testscript index 5f9a05d..13e7eca 100644 --- a/tests/variable/scope-specific/testscript +++ b/tests/variable/scope-specific/testscript @@ -42,7 +42,7 @@ EOO $* <<EOI 2>>EOE != 0 foo/ [uint64] y EOI -<stdin>:1:16: error: variable assignment expected instead of <newline> +<stdin>:1:16: error: expected variable assignment instead of <newline> EOE : unexpected-attribute diff --git a/tests/variable/target-specific/testscript b/tests/variable/target-specific/testscript index 497c863..8b0a846 100644 --- a/tests/variable/target-specific/testscript +++ b/tests/variable/target-specific/testscript @@ -1,10 +1,10 @@ -# file : tests/variable/scope-specific/testscript +# file : tests/variable/target-specific/testscript # copyright : Copyright (c) 2014-2018 Code Synthesis Ltd # license : MIT; see accompanying LICENSE file .include ../../common.testscript -: basic-line +: basic : $* <<EOI >>EOO x = x @@ -25,6 +25,38 @@ X Z EOO +: block +: +$* <<EOI >>EOO +x = x +./: +{ + x = X + y = $x +} +print $(./: x) +print $(./: y) +EOI +X +X +EOO + +: block-multiple +: +$* <<EOI >>EOO +x = x +file{foo} file{bar}: +{ + x += X + y = $x +} +print $(file{foo}: y) +print $(file{bar}: y) +EOI +x X +x X +EOO + : eval-qual : $* <<EOI >>EOO diff --git a/tests/variable/target-type-pattern-specific/buildfile b/tests/variable/target-type-pattern-specific/buildfile new file mode 100644 index 0000000..efed550 --- /dev/null +++ b/tests/variable/target-type-pattern-specific/buildfile @@ -0,0 +1,5 @@ +# file : tests/variable/target-type-pattern-specific/buildfile +# copyright : Copyright (c) 2014-2018 Code Synthesis Ltd +# license : MIT; see accompanying LICENSE file + +./: testscript $b diff --git a/tests/variable/target-type-pattern-specific/testscript b/tests/variable/target-type-pattern-specific/testscript new file mode 100644 index 0000000..e60dbe1 --- /dev/null +++ b/tests/variable/target-type-pattern-specific/testscript @@ -0,0 +1,58 @@ +# file : tests/variable/target-type-pattern-specific/testscript +# copyright : Copyright (c) 2014-2018 Code Synthesis Ltd +# license : MIT; see accompanying LICENSE file + +# NOTE: see also old tests. + +.include ../../common.testscript + +: basic +: +$* <<EOI >>EOO +x = x +y = y +dir{*}: x = X +dir{*}: y += Y +print $(./: x) +print $(./: y) +EOI +X +y Y +EOO + +: block +: +$* <<EOI >>EOO +x = x +y = y +dir{*}: +{ + x = X + y += Y + z = $x # Note: from scope. +} +print $(./: x) +print $(./: y) +print $(./: z) +EOI +X +y Y +x +EOO + +: block-multiple +: +$* <<EOI >>EOO +x = x +y = y +file{f*} file{b*}: +{ + x = X + y += Y +} +print $(file{foo}: x) +print $(file{bar}: y) +EOI +X +y Y +EOO |