From 41a31b0a61464fd506166887f621100364e67276 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Mon, 4 Nov 2019 09:37:30 +0200 Subject: Add support for configuration exporting and importing The new config.export variable specifies the alternative file to write the configuration to as part of the configure meta-operation. For example: $ b configure: proj/ config.export=proj-config.build The config.export value "applies" only to the projects on whose root scope it is specified or if it is a global override (the latter is a bit iffy but we allow it, for example, to dump everything to stdout). This means that in order to save a subproject's configuration we will have to use a scope-specific override (since the default will apply to the outermost amalgamation). For example: $ b configure: subproj/ subproj/config.export=.../subproj-config.build This could be somewhat unnatural but then it will be the amalgamation whose configuration we normally want to export. The new config.import variable specifies additional configuration files to be loaded after the project's default config.build, if any. For example: $ b create: cfg/,cc config.import=my-config.build Similar to config.export, the config.import value "applies" only to the project on whose root scope it is specified or if it is a global override. This allows the use of the standard override "positioning" machinery (i.e., where the override applies) to decide where the extra configuration files are loaded. The resulting semantics is quite natural and consistent with command line variable overrides, for example: $ b config.import=.../config.build # outermost amalgamation $ b ./config.import=.../config.build # this project $ b !config.import=.../config.build # every project Both config.export and config.import recognize the special `-` file name as an instruction to write/read to/from stdout/stdin, respectively. For example: $ b configure: src-prj/ config.export=- | b configure: dst-prj/ config.import=- --- libbuild2/config/init.cxx | 108 ++++++++++++----- libbuild2/config/module.cxx | 2 +- libbuild2/config/operation.cxx | 264 +++++++++++++++++++++++++---------------- libbuild2/context.cxx | 2 +- libbuild2/dist/operation.cxx | 6 +- libbuild2/file.cxx | 95 +++++++++++---- libbuild2/file.hxx | 26 ++++ libbuild2/lexer.hxx | 2 +- libbuild2/module.cxx | 2 +- libbuild2/operation.cxx | 14 +-- libbuild2/operation.hxx | 7 +- libbuild2/parser.cxx | 11 +- libbuild2/parser.hxx | 3 + libbuild2/utility.cxx | 32 ++++- libbuild2/utility.hxx | 13 ++ libbuild2/version/init.cxx | 3 + 16 files changed, 415 insertions(+), 175 deletions(-) (limited to 'libbuild2') diff --git a/libbuild2/config/init.cxx b/libbuild2/config/init.cxx index 6998017..4e1890a 100644 --- a/libbuild2/config/init.cxx +++ b/libbuild2/config/init.cxx @@ -6,6 +6,7 @@ #include #include +#include #include #include #include // exists() @@ -32,9 +33,18 @@ namespace build2 const string& mname (rs.ctx.current_mname); const string& oname (rs.ctx.current_oname); - // Only create the module if we are configuring or creating. This is a - // bit tricky since the build2 core may not yet know if this is the - // case. But we know. + // While config.import (see below) could theoretically be specified in a + // buildfile, config.export is expected to always be specified as a + // command line override. + // + // Note: must be entered during bootstrap since we need it in + // configure_execute(). + // + vp.insert ("config.export", true /* ovr */); + + // Only create the module if we are configuring or creating or if it was + // forced with config.module (useful if we need to call $config.export() + // during other meta-operations). // if (( mname == "configure" || mname == "create") || (mname.empty () && (oname == "configure" || oname == "create"))) @@ -80,42 +90,80 @@ namespace build2 assert (config_hints.empty ()); // We don't known any hints. + // Note that the config.* variables belong to the module . + // So the only "special" variables we can allocate in config.* are + // config.config.*, names that have been "gifted" to us by other modules + // (like config.version) as well as names that we have reserved to not + // be valid module names (build, import, export). + // auto& vp (rs.ctx.var_pool.rw (rs)); - // Load config.build if one exists (we don't need to worry about - // disfigure since we will never be init'ed). + auto& c_v (vp.insert ("config.version", false /*ovr*/)); + auto& c_i (vp.insert ("config.import", true /* ovr */)); + + // Load config.build if one exists followed by extra files specified in + // config.import (we don't need to worry about disfigure since we will + // never be init'ed). // - const variable& c_v (vp.insert ("config.version", false)); + auto load_config = [&rs, &c_v] (const path& f, const location& l) + { + // Check the config version. We assume that old versions cannot + // understand new configs and new versions are incompatible with old + // configs. + // + // We extract the value manually instead of loading and then checking + // in order to be able to fixup/migrate the file which we may want to + // do in the future. + // + + // This is tricky for stdin since we cannot reopen it (or put more + // than one character back). So what we are going to do is continue + // reading after extracting the variable. One side effect of this is + // that we won't have the config.version variable entered in the scope + // but that is harmless (we could do it manually if necessary). + // + ifdstream ifs; + lexer lex (open_file_or_stdin (f, ifs), f); + + // Assume missing version is 0. + // + auto p (extract_variable (rs.ctx, lex, c_v)); + uint64_t v (p.second ? cast (p.first) : 0); + + if (v != module::version) + fail (l) << "incompatible config file " << f << + info << "config file version " << v + << (p.second ? "" : " (missing)") << + info << "config module version " << module::version << + info << "consider reconfiguring " << project (rs) << '@' + << rs.out_path (); + + source (rs, rs, lex); + }; { path f (config_file (rs)); if (exists (f)) + load_config (f, l); + } + + if (lookup l = rs[c_i]) + { + // Only load files that were specified on our root scope as well as + // global overrides. This way we can use our override "positioning" + // machinery (i.e., where the override applies) to decide where the + // extra config is loaded. The resulting semantics feels quite natural + // and consistent with command line variable overrides: + // + // b config.import=.../config.build # outermost amalgamation + // b ./config.import=.../config.build # this project + // b !config.import=.../config.build # every project + // + if (l.belongs (rs) || l.belongs (rs.ctx.global_scope)) { - // Check the config version. We assume that old versions cannot - // understand new configs and new versions are incompatible with old - // configs. - // - // We extract the value manually instead of loading and then - // checking in order to be able to fixup/migrate the file which we - // may want to do in the future. - // - { - // Assume missing version is 0. - // - auto p (extract_variable (rs.ctx, f, c_v)); - uint64_t v (p.second ? cast (p.first) : 0); - - if (v != module::version) - fail (l) << "incompatible config file " << f << - info << "config file version " << v - << (p.second ? "" : " (missing)") << - info << "config module version " << module::version << - info << "consider reconfiguring " << project (rs) << '@' - << out_root; - } - - source (rs, rs, f); + for (const path& f: cast (l)) + load_config (f, location (&f)); } } diff --git a/libbuild2/config/module.cxx b/libbuild2/config/module.cxx index 7e9b765..b43f1d9 100644 --- a/libbuild2/config/module.cxx +++ b/libbuild2/config/module.cxx @@ -30,7 +30,7 @@ namespace build2 i = sm.insert (string (n, 0, n.find ('.', 7))); } - // Don't insert duplicates. The config.import vars are particularly + // Don't insert duplicates. The config.import.* vars are particularly // susceptible to duplication. // saved_variables& sv (i->second); diff --git a/libbuild2/config/operation.cxx b/libbuild2/config/operation.cxx index 535018e..9050645 100644 --- a/libbuild2/config/operation.cxx +++ b/libbuild2/config/operation.cxx @@ -87,35 +87,45 @@ namespace build2 using project_set = set; // Use pointers to get comparison. + // If inherit is false, then don't rely on inheritance from outer scopes + // (used for config.export). + // static void - save_config (const scope& rs, const project_set& projects) + save_config (const scope& rs, + const path& f, + bool inherit, + const project_set& projects) { context& ctx (rs.ctx); - path f (config_file (rs)); + const module& mod (*rs.lookup_module (module::name)); - if (verb) - text << (verb >= 2 ? "cat >" : "save ") << f; + const string& df (f.string () != "-" ? f.string () : ""); - const module& mod (*rs.lookup_module (module::name)); + if (verb) + text << (verb >= 2 ? "cat >" : "save ") << df; try { - ofdstream ofs (f); + ofdstream ofs; + ostream& os (open_file_or_stdout (f, ofs)); - ofs << "# Created automatically by the config module, but feel " << + os << "# Created automatically by the config module, but feel " << "free to edit." << endl - << "#" << endl; + << "#" << endl; - ofs << "config.version = " << module::version << endl; + os << "config.version = " << module::version << endl; - if (auto l = rs.vars[ctx.var_amalgamation]) + if (inherit) { - const dir_path& d (cast (l)); + if (auto l = rs.vars[ctx.var_amalgamation]) + { + const dir_path& d (cast (l)); - ofs << endl - << "# Base configuration inherited from " << d << endl - << "#" << endl; + os << endl + << "# Base configuration inherited from " << d << endl + << "#" << endl; + } } // Save config variables. @@ -146,6 +156,11 @@ namespace build2 if (!l.defined ()) continue; + // Handle inherited from outer scope values. + // + // Note that we keep this logic (with warnings and all) even if + // inherit is false to make things easier to reason about. + // if (!(l.belongs (rs) || l.belongs (ctx.global_scope))) { // This is presumably an inherited value. But it could also be @@ -205,42 +220,50 @@ namespace build2 } } - if (found) // Inherited. - continue; - - location loc (&f); - - // If this value is not defined in a project's root scope, then - // something is broken. - // - if (r == nullptr) - fail (loc) << "inherited variable " << var << " value " - << "is not from a root scope"; - - // If none of the outer project's configurations use this value, - // then we warn and save as our own. One special case where we - // don't want to warn the user is if the variable is overriden. - // - if (org.first == ovr.first) + if (found) { - diag_record dr; - dr << warn (loc) << "saving previously inherited variable " - << var; - - dr << info (loc) << "because project " << *r - << " no longer uses it in its configuration"; - - if (verb >= 2) + // Inherited. + // + if (inherit) + continue; + } + else + { + location loc (&f); + + // If this value is not defined in a project's root scope, + // then something is broken. + // + if (r == nullptr) + fail (loc) << "inherited variable " << var << " value " + << "is not from a root scope"; + + // If none of the outer project's configurations use this + // value, then we warn and save as our own. One special case + // where we don't want to warn the user is if the variable is + // overriden. + // + if (org.first == ovr.first) { - dr << info (loc) << "variable value: "; + diag_record dr; + dr << warn (loc) << "saving previously inherited variable " + << var; - if (*l) + dr << info (loc) << "because project " << *r + << " no longer uses it in its configuration"; + + if (verb >= 2) { - storage.clear (); - dr << "'" << reverse (*l, storage) << "'"; + dr << info (loc) << "variable value: "; + + if (*l) + { + storage.clear (); + dr << "'" << reverse (*l, storage) << "'"; + } + else + dr << "[null]"; } - else - dr << "[null]"; } } } @@ -264,7 +287,7 @@ namespace build2 // if (first) { - ofs << endl; + os << endl; first = false; } @@ -274,7 +297,7 @@ namespace build2 org.first == ovr.first && // Not overriden. (sv.flags & save_commented) == save_commented) { - ofs << '#' << n << " =" << endl; + os << '#' << n << " =" << endl; continue; } @@ -283,20 +306,20 @@ namespace build2 storage.clear (); names_view ns (reverse (v, storage)); - ofs << n; + os << n; if (ns.empty ()) - ofs << " ="; + os << " ="; else { - ofs << " = "; - to_stream (ofs, ns, true, '@'); // Quote. + os << " = "; + to_stream (os, ns, true, '@'); // Quote. } - ofs << endl; + os << endl; } else - ofs << n << " = [null]" << endl; + os << n << " = [null]" << endl; } } @@ -304,12 +327,15 @@ namespace build2 } catch (const io_error& e) { - fail << "unable to write " << f << ": " << e; + fail << "unable to write " << df << ": " << e; } } static void - configure_project (action a, const scope& rs, project_set& projects) + configure_project (action a, + const scope& rs, + const variable* c_e, // config.export + project_set& projects) { tracer trace ("configure_project"); @@ -332,8 +358,7 @@ namespace build2 mkdir (out_root / rs.root_extra->bootstrap_dir, 2); } - // We distinguish between a complete configure and operation- - // specific. + // We distinguish between a complete configure and operation-specific. // if (a.operation () == default_id) { @@ -341,15 +366,48 @@ namespace build2 // Save src-root.build unless out_root is the same as src. // - if (out_root != src_root) + if (c_e == nullptr && out_root != src_root) save_src_root (rs); - // Save config.build. + // Save config.build unless an alternative is specified with + // config.export. Similar to config.import we will only save to that + // file if it is specified on our root scope or as a global override + // (the latter is a bit iffy but let's allow it, for example, to dump + // everything to stdout). Note that to save a subproject's config we + // will have to use a scope-specific override (since the default will + // apply to the amalgamation): // - save_config (rs, projects); + // b configure: subproj/ subproj/config.export=.../config.build + // + // Could be confusing but then normally it will be the amalgamation + // whose configuration we want to export. + // + // Note also that if config.export is specified we do not rewrite + // config.build files (say, of subprojects) as well as src-root.build + // above. Failed that, if we are running in a disfigured project, we + // may end up leaving it in partially configured state. + // + if (c_e == nullptr) + save_config (rs, config_file (rs), true /* inherit */, projects); + else + { + lookup l (rs[*c_e]); + if (l && (l.belongs (rs) || l.belongs (ctx.global_scope))) + { + // While writing the complete configuration seems like a natural + // default, there might be a desire to take inheritance into + // account (if, say, we are exporting at multiple levels). One can + // of course just copy the relevant config.build files, but we may + // still want to support this mode somehow in the future (maybe + // using `+` as a modifier, say config.export=+.../config.build). + // + save_config (rs, cast (l), false /* inherit */, projects); + } + } } else { + fail << "operation-specific configuration not yet supported"; } // Configure subprojects that have been loaded. @@ -368,7 +426,7 @@ namespace build2 if (nrs.out_path () != out_nroot) // This subproject not loaded. continue; - configure_project (a, nrs, projects); + configure_project (a, nrs, c_e, projects); } } } @@ -513,6 +571,15 @@ namespace build2 { bool fwd (forward (params)); + context& ctx (fwd ? ts[0].as ().ctx : ts[0].as ().ctx); + + const variable* c_e (ctx.var_pool.find ("config.export")); + + if (c_e->overrides == nullptr) + c_e = nullptr; + else if (fwd) + fail << "config.export specified for forward configuration"; + project_set projects; for (const action_target& at: ts) @@ -521,53 +588,52 @@ namespace build2 { // Forward configuration. // - const scope& rs (*static_cast (at.target)); + const scope& rs (at.as ()); configure_forward (rs, projects); - continue; } + else + { + // Normal configuration. + // + // Match rules to configure every operation supported by each + // project. Note that we are not calling operation_pre/post() + // callbacks here since the meta operation is configure and we know + // what we are doing. + // + // Note that we cannot do this in parallel. We cannot parallelize + // the outer loop because we should match for a single action at a + // time. And we cannot swap the loops because the list of operations + // is target-specific. However, inside match(), things can proceed + // in parallel. + // + const target& t (at.as ()); + const scope* rs (t.base_scope ().root_scope ()); - // Normal configuration. - // - // Match rules to configure every operation supported by each project. - // Note that we are not calling operation_pre/post() callbacks here - // since the meta operation is configure and we know what we are - // doing. - // - // Note that we cannot do this in parallel. We cannot parallelize the - // outer loop because we should match for a single action at a time. - // And we cannot swap the loops because the list of operations is - // target-specific. However, inside match(), things can proceed in - // parallel. - // - const target& t (at.as_target ()); - const scope* rs (t.base_scope ().root_scope ()); - - if (rs == nullptr) - fail << "out of project target " << t; - - context& ctx (t.ctx); + if (rs == nullptr) + fail << "out of project target " << t; - const operations& ops (rs->root_extra->operations); + const operations& ops (rs->root_extra->operations); - for (operation_id id (default_id + 1); // Skip default_id. - id < ops.size (); - ++id) - { - if (const operation_info* oif = ops[id]) + for (operation_id id (default_id + 1); // Skip default_id. + id < ops.size (); + ++id) { - // Skip aliases (e.g., update-for-install). - // - if (oif->id != id) - continue; + if (const operation_info* oif = ops[id]) + { + // Skip aliases (e.g., update-for-install). + // + if (oif->id != id) + continue; - ctx.current_operation (*oif); + ctx.current_operation (*oif); - phase_lock pl (ctx, run_phase::match); - match (action (configure_id, id), t); + phase_lock pl (ctx, run_phase::match); + match (action (configure_id, id), t); + } } - } - configure_project (a, *rs, projects); + configure_project (a, *rs, c_e, projects); + } } } @@ -802,7 +868,7 @@ namespace build2 // for (const action_target& at: ts) { - const scope& rs (*static_cast (at.target)); + const scope& rs (at.as ()); if (!(fwd ? disfigure_forward ( rs, projects) diff --git a/libbuild2/context.cxx b/libbuild2/context.cxx index 292feed..b4a3e93 100644 --- a/libbuild2/context.cxx +++ b/libbuild2/context.cxx @@ -473,7 +473,7 @@ namespace build2 // Enter builtin variables and patterns. // - // All config. variables are by default overridable. + // All config.* variables are by default overridable. // vp.insert_pattern ("config.**", nullopt, true, nullopt, true, false); diff --git a/libbuild2/dist/operation.cxx b/libbuild2/dist/operation.cxx index 391f7d8..ad829df 100644 --- a/libbuild2/dist/operation.cxx +++ b/libbuild2/dist/operation.cxx @@ -75,7 +75,7 @@ namespace build2 // For now we assume all the targets are from the same project. // - const target& t (ts[0].as_target ()); + const target& t (ts[0].as ()); const scope* rs (t.base_scope ().root_scope ()); if (rs == nullptr) @@ -118,7 +118,7 @@ namespace build2 // for (const action_target& at: ts) { - const target& t (at.as_target ()); + const target& t (at.as ()); if (rs != t.base_scope ().root_scope ()) fail << "target " << t << " is from a different project" << @@ -353,7 +353,7 @@ namespace build2 for (size_t i (0), n (files.size ()); i != n; ++i) { - const file& t (*files[i].as_target ().is_a ()); + const file& t (*files[i].as ().is_a ()); // Figure out where this file is inside the target directory. // diff --git a/libbuild2/file.cxx b/libbuild2/file.cxx index 603943c..b55d576 100644 --- a/libbuild2/file.cxx +++ b/libbuild2/file.cxx @@ -4,8 +4,6 @@ #include -#include // cin - #include #include #include @@ -161,27 +159,39 @@ namespace build2 } static void - source (scope& root, scope& base, const path& bf, bool boot) + source (scope& root, scope& base, lexer& l, bool boot) { tracer trace ("source"); + const path& bf (l.name ()); + try { - bool sin (bf.string () == "-"); - - ifdstream ifs; - - if (!sin) - ifs.open (bf); - else - cin.exceptions (ifdstream::failbit | ifdstream::badbit); - - istream& is (sin ? cin : ifs); - l5 ([&]{trace << "sourcing " << bf;}); parser p (root.ctx, boot); - p.parse_buildfile (is, bf, root, base); + p.parse_buildfile (l, root, base); + } + catch (const io_error& e) + { + fail << "unable to read buildfile " << bf << ": " << e; + } + } + + static void + source (scope& root, scope& base, istream& is, const path& bf, bool boot) + { + lexer l (is, bf); + source (root, base, l, boot); + } + + static void + source (scope& root, scope& base, const path& bf, bool boot) + { + try + { + ifdstream ifs; + return source (root, base, open_file_or_stdin (bf, ifs), bf, boot); } catch (const io_error& e) { @@ -195,6 +205,18 @@ namespace build2 source (root, base, bf, false); } + void + source (scope& root, scope& base, istream& is, const path& bf) + { + source (root, base, is, bf, false); + } + + void + source (scope& root, scope& base, lexer& l) + { + source (root, base, l, false); + } + bool source_once (scope& root, scope& base, const path& bf, scope& once) { @@ -206,7 +228,7 @@ namespace build2 return false; } - source (root, base, bf); + source (root, base, bf, false); return true; } @@ -498,18 +520,17 @@ namespace build2 } pair - extract_variable (context& ctx, const path& bf, const variable& var) + extract_variable (context& ctx, lexer& l, const variable& var) { + const path& bf (l.name ()); + try { - ifdstream ifs (bf); - - lexer lex (ifs, bf); - token t (lex.next ()); + token t (l.next ()); token_type tt; if (t.type != token_type::word || t.value != var.name || - ((tt = lex.next ().type) != token_type::assign && + ((tt = l.next ().type) != token_type::assign && tt != token_type::prepend && tt != token_type::append)) { @@ -518,7 +539,7 @@ namespace build2 parser p (ctx); temp_scope tmp (ctx.global_scope.rw ()); - p.parse_variable (lex, tmp, var, tt); + p.parse_variable (l, tmp, var, tt); value* v (tmp.vars.find_to_modify (var).first); assert (v != nullptr); @@ -533,6 +554,32 @@ namespace build2 } } + pair + extract_variable (context& ctx, + istream& is, + const path& bf, + const variable& var) + { + lexer l (is, bf); + return extract_variable (ctx, l, var); + } + + pair + extract_variable (context& ctx, const path& bf, const variable& var) + { + try + { + ifdstream ifs (bf); + return extract_variable (ctx, ifs, bf, var); + } + catch (const io_error& e) + { + fail << "unable to read buildfile " << bf << ": " << e << endf; + } + } + + + // Extract the project name from bootstrap.build. // static project_name @@ -745,7 +792,7 @@ namespace build2 // root scope multiple time. // if (rs.buildfiles.insert (f).second) - source (rs, rs, f, true); + source (rs, rs, f, true /* boot */); else l5 ([&]{trace << "skipping already sourced " << f;}); diff --git a/libbuild2/file.hxx b/libbuild2/file.hxx index 3d3c38b..78bd049 100644 --- a/libbuild2/file.hxx +++ b/libbuild2/file.hxx @@ -18,6 +18,8 @@ namespace build2 { + class lexer; + using subprojects = std::map; LIBBUILD2_SYMEXPORT ostream& @@ -71,6 +73,18 @@ namespace build2 LIBBUILD2_SYMEXPORT void source (scope& root, scope& base, const path&); + // As above, but extract from a stream. The name argument is used for + // diagnostics. + // + LIBBUILD2_SYMEXPORT void + source (scope& root, scope& base, istream&, const path& name); + + // As above, but extract from a lexer (this could be useful for sourcing + // stdin that requires parse_variable()). + // + LIBBUILD2_SYMEXPORT void + source (scope& root, scope& base, lexer&); + // As above but first check if this buildfile has already been sourced for // the base scope. Return false if the file has already been sourced. // @@ -195,6 +209,18 @@ namespace build2 LIBBUILD2_SYMEXPORT pair extract_variable (context&, const path&, const variable&); + // As above, but extract from a stream. The name argument is used for + // diagnostics. + // + LIBBUILD2_SYMEXPORT pair + extract_variable (context&, istream&, const path& name, const variable&); + + // As above, but extract from a lexer (this could be useful for extracting + // from stdin). + // + LIBBUILD2_SYMEXPORT pair + extract_variable (context&, lexer&, const variable&); + // Import has two phases: the first is triggered by the import directive in // the buildfile. It will try to find and load the project. Failed that, it // will return the project-qualified name of the target which will be used diff --git a/libbuild2/lexer.hxx b/libbuild2/lexer.hxx index 90d546d..a2c7431 100644 --- a/libbuild2/lexer.hxx +++ b/libbuild2/lexer.hxx @@ -194,7 +194,7 @@ namespace build2 mode (lexer_mode::normal, '@', escapes); } - const path name_; + const path name_; // @@ TODO: why not shallow (like istream)? std::stack state_; bool sep_; // True if we skipped spaces in peek(). diff --git a/libbuild2/module.cxx b/libbuild2/module.cxx index 50c6d53..a8304ff 100644 --- a/libbuild2/module.cxx +++ b/libbuild2/module.cxx @@ -304,7 +304,7 @@ namespace build2 } assert (tgs.size () == 1); - const target& l (tgs[0].as_target ()); + const target& l (tgs[0].as ()); if (!l.is_a ("libs")) fail (loc) << "wrong export from build system module " << mod; diff --git a/libbuild2/operation.cxx b/libbuild2/operation.cxx index a9b6107..86cd571 100644 --- a/libbuild2/operation.cxx +++ b/libbuild2/operation.cxx @@ -136,7 +136,7 @@ namespace build2 if (ts.empty ()) return; - context& ctx (ts[0].as_target ().ctx); + context& ctx (ts[0].as ().ctx); { phase_lock l (ctx, run_phase::match); @@ -176,7 +176,7 @@ namespace build2 for (; i != n; ++i) { - const target& t (ts[i].as_target ()); + const target& t (ts[i].as ()); l5 ([&]{trace << diag_doing (a, t);}); target_state s (match_async (a, t, 0, task_count, false)); @@ -208,7 +208,7 @@ namespace build2 for (size_t j (0); j != n; ++j) { action_target& at (ts[j]); - const target& t (at.as_target ()); + const target& t (at.as ()); target_state s (j < i ? match (a, t, false) @@ -264,7 +264,7 @@ namespace build2 if (ts.empty ()) return; - context& ctx (ts[0].as_target ().ctx); + context& ctx (ts[0].as ().ctx); // Reverse the order of targets if the execution mode is 'last'. // @@ -338,7 +338,7 @@ namespace build2 for (const action_target& at: ts) { - const target& t (at.as_target ()); + const target& t (at.as ()); l5 ([&]{trace << diag_doing (a, t);}); @@ -389,7 +389,7 @@ namespace build2 bool fail (false); for (action_target& at: ts) { - const target& t (at.as_target ()); + const target& t (at.as ()); switch ((at.state = t.executed_state (a, false))) { @@ -521,7 +521,7 @@ namespace build2 if (i != 0) cout << endl; - const scope& rs (*static_cast (ts[i].target)); + const scope& rs (ts[i].as ()); context& ctx (rs.ctx); diff --git a/libbuild2/operation.hxx b/libbuild2/operation.hxx index 7b6310f..921b77a 100644 --- a/libbuild2/operation.hxx +++ b/libbuild2/operation.hxx @@ -29,16 +29,15 @@ namespace build2 // struct action_target { - using target_type = build2::target; - const void* target = nullptr; target_state state = target_state::unknown; action_target () = default; action_target (const void* t): target (t) {} - const target_type& - as_target () const {return *static_cast (target);} + template + const T& + as () const {return *static_cast (target);} }; class action_targets: public vector diff --git a/libbuild2/parser.cxx b/libbuild2/parser.cxx index ca4f8d5..7b76d18 100644 --- a/libbuild2/parser.cxx +++ b/libbuild2/parser.cxx @@ -213,9 +213,14 @@ namespace build2 void parser:: parse_buildfile (istream& is, const path& p, scope& root, scope& base) { - path_ = &p; + lexer l (is, p); + parse_buildfile (l, root, base); + } - lexer l (is, *path_); + void parser:: + parse_buildfile (lexer& l, scope& root, scope& base) + { + path_ = &l.name (); lexer_ = &l; root_ = &root; scope_ = &base; @@ -224,7 +229,7 @@ namespace build2 prerequisite_ = nullptr; default_target_ = nullptr; - enter_buildfile (p); // Needs scope_. + enter_buildfile (*path_); // Needs scope_. token t; type tt; diff --git a/libbuild2/parser.hxx b/libbuild2/parser.hxx index 8b6179c..04a8e5c 100644 --- a/libbuild2/parser.hxx +++ b/libbuild2/parser.hxx @@ -36,6 +36,9 @@ namespace build2 void parse_buildfile (istream&, const path& name, scope& root, scope& base); + void + parse_buildfile (lexer&, scope& root, scope& base); + buildspec parse_buildspec (istream&, const path& name); diff --git a/libbuild2/utility.cxx b/libbuild2/utility.cxx index 78d2df2..7f40688 100644 --- a/libbuild2/utility.cxx +++ b/libbuild2/utility.cxx @@ -8,7 +8,7 @@ #include // ENOENT #include // strlen(), str[n]cmp() -#include // cerr +#include // cin cout cerr #include #include @@ -100,6 +100,36 @@ namespace build2 dir_path home; const dir_path* relative_base = &work; + istream& + open_file_or_stdin (const path& f, ifdstream& ifs) + { + if (f.string () != "-") + { + ifs.open (f); + return ifs; + } + else + { + cin.exceptions (ifdstream::failbit | ifdstream::badbit); + return cin; + } + } + + ostream& + open_file_or_stdout (const path& f, ofdstream& ofs) + { + if (f.string () != "-") + { + ofs.open (f); + return ofs; + } + else + { + cout.exceptions (ofdstream::failbit | ofdstream::badbit); + return cout; + } + } + path relative (const path_target& t) { diff --git a/libbuild2/utility.hxx b/libbuild2/utility.hxx index 43b556e..415dc8b 100644 --- a/libbuild2/utility.hxx +++ b/libbuild2/utility.hxx @@ -88,6 +88,19 @@ namespace build2 using butl::eof; + // Open a file or, if the file name is `-`, stdin/stdout. + // + // Note that ofdstream::close() should be called explicitly if not stdout + // (but harmless to call even if it is). Also note that our overload of + // operator<<(path) always translats `-` to `` so care must be taken + // when issuing diagnostics. + // + istream& + open_file_or_stdin (const path&, ifdstream&); + + ostream& + open_file_or_stdout (const path&, ofdstream&); + // Diagnostics state (verbosity level, etc; see ). // // Note on naming of values (here and in the global state below) that come diff --git a/libbuild2/version/init.cxx b/libbuild2/version/init.cxx index 123dc65..c9d5021 100644 --- a/libbuild2/version/init.cxx +++ b/libbuild2/version/init.cxx @@ -221,6 +221,9 @@ namespace build2 // Set all the version.* variables. // + // Note also that we have "gifted" the config.version variable name to + // the config module. + // auto& vp (ctx.var_pool.rw (rs)); auto set = [&vp, &rs] (const char* var, auto val) -- cgit v1.1