diff options
Diffstat (limited to 'build/parser.cxx')
| -rw-r--r-- | build/parser.cxx | 2206 |
1 files changed, 0 insertions, 2206 deletions
diff --git a/build/parser.cxx b/build/parser.cxx deleted file mode 100644 index ad17ae9..0000000 --- a/build/parser.cxx +++ /dev/null @@ -1,2206 +0,0 @@ -// file : build/parser.cxx -*- C++ -*- -// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd -// license : MIT; see accompanying LICENSE file - -#include <build/parser> - -#include <cctype> // is{alpha alnum}() - -#include <memory> // unique_ptr -#include <fstream> -#include <utility> // move() -#include <iterator> // make_move_iterator() -#include <iostream> - -#include <build/types> -#include <build/utility> -#include <build/version> - -#include <build/scope> -#include <build/target> -#include <build/prerequisite> -#include <build/variable> -#include <build/module> -#include <build/file> -#include <build/diagnostics> -#include <build/context> - -using namespace std; - -namespace build -{ - static location - get_location (const token&, const void*); - - typedef token_type type; - - void parser:: - parse_buildfile (istream& is, const path& p, scope& root, scope& base) - { - enter_buildfile (p); - - path_ = &path_pool.find (diag_relative (p)); // Relative to work. - - lexer l (is, *path_); - lexer_ = &l; - target_ = nullptr; - scope_ = &base; - root_ = &root; - default_target_ = nullptr; - - token t (type::eos, false, 0, 0); - type tt; - next (t, tt); - - clause (t, tt); - - if (tt != type::eos) - fail (t) << "unexpected " << t; - - process_default_target (t); - } - - token parser:: - parse_variable (lexer& l, scope& s, string name, type kind) - { - path_ = &l.name (); // Note: not pooled. - lexer_ = &l; - target_ = nullptr; - scope_ = &s; - - type tt; - token t (type::eos, false, 0, 0); - variable (t, tt, name, kind); - return t; - } - - void parser:: - clause (token& t, type& tt) - { - tracer trace ("parser::clause", &path_); - - // clause() should always stop at a token that is at the beginning of - // the line (except for eof). That is, if something is called to parse - // a line, it should parse it until newline (or fail). This is important - // for if-else blocks, directory scopes, etc., that assume the } token - // they see is on the new line. - // - while (tt != type::eos) - { - // We always start with one or more names. - // - if (tt != type::name && - tt != type::lcbrace && // Untyped name group: '{foo ...' - tt != type::dollar && // Variable expansion: '$foo ...' - tt != type::lparen && // Eval context: '(foo) ...' - tt != type::colon) // Empty name: ': ...' - break; // Something else. Let our caller handle that. - - // See if this is one of the directives. - // - if (tt == type::name && keyword (t)) - { - const string& n (t.value); - - if (n == "print") - { - // @@ Is this the only place where it is valid? Probably also - // in var namespace. - // - print (t, tt); - continue; - } - else if (n == "source") - { - source (t, tt); - continue; - } - else if (n == "include") - { - include (t, tt); - continue; - } - else if (n == "import") - { - import (t, tt); - continue; - } - else if (n == "export") - { - export_ (t, tt); - continue; - } - else if (n == "using" || - n == "using?") - { - using_ (t, tt); - continue; - } - else if (n == "define") - { - define (t, tt); - continue; - } - else if (n == "if" || - n == "if!") - { - if_else (t, tt); - continue; - } - else if (n == "else" || - n == "elif" || - n == "elif!") - { - // Valid ones are handled in if_else(). - // - fail (t) << n << " without if"; - } - } - - // ': foo' is equvalent to '{}: foo' and to 'dir{}: foo'. - // - const location nloc (get_location (t, &path_)); - names_type ns (tt != type::colon - ? names (t, tt) - : names_type ({name ("dir", string ())})); - - if (tt == type::colon) - { - // While '{}:' means empty name, '{$x}:' where x is empty list - // means empty list. - // - if (ns.empty ()) - fail (t) << "target expected before :"; - - next (t, tt); - - if (tt == type::newline) - { - // See if this is a directory/target scope. - // - if (peek () == type::lcbrace) - { - next (t, tt); - - // Should be on its own line. - // - if (next (t, tt) != type::newline) - fail (t) << "expected newline after {"; - - // See if this is a directory or target scope. Different - // things can appear inside depending on which one it is. - // - bool dir (false); - for (const auto& n: ns) - { - // A name represents directory as an empty value. - // - if (n.directory ()) - { - if (ns.size () != 1) - { - // @@ TODO: point to name (and above). - // - fail (nloc) << "multiple names in directory scope"; - } - - dir = true; - } - } - - next (t, tt); - - if (dir) - { - // Directory scope. - // - dir_path p (move (ns[0].dir)); // Steal. - - // Relative scopes are opened relative to out, not src. - // - if (p.relative ()) - p = scope_->out_path () / p; - - p.normalize (); - - scope* ors (root_); - scope* ocs (scope_); - switch_scope (p); - - // A directory scope can contain anything that a top level can. - // - clause (t, tt); - - scope_ = ocs; - root_ = ors; - } - else - { - // @@ TODO: target scope. - } - - if (tt != type::rcbrace) - fail (t) << "expected } instead of " << t; - - // Should be on its own line. - // - if (next (t, tt) == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline after }"; - - continue; - } - - // If this is not a scope, then it is a target without any - // prerequisites. - // - } - - // Dependency declaration or scope/target-specific variable - // assignment. - // - if (tt == type::name || - tt == type::lcbrace || - tt == type::dollar || - tt == type::lparen || - tt == type::newline || - tt == type::eos) - { - const location ploc (get_location (t, &path_)); - names_type pns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - // Common target entering code used in both cases. - // - auto enter_target = [this, &nloc, &trace] (name&& tn) -> target& - { - const string* e; - const target_type* ti (scope_->find_target_type (tn, e)); - - if (ti == nullptr) - fail (nloc) << "unknown target type " << tn.type; - - path& d (tn.dir); - - if (d.empty ()) - d = scope_->out_path (); // Already normalized. - else - { - if (d.relative ()) - d = scope_->out_path () / d; - - d.normalize (); - } - - // Find or insert. - // - return targets.insert ( - *ti, move (tn.dir), move (tn.value), e, trace).first; - }; - - // Scope/target-specific variable assignment. - // - if (tt == type::equal || - tt == type::equal_plus || - tt == type::plus_equal) - { - token at (t); - type att (tt); - - string v (variable_name (move (pns), ploc)); - - // If we have multiple targets/scopes, 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. - // - replay_guard rg (*this, ns.size () > 1); - - for (name& n: ns) - { - if (n.qualified ()) - fail (nloc) << "project name in scope/target " << n; - - if (n.directory ()) - { - // The same code as in directory scope handling code above. - // - dir_path p (move (n.dir)); - - if (p.relative ()) - p = scope_->out_path () / p; - - p.normalize (); - - scope* ors (root_); - scope* ocs (scope_); - switch_scope (p); - - variable (t, tt, v, att); - - scope_ = ocs; - root_ = ors; - } - else - { - // Figure out if this is a target or type/pattern specific - // variable. - // - size_t p (n.value.find ('*')); - - if (p == string::npos) - { - target* ot (target_); - target_ = &enter_target (move (n)); - variable (t, tt, v, att); - target_ = ot; - } - else - { - // See tests/variable/type-pattern. - // - if (!n.dir.empty ()) - fail (nloc) << "directory in target type/pattern " << n; - - if (n.value.find ('*', p + 1) != string::npos) - fail (nloc) << "multiple wildcards in target type/pattern " - << n; - - // Resolve target type. If none is specified, use the root - // of the hierarchy. - // - const target_type* ti ( - n.untyped () - ? &target::static_type - : scope_->find_target_type (n.type)); - - if (ti == nullptr) - fail (nloc) << "unknown target type " << n.type; - - if (att == type::equal_plus) - fail (at) << "prepend to target type/pattern-specific " - << "variable " << v; - - if (att == type::plus_equal) - fail (at) << "append to target type/pattern-specific " - << "variable " << v; - - const auto& var (var_pool.find (v)); - - // Note: expand variables in the value in the context of - // the scope. - // - names_type vns (variable_value (t, tt, var)); - value& val (scope_->target_vars[*ti][move (n.value)].assign ( - var).first); - val.assign (move (vns), var); - } - } - - rg.play (); // Replay. - } - } - // Dependency declaration. - // - else - { - // Prepare the prerequisite list. - // - target::prerequisites_type ps; - ps.reserve (pns.size ()); - - for (auto& pn: pns) - { - const string* e; - const target_type* ti (scope_->find_target_type (pn, e)); - - if (ti == nullptr) - fail (ploc) << "unknown target type " << pn.type; - - pn.dir.normalize (); - - // Find or insert. - // - prerequisite& p ( - scope_->prerequisites.insert ( - pn.proj, - *ti, - move (pn.dir), - move (pn.value), - e, - *scope_, - trace).first); - - ps.emplace_back (p); - } - - for (auto& tn: ns) - { - if (tn.qualified ()) - fail (nloc) << "project name in target " << tn; - - target& t (enter_target (move (tn))); - - //@@ OPT: move if last/single target (common cases). - // - t.prerequisites.insert (t.prerequisites.end (), - ps.begin (), - ps.end ()); - - if (default_target_ == nullptr) - default_target_ = &t; - } - } - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - - continue; - } - - if (tt == type::eos) - continue; - - fail (t) << "expected newline instead of " << t; - } - - // Variable assignment. - // - if (tt == type::equal || - tt == type::equal_plus || - tt == type::plus_equal) - { - variable (t, tt, variable_name (move (ns), nloc), tt); - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - - continue; - } - - // Allow things like function calls that don't result in anything. - // - if (tt == type::newline && ns.empty ()) - { - next (t, tt); - continue; - } - - fail (t) << "unexpected " << t; - } - } - - void parser:: - source (token& t, type& tt) - { - tracer trace ("parser::source", &path_); - - // The rest should be a list of buildfiles. Parse them as names - // to get variable expansion and directory prefixes. - // - mode (lexer_mode::value); - next (t, tt); - const location l (get_location (t, &path_)); - names_type ns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - for (name& n: ns) - { - if (n.qualified () || n.empty () || n.value.empty ()) - fail (l) << "expected buildfile instead of " << n; - - // Construct the buildfile path. - // - path p (move (n.dir)); - p /= path (move (n.value)); - - // If the path is relative then use the src directory corresponding - // to the current directory scope. - // - if (root_->src_path_ != nullptr && p.relative ()) - p = src_out (scope_->out_path (), *root_) / p; - - p.normalize (); - - try - { - ifstream ifs (p.string ()); - - if (!ifs.is_open ()) - fail (l) << "unable to open " << p; - - ifs.exceptions (ifstream::failbit | ifstream::badbit); - - level5 ([&]{trace (t) << "entering " << p;}); - - enter_buildfile (p); - - const string* op (path_); - path_ = &path_pool.find (diag_relative (p)); // Relative to work. - - lexer l (ifs, *path_); - lexer* ol (lexer_); - lexer_ = &l; - - token t (type::eos, false, 0, 0); - type tt; - next (t, tt); - clause (t, tt); - - if (tt != type::eos) - fail (t) << "unexpected " << t; - - level5 ([&]{trace (t) << "leaving " << p;}); - - lexer_ = ol; - path_ = op; - } - catch (const ifstream::failure&) - { - fail (l) << "unable to read buildfile " << p; - } - } - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - void parser:: - include (token& t, type& tt) - { - tracer trace ("parser::include", &path_); - - if (root_->src_path_ == nullptr) - fail (t) << "inclusion during bootstrap"; - - // The rest should be a list of buildfiles. Parse them as names - // to get variable expansion and directory prefixes. - // - mode (lexer_mode::value); - next (t, tt); - const location l (get_location (t, &path_)); - names_type ns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - for (name& n: ns) - { - if (n.qualified () || n.empty ()) - fail (l) << "expected buildfile instead of " << n; - - // Construct the buildfile path. If it is a directory, then append - // 'buildfile'. - // - path p (move (n.dir)); - if (n.value.empty ()) - p /= path ("buildfile"); - else - { - bool d (path::traits::is_separator (n.value.back ()) - || n.type == "dir"); - - p /= path (move (n.value)); - if (d) - p /= path ("buildfile"); - } - - level6 ([&]{trace (l) << "relative path " << p;}); - - // Determine new out_base. - // - dir_path out_base; - - if (p.relative ()) - { - out_base = scope_->out_path () / p.directory (); - out_base.normalize (); - } - else - { - p.normalize (); - - // Make sure the path is in this project. Include is only meant - // to be used for intra-project inclusion (plus amalgamation). - // - bool in_out (false); - if (!p.sub (root_->src_path ()) && - !(in_out = p.sub (root_->out_path ()))) - fail (l) << "out of project include " << p; - - out_base = in_out - ? p.directory () - : out_src (p.directory (), *root_); - } - - // Switch the scope. Note that we need to do this before figuring - // out the absolute buildfile path since we may switch the project - // root and src_root with it (i.e., include into a sub-project). - // - scope* ors (root_); - scope* ocs (scope_); - switch_scope (out_base); - - // Use the new scope's src_base to get absolute buildfile path - // if it is relative. - // - if (p.relative ()) - p = scope_->src_path () / p.leaf (); - - level6 ([&]{trace (l) << "absolute path " << p;}); - - if (!root_->buildfiles.insert (p).second) // Note: may be "new" root. - { - level5 ([&]{trace (l) << "skipping already included " << p;}); - scope_ = ocs; - root_ = ors; - continue; - } - - try - { - ifstream ifs (p.string ()); - - if (!ifs.is_open ()) - fail (l) << "unable to open " << p; - - ifs.exceptions (ifstream::failbit | ifstream::badbit); - - level5 ([&]{trace (t) << "entering " << p;}); - - enter_buildfile (p); - - const string* op (path_); - path_ = &path_pool.find (diag_relative (p)); // Relative to work. - - lexer l (ifs, *path_); - lexer* ol (lexer_); - lexer_ = &l; - - target* odt (default_target_); - default_target_ = nullptr; - - token t (type::eos, false, 0, 0); - type tt; - next (t, tt); - clause (t, tt); - - if (tt != type::eos) - fail (t) << "unexpected " << t; - - process_default_target (t); - - level5 ([&]{trace (t) << "leaving " << p;}); - - default_target_ = odt; - lexer_ = ol; - path_ = op; - } - catch (const ifstream::failure&) - { - fail (l) << "unable to read buildfile " << p; - } - - scope_ = ocs; - root_ = ors; - } - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - void parser:: - import (token& t, type& tt) - { - tracer trace ("parser::import", &path_); - - if (root_->src_path_ == nullptr) - fail (t) << "import during bootstrap"; - - next (t, tt); - - // General import format: - // - // import [<var>=](<project>|<project>/<target>])+ - // - value* val (nullptr); - const build::variable* var (nullptr); - - type at; // Assignment type. - if (tt == type::name) - { - at = peek (); - - if (at == type::equal || - at == type::equal_plus || - at == type::plus_equal) - { - var = &var_pool.find (t.value); - val = at == type::equal - ? &scope_->assign (*var) - : &scope_->append (*var); - next (t, tt); // Consume =/=+/+=. - mode (lexer_mode::value); - next (t, tt); - } - } - - // The rest should be a list of projects and/or targets. Parse - // them as names to get variable expansion and directory prefixes. - // - const location l (get_location (t, &path_)); - names_type ns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - for (name& n: ns) - { - // build::import() will check the name, if required. - // - names_type r (build::import (*scope_, move (n), l)); - - if (val != nullptr) - { - if (at == type::equal) - val->assign (move (r), *var); - else if (at == type::equal_plus) - val->prepend (move (r), *var); - else - val->append (move (r), *var); - } - } - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - void parser:: - export_ (token& t, type& tt) - { - tracer trace ("parser::export", &path_); - - scope* ps (scope_->parent_scope ()); - - // This should be temp_scope. - // - if (ps == nullptr || ps->out_path () != scope_->out_path ()) - fail (t) << "export outside export stub"; - - // The rest is a value. Parse it as names to get variable expansion. - // build::import() will check the names, if required. - // - mode (lexer_mode::value); - next (t, tt); - - if (tt != type::newline && tt != type::eos) - export_value_ = names (t, tt); - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - void parser:: - using_ (token& t, type& tt) - { - tracer trace ("parser::using", &path_); - - bool optional (t.value.back () == '?'); - - if (optional && boot_) - fail (t) << "optional module in bootstrap"; - - // The rest should be a list of module names. Parse them as names - // to get variable expansion, etc. - // - mode (lexer_mode::pairs, '@'); - next (t, tt); - const location l (get_location (t, &path_)); - names_type ns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - for (auto i (ns.begin ()); i != ns.end (); ++i) - { - string n, v; - - if (!i->simple ()) - fail (l) << "module name expected instead of " << *i; - - n = move (i->value); - - if (i->pair) - { - ++i; - if (!i->simple ()) - fail (l) << "module version expected instead of " << *i; - - v = move (i->value); - } - - // Handle the special 'build' module. - // - if (n == "build") - { - if (!v.empty ()) - { - unsigned int iv; - try {iv = to_version (v);} - catch (const invalid_argument& e) - { - fail (l) << "invalid version '" << v << "': " << e.what (); - } - - if (iv > BUILD_VERSION) - fail (l) << "build2 " << v << " required" << - info << "running build2 " << BUILD_VERSION_STR; - } - } - else - { - assert (v.empty ()); // Module versioning not yet implemented. - - if (boot_) - boot_module (n, *root_, l); - else - load_module (optional, n, *root_, *scope_, l); - } - } - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - static target* - derived_factory (const target_type& t, dir_path d, string n, const string* e) - { - // Pass our type to the base factory so that it can detect that it is - // being called to construct a derived target. This can be used, for - // example, to decide whether to "link up" to the group. - // - target* r (t.base->factory (t, move (d), move (n), e)); - r->derived_type = &t; - return r; - } - - constexpr const char derived_ext_var[] = "extension"; - - void parser:: - define (token& t, type& tt) - { - // define <derived>: <base> - // - // See tests/define. - // - if (next (t, tt) != type::name) - fail (t) << "expected name instead of " << t << " in target type " - << "definition"; - - string dn (move (t.value)); - const location dnl (get_location (t, &path_)); - - if (next (t, tt) != type::colon) - fail (t) << "expected ':' instead of " << t << " in target type " - << "definition"; - - next (t, tt); - - if (tt == type::name) - { - // Target. - // - const string& bn (t.value); - const target_type* bt (scope_->find_target_type (bn)); - - if (bt == nullptr) - fail (t) << "unknown target type " << bn; - - unique_ptr<target_type> dt (new target_type (*bt)); - dt->base = bt; - dt->factory = &derived_factory; - - // Override extension derivation function: we most likely don't want - // to use the same default as our base (think cli: file). - // - dt->extension = &target_extension_var<derived_ext_var, nullptr>; - - target_type& rdt (*dt); // Save a non-const reference to the object. - - auto pr (scope_->target_types.emplace (dn, target_type_ref (move (dt)))); - - if (!pr.second) - fail (dnl) << "target type " << dn << " already define in this scope"; - - // Patch the alias name to use the map's key storage. - // - rdt.name = pr.first->first.c_str (); - - next (t, tt); // Get newline. - } - else - fail (t) << "expected name instead of " << t << " in target type " - << "definition"; - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline instead of " << t; - } - - void parser:: - if_else (token& t, type& tt) - { - // Handle the whole if-else chain. See tests/if-else. - // - bool taken (false); // One of the branches has been taken. - - for (;;) - { - string k (move (t.value)); - next (t, tt); - - bool take (false); // Take this branch? - - if (k != "else") - { - // Should we evaluate the expression if one of the branches has - // already been taken? On the one hand, evaluating it is a waste - // of time. On the other, it can be invalid and the only way for - // the user to know their buildfile is valid is to test every - // branch. There could also be side effects. We also have the same - // problem with ignored branch blocks except there evaluating it - // is not an option. So let's skip it. - // - if (taken) - skip_line (t, tt); - else - { - if (tt == type::newline || tt == type::eos) - fail (t) << "expected " << k << "-expression instead of " << t; - - // Parse as names to get variable expansion, evaluation, etc. - // - const location nsl (get_location (t, &path_)); - names_type ns (names (t, tt)); - - // Should evaluate to true or false. - // - if (ns.size () != 1 || !value_traits<bool>::assign (ns[0])) - fail (nsl) << "expected " << k << "-expression to evaluate to " - << "'true' or 'false' instead of '" << ns << "'"; - - bool e (ns[0].value == "true"); - take = (k.back () == '!' ? !e : e); - } - } - else - take = !taken; - - if (tt != type::newline) - fail (t) << "expected newline instead of " << t << " after " << k - << (k != "else" ? "-expression" : ""); - - if (next (t, tt) != type::lcbrace) - fail (t) << "expected { instead of " << t << " at the beginning of " - << k << "-block"; - - if (next (t, tt) != type::newline) - fail (t) << "expected newline after {"; - - next (t, tt); - - if (take) - { - clause (t, tt); - taken = true; - } - else - skip_block (t, tt); - - if (tt != type::rcbrace) - fail (t) << "expected } instead of " << t << " at the end of " << k - << "-block"; - - next (t, tt); - - if (tt == type::newline) - next (t, tt); - else if (tt != type::eos) - fail (t) << "expected newline after }"; - - // See if we have another el* keyword. - // - if (k != "else" && tt == type::name && keyword (t)) - { - const string& n (t.value); - - if (n == "else" || n == "elif" || n == "elif!") - continue; - } - - break; - } - } - - void parser:: - print (token& t, type& tt) - { - // Parse the rest as names to get variable expansion, etc. Switch - // to the variable value lexing mode so that we don't treat special - // characters (e.g., ':') as the end of the names. - // - mode (lexer_mode::value); - next (t, tt); - names_type ns (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - - cout << ns << endl; - - if (tt != type::eos) - next (t, tt); // Swallow newline. - } - - string parser:: - variable_name (names_type&& ns, const location& l) - { - // 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; - - string& n (ns[0].value); - - if (n.front () == '.') // Fully qualified name. - return string (n, 1, string::npos); - else - //@@ TODO: append namespace if any. - return move (n); - } - - void parser:: - variable (token& t, type& tt, string name, type kind) - { - const auto& var (var_pool.find (move (name))); - names_type vns (variable_value (t, tt, var)); - - if (kind == type::equal) - { - value& v (target_ != nullptr - ? target_->assign (var) - : scope_->assign (var)); - v.assign (move (vns), var); - } - else - { - value& v (target_ != nullptr - ? target_->append (var) - : scope_->append (var)); - - if (kind == type::equal_plus) - v.prepend (move (vns), var); - else - v.append (move (vns), var); - } - } - - names parser:: - variable_value (token& t, type& tt, const variable_type& var) - { - if (var.pairs != '\0') - mode (lexer_mode::pairs, var.pairs); - else - mode (lexer_mode::value); - - next (t, tt); - return (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); - } - - parser::names_type parser:: - eval (token& t, type& tt) - { - mode (lexer_mode::eval); - next (t, tt); - - names_type ns (tt != type::rparen ? names (t, tt) : names_type ()); - - if (tt != type::rparen) - fail (t) << "expected ')' instead of " << t; - - return ns; - } - - // Parse names inside {} and handle the following "crosses" (i.e., - // {a b}{x y}) if any. Return the number of names added to the list. - // - size_t parser:: - names_trailer (token& t, type& tt, - names_type& ns, - size_t pair, - const string* pp, - const dir_path* dp, - const string* tp) - { - next (t, tt); // Get what's after '{'. - - size_t count (ns.size ()); - names (t, tt, - ns, - false, - (pair != 0 - ? pair - : (ns.empty () || ns.back ().pair == '\0' ? 0 : ns.size ())), - pp, dp, tp); - count = ns.size () - count; - - if (tt != type::rcbrace) - fail (t) << "expected } instead of " << t; - - // See if we have a cross. See tests/names. - // - if (peek () == type::lcbrace && !peeked ().separated) - { - next (t, tt); // Get '{'. - const location loc (get_location (t, &path_)); - - names_type x; // Parse into a separate list of names. - names_trailer (t, tt, x, 0, nullptr, nullptr, nullptr); - - if (size_t n = x.size ()) - { - // Now cross the last 'count' names in 'ns' with 'x'. First we will - // allocate n - 1 additional sets of last 'count' names in 'ns'. - // - size_t b (ns.size () - count); // Start of 'count' names. - ns.reserve (ns.size () + count * (n - 1)); - for (size_t i (0); i != n - 1; ++i) - for (size_t j (0); j != count; ++j) - ns.push_back (ns[b + j]); - - // Now cross each name, this time including the first set. - // - for (size_t i (0); i != n; ++i) - { - for (size_t j (0); j != count; ++j) - { - name& l (ns[b + i * count + j]); - const name& r (x[i]); - - // Move the project names. - // - if (r.proj != nullptr) - { - if (l.proj != nullptr) - fail (loc) << "nested project name " << *r.proj; - - l.proj = r.proj; - } - - // Merge directories. - // - if (!r.dir.empty ()) - { - if (l.dir.empty ()) - l.dir = move (r.dir); - else - l.dir /= r.dir; - } - - // Figure out the type. As a first step, "promote" the lhs value - // to type. - // - if (!l.value.empty ()) - { - if (!l.type.empty ()) - fail (loc) << "nested type name " << l.value; - - l.type.swap (l.value); - } - - if (!r.type.empty ()) - { - if (!l.type.empty ()) - fail (loc) << "nested type name " << r.type; - - l.type = move (r.type); - } - - l.value = move (r.value); - - // @@ TODO: need to handle pairs on lhs. I think all that needs - // to be done is skip pair's first elements. Maybe also check - // that there are no pairs on the rhs. There is just no easy - // way to enable the pairs mode to test it, yet. - } - } - - count *= n; - } - } - - return count; - } - - void parser:: - names (token& t, type& tt, - names_type& ns, - bool chunk, - size_t pair, - const string* pp, - const dir_path* dp, - const string* tp) - { - // If pair is not 0, then it is an index + 1 of the first half of - // the pair for which we are parsing the second halves, e.g., - // a={b c d{e f} {}}. - // - - // Buffer that is used to collect the complete name in case of - // an unseparated variable expansion or eval context, e.g., - // 'foo$bar($baz)fox'. The idea is to concatenate all the - // individual parts in this buffer and then re-inject it into - // the loop as a single token. - // - string concat; - - // Number of names in the last group. This is used to detect when - // we need to add an empty first pair element (e.g., {=y}) or when - // we have a for now unsupported multi-name LHS (e.g., {x y}=z). - // - size_t count (0); - - for (bool first (true);; first = false) - { - // If the accumulating buffer is not empty, then we have two options: - // continue accumulating or inject. We inject if the next token is - // not a name, var expansion, or eval context or if it is separated. - // - if (!concat.empty () && - ((tt != type::name && - tt != type::dollar && - tt != type::lparen) || peeked ().separated)) - { - tt = type::name; - t = token (move (concat), true, false, t.line, t.column); - concat.clear (); - } - else if (!first) - { - // If we are chunking, stop at the next separated token. Unless - // current or next token is a pair separator, since we want the - // "x = y" pair to be parsed as a single chunk. - // - bool p (t.type == type::pair_separator); // Current token. - - next (t, tt); - - if (chunk && t.separated && (tt != type::pair_separator && !p)) - break; - } - - // Name. - // - if (tt == type::name) - { - string name (t.value); //@@ move? - tt = peek (); - - // Should we accumulate? If the buffer is not empty, then - // we continue accumulating (the case where we are separated - // should have been handled by the injection code above). If - // the next token is a var expansion or eval context and it - // is not separated, then we need to start accumulating. - // - if (!concat.empty () || // Continue. - ((tt == type::dollar || - tt == type::lparen) && !peeked ().separated)) // Start. - { - concat += name; - continue; - } - - string::size_type p (name.find_last_of ("/%")); - - // First take care of project. A project-qualified name is - // not very common, so we can afford some copying for the - // sake of simplicity. - // - const string* pp1 (pp); - - if (p != string::npos) - { - bool last (name[p] == '%'); - string::size_type p1 (last ? p : name.rfind ('%', p - 1)); - - if (p1 != string::npos) - { - string proj; - proj.swap (name); - - // First fix the rest of the name. - // - name.assign (proj, p1 + 1, string::npos); - p = last ? string::npos : p - (p1 + 1); - - // Now process the project name. - // @@ Validate it. - // - proj.resize (p1); - - if (pp != nullptr) - fail (t) << "nested project name " << proj; - - pp1 = &project_name_pool.find (proj); - } - } - - string::size_type n (p != string::npos ? name.size () - 1 : 0); - - // See if this is a type name, directory prefix, or both. That - // is, it is followed by an un-separated '{'. - // - if (tt == type::lcbrace && !peeked ().separated) - { - next (t, tt); - - if (p != n && tp != nullptr) - fail (t) << "nested type name " << name; - - dir_path d1; - const dir_path* dp1 (dp); - - string t1; - const string* tp1 (tp); - - if (p == string::npos) // type - tp1 = &name; - else if (p == n) // directory - { - if (dp == nullptr) - d1 = dir_path (name); - else - d1 = *dp / dir_path (name); - - dp1 = &d1; - } - else // both - { - t1.assign (name, p + 1, n - p); - - if (dp == nullptr) - d1 = dir_path (name, 0, p + 1); - else - d1 = *dp / dir_path (name, 0, p + 1); - - dp1 = &d1; - tp1 = &t1; - } - - count = names_trailer (t, tt, ns, pair, pp1, dp1, tp1); - tt = peek (); - continue; - } - - // If we are a second half of a pair, add another first half - // unless this is the first instance. - // - if (pair != 0 && pair != ns.size ()) - ns.push_back (ns[pair - 1]); - - count = 1; - - // If it ends with a directory separator, then it is a directory. - // Note that at this stage we don't treat '.' and '..' as special - // (unless they are specified with a directory separator) because - // then we would have ended up treating '.: ...' as a directory - // scope. Instead, this is handled higher up the processing chain, - // in target_types::find(). This would also mess up reversibility - // to simple name. - // - // @@ TODO: and not quoted - // - if (p == n) - { - // For reversibility to simple name, only treat it as a directory - // if the string is an exact representation. - // - if (p != 0 && name[p - 1] != '/') // Take care of the "//" case. - name.resize (p); // Strip trailing '/'. - - dir_path dir (move (name), dir_path::exact); - - if (!dir.empty ()) - { - if (dp != nullptr) - dir = *dp / dir; - - ns.emplace_back (pp1, - move (dir), - (tp != nullptr ? *tp : string ()), - string ()); - continue; - } - - // Add the trailing slash back and treat it as a simple name. - // - if (p != 0 && name[p - 1] != '/') - name.push_back ('/'); - } - - ns.emplace_back (pp1, - (dp != nullptr ? *dp : dir_path ()), - (tp != nullptr ? *tp : string ()), - move (name)); - continue; - } - - // Variable expansion/function call or eval context. - // - if (tt == type::dollar || tt == type::lparen) - { - // These two cases are pretty similar in that in both we - // pretty quickly end up with a list of names that we need - // to splice into the result. - // - names_type lv_data; - const names_type* plv; - - location loc; - const char* what; // Variable or evaluation context. - - 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 switch to the eval mode if what we get next - // is a paren. - // - mode (lexer_mode::variable); - next (t, tt); - loc = get_location (t, &path_); - - string n; - if (tt == type::name) - n = t.value; - else if (tt == type::lparen) - { - expire_mode (); - names_type ns (eval (t, tt)); - - // Make sure the result of evaluation is a single, simple name. - // - if (ns.size () != 1 || !ns.front ().simple ()) - fail (loc) << "variable/function name expected instead of '" - << ns << "'"; - - n = move (ns.front ().value); - } - else - fail (t) << "variable/function name expected instead of " << t; - - if (n.empty ()) - fail (loc) << "empty variable/function name"; - - // Figure out whether this is a variable expansion or a function - // call. - // - tt = peek (); - - if (tt == type::lparen) - { - next (t, tt); // Get '('. - names_type ns (eval (t, tt)); - - // Just a stub for now. - // - cout << n << "(" << ns << ")" << endl; - - tt = peek (); - - if (lv_data.empty ()) - continue; - - plv = &lv_data; - what = "function call"; - } - else - { - // Process variable name. - // - if (n.front () == '.') // Fully qualified name. - n.erase (0, 1); - else - { - //@@ TODO: append namespace if any. - } - - // Lookup. - // - const auto& var (var_pool.find (move (n))); - auto l (target_ != nullptr ? (*target_)[var] : (*scope_)[var]); - - // Undefined/NULL namespace variables are not allowed. - // - if (!l && var.name.find ('.') != string::npos) - fail (loc) << "undefined/null namespace variable " << var.name; - - if (!l || l->empty ()) - continue; - - plv = &l->data_; - what = "variable expansion"; - } - } - else - { - loc = get_location (t, &path_); - lv_data = eval (t, tt); - - tt = peek (); - - if (lv_data.empty ()) - continue; - - plv = &lv_data; - what = "context evaluation"; - } - - // @@ Could move if (lv == &lv_data). - // - const names_type& lv (*plv); - - // Should we accumulate? If the buffer is not empty, then - // we continue accumulating (the case where we are separated - // should have been handled by the injection code above). If - // the next token is a name or var expansion and it is not - // separated, then we need to start accumulating. - // - if (!concat.empty () || // Continue. - ((tt == type::name || // Start. - tt == type::dollar || - tt == type::lparen) && !peeked ().separated)) - { - // This should be a simple value or a simple directory. The - // token still points to the name (or closing paren). - // - if (lv.size () > 1) - fail (loc) << "concatenating " << what << " contains multiple " - << "values"; - - const name& n (lv[0]); - - if (n.qualified ()) - fail (loc) << "concatenating " << what << " contains project name"; - - if (n.typed ()) - fail (loc) << "concatenating " << what << " contains type"; - - if (!n.dir.empty ()) - { - if (!n.value.empty ()) - fail (loc) << "concatenating " << what << " contains directory"; - - concat += n.dir.string (); - } - else - concat += n.value; - } - else - { - // Copy the names from the variable into the resulting name list - // while doing sensible things with the types and directories. - // - for (const name& n: lv) - { - const string* pp1 (pp); - const dir_path* dp1 (dp); - const string* tp1 (tp); - - if (n.proj != 0) - { - if (pp == nullptr) - pp1 = n.proj; - else - fail (loc) << "nested project name " << *n.proj << " in " - << what; - } - - dir_path d1; - if (!n.dir.empty ()) - { - if (dp != nullptr) - { - if (n.dir.absolute ()) - fail (loc) << "nested absolute directory " << n.dir - << " in " << what; - - d1 = *dp / n.dir; - dp1 = &d1; - } - else - dp1 = &n.dir; - } - - if (!n.type.empty ()) - { - if (tp == nullptr) - tp1 = &n.type; - else - fail (loc) << "nested type name " << n.type << " in " << what; - } - - // If we are a second half of a pair. - // - if (pair != 0) - { - // Check that there are no nested pairs. - // - if (n.pair != '\0') - fail (loc) << "nested pair in " << what; - - // And add another first half unless this is the first instance. - // - if (pair != ns.size ()) - ns.push_back (ns[pair - 1]); - } - - ns.emplace_back (pp1, - (dp1 != nullptr ? *dp1 : dir_path ()), - (tp1 != nullptr ? *tp1 : string ()), - n.value); - - ns.back ().pair = n.pair; - } - - count = lv.size (); - } - - continue; - } - - // Untyped name group without a directory prefix, e.g., '{foo bar}'. - // - if (tt == type::lcbrace) - { - count = names_trailer (t, tt, ns, pair, pp, dp, tp); - tt = peek (); - continue; - } - - // A pair separator (only in the pairs mode). - // - if (tt == type::pair_separator) - { - if (pair != 0) - fail (t) << "nested pair on the right hand side of a pair"; - - if (count > 1) - fail (t) << "multiple names on the left hand side of a pair"; - - if (count == 0) - { - // Empty LHS, (e.g., {=y}), create an empty name. - // - ns.emplace_back (pp, - (dp != nullptr ? *dp : dir_path ()), - (tp != nullptr ? *tp : string ()), - string ()); - count = 1; - } - - ns.back ().pair = t.pair; - tt = peek (); - continue; - } - - if (!first) - break; - - if (tt == type::rcbrace) // Empty name, e.g., dir{}. - { - // If we are a second half of a pair, add another first half - // unless this is the first instance. - // - if (pair != 0 && pair != ns.size ()) - ns.push_back (ns[pair - 1]); - - ns.emplace_back (pp, - (dp != nullptr ? *dp : dir_path ()), - (tp != nullptr ? *tp : string ()), - string ()); - break; - } - else - // Our caller expected this to be a name. - // - fail (t) << "expected name instead of " << t; - } - - // Handle the empty RHS in a pair, (e.g., {y=}). - // - if (!ns.empty () && ns.back ().pair != '\0') - { - ns.emplace_back (pp, - (dp != nullptr ? *dp : dir_path ()), - (tp != nullptr ? *tp : string ()), - string ()); - } - } - - void parser:: - skip_line (token& t, type& tt) - { - for (; tt != type::newline && tt != type::eos; next (t, tt)) ; - } - - void parser:: - skip_block (token& t, type& tt) - { - // Skip until } or eos, keeping track of the {}-balance. - // - for (size_t b (0); tt != type::eos; ) - { - if (tt == type::lcbrace || tt == type::rcbrace) - { - type ptt (peek ()); - if (ptt == type::newline || ptt == type::eos) // Block { or }. - { - if (tt == type::lcbrace) - ++b; - else - { - if (b == 0) - break; - - --b; - } - } - } - - skip_line (t, tt); - - if (tt != type::eos) - next (t, tt); - } - } - - bool parser:: - keyword (token& t) - { - assert (replay_ == replay::stop); // Can't be used in a replay. - assert (t.type == type::name); - - // The goal here is to allow using keywords as variable names and - // target types without imposing ugly restrictions/decorators on - // keywords (e.g., '.using' or 'USING'). A name is considered a - // potential keyword if: - // - // - it is not quoted [so a keyword can always be escaped] and - // - next token is '\n' (or eos) or '(' [so if(...) will work] or - // - next token is separated and is not '=', '=+', or '+=' [which - // means a "directive trailer" can never start with one of them]. - // - // See tests/keyword. - // - if (!t.quoted) - { - // We cannot peek at the whole token here since it might have to be - // lexed in a different mode. So peek at its first character. - // - pair<char, bool> p (lexer_->peek_char ()); - char c (p.first); - - return c == '\n' || c == '\0' || c == '(' || - (p.second && c != '=' && c != '+'); - } - - return false; - } - - // Buildspec parsing. - // - - // Here is the problem: we "overload" '(' and ')' to mean operation - // application rather than the eval context. At the same time we want - // to use names() to parse names, get variable expansion/function calls, - // quoting, etc. We just need to disable the eval context. The way this - // is done has two parts: Firstly, we parse names in chunks and detect - // and handle the opening paren. In other words, a buildspec like - // 'clean (./)' is "chunked" as 'clean', '(', etc. While this is fairly - // straightforward, there is one snag: concatenating eval contexts, as - // in 'clean(./)'. Normally, this will be treated as a single chunk and - // we don't want that. So here comes the trick (or hack, if you like): - // we will make every opening paren token "separated" (i.e., as if it - // was proceeded by a space). This will disable concatenating eval. In - // fact, we will even go a step further and only do this if we are in - // the original pairs mode. This will allow us to still use eval - // contexts in buildspec, provided that we quote it: '"cle(an)"'. Note - // also that function calls still work as usual: '$filter (clean test)'. - // To disable a function call and make it instead a var that is expanded - // into operation name(s), we can use quoting: '"$ops"(./)'. - // - static void - paren_processor (token& t, const lexer& l) - { - if (t.type == type::lparen && l.mode () == lexer_mode::pairs) - t.separated = true; - } - - buildspec parser:: - parse_buildspec (istream& is, const std::string& name) - { - path_ = &name; // Note: caller pools. - - lexer l (is, name, &paren_processor); - lexer_ = &l; - target_ = nullptr; - scope_ = root_ = global_scope; - - // Turn on pairs recognition with '@' as the pair separator (e.g., - // src_root/@out_root/exe{foo bar}). - // - mode (lexer_mode::pairs, '@'); - - token t (type::eos, false, 0, 0); - type tt; - next (t, tt); - - return buildspec_clause (t, tt, type::eos); - } - - static bool - opname (const name& n) - { - // First it has to be a non-empty simple name. - // - if (n.pair != '\0' || !n.simple () || n.empty ()) - return false; - - // C identifier. - // - for (size_t i (0); i != n.value.size (); ++i) - { - char c (n.value[i]); - if (c != '_' && !(i != 0 ? isalnum (c) : isalpha (c))) - return false; - } - - return true; - } - - buildspec parser:: - buildspec_clause (token& t, type& tt, type tt_end) - { - buildspec bs; - - while (tt != tt_end) - { - // We always start with one or more names. Eval context - // (lparen) only allowed if quoted. - // - if (tt != type::name && - tt != type::lcbrace && // Untyped name group: '{foo ...' - tt != type::dollar && // Variable expansion: '$foo ...' - !(tt == type::lparen && mode () == lexer_mode::quoted) && - tt != type::pair_separator) // Empty pair LHS: '@foo ...' - fail (t) << "operation or target expected instead of " << t; - - const location l (get_location (t, &path_)); // Start of names. - - // This call will parse the next chunk of output and produce - // zero or more names. - // - names_type ns (names (t, tt, true)); - - // What these names mean depends on what's next. If it is an - // opening paren, then they are operation/meta-operation names. - // Otherwise they are targets. - // - if (tt == type::lparen) // Peeked into by names(). - { - if (ns.empty ()) - fail (t) << "operation name expected before '('"; - - for (const name& n: ns) - if (!opname (n)) - fail (l) << "operation name expected instead of '" << n << "'"; - - // Inside '(' and ')' we have another, nested, buildspec. - // - next (t, tt); - const location l (get_location (t, &path_)); // Start of nested names. - buildspec nbs (buildspec_clause (t, tt, type::rparen)); - - // Merge the nested buildspec into ours. But first determine - // if we are an operation or meta-operation and do some sanity - // checks. - // - bool meta (false); - for (const metaopspec& nms: nbs) - { - // We definitely shouldn't have any meta-operations. - // - if (!nms.name.empty ()) - fail (l) << "nested meta-operation " << nms.name; - - if (!meta) - { - // If we have any operations in the nested spec, then this - // mean that our names are meta-operation names. - // - for (const opspec& nos: nms) - { - if (!nos.name.empty ()) - { - meta = true; - break; - } - } - } - } - - // No nested meta-operations means we should have a single - // metaopspec object with empty meta-operation name. - // - assert (nbs.size () == 1); - const metaopspec& nmo (nbs.back ()); - - if (meta) - { - for (name& n: ns) - { - bs.push_back (nmo); - bs.back ().name = move (n.value); - } - } - else - { - // Since we are not a meta-operation, the nested buildspec - // should be just a bunch of targets. - // - assert (nmo.size () == 1); - const opspec& nos (nmo.back ()); - - if (bs.empty () || !bs.back ().name.empty ()) - bs.push_back (metaopspec ()); // Empty (default) meta operation. - - for (name& n: ns) - { - bs.back ().push_back (nos); - bs.back ().back ().name = move (n.value); - } - } - - next (t, tt); // Done with '('. - } - else if (!ns.empty ()) - { - // Group all the targets into a single operation. In other - // words, 'foo bar' is equivalent to 'update(foo bar)'. - // - if (bs.empty () || !bs.back ().name.empty ()) - bs.push_back (metaopspec ()); // Empty (default) meta operation. - - metaopspec& ms (bs.back ()); - - for (auto i (ns.begin ()), e (ns.end ()); i != e; ++i) - { - // @@ We may actually want to support this at some point. - // - if (i->qualified ()) - fail (l) << "target name expected instead of " << *i; - - if (opname (*i)) - ms.push_back (opspec (move (i->value))); - else - { - // Do we have the src_base? - // - dir_path src_base; - if (i->pair != '\0') - { - if (i->typed ()) - fail (l) << "expected target src_base instead of " << *i; - - src_base = move (i->dir); - - if (!i->value.empty ()) - src_base /= dir_path (move (i->value)); - - ++i; - assert (i != e); // Got to have the second half of the pair. - } - - if (ms.empty () || !ms.back ().name.empty ()) - ms.push_back (opspec ()); // Empty (default) operation. - - opspec& os (ms.back ()); - os.emplace_back (move (src_base), move (*i)); - } - } - } - } - - return bs; - } - - void parser:: - switch_scope (const dir_path& p) - { - tracer trace ("parser::switch_scope", &path_); - - // First, enter the scope into the map and see if it is in any - // project. If it is not, then there is nothing else to do. - // - auto i (scopes.insert (p, nullptr, true, false)); - scope_ = i->second; - scope* rs (scope_->root_scope ()); - - if (rs == nullptr) - return; - - // Path p can be src_base or out_base. Figure out which one it is. - // - dir_path out_base (p.sub (rs->out_path ()) ? p : src_out (p, *rs)); - - // Create and bootstrap root scope(s) of subproject(s) that this - // scope may belong to. If any were created, load them. Note that - // we need to do this before figuring out src_base since we may - // switch the root project (and src_root with it). - // - { - scope* nrs (&create_bootstrap_inner (*rs, out_base)); - - if (rs != nrs) - { - load_root_pre (*nrs); // Load outer roots recursively. - rs = nrs; - } - } - - // Switch to the new root scope. - // - if (rs != root_) - { - level5 ([&]{trace << "switching to root scope " << rs->out_path ();}); - root_ = rs; - } - - // Now we can figure out src_base and finish setting the scope. - // - dir_path src_base (src_out (out_base, *rs)); - setup_base (i, move (out_base), move (src_base)); - } - - void parser:: - process_default_target (token& t) - { - tracer trace ("parser::process_default_target", &path_); - - // The logic is as follows: if we have an explicit current directory - // target, then that's the default target. Otherwise, we take the - // first target and use it as a prerequisite to create an implicit - // current directory target, effectively making it the default - // target via an alias. If there are no targets in this buildfile, - // then we don't do anything. - // - if (default_target_ == nullptr || // No targets in this buildfile. - targets.find (dir::static_type, // Explicit current dir target. - scope_->out_path (), - "", - nullptr, - trace) != targets.end ()) - return; - - target& dt (*default_target_); - - level5 ([&]{trace (t) << "creating current directory alias for " << dt;}); - - target& ct ( - targets.insert ( - dir::static_type, scope_->out_path (), "", nullptr, trace).first); - - prerequisite& p ( - scope_->prerequisites.insert ( - nullptr, - dt.type (), - dt.dir, - dt.name, - dt.ext, - *scope_, // Doesn't matter which scope since dir is absolute. - trace).first); - - p.target = &dt; - 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); - } - - type parser:: - next (token& t, type& tt) - { - if (peeked_) - { - t = move (peek_); - peeked_ = false; - } - else - t = (replay_ == replay::play ? replay_next () : lexer_->next ()); - - if (replay_ == replay::save) - replay_data_.push_back (t); - - tt = t.type; - return tt; - } - - type parser:: - peek () - { - if (!peeked_) - { - peek_ = (replay_ == replay::play ? replay_next () : lexer_->next ()); - peeked_ = true; - } - - return peek_.type; - } - - static location - get_location (const token& t, const void* data) - { - assert (data != nullptr); - const string& p (**static_cast<const string* const*> (data)); - return location (p.c_str (), t.line, t.column); - } -} |