diff options
Diffstat (limited to 'build')
37 files changed, 1988 insertions, 955 deletions
diff --git a/build/b.cxx b/build/b.cxx index 11280e1..412fb12 100644 --- a/build/b.cxx +++ b/build/b.cxx @@ -31,6 +31,7 @@ #include <build/diagnostics> #include <build/context> #include <build/utility> +#include <build/variable> #include <build/token> #include <build/lexer> @@ -408,14 +409,14 @@ main (int argc, char* argv[]) // See if the bootstrap process set/changed src_root. // { - auto v (rs.assign ("src_root")); + value& v (rs.assign ("src_root")); if (v) { // If we also have src_root specified by the user, make // sure they match. // - const dir_path& p (v.as<const dir_path&> ()); + const dir_path& p (as<dir_path> (v)); if (src_root.empty ()) src_root = p; @@ -448,7 +449,7 @@ main (int argc, char* argv[]) v = src_root; } - rs.src_path_ = &v.as<const dir_path&> (); + rs.src_path_ = &as<dir_path> (v); } // At this stage we should have both roots and out_base figured @@ -468,9 +469,9 @@ main (int argc, char* argv[]) // Why don't we support it? Because things are already complex // enough here. // - if (auto v = rs.vars["subprojects"]) + if (auto l = rs.vars["subprojects"]) { - for (const name& n: v.as<const list_value&> ()) + for (const name& n: *l) { if (n.pair != '\0') continue; // Skip project names. diff --git a/build/bin/module.cxx b/build/bin/module.cxx index e03c658..4c5cca5 100644 --- a/build/bin/module.cxx +++ b/build/bin/module.cxx @@ -25,16 +25,16 @@ namespace build // Default config.bin.*.lib values. // - static const list_value exe_lib (names {name ("shared"), name ("static")}); - static const list_value liba_lib ("static"); - static const list_value libso_lib ("shared"); + static const strings exe_lib {"shared", "static"}; + static const strings liba_lib {"static"}; + static const strings libso_lib {"shared"}; extern "C" void bin_init (scope& r, scope& b, const location&, std::unique_ptr<module>&, - bool) + bool first) { tracer trace ("bin::init"); level4 ([&]{trace << "for " << b.path ();}); @@ -75,6 +75,21 @@ namespace build rs.insert<lib> (install_id, "bin.lib", lib_); } + // Enter module variables. + // + if (first) + { + variable_pool.find ("config.bin.lib", string_type); + variable_pool.find ("config.bin.exe.lib", strings_type); + variable_pool.find ("config.bin.liba.lib", strings_type); + variable_pool.find ("config.bin.libso.lib", strings_type); + + variable_pool.find ("bin.lib", string_type); + variable_pool.find ("bin.exe.lib", strings_type); + variable_pool.find ("bin.liba.lib", strings_type); + variable_pool.find ("bin.libso.lib", strings_type); + } + // Configure. // using config::required; @@ -92,7 +107,7 @@ namespace build // config.bin.lib // { - auto v (b.assign ("bin.lib")); + value& v (b.assign ("bin.lib")); if (!v) v = required (r, "config.bin.lib", "both").first; } @@ -100,7 +115,7 @@ namespace build // config.bin.exe.lib // { - auto v (b.assign ("bin.exe.lib")); + value& v (b.assign ("bin.exe.lib")); if (!v) v = required (r, "config.bin.exe.lib", exe_lib).first; } @@ -108,7 +123,7 @@ namespace build // config.bin.liba.lib // { - auto v (b.assign ("bin.liba.lib")); + value& v (b.assign ("bin.liba.lib")); if (!v) v = required (r, "config.bin.liba.lib", liba_lib).first; } @@ -116,14 +131,14 @@ namespace build // config.bin.libso.lib // { - auto v (b.assign ("bin.libso.lib")); + value& v (b.assign ("bin.libso.lib")); if (!v) v = required (r, "config.bin.libso.lib", libso_lib).first; } // Configure "installability" of our target types. // - install::path<exe> (b, "bin"); // Install into install.bin. + install::path<exe> (b, dir_path ("bin")); // Install into install.bin. // Should shared libraries have executable bit? That depends on // who you ask. In Debian, for example, it should not unless, it @@ -143,9 +158,9 @@ namespace build // // Everyone is happy then? // - install::path<libso> (b, "lib"); // Install into install.lib. + install::path<libso> (b, dir_path ("lib")); // Install into install.lib. - install::path<liba> (b, "lib"); // Install into install.lib. + install::path<liba> (b, dir_path ("lib")); // Install into install.lib. install::mode<liba> (b, "644"); } } diff --git a/build/bin/rule.cxx b/build/bin/rule.cxx index a09bffd..21db183 100644 --- a/build/bin/rule.cxx +++ b/build/bin/rule.cxx @@ -46,7 +46,7 @@ namespace build // Get the library type to build. If not set for a target, this // should be configured at the project scope by init_lib(). // - const string& type (t["bin.lib"].as<const string&> ()); + const string& type (as<string> (*t["bin.lib"])); bool ar (type == "static" || type == "both"); bool so (type == "shared" || type == "both"); @@ -121,7 +121,7 @@ namespace build // prerequisite vs prerequisite_target. // // - const string& type (t["bin.lib"].as<const string&> ()); + const string& type (as<string> (*t["bin.lib"])); bool ar (type == "static" || type == "both"); bool so (type == "shared" || type == "both"); diff --git a/build/buildfile b/build/buildfile index 7522dc2..ce917f6 100644 --- a/build/buildfile +++ b/build/buildfile @@ -8,13 +8,13 @@ config = config/{operation module utility} bin = bin/{target rule module} cxx = cxx/{target compile link install module utility} cli = cli/{target rule module} -test = test/{operation rule module} -install = install/{operation rule module} +test1 = test/{operation rule module} +install1 = install/{operation rule module} exe{b}: cxx{b algorithm name operation spec scope variable target \ prerequisite rule file module context search diagnostics token \ lexer parser path-io utility dump options $config $bin $cxx $cli \ - $test $install} $libs + $test1 $install1} $libs #@@ TODO # diff --git a/build/cli/module.cxx b/build/cli/module.cxx index f112cd4..7702589 100644 --- a/build/cli/module.cxx +++ b/build/cli/module.cxx @@ -78,6 +78,16 @@ namespace build rs.insert<cxx::ixx> (clean_id, "cli.compile", compile_); } + // Enter module variables. + // + if (first) + { + variable_pool.find ("config.cli", string_type); //@@ VAR type + + variable_pool.find ("config.cli.options", strings_type); + variable_pool.find ("cli.options", strings_type); + } + // Configure. // @@ -85,13 +95,13 @@ namespace build // if (first) { - auto r (config::required (root, "config.cli", "cli")); + auto p (config::required (root, "config.cli", "cli")); // If we actually set a new value, test it by trying to execute. // - if (r.second) + if (p.second) { - const string& cli (r.first); + const string& cli (as<string> (p.first)); const char* args[] = {cli.c_str (), "--version", nullptr}; if (verb) @@ -142,8 +152,8 @@ namespace build // cli.* variables. See the cxx module for more information on // this merging semantics and some of its tricky aspects. // - if (auto* v = config::optional<list_value> (root, "config.cli.options")) - base.assign ("cli.options") += *v; + if (const value& v = config::optional (root, "config.cli.options")) + base.assign ("cli.options") += as<strings> (v); } } } diff --git a/build/cli/rule.cxx b/build/cli/rule.cxx index 247b5b4..a892d7c 100644 --- a/build/cli/rule.cxx +++ b/build/cli/rule.cxx @@ -223,7 +223,7 @@ namespace build path rels (relative (s->path ())); scope& rs (t.root_scope ()); - const string& cli (rs["config.cli"].as<const string&> ()); + const string& cli (as<string> (*rs["config.cli"])); cstrings args {cli.c_str ()}; diff --git a/build/config/operation.cxx b/build/config/operation.cxx index a602325..913ae29 100644 --- a/build/config/operation.cxx +++ b/build/config/operation.cxx @@ -81,9 +81,9 @@ namespace build << "# feel free to edit." << endl << "#" << endl; - if (auto v = root.vars["amalgamation"]) + if (auto l = root.vars["amalgamation"]) { - const dir_path& d (v.as<const dir_path&> ()); + const dir_path& d (as<dir_path> (*l)); ofs << "# Base configuration inherited from " << d << endl << "#" << endl; @@ -97,27 +97,23 @@ namespace build ++p.first) { const variable& var (p.first->first); - const value_ptr& pval (p.first->second); + const value& val (p.first->second); // Warn the user if the value that we are saving differs // from the one they specified on the command line. // - if (auto gval = (*global_scope)[var]) + auto l ((*global_scope)[var]); + if (l.defined () && *l != val) { - if (pval == nullptr || !pval->compare (gval.as<const value&> ())) - warn << "variable " << var.name << " configured value " - << "differs from command line value" << - info << "reconfigure the project to use command line value"; + warn << "variable " << var.name << " configured value " + << "differs from command line value" << + info << "reconfigure the project to use command line value"; } - if (pval != nullptr) + if (val) { - //@@ TODO: assuming list - // - const list_value& lv (dynamic_cast<const list_value&> (*pval)); - - ofs << var.name << " = " << lv << endl; - //text << var.name << " = " << lv; + ofs << var.name << " = " << val.data_ << endl; + //text << var.name << " = " << val.data_; } else { @@ -171,14 +167,12 @@ namespace build // Configure subprojects that have been loaded. // - if (auto v = root.vars["subprojects"]) + if (auto l = root.vars["subprojects"]) { - for (const name& n: v.as<const list_value&> ()) + for (auto p: as<subprojects> (*l)) { - if (n.pair != '\0') - continue; // Skip project names. - - dir_path out_nroot (out_root / n.dir); + const dir_path& pd (p.second); + dir_path out_nroot (out_root / pd); scope& nroot (scopes.find (out_nroot)); // @@ Strictly speaking we need to check whether the config @@ -271,30 +265,27 @@ namespace build // Disfigure subprojects. Since we don't load buildfiles during // disfigure, we do it for all known subprojects. // - if (auto v = root.vars["subprojects"]) + if (auto l = root.vars["subprojects"]) { - for (const name& n: v.as<const list_value&> ()) + for (auto p: as<subprojects> (*l)) { - if (n.pair != '\0') - continue; // Skip project names. + const dir_path& pd (p.second); // Create and bootstrap subproject's root scope. // - dir_path out_nroot (out_root / n.dir); + dir_path out_nroot (out_root / pd); // The same logic for src_root as in create_bootstrap_inner(). // scope& nroot (create_root (out_nroot, dir_path ())); bootstrap_out (nroot); - auto val (nroot.assign ("src_root")); + value& val (nroot.assign ("src_root")); if (!val) - val = is_src_root (out_nroot) - ? out_nroot - : (src_root / n.dir); + val = is_src_root (out_nroot) ? out_nroot : (src_root / pd); - nroot.src_path_ = &val.as<const dir_path&> (); + nroot.src_path_ = &as<dir_path> (val); bootstrap_src (nroot); @@ -304,9 +295,9 @@ namespace build // which means there could be empty parent directories left // behind. Clean them up. // - if (!n.dir.simple () && out_root != src_root) + if (!pd.simple () && out_root != src_root) { - for (dir_path d (n.dir.directory ()); + for (dir_path d (pd.directory ()); !d.empty (); d = d.directory ()) { diff --git a/build/config/utility b/build/config/utility index ef3ceed..82f71fe 100644 --- a/build/config/utility +++ b/build/config/utility @@ -6,15 +6,16 @@ #define BUILD_CONFIG_UTILITY #include <string> -#include <utility> // pair +#include <utility> // pair +#include <functional> // reference_wrapper #include <build/types> +#include <build/variable> #include <build/diagnostics> namespace build { class scope; - class list_value; namespace config { @@ -24,35 +25,36 @@ namespace build // whether the variable has actually been set. // template <typename T> - std::pair<const T&, bool> - required (scope& root, const char* name, const T& default_value); + std::pair<std::reference_wrapper<const value>, bool> + required (scope& root, const variable&, const T& default_value); template <typename T> - inline std::pair<const T&, bool> + inline std::pair<std::reference_wrapper<const value>, bool> required (scope& root, const std::string& name, const T& default_value) { - return required<T> (root, name.c_str (), default_value); + return required (root, variable_pool.find (name), default_value); } - std::pair<const std::string&, bool> - required (scope& root, const char* name, const char* default_value); + inline std::pair<std::reference_wrapper<const value>, bool> + required (scope& root, const std::string& name, const char* default_value) + { + return required (root, name, std::string (default_value)); + } // Set, if necessary, an optional config.* variable. In particular, // an unspecified variable is set to NULL which is used to distinguish // between the "configured as unspecified" and "not yet configured" // cases. // - // Return the pointer to the value, which can be NULL. + // Return the value, which can be NULL. // - template <typename T> - const T* - optional (scope& root, const char* name); + const value& + optional (scope& root, const variable& var); - template <typename T> - inline const T* + inline const value& optional (scope& root, const std::string& name) { - return optional<T> (root, name.c_str ()); + return optional (root, variable_pool.find (name)); } // Check whether there are any variables specified from the @@ -60,8 +62,8 @@ namespace build // are any, say, config.install.* values. If there are none, // then we can assume this functionality is not (yet) used // and omit writing a whole bunch of NULL config.install.* - // values to config.build. We call it omitted/delayed - // configuration. + // values to the config.build file . We call it omitted/ + // delayed configuration. // bool specified (scope& root, const std::string& ns); @@ -70,19 +72,20 @@ namespace build // // Add all the values from a variable to the C-string list. T is - // either target or scope. + // either target or scope. The variable is expected to be of type + // strings. // template <typename T> void append_options (cstrings& args, T& s, const char* var); - // As above but from the list value directly. Variable name is for - // diagnostics. + // As above but from the strings value directly. // void - append_options (cstrings& args, const list_value&, const char* var); + append_options (cstrings& args, const const_strings_value&); - // Check if a specified option is present. T is either target or scope. + // Check if a specified option is present in the variable value. + // T is either target or scope. // template <typename T> bool @@ -91,5 +94,6 @@ namespace build } #include <build/config/utility.txx> +#include <build/config/utility.ixx> #endif // BUILD_CONFIG_UTILITY diff --git a/build/config/utility.cxx b/build/config/utility.cxx index e2afc80..ce723fe 100644 --- a/build/config/utility.cxx +++ b/build/config/utility.cxx @@ -10,32 +10,14 @@ namespace build { namespace config { - // The same as the template except it is a bit more efficient - // when it comes to not creating the default value string - // unnecessarily. - // - pair<const string&, bool> - required (scope& root, const char* name, const char* def_value) + const value& + optional (scope& root, const variable& var) { - string r; - const variable& var (variable_pool.find (name)); + auto l (root[var]); - if (auto v = root[var]) - { - const string& s (v.as<const string&> ()); - - if (!v.belongs (*global_scope)) // A value from (some) config.build. - return pair<const string&, bool> (s, false); - - r = s; - } - else - r = def_value; - - auto v (root.assign (var)); - v = move (r); - - return pair<const string&, bool> (v.as<const string&> (), true); + return l.defined () + ? l.belongs (*global_scope) ? (root.assign (var) = *l) : *l + : root.assign (var); // NULL } bool @@ -54,17 +36,14 @@ namespace build } void - append_options (cstrings& args, const list_value& lv, const char* var) + append_options (cstrings& args, const const_strings_value& sv) { - for (const name& n: lv) + if (!sv.empty ()) { - if (n.simple ()) - args.push_back (n.value.c_str ()); - else if (n.directory ()) - args.push_back (n.dir.string ().c_str ()); - else - fail << "expected option instead of " << n << - info << "in variable " << var; + args.reserve (args.size () + sv.size ()); + + for (const string& s: sv) + args.push_back (s.c_str ()); } } } diff --git a/build/config/utility.ixx b/build/config/utility.ixx new file mode 100644 index 0000000..4e32119 --- /dev/null +++ b/build/config/utility.ixx @@ -0,0 +1,17 @@ +// file : build/config/utility.ixx -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +namespace build +{ + namespace config + { + template <typename T> + inline void + append_options (cstrings& args, T& s, const char* var) + { + if (auto l = s[var]) + append_options (args, as<strings> (*l)); + } + } +} diff --git a/build/config/utility.txx b/build/config/utility.txx index cffdecf..943d308 100644 --- a/build/config/utility.txx +++ b/build/config/utility.txx @@ -2,79 +2,37 @@ // copyright : Copyright (c) 2014-2015 Code Synthesis Ltd // license : MIT; see accompanying LICENSE file -#include <utility> // move() - #include <build/scope> -#include <build/variable> namespace build { namespace config { template <typename T> - std::pair<const T&, bool> - required (scope& root, const char* name, const T& def_value) - { - T r; - const variable& var (variable_pool.find (name)); - - if (auto v = root[var]) - { - const T& s (v.as<const T&> ()); - - if (!v.belongs (*global_scope)) // A value from (some) config.build. - return std::pair<const T&, bool> (s, false); - - r = s; - } - else - r = def_value; - - auto v (root.assign (var)); - v = std::move (r); - - return std::pair<const T&, bool> (v.as<const T&> (), true); - } - - template <typename T> - const T* - optional (scope& root, const char* name) + std::pair<std::reference_wrapper<const value>, bool> + required (scope& root, const variable& var, const T& def_value) { - const T* r (nullptr); - const variable& var (variable_pool.find (name)); + using result = std::pair<std::reference_wrapper<const value>, bool>; - auto v (root[var]); - - if (v.defined ()) + if (auto l = root[var]) { - if (v.belongs (*global_scope)) - root.assign (var) = v; - - r = v.null () ? nullptr : &v.as<const T&> (); + return l.belongs (*global_scope) + ? result (root.assign (var) = *l, true) + : result (*l, false); } else - root.assign (var) = nullptr; - - return r; - } - - template <typename T> - void - append_options (cstrings& args, T& s, const char* var) - { - if (auto val = s[var]) - append_options (args, val.template as<const list_value&> (), var); + return result (root.assign (var) = def_value, true); } template <typename T> bool find_option (const char* option, T& s, const char* var) { - if (auto val = s[var]) + if (auto l = s[var]) { - for (const name& n: val.template as<const list_value&> ()) + for (const std::string& s: as<strings> (*l)) { - if (n.simple () && n.value == option) + if (s == option) return true; } } diff --git a/build/context.cxx b/build/context.cxx index 259c6ea..530ac7a 100644 --- a/build/context.cxx +++ b/build/context.cxx @@ -57,7 +57,20 @@ namespace build // Enter builtin variables. // - variable_pool.insert (variable ("subprojects", '=')); + variable_pool.find ("work", dir_path_type); + variable_pool.find ("home", dir_path_type); + + variable_pool.find ("src_root", dir_path_type); + variable_pool.find ("out_root", dir_path_type); + variable_pool.find ("src_base", dir_path_type); + variable_pool.find ("out_base", dir_path_type); + + variable_pool.find ("project", string_type); + variable_pool.find ("amalgamation", dir_path_type); + + // Shouldn't be typed since the value requires pre-processing. + // + variable_pool.find ("subprojects", nullptr, '='); // Create global scope. For Win32 we use the empty path since there // is no "real" root path. On POSIX, however, this is a real path. diff --git a/build/cxx/compile.cxx b/build/cxx/compile.cxx index 8dcad1e..65806ed 100644 --- a/build/cxx/compile.cxx +++ b/build/cxx/compile.cxx @@ -166,23 +166,23 @@ namespace build { ext_map m; - if (auto val = r["h.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &h::static_type; + if (auto l = r["h.ext"]) + m[&extension_pool.find (as<string> (*l))] = &h::static_type; - if (auto val = r["c.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &c::static_type; + if (auto l = r["c.ext"]) + m[&extension_pool.find (as<string> (*l))] = &c::static_type; - if (auto val = r["hxx.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &hxx::static_type; + if (auto l = r["hxx.ext"]) + m[&extension_pool.find (as<string> (*l))] = &hxx::static_type; - if (auto val = r["ixx.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &ixx::static_type; + if (auto l = r["ixx.ext"]) + m[&extension_pool.find (as<string> (*l))] = &ixx::static_type; - if (auto val = r["txx.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &txx::static_type; + if (auto l = r["txx.ext"]) + m[&extension_pool.find (as<string> (*l))] = &txx::static_type; - if (auto val = r["cxx.ext"]) - m[&extension_pool.find (val.as<const string&> ())] = &cxx::static_type; + if (auto l = r["cxx.ext"]) + m[&extension_pool.find (as<string> (*l))] = &cxx::static_type; return m; } @@ -215,26 +215,24 @@ namespace build const dir_path& out_base (t.dir); const dir_path& out_root (rs->path ()); - if (auto val = t[var]) + if (auto l = t[var]) { - const list_value& l (val.template as<const list_value&> ()); + const auto& v (as<strings> (*l)); - // Assume the names have already been vetted by append_options(). - // - for (auto i (l.begin ()), e (l.end ()); i != e; ++i) + for (auto i (v.begin ()), e (v.end ()); i != e; ++i) { - // -I can either be in the -Ifoo or -I foo form. + // -I can either be in the "-Ifoo" or "-I foo" form. // dir_path d; - if (i->value == "-I") + if (*i == "-I") { if (++i == e) break; // Let the compiler complain. - d = i->simple () ? dir_path (i->value) : i->dir; + d = dir_path (*i); } - else if (i->value.compare (0, 2, "-I") == 0) - d = dir_path (i->value, 2, string::npos); + else if (i->compare (0, 2, "-I") == 0) + d = dir_path (*i, 2, string::npos); else continue; @@ -368,7 +366,7 @@ namespace build tracer trace ("cxx::compile::inject_prerequisites"); scope& rs (t.root_scope ()); - const string& cxx (rs["config.cxx"].as<const string&> ()); + const string& cxx (as<string> (*rs["config.cxx"])); cstrings args {cxx.c_str ()}; @@ -715,7 +713,7 @@ namespace build path rels (relative (s->path ())); scope& rs (t.root_scope ()); - const string& cxx (rs["config.cxx"].as<const string&> ()); + const string& cxx (as<string> (*rs["config.cxx"])); cstrings args {cxx.c_str ()}; diff --git a/build/cxx/link.cxx b/build/cxx/link.cxx index 97c9696..1b900c2 100644 --- a/build/cxx/link.cxx +++ b/build/cxx/link.cxx @@ -59,10 +59,10 @@ namespace build case type::so: var = "bin.libso.lib"; break; } - const list_value& lv (t[var].as<const list_value&> ()); - return lv[0].value == "shared" - ? lv.size () > 1 && lv[1].value == "static" ? order::so_a : order::so - : lv.size () > 1 && lv[1].value == "shared" ? order::a_so : order::a; + const auto& v (as<strings> (*t[var])); + return v[0] == "shared" + ? v.size () > 1 && v[1] == "static" ? order::so_a : order::so + : v.size () > 1 && v[1] == "shared" ? order::a_so : order::a; } link::search_paths link:: @@ -73,32 +73,24 @@ namespace build // Extract user-supplied search paths (i.e., -L). // - if (auto val = bs["cxx.loptions"]) + if (auto l = bs["cxx.loptions"]) { - const list_value& l (val.as<const list_value&> ()); + const auto& v (as<strings> (*l)); - for (auto i (l.begin ()), e (l.end ()); i != e; ++i) + for (auto i (v.begin ()), e (v.end ()); i != e; ++i) { - if (!i->simple ()) - continue; - - // -L can either be in the -Lfoo or -L foo form. + // -L can either be in the "-Lfoo" or "-L foo" form. // dir_path d; - if (i->value == "-L") + if (*i == "-L") { if (++i == e) break; // Let the compiler complain. - if (i->simple ()) - d = dir_path (i->value); - else if (i->directory ()) - d = i->dir; - else - break; // Let the compiler complain. + d = dir_path (*i); } - else if (i->value.compare (0, 2, "-L") == 0) - d = dir_path (i->value, 2, string::npos); + else if (i->compare (0, 2, "-L") == 0) + d = dir_path (*i, 2, string::npos); else continue; @@ -114,7 +106,7 @@ namespace build cstrings args; string std_storage; - args.push_back (rs["config.cxx"].as<const string&> ().c_str ()); + args.push_back (as<string> (*rs["config.cxx"]).c_str ()); append_options (args, bs, "cxx.coptions"); append_std (args, bs, std_storage); append_options (args, bs, "cxx.loptions"); @@ -550,7 +542,7 @@ namespace build // Determine the library type to link. // bool lso (true); - const string& at ((*l)["bin.lib"].as<const string&> ()); + const string& at (as<string> (*(*l)["bin.lib"])); if (!lo) lo = link_order (t); @@ -776,10 +768,8 @@ namespace build } else { - args.push_back (rs["config.cxx"].as<const string&> ().c_str ()); - + args.push_back (as<string> (*rs["config.cxx"]).c_str ()); append_options (args, t, "cxx.coptions"); - append_std (args, t, storage1); if (so) diff --git a/build/cxx/module.cxx b/build/cxx/module.cxx index 042fb53..7f200cd 100644 --- a/build/cxx/module.cxx +++ b/build/cxx/module.cxx @@ -91,6 +91,43 @@ namespace build rs.insert<libso> (install_id, "cxx.install", install::instance); } + // Enter module variables. + // + // @@ Probably should only be done on load; make sure reset() unloads + // modules. + // + // @@ Should probably cache the variable pointers so we don't have + // to keep looking them up. + // + if (first) + { + variable_pool.find ("config.cxx", string_type); //@@ VAR type + + variable_pool.find ("config.cxx.poptions", strings_type); + variable_pool.find ("config.cxx.coptions", strings_type); + variable_pool.find ("config.cxx.loptions", strings_type); + variable_pool.find ("config.cxx.libs", strings_type); + + variable_pool.find ("cxx.poptions", strings_type); + variable_pool.find ("cxx.coptions", strings_type); + variable_pool.find ("cxx.loptions", strings_type); + variable_pool.find ("cxx.libs", strings_type); + + variable_pool.find ("cxx.export.poptions", strings_type); + variable_pool.find ("cxx.export.coptions", strings_type); + variable_pool.find ("cxx.export.loptions", strings_type); + variable_pool.find ("cxx.export.libs", strings_type); + + variable_pool.find ("cxx.std", string_type); + + variable_pool.find ("h.ext", string_type); + variable_pool.find ("c.ext", string_type); + variable_pool.find ("hxx.ext", string_type); + variable_pool.find ("ixx.ext", string_type); + variable_pool.find ("txx.ext", string_type); + variable_pool.find ("cxx.ext", string_type); + } + // Configure. // @@ -104,7 +141,7 @@ namespace build // if (p.second) { - const string& cxx (p.first); + const string& cxx (as<string> (p.first)); const char* args[] = {cxx.c_str (), "-dumpversion", nullptr}; if (verb) @@ -157,27 +194,27 @@ namespace build // using cxx // cxx.coptions += <overriding options> # Note: '+='. // - if (auto* v = config::optional<list_value> (r, "config.cxx.poptions")) - b.assign ("cxx.poptions") += *v; + if (const value& v = config::optional (r, "config.cxx.poptions")) + b.assign ("cxx.poptions") += as<strings> (v); - if (auto* v = config::optional<list_value> (r, "config.cxx.coptions")) - b.assign ("cxx.coptions") += *v; + if (const value& v = config::optional (r, "config.cxx.coptions")) + b.assign ("cxx.coptions") += as<strings> (v); - if (auto* v = config::optional<list_value> (r, "config.cxx.loptions")) - b.assign ("cxx.loptions") += *v; + if (const value& v = config::optional (r, "config.cxx.loptions")) + b.assign ("cxx.loptions") += as<strings> (v); - if (auto* v = config::optional<list_value> (r, "config.cxx.libs")) - b.assign ("cxx.libs") += *v; + if (const value& v = config::optional (r, "config.cxx.libs")) + b.assign ("cxx.libs") += as<strings> (v); // Configure "installability" of our target types. // { using build::install::path; - path<hxx> (b, "include"); // Install into install.include. - path<ixx> (b, "include"); - path<txx> (b, "include"); - path<h> (b, "include"); + path<hxx> (b, dir_path ("include")); // Install into install.include. + path<ixx> (b, dir_path ("include")); + path<txx> (b, dir_path ("include")); + path<h> (b, dir_path ("include")); } } } diff --git a/build/cxx/utility.txx b/build/cxx/utility.txx index 7d9d686..561a54e 100644 --- a/build/cxx/utility.txx +++ b/build/cxx/utility.txx @@ -12,9 +12,9 @@ namespace build void append_std (cstrings& args, T& t, std::string& s) { - if (auto val = t["cxx.std"]) + if (auto l = t["cxx.std"]) { - const std::string& v (val.template as<const string&> ()); + const std::string& v (as<string> (*l)); // Translate 11 to 0x and 14 to 1y for compatibility with // older versions of the compiler. diff --git a/build/dump.cxx b/build/dump.cxx index e426f0b..f3b8c4b 100644 --- a/build/dump.cxx +++ b/build/dump.cxx @@ -19,18 +19,14 @@ using namespace std; namespace build { static void - dump_variable (ostream& os, const variable& var, const value_ptr& val) + dump_variable (ostream& os, const variable& var, const value& val) { os << var.name << " = "; - if (val == nullptr) + if (val.null ()) os << "[null]"; else - { - //@@ TODO: assuming it is a list. - // - os << dynamic_cast<list_value&> (*val); - } + os << val.data_; } static void @@ -5,6 +5,9 @@ #ifndef BUILD_FILE #define BUILD_FILE +#include <map> +#include <string> + #include <build/types> #include <build/variable> // list_value @@ -15,6 +18,8 @@ namespace build class location; class prerequisite_key; + using subprojects = std::map<std::string, dir_path>; + extern const dir_path build_dir; // build extern const dir_path bootstrap_dir; // build/bootstrap @@ -114,7 +119,7 @@ namespace build // there is a package foo available in repository bar. Wanna // download and use it?" // - list_value + names import (scope& base, name, const location&); target& diff --git a/build/file.cxx b/build/file.cxx index e5deecf..b303740 100644 --- a/build/file.cxx +++ b/build/file.cxx @@ -4,7 +4,6 @@ #include <build/file> -#include <map> #include <fstream> #include <utility> // move() @@ -135,13 +134,13 @@ namespace build // consistent. // { - auto v (rs.assign ("out_root")); + value& v (rs.assign ("out_root")); if (!v) v = out_root; else { - const dir_path& p (v.as<const dir_path&> ()); + const dir_path& p (as<dir_path> (v)); if (p != out_root) fail << "new out_root " << out_root << " does not match " @@ -151,13 +150,13 @@ namespace build if (!src_root.empty ()) { - auto v (rs.assign ("src_root")); + value& v (rs.assign ("src_root")); if (!v) v = src_root; else { - const dir_path& p (v.as<const dir_path&> ()); + const dir_path& p (as<dir_path> (v)); if (p != src_root) fail << "new src_root " << src_root << " does not match " @@ -188,7 +187,7 @@ namespace build // expected to be the first non-comment line and not to rely on // any variable expansion other than those from the global scope. // - static value_ptr + static value extract_variable (const path& bf, const char* var) { ifstream ifs (bf.string ()); @@ -201,34 +200,32 @@ namespace build { path rbf (diag_relative (bf)); - lexer l (ifs, rbf.string ()); - token t (l.next ()); + lexer lex (ifs, rbf.string ()); + token t (lex.next ()); token_type tt; if (t.type () != token_type::name || t.name () != var || - ((tt = l.next ().type ()) != token_type::equal && + ((tt = lex.next ().type ()) != token_type::equal && tt != token_type::plus_equal)) fail << "variable '" << var << "' expected as first line in " << rbf; parser p; temp_scope tmp (*global_scope); - p.parse_variable (l, tmp, t.name (), tt); + p.parse_variable (lex, tmp, t.name (), tt); - auto val (tmp.vars[var]); - assert (val.defined ()); - value_ptr& vp (val); - return move (vp); // Steal the value, the scope is going away. + auto l (tmp.vars[var]); + assert (l.defined ()); + value& v (*l); + return move (v); // Steal the value, the scope is going away. } catch (const std::ios_base::failure&) { fail << "failed to read from " << bf; } - return nullptr; + return value (); // Never reaches. } - using subprojects = map<string, dir_path>; - // Extract the project name from bootstrap.build. // static string @@ -243,7 +240,7 @@ namespace build // have to discover its src_root. // const dir_path* src_root; - value_ptr src_root_vp; // Need it to live until the end. + value src_root_v; // Need it to live until the end. if (src_hint != nullptr ? *src_hint : is_src_root (out_root)) src_root = &out_root; @@ -255,9 +252,8 @@ namespace build src_root = &fallback_src_root; else { - src_root_vp = extract_variable (f, "src_root"); - value_proxy v (&src_root_vp, nullptr); // Read-only. - src_root = &v.as<const dir_path&> (); + src_root_v = extract_variable (f, "src_root"); + src_root = &as<dir_path> (src_root_v); level4 ([&]{trace << "extracted src_root " << *src_root << " for " << out_root;}); } @@ -265,9 +261,8 @@ namespace build string name; { - value_ptr vp (extract_variable (*src_root / bootstrap_file, "project")); - value_proxy v (&vp, nullptr); // Read-only. - name = move (v.as<string&> ()); + value v (extract_variable (*src_root / bootstrap_file, "project")); + name = move (as<string> (v)); } level4 ([&]{trace << "extracted project name " << name << " for " @@ -367,11 +362,11 @@ namespace build // amalgamated. // { - auto rp (root.vars.assign("amalgamation")); // Set NULL by default. - auto& val (rp.first); + auto rp (root.vars.assign ("amalgamation")); // Set NULL by default. + value& v (rp.first); - if (!val.null () && val.empty ()) // Convert empty to NULL. - val = nullptr; + if (v && v.empty ()) // Convert empty to NULL. + v = nullptr; if (scope* aroot = root.parent_scope ()->root_scope ()) { @@ -383,14 +378,14 @@ namespace build // if (!rp.second) { - if (val.null ()) + if (!v) { fail << out_root << " cannot be amalgamated" << info << "amalgamated by " << ad; } else { - const dir_path& vd (val.as<const dir_path&> ()); + const dir_path& vd (as<dir_path> (v)); if (vd != rd) { @@ -405,7 +400,7 @@ namespace build // Otherwise, use the outer root as our amalgamation. // level4 ([&]{trace << out_root << " amalgamated as " << rd;}); - val = move (rd); + v = move (rd); } } else if (rp.second) @@ -421,7 +416,7 @@ namespace build { dir_path rd (ad.relative (out_root)); level4 ([&]{trace << out_root << " amalgamated as " << rd;}); - val = move (rd); + v = move (rd); } } } @@ -439,8 +434,9 @@ namespace build // the NULL value indicates that we found no subprojects. // { - auto rp (root.vars.assign("subprojects")); // Set NULL by default. - auto& val (rp.first); + const variable& var (variable_pool.find ("subprojects")); + auto rp (root.vars.assign(var)); // Set NULL by default. + value& v (rp.first); if (rp.second) { @@ -459,34 +455,21 @@ namespace build if (out_root != src_root) find_subprojects (sps, src_root, src_root, false); - // Transform our map to list_value. - // - if (!sps.empty ()) - { - list_value_ptr vp (new list_value); - for (auto& p: sps) - { - vp->emplace_back (p.first); - vp->back ().pair = '='; - vp->emplace_back (move (p.second)); - } - val = move (vp); - } + if (!sps.empty ()) // Keep it NULL if no subprojects. + v = move (sps); } - else if (!val.null ()) + else if (v) { // Convert empty to NULL. // - if (val.empty ()) - val = nullptr; + if (v.empty ()) + v = nullptr; else { - // Scan the value and convert it to the "canonical" form, - // that is, a list of dir=simple pairs. + // Pre-scan the value and convert it to the "canonical" form, + // that is, a list of simple=dir pairs. // - list_value& lv (val.as<list_value&> ()); - - for (auto i (lv.begin ()); i != lv.end (); ++i) + for (auto i (v.data_.begin ()); i != v.data_.end (); ++i) { bool p (i->pair != '\0'); @@ -494,25 +477,19 @@ namespace build { // Project name. // - if (!i->simple () || i->empty ()) + if (!assign<string> (*i) || as<string> (*i).empty ()) fail << "expected project name instead of '" << *i << "' in " << "the subprojects variable"; ++i; // Got to have the second half of the pair. } - name& n (*i); - - if (n.simple ()) - { - n.dir = dir_path (move (n.value)); - n.value.clear (); - } - - if (!n.directory ()) - fail << "expected directory instead of '" << n << "' in the " + if (!assign<dir_path> (*i)) + fail << "expected directory instead of '" << *i << "' in the " << "subprojects variable"; + auto& d (as<dir_path> (*i)); + // Figure out the project name if the user didn't specify one. // if (!p) @@ -521,12 +498,18 @@ namespace build // was specified by the user so it is most likely in our // src. // - i = lv.emplace (i, find_project_name (out_root / n.dir, - src_root / n.dir)); + i = v.data_.emplace ( + i, + find_project_name (out_root / d, src_root / d)); + i->pair = '='; ++i; } } + + // Make it of the map type. + // + assign<subprojects> (v, var); } } } @@ -537,12 +520,12 @@ namespace build void create_bootstrap_outer (scope& root) { - auto v (root.vars["amalgamation"]); + auto l (root.vars["amalgamation"]); - if (!v) + if (!l) return; - const dir_path& d (v.as<const dir_path&> ()); + const dir_path& d (as<dir_path> (*l)); dir_path out_root (root.path () / d); out_root.normalize (); @@ -560,21 +543,21 @@ namespace build scope& rs (create_root (out_root, dir_path ())); bootstrap_out (rs); // #3 happens here, if at all. - auto val (rs.assign ("src_root")); + value& v (rs.assign ("src_root")); - if (!val) + if (!v) { if (is_src_root (out_root)) // #2 - val = out_root; + v = out_root; else // #1 { dir_path src_root (root.src_path () / d); src_root.normalize (); - val = move (src_root); + v = move (src_root); } } - rs.src_path_ = &val.as<const dir_path&> (); + rs.src_path_ = &as<dir_path> (v); bootstrap_src (rs); create_bootstrap_outer (rs); @@ -588,9 +571,9 @@ namespace build scope& create_bootstrap_inner (scope& root, const dir_path& out_base) { - if (auto v = root.vars["subprojects"]) + if (auto l = root.vars["subprojects"]) { - for (const name& n: v.as<const list_value&> ()) + for (const name& n: *l) { if (n.pair != '\0') continue; // Skip project names. @@ -605,14 +588,14 @@ namespace build scope& rs (create_root (out_root, dir_path ())); bootstrap_out (rs); - auto val (rs.assign ("src_root")); + value& v (rs.assign ("src_root")); - if (!val) - val = is_src_root (out_root) + if (!v) + v = is_src_root (out_root) ? out_root : (root.src_path () / n.dir); - rs.src_path_ = &val.as<const dir_path&> (); + rs.src_path_ = &as<dir_path> (v); bootstrap_src (rs); @@ -646,8 +629,8 @@ namespace build source_once (bf, root, root); } - list_value - import (scope& ibase, name target, const location& l) + names + import (scope& ibase, name target, const location& loc) { tracer trace ("import"); @@ -659,7 +642,7 @@ namespace build if (target.unqualified ()) { target.proj = &project_name_pool.find (""); - return list_value (move (target)); + return names {move (target)}; } // Otherwise, get the project name and convert the target to @@ -680,14 +663,16 @@ namespace build // for (scope* r (&iroot);; r = r->parent_scope ()->root_scope ()) { - if (auto v = r->vars["subprojects"]) + if (auto l = r->vars["subprojects"]) { - // @@ Map sure would have been handy. - // - if (const name* n = v.as<const list_value&> ().find_pair (project)) + const auto& m (as<subprojects> (*l)); + auto i (m.find (project)); + + if (i != m.end ()) { - out_root = r->path () / n->dir; - fallback_src_root = r->src_path () / n->dir; + const dir_path& d ((*i).second); + out_root = r->path () / d; + fallback_src_root = r->src_path () / d; break; } } @@ -700,42 +685,34 @@ namespace build // if (out_root.empty ()) { - string var ("config.import." + project); + const variable& var ( + variable_pool.find ("config.import." + project, + dir_path_type)); - if (auto v = iroot[var]) + if (auto l = iroot[var]) { - if (!v.belongs (*global_scope)) // A value from (some) config.build. - out_root = v.as<const dir_path&> (); - else + out_root = as<dir_path> (*l); + + if (l.belongs (*global_scope)) // A value from command line. { - // Process the path by making it absolute and normalized. Also, - // for usability's sake, treat a simple name that doesn't end - // with '/' as a directory. + // Process the path by making it absolute and normalized. // - list_value& lv (v.as<list_value&> ()); - - if (lv.size () != 1 || lv[0].empty () || lv[0].typed ()) - fail (l) << "invalid " << var << " value " << lv; - - name& n (lv[0]); - - if (n.directory ()) - out_root = n.dir; - else - out_root = dir_path (n.value); - if (out_root.relative ()) out_root = work / out_root; out_root.normalize (); + + // Set on our root scope (part of our configuration). + // iroot.assign (var) = out_root; // Also update the command-line value. This is necessary to avoid // a warning issued by the config module about global/root scope - // value mismatch. + // value mismatch. Not very clean. // - if (n.dir != out_root) - n = name (out_root); + dir_path& d (as<dir_path> (const_cast<value&> (*l))); + if (d != out_root) + d = out_root; } } else @@ -746,7 +723,7 @@ namespace build // target.proj = &project; level4 ([&]{trace << "postponing " << target;}); - return list_value (move (target)); + return names {move (target)}; } } @@ -761,13 +738,13 @@ namespace build // Check that the bootstrap process set src_root. // - if (auto v = root.vars["src_root"]) + if (auto l = root.vars["src_root"]) { - const dir_path& p (v.as<const dir_path&> ()); + const dir_path& p (as<dir_path> (*l)); if (!src_root.empty () && p != src_root) - fail (l) << "bootstrapped src_root " << p << " does not match " - << "discovered " << src_root; + fail (loc) << "bootstrapped src_root " << p << " does not match " + << "discovered " << src_root; root.src_path_ = &p; } @@ -775,12 +752,12 @@ namespace build // else if (!fallback_src_root.empty ()) { - auto v (root.assign ("src_root")); + value& v (root.assign ("src_root")); v = move (fallback_src_root); - root.src_path_ = &v.as<const dir_path&> (); + root.src_path_ = &as<dir_path> (v); } else - fail (l) << "unable to determine src_root for imported " << project << + fail (loc) << "unable to determine src_root for imported " << project << info << "consider configuring " << out_root; bootstrap_src (root); @@ -807,10 +784,10 @@ namespace build // Also pass the target being imported. // { - auto v (ts.assign ("target")); + value& v (ts.assign ("target")); if (!target.empty ()) // Otherwise leave NULL. - v = list_value {move (target)}; + v = move (target); } // Load the export stub. Note that it is loaded in the context @@ -821,7 +798,7 @@ namespace build path es (root.src_path () / path ("build/export.build")); ifstream ifs (es.string ()); if (!ifs.is_open ()) - fail (l) << "unable to open " << es; + fail (loc) << "unable to open " << es; level4 ([&]{trace << "importing " << es;}); @@ -830,18 +807,18 @@ namespace build try { - p.parse_buildfile (ifs, es, iroot, ts); + // @@ Should we verify these are all unqualified names? Or maybe + // there is a use-case for the export stub to return a qualified + // name? + // + return p.parse_export_stub (ifs, es, iroot, ts); } catch (const std::ios_base::failure&) { - fail (l) << "failed to read from " << es; + fail (loc) << "failed to read from " << es; } - // @@ Should we verify these are all unqualified names? Or maybe - // there is a use-case for the export stub to return a qualified - // name? - // - return p.export_value (); + return names (); // Never reached. } target& diff --git a/build/install/module.cxx b/build/install/module.cxx index 834b0e8..610154a 100644 --- a/build/install/module.cxx +++ b/build/install/module.cxx @@ -29,54 +29,64 @@ namespace build // to set all the install.* values to defaults, as if we had the // default configuration. // + template <typename T> static void - set_dir (bool spec, + set_var (bool spec, scope& r, const char* name, - const char* path, - const char* mode = nullptr, - const char* dir_mode = nullptr, - const char* cmd = nullptr, - const char* options = nullptr) + const char* var, + const T* dv) { - auto set = [spec, &r, name] (const char* var, const char* dv) - { - string vn; - const list_value* lv (nullptr); - - if (spec) - { - vn = "config.install."; - vn += name; - vn += var; - - lv = dv != nullptr - ? &config::required (r, vn, list_value (dv)).first - : config::optional<list_value> (r, vn); - } - - vn = "install."; - vn += name; - vn += var; - auto v (r.assign (vn)); - - if (spec) - { - if (lv != nullptr && !lv->empty ()) - v = *lv; - } - else - { - if (dv != nullptr) - v = dv; - } - }; - - set ("", path); - set (".mode", mode); - set (".dir_mode", dir_mode); - set (".cmd", cmd); - set (".options", options); + string vn; + const value* cv (nullptr); + + if (spec) + { + vn = "config.install."; + vn += name; + vn += var; + const variable& vr ( + variable_pool.find (move (vn), &value_traits<T>::value_type)); + + cv = dv != nullptr + ? &config::required (r, vr, *dv).first.get () + : &config::optional (r, vr); + } + + vn = "install."; + vn += name; + vn += var; + const variable& vr ( + variable_pool.find (move (vn), &value_traits<T>::value_type)); + + value& v (r.assign (vr)); + + if (spec) + { + if (cv != nullptr && *cv && !cv->empty ()) + v = *cv; + } + else + { + if (dv != nullptr) + v = *dv; + } + } + + static void + set_dir (bool s, + scope& r, + const char* name, + const dir_path& path, + const string& fmode = string (), + const string& dmode = string (), + const string& cmd = string ()) + { + set_var (s, r, name, "", path.empty () ? nullptr : &path); + set_var (s, r, name, ".mode", fmode.empty () ? nullptr : &fmode); + set_var (s, r, name, ".dir_mode", dmode.empty () ? nullptr : &dmode); + set_var (s, r, name, ".cmd", cmd.empty () ? nullptr : &cmd); + set_var<strings> (s, r, name, ".options", nullptr); } static rule rule_; @@ -120,6 +130,15 @@ namespace build rs.insert<file> (install_id, "install", rule_); } + // Enter module variables. + // + // Note that the set_dir() calls below enter some more. + // + if (first) + { + variable_pool.find ("install", dir_path_type); + } + // Configuration. // // Note that we don't use any defaults for root -- the location @@ -129,31 +148,31 @@ namespace build if (first) { bool s (config::specified (r, "config.install")); - const string& n (r["project"].as<const string&> ()); + const string& n (as<string> (*r["project"])); - set_dir (s, r, "root", nullptr, nullptr, "755", "install"); - set_dir (s, r, "data_root", "root", "644"); - set_dir (s, r, "exec_root", "root", "755"); + set_dir (s, r, "root", dir_path (), "", "755", "install"); + set_dir (s, r, "data_root", dir_path ("root"), "644"); + set_dir (s, r, "exec_root", dir_path ("root"), "755"); - set_dir (s, r, "sbin", "exec_root/sbin"); - set_dir (s, r, "bin", "exec_root/bin"); - set_dir (s, r, "lib", "exec_root/lib"); - set_dir (s, r, "libexec", ("exec_root/libexec/" + n).c_str ()); + set_dir (s, r, "sbin", dir_path ("exec_root/sbin")); + set_dir (s, r, "bin", dir_path ("exec_root/bin")); + set_dir (s, r, "lib", dir_path ("exec_root/lib")); + set_dir (s, r, "libexec", dir_path ("exec_root/libexec/" + n)); - set_dir (s, r, "data", ("data_root/share/" + n).c_str ()); - set_dir (s, r, "include", "data_root/include"); + set_dir (s, r, "data", dir_path ("data_root/share/" + n)); + set_dir (s, r, "include", dir_path ("data_root/include")); - set_dir (s, r, "doc", ("data_root/share/doc/" + n).c_str ()); - set_dir (s, r, "man", "data_root/share/man"); + set_dir (s, r, "doc", dir_path ("data_root/share/doc/" + n)); + set_dir (s, r, "man", dir_path ("data_root/share/man")); - set_dir (s, r, "man1", "man/man1"); + set_dir (s, r, "man1", dir_path ("man/man1")); } // Configure "installability" for built-in target types. // - path<doc> (b, "doc"); // Install into install.doc. - path<man> (b, "man"); // Install into install.man. - path<man> (b, "man1"); // Install into install.man1. + path<doc> (b, dir_path ("doc")); // Install into install.doc. + path<man> (b, dir_path ("man")); // Install into install.man. + path<man1> (b, dir_path ("man1")); // Install into install.man1. } } } diff --git a/build/install/rule.cxx b/build/install/rule.cxx index f14547c..8f67001 100644 --- a/build/install/rule.cxx +++ b/build/install/rule.cxx @@ -21,48 +21,23 @@ namespace build { namespace install { - // Lookup the install or install.* variable and check that - // the value makes sense. Return NULL if not found or if - // the value is the special 'false' name (which means do - // not install). T is either scope or target. + // Lookup the install or install.* variable. Return NULL if + // not found or if the value is the special 'false' name (which + // means do not install). T is either scope or target. // template <typename T> - static const name* - lookup (T& t, const char* var) + static const dir_path* + lookup (T& t, const string& var) { - auto v (t[var]); + auto l (t[var]); - const name* r (nullptr); + if (!l) + return nullptr; - if (!v) - return r; - - const list_value& lv (v.template as<const list_value&> ()); - - if (lv.empty ()) - return r; - - if (lv.size () == 1) - { - const name& n (lv.front ()); - - if (n.simple () && n.value == "false") - return r; - - if (!n.empty () && (n.simple () || n.directory ())) - return &n; - } - - fail << "expected directory instead of '" << lv << "' in " - << "the " << var << " variable"; - - return r; + const dir_path& r (as<dir_path> (*l)); + return r.simple () && r.string () == "false" ? nullptr : &r; } - template <typename T> - static inline const name* - lookup (T& t, const string& var) {return lookup (t, var.c_str ());} - match_result rule:: match (action a, target& t, const std::string&) const { @@ -185,8 +160,8 @@ namespace build struct install_dir { dir_path dir; - string cmd; - const list_value* options {nullptr}; + string cmd; //@@ VAR type + const_strings_value options {nullptr}; string mode; string dir_mode; }; @@ -200,8 +175,8 @@ namespace build cstrings args {base.cmd.c_str (), "-d"}; - if (base.options != nullptr) - config::append_options (args, *base.options, "install.*.options"); + if (base.options.d != nullptr) //@@ VAR + config::append_options (args, base.options); args.push_back ("-m"); args.push_back (base.dir_mode.c_str ()); @@ -241,8 +216,8 @@ namespace build cstrings args {base.cmd.c_str ()}; - if (base.options != nullptr) - config::append_options (args, *base.options, "install.*.options"); + if (base.options.d != nullptr) //@@ VAR + config::append_options (args, base.options); args.push_back ("-m"); args.push_back (base.mode.c_str ()); @@ -277,10 +252,9 @@ namespace build // creating leading directories as necessary. // static install_dir - resolve (scope& s, const name& n, const string* var = nullptr) + resolve (scope& s, dir_path d, const string* var = nullptr) { install_dir r; - dir_path d (n.simple () ? dir_path (n.value) : n.dir); if (d.absolute ()) { @@ -298,11 +272,11 @@ namespace build // as the installation directory name, e.g., bin, sbin, lib, // etc. Look it up and recurse. // - const string& dn (*d.begin ()); - const string var ("install." + dn); - if (const name* n = lookup (s, var)) + const string& sn (*d.begin ()); + const string var ("install." + sn); + if (const dir_path* dn = lookup (s, var)) { - r = resolve (s, *n, &var); + r = resolve (s, *dn, &var); d = r.dir / dir_path (++d.begin (), d.end ()); d.normalize (); @@ -310,7 +284,7 @@ namespace build install (r, d); // install -d } else - fail << "unknown installation directory name " << dn << + fail << "unknown installation directory name " << sn << info << "did you forget to specify config." << var << "?"; } @@ -320,12 +294,10 @@ namespace build // if (var != nullptr) { - if (auto v = s[*var + ".cmd"]) r.cmd = v.as<const string&> (); - if (auto v = s[*var + ".mode"]) r.mode = v.as<const string&> (); - if (auto v = s[*var + ".dir_mode"]) - r.dir_mode = v.as<const string&> (); - if (auto v = s[*var + ".options"]) - r.options = &v.as<const list_value&> (); + if (auto l = s[*var + ".cmd"]) r.cmd = as<string> (*l); + if (auto l = s[*var + ".mode"]) r.mode = as<string> (*l); + if (auto l = s[*var + ".dir_mode"]) r.dir_mode = as<string> (*l); + if (auto l = s[*var + ".options"]) r.options = as<strings> (*l); } // Set defaults for unspecified components. @@ -351,12 +323,12 @@ namespace build // install_dir d ( resolve (t.base_scope (), - t["install"].as<const name&> ())); // We know it's there. + as<dir_path> (*t["install"]))); // We know it's there. // Override mode if one was specified. // - if (auto v = t["install.mode"]) - d.mode = v.as<const string&> (); + if (auto l = t["install.mode"]) + d.mode = as<string> (*l); install (d, ft); return (r |= target_state::changed); diff --git a/build/install/utility b/build/install/utility index 5c703fc..9bc41f1 100644 --- a/build/install/utility +++ b/build/install/utility @@ -5,7 +5,11 @@ #ifndef BUILD_INSTALL_UTILITY #define BUILD_INSTALL_UTILITY +#include <string> +#include <utility> + #include <build/scope> +#include <build/types> namespace build { @@ -15,20 +19,20 @@ namespace build // template <typename T> inline void - path (scope& s, const char* v) + path (scope& s, dir_path d) { - auto p (s.target_vars[T::static_type]["*"].assign ("install")); - if (p.second) // Already set by the user? - p.first = v; + auto r (s.target_vars[T::static_type]["*"].assign ("install")); + if (r.second) // Already set by the user? + r.first.get () = std::move (d); } template <typename T> inline void - mode (scope& s, const char* v) + mode (scope& s, std::string m) { - auto m (s.target_vars[T::static_type]["*"].assign ("install.mode")); - if (m.second) // Already set by the user? - m.first = v; + auto r (s.target_vars[T::static_type]["*"].assign ("install.mode")); + if (r.second) // Already set by the user? + r.first.get () = std::move (m); } } } @@ -33,11 +33,11 @@ namespace build { name () = default; - explicit - name (std::string v): value (std::move (v)) {} + explicit name (std::string v): value (std::move (v)) {} + name& operator= (std::string v) {return *this = name (std::move (v));} - explicit - name (dir_path d): dir (std::move (d)) {} + explicit name (dir_path d): dir (std::move (d)) {} + name& operator= (dir_path d) {return *this = name (std::move (d));} name (std::string t, std::string v) : type (std::move (t)), value (std::move (v)) {} diff --git a/build/operation.cxx b/build/operation.cxx index 607658f..a92c912 100644 --- a/build/operation.cxx +++ b/build/operation.cxx @@ -67,8 +67,7 @@ namespace build scope& base (scopes[out_base]); base.assign ("out_base") = out_base; - auto v (base.assign ("src_base") = src_base); - base.src_path_ = &v.as<const dir_path&> (); + base.src_path_ = &as<dir_path> (base.assign ("src_base") = src_base); // Load the buildfile unless it has already been loaded. // diff --git a/build/parser b/build/parser index 6eefccd..c6d275b 100644 --- a/build/parser +++ b/build/parser @@ -24,6 +24,8 @@ namespace build class parser { public: + typedef build::names names_type; + parser (): fail (&path_) {} // Issue diagnostics and throw failed in case of an error. @@ -37,19 +39,16 @@ namespace build token parse_variable (lexer&, scope&, std::string name, token_type kind); - list_value - export_value () + names_type + parse_export_stub (std::istream& is, const path& p, scope& r, scope& b) { - list_value r (std::move (export_value_)); - export_value_.clear (); // Empty state. - return r; + parse_buildfile (is, p, r, b); + return std::move (export_value_); } // Recursive descent parser. // private: - typedef build::names names_type; - void clause (token&, token_type&); @@ -139,7 +138,7 @@ namespace build const dir_path* out_root_; const dir_path* src_root_; target* default_target_; - list_value export_value_; + names_type export_value_; token peek_ {token_type::eos, false, 0, 0}; bool peeked_ {false}; diff --git a/build/parser.cxx b/build/parser.cxx index 682a720..c728cb8 100644 --- a/build/parser.cxx +++ b/build/parser.cxx @@ -478,8 +478,8 @@ namespace build // if (src_root_ == nullptr) { - auto v (root_->vars["src_root"]); - src_root_ = v ? &v.as<const dir_path&> () : nullptr; + auto l (root_->vars["src_root"]); + src_root_ = l ? &as<dir_path> (*l) : nullptr; } } @@ -597,8 +597,8 @@ namespace build scope_ = &scopes[out_base]; scope_->assign ("out_base") = move (out_base); - auto v (scope_->assign ("src_base") = move (src_base)); - scope_->src_path_ = &v.as<const dir_path&> (); + scope_->src_path_ = &as<dir_path> ( + scope_->assign ("src_base") = move (src_base)); target* odt (default_target_); default_target_ = nullptr; @@ -641,7 +641,9 @@ namespace build // // import [<var>=](<project>|<project>/<target>])+ // - value_proxy val; + value* val (nullptr); + const build::variable* var (nullptr); + token_type at; // Assignment type. if (tt == type::name) { @@ -649,9 +651,10 @@ namespace build if (at == token_type::equal || at == token_type::plus_equal) { - val.rebind (at == token_type::equal - ? scope_->assign (t.name ()) - : scope_->append (t.name ())); + var = &variable_pool.find (t.name ()); + val = at == token_type::equal + ? &scope_->assign (*var) + : &scope_->append (*var); next (t, tt); // Consume =/+=. next (t, tt); } @@ -669,14 +672,14 @@ namespace build { // build::import() will check the name, if required. // - list_value r (build::import (*scope_, move (n), l)); + names_type r (build::import (*scope_, move (n), l)); - if (val.defined ()) + if (val != nullptr) { if (at == token_type::equal) - val = move (r); + val->assign (move (r), *var); else - val += move (r); + val->append (move (r), *var); } } @@ -701,9 +704,8 @@ namespace build // The rest is a value. Parse it as names to get variable expansion. // build::import() will check the names, if required. // - export_value_ = list_value (tt != type::newline && tt != type::eos - ? names (t, tt) - : names_type ()); + if (tt != type::newline && tt != type::eos) + export_value_ = names (t, tt); if (tt == type::newline) next (t, tt); @@ -785,28 +787,17 @@ namespace build : names_type ()); if (assign) { - auto v (target_ != nullptr - ? target_->assign (var) - : scope_->assign (var)); - v = list_value (move (vns)); + value& v (target_ != nullptr + ? target_->assign (var) + : scope_->assign (var)); + v.assign (move (vns), var); } else { - auto v (target_ != nullptr - ? target_->append (var) - : scope_->append (var)); - - // More efficient than calling operator+=. - // - if (v) - { - list_value& lv (v.as<list_value&> ()); - lv.insert (lv.end (), - make_move_iterator (vns.begin ()), - make_move_iterator (vns.end ())); - } - else - v = list_value (move (vns)); // Same as assignment. + value& v (target_ != nullptr + ? target_->append (var) + : scope_->append (var)); + v.append (move (vns), var); } } @@ -1031,12 +1022,12 @@ namespace build n = t.name (); const auto& var (variable_pool.find (move (n))); - auto val (target_ != nullptr ? (*target_)[var] : (*scope_)[var]); + auto l (target_ != nullptr ? (*target_)[var] : (*scope_)[var]); - // Undefined namespace variables are not allowed. + // Undefined/NULL namespace variables are not allowed. // - if (!val && var.name.find ('.') != string::npos) - fail (t) << "undefined namespace variable " << var.name; + if (!l && var.name.find ('.') != string::npos) + fail (t) << "undefined/null namespace variable " << var.name; if (paren) { @@ -1048,15 +1039,10 @@ namespace build tt = peek (); - if (!val) + if (!l || l->empty ()) continue; - //@@ TODO: assuming it is a list. - // - const list_value& lv (val.as<list_value&> ()); - - if (lv.empty ()) - continue; + const names_type& lv (l->data_); // Should we accumulate? If the buffer is not empty, then // we continue accumulating (the case where we are separated @@ -1077,11 +1063,11 @@ namespace build const name& n (lv[0]); - if (n.proj != nullptr) + if (n.qualified ()) fail (t) << "concatenating expansion of " << var.name << " contains project name"; - if (!n.type.empty ()) + if (n.typed ()) fail (t) << "concatenating expansion of " << var.name << " contains type"; @@ -1452,10 +1438,10 @@ namespace build // to their return values are not guaranteed to be stable (and, // in fact, path()'s is not). // - out_root_ = &root_->vars["out_root"].as<const dir_path&> (); + out_root_ = &as<dir_path> (*root_->vars["out_root"]); - auto v (root_->vars["src_root"]); - src_root_ = v ? &v.as<const dir_path&> () : nullptr; + auto l (root_->vars["src_root"]); + src_root_ = l ? &as<dir_path> (*l) : nullptr; } return r; diff --git a/build/scope b/build/scope index 6edb43a..50c4f6b 100644 --- a/build/scope +++ b/build/scope @@ -68,37 +68,37 @@ namespace build // Lookup, including in outer scopes. If you only want to lookup // in this scope, do it on the the variables map directly. // - value_proxy + lookup<const value> operator[] (const variable&) const; - value_proxy + lookup<const value> operator[] (const std::string& name) const { return operator[] (variable_pool.find (name)); } - // Return a value_proxy suitable for assignment (or append if you - // only want to append to the value from this scope). If the variable - // does not exist in this scope's map, then a new one with the NULL - // value is added and returned. Otherwise the existing value is - // returned. + // Return a value suitable for assignment (or append if you only + // want to append to the value from this scope). If the variable + // does not exist in this scope's map, then a new one with the + // NULL value is added and returned. Otherwise the existing value + // is returned. // - value_proxy - assign (const variable& var) {return vars.assign (var).first;} + value& + assign (const variable& var) {return vars.assign (var).first.get ();} - value_proxy - assign (const std::string& name) {return vars.assign (name).first;} + value& + assign (const std::string& name) {return vars.assign (name).first.get ();} - // Return a value_proxy suitable for appending. If the variable - // does not exist in this scope's map, then outer scopes are - // searched for the same variable. If found then a new variable - // with the found value is added to this scope and returned. - // Otherwise this function proceeds as assign(). + // Return a value suitable for appending. If the variable does not + // exist in this scope's map, then outer scopes are searched for + // the same variable. If found then a new variable with the found + // value is added to this scope and returned. Otherwise this + // function proceeds as assign(). // - value_proxy + value& append (const variable&); - value_proxy + value& append (const std::string& name) { return append (variable_pool.find (name)); diff --git a/build/scope.cxx b/build/scope.cxx index d878726..e6d165e 100644 --- a/build/scope.cxx +++ b/build/scope.cxx @@ -12,30 +12,33 @@ namespace build { // scope // - value_proxy scope:: + lookup<const value> scope:: operator[] (const variable& var) const { - for (const scope* s (this); s != nullptr; s = s->parent_scope ()) + const value* r (nullptr); + const scope* s (this); + + for (; s != nullptr; s = s->parent_scope ()) { - if (const value_ptr* v = s->vars.find (var)) - return value_proxy (v, &s->vars); + if ((r = s->vars.find (var)) != nullptr) + break; } - return value_proxy (); + return lookup<const value> (r, &s->vars); } - value_proxy scope:: + value& scope:: append (const variable& var) { - value_proxy val (operator[] (var)); + auto l (operator[] (var)); - if (val && val.belongs (*this)) // Existing variable in this scope. - return val; + if (l && l.belongs (*this)) // Existing variable in this scope. + return const_cast<value&> (*l); - value_proxy r (assign (var)); + value& r (assign (var)); - if (val) - r = val; // Copy value from the outer scope. + if (l) + r = *l; // Copy value from the outer scope. return r; } diff --git a/build/target b/build/target index 9e15550..2c05ea1 100644 --- a/build/target +++ b/build/target @@ -262,33 +262,33 @@ namespace build // Lookup, including in groups to which this target belongs and // then in outer scopes (including target type/pattern-specific // variables). If you only want to lookup in this target, do it - // on the the variable map directly. + // on the variable map directly. // - value_proxy + lookup<const value> operator[] (const variable&) const; - value_proxy + lookup<const value> operator[] (const std::string& name) const { return operator[] (variable_pool.find (name)); } - // Return a value_proxy suitable for assignment. See class scope - // for details. + // Return a value suitable for assignment. See class scope for + // details. // - value_proxy + value& assign (const variable& var) {return vars.assign (var).first;} - value_proxy + value& assign (const std::string& name) {return vars.assign (name).first;} - // Return a value_proxy suitable for appending. See class scope - // for details. + // Return a value suitable for appending. See class scope for + // details. // - value_proxy + value& append (const variable&); - value_proxy + value& append (const std::string& name) { return append (variable_pool.find (name)); diff --git a/build/target.cxx b/build/target.cxx index aaf8a5e..6315d04 100644 --- a/build/target.cxx +++ b/build/target.cxx @@ -116,16 +116,18 @@ namespace build return *r; } - value_proxy target:: + lookup<const value> target:: operator[] (const variable& var) const { + using result = lookup<const value>; + if (auto p = vars.find (var)) - return value_proxy (p, &vars); + return result (p, &vars); if (group != nullptr) { if (auto p = group->vars.find (var)) - return value_proxy (p, &group->vars); + return result (p, &group->vars); } // Cannot simply delegate to scope's operator[] since we also @@ -135,7 +137,7 @@ namespace build { if (!s->target_vars.empty ()) { - auto find_specific = [&var, s] (const target& t) -> value_proxy + auto find_specific = [&var, s] (const target& t) -> result { // Search across target type hierarchy. // @@ -154,10 +156,10 @@ namespace build continue; if (auto p = j->second.find (var)) - return value_proxy (p, &j->second); + return result (p, &j->second); } - return value_proxy (); + return result (); }; if (auto p = find_specific (*this)) @@ -171,24 +173,24 @@ namespace build } if (auto p = s->vars.find (var)) - return value_proxy (p, &s->vars); + return result (p, &s->vars); } - return value_proxy (); + return result (); } - value_proxy target:: + value& target:: append (const variable& var) { - value_proxy val (operator[] (var)); + auto l (operator[] (var)); - if (val && val.belongs (*this)) // Existing variable in this target. - return val; + if (l && l.belongs (*this)) // Existing variable in this target. + return const_cast<value&> (*l); - value_proxy r (assign (var)); + value& r (assign (var)); - if (val) - r = val; // Copy value from the outer scope. + if (l) + r = *l; // Copy value from the outer scope. return r; } diff --git a/build/target.txx b/build/target.txx index bded149..a293018 100644 --- a/build/target.txx +++ b/build/target.txx @@ -20,9 +20,9 @@ namespace build const std::string& target_extension_var (const target_key& tk, scope& s) { - auto val (s[var]); + auto l (s[var]); - if (!val) + if (!l) { diag_record dr; dr << fail << "no default extension in variable " << var @@ -42,6 +42,6 @@ namespace build } } - return extension_pool.find (val.as<const std::string&> ()); + return extension_pool.find (as<std::string> (*l)); } } diff --git a/build/test/module.cxx b/build/test/module.cxx index cba930f..9495275 100644 --- a/build/test/module.cxx +++ b/build/test/module.cxx @@ -59,6 +59,18 @@ namespace build // rs.insert<target> (test_id, "test", rule_); } + + // Enter module variables. + // + if (first) + { + variable_pool.find ("test", bool_type); + variable_pool.find ("test.input", name_type); + variable_pool.find ("test.output", name_type); + variable_pool.find ("test.roundtrip", name_type); + variable_pool.find ("test.options", strings_type); + variable_pool.find ("test.arguments", strings_type); + } } } } diff --git a/build/test/rule.cxx b/build/test/rule.cxx index 10b628d..eecd613 100644 --- a/build/test/rule.cxx +++ b/build/test/rule.cxx @@ -11,6 +11,8 @@ #include <build/algorithm> #include <build/diagnostics> +#include <build/config/utility> // add_options() + using namespace std; using namespace butl; @@ -28,7 +30,7 @@ namespace build // this is a test. So take care of that as well. // bool r (false); - value_proxy v; + lookup<const value> l; // @@ This logic doesn't take into account target type/pattern- // specific variables. @@ -40,13 +42,13 @@ namespace build ++p.first) { const variable& var (p.first->first); - const value_ptr& val (p.first->second); + const value& val (p.first->second); // If we have test, then always use that. // if (var.name == "test") { - v.rebind (value_proxy (val, t)); + l = lookup<const value> (val, t); break; } @@ -68,10 +70,11 @@ namespace build { // See if there is a scope variable. // - if (!v) - v.rebind (t.base_scope ()[string("test.") + t.type ().name]); + if (!l.defined ()) + l = t.base_scope ()[ + variable_pool.find (string("test.") + t.type ().name, bool_type)]; - r = v && v.as<bool> (); + r = l && as<bool> (*l); } // If this is the update pre-operation, then all we really need to @@ -129,50 +132,47 @@ namespace build // First check the target-specific vars since they override any // scope ones. // - auto iv (t.vars["test.input"]); - auto ov (t.vars["test.output"]); - auto rv (t.vars["test.roundtrip"]); - - // Can either be input or arguments. - // - auto av (t.vars["test.arguments"]); + auto il (t.vars["test.input"]); + auto ol (t.vars["test.output"]); + auto rl (t.vars["test.roundtrip"]); + auto al (t.vars["test.arguments"]); // Should be input or arguments. - if (av) + if (al) { - if (iv) + if (il) fail << "both test.input and test.arguments specified for " << "target " << t; - if (rv) + if (rl) fail << "both test.roundtrip and test.arguments specified for " << "target " << t; } scope& bs (t.base_scope ()); - if (!iv && !ov && !rv) + if (!il && !ol && !rl) { string n ("test."); n += t.type ().name; - const variable& in (variable_pool.find (n + ".input")); - const variable& on (variable_pool.find (n + ".output")); - const variable& rn (variable_pool.find (n + ".roundtrip")); + const variable& in (variable_pool.find (n + ".input", name_type)); + const variable& on (variable_pool.find (n + ".output", name_type)); + const variable& rn (variable_pool.find (n + ".roundtrip", name_type)); // We should only keep value(s) that were specified together // in the innermost scope. // for (scope* s (&bs); s != nullptr; s = s->parent_scope ()) { - ov.rebind (s->vars[on]); + ol = s->vars[on]; - if (!av) // Not overriden at target level by test.arguments? + if (!al) // Not overriden at target level by test.arguments? { - iv.rebind (s->vars[in]); - rv.rebind (s->vars[rn]); + il = s->vars[in]; + rl = s->vars[rn]; } - if (iv || ov || rv) + if (il || ol || rl) break; } } @@ -182,18 +182,18 @@ namespace build // Reduce the roundtrip case to input/output. // - if (rv) + if (rl) { - if (iv || ov) + if (il || ol) fail << "both test.roundtrip and test.input/output specified " << "for target " << t; - in = on = rv.as<const name*> (); + in = on = &as<name> (*rl); } else { - in = iv ? iv.as<const name*> () : nullptr; - on = ov ? ov.as<const name*> () : nullptr; + in = il ? &as<name> (*il) : nullptr; + on = ol ? &as<name> (*ol) : nullptr; } // Resolve them to targets, which normally would be existing files @@ -283,35 +283,24 @@ namespace build } static void - add_arguments (cstrings& args, target& t, const char* n) + add_arguments (cstrings& args, const target& t, const char* n) { string var ("test."); var += n; - auto v (t.vars[var]); + auto l (t.vars[var]); - if (!v) + if (!l) { var.resize (5); var += t.type ().name; var += '.'; var += n; - v.rebind (t.base_scope ()[var]); + l = t.base_scope ()[variable_pool.find (var, strings_type)]; } - if (v) - { - for (const name& n: v.as<const list_value&> ()) - { - if (n.simple ()) - args.push_back (n.value.c_str ()); - else if (n.directory ()) - args.push_back (n.dir.string ().c_str ()); - else - fail << "expected argument instead of " << n << - info << "in variable " << var; - } - } + if (l) + config::append_options (args, as<strings> (*l)); } // The format of args shall be: diff --git a/build/variable b/build/variable index bc78289..3bd8922 100644 --- a/build/variable +++ b/build/variable @@ -6,13 +6,14 @@ #define BUILD_VARIABLE #include <map> +#include <vector> #include <string> -#include <memory> // unique_ptr #include <cstddef> // nullptr_t #include <utility> // move(), pair, make_pair() #include <cassert> +#include <iterator> #include <functional> // hash, reference_wrapper -#include <typeindex> +#include <type_traits> // conditional, is_reference, remove_reference, etc. #include <unordered_set> #include <butl/prefix-map> @@ -22,12 +23,18 @@ namespace build { - struct value; + struct variable; + // If assign is NULL, then the value is assigned as is. If append + // is NULL, then the names are appended to the end of the value + // and assign is called, if not NULL. Variable is provided primarily + // for diagnostics. Return true if the resulting value is not empty. + // struct value_type { - std::type_index id; - value* (*const factory) (); + const std::string name; + bool (*const assign) (names&, const variable&); + bool (*const append) (names&, names, const variable&); }; // variable @@ -37,11 +44,12 @@ namespace build struct variable { explicit - variable (std::string n, char p = '\0'): name (std::move (n)), pairs (p) {} + variable (std::string n, const value_type* t = nullptr, char p = '\0') + : name (std::move (n)), pairs (p), type (t) {} std::string name; char pairs; - //const value_type* type = nullptr; // If NULL, then no fixed type. + const value_type* type; // If NULL, then not (yet) typed. }; inline bool @@ -51,119 +59,121 @@ namespace build // value // - struct value; - typedef std::unique_ptr<value> value_ptr; - - struct value + class value { public: - virtual value_ptr - clone () const = 0; + // By default we create NULL value. + // + explicit value (const value_type* t = nullptr) + : type (t), state_ (state_type::null) {} - virtual bool - compare (const value&) const = 0; + value (value&&) = default; - virtual - ~value () = default; - }; - - class list_value: public value, public names - { - public: - using names::names; - - list_value () = default; - explicit list_value (names d): names (std::move (d)) {} - explicit list_value (name n) {emplace_back (std::move (n));} - explicit list_value (dir_path d) {emplace_back (std::move (d));} - explicit list_value (std::string s) {emplace_back (std::move (s));} - explicit list_value (const char* s) {emplace_back (s);} + value& + operator= (std::nullptr_t) + { + data_.clear (); + state_ = state_type::null; + return *this; + } - virtual value_ptr - clone () const {return value_ptr (new list_value (*this));} + value& + operator= (value&&); - virtual bool - compare (const value& v) const + value& + operator= (const value& v) { - const list_value* lv (dynamic_cast<const list_value*> (&v)); - return lv != nullptr && static_cast<const names&> (*this) == *lv; + if (&v != this) + *this = value (v); + return *this; } - // Pair (i.e., key-value) search. Note that this funtion assumes - // the list contains only pairs and keys are simple names. Returns - // NULL if not found. - // - const name* - find_pair (const std::string& key) const + value& + operator= (std::reference_wrapper<const value> v) { - for (auto i (begin ()); i != end (); i += 2) - if (i->value == key) - return &*++i; - return nullptr; + return *this = v.get (); } - }; - typedef std::unique_ptr<list_value> list_value_ptr; - // value_proxy - // - // A variable can be undefined, null, or contain some actual value. - // Note that once value_proxy is bound to a value, the only way to - // rebind it to a different value is by using explicit rebind(). In - // particular, assigning one value proxy to another will assing the - // values. - // - struct variable_map; + value& + append (value, const variable&); // Aka operator+=(). - struct value_proxy - { - bool - defined () const {return p != nullptr;} + // Forwarded to the representation type's assign()/append() (see below). + // + template <typename T> value& operator= (T); + value& operator= (const char* v) {return *this = std::string (v);} - bool - null () const {return *p == nullptr;} + template <typename T> value& operator+= (T); + value& operator+= (const char* v) {return *this += std::string (v);} - bool - empty () const; + private: + explicit value (const value&) = default; + + public: + const value_type* type; // NULL means this value is not (yet) typed. - explicit operator bool () const {return defined () && !null ();} - explicit operator value_ptr& () const {return *p;} + bool null () const {return state_ == state_type::null;} + bool empty () const {return state_ == state_type::empty;} - // Get interface. See available specializations below. + explicit operator bool () const {return !null ();} + + // Raw data read interface. // - template <typename T> - T - as () const; + using const_iterator = names::const_iterator; + + const_iterator begin () const {return data_.begin ();} + const_iterator end () const {return data_.end ();} - // Assign. + // Raw data write interface. Note that it triggers callbacks for + // typed values. Variable is passed for diagnostics. // - const value_proxy& - operator= (value_ptr) const; + void + assign (names, const variable&); - const value_proxy& - operator= (const value_proxy&) const; + void + append (names, const variable&); - const value_proxy& - operator= (list_value) const; + public: + // Don't use directly except in the implementation of representation + // types, in which case take care to update state. + // + enum class state_type {null, empty, filled} state_; + names data_; + }; - const value_proxy& - operator= (std::string) const; + //@@ Right now we assume that for each value type each value has a + // unique representation. This is currently not the case for map. + // + inline bool + operator== (const value& x, const value& y) + { + return x.state_ == y.state_ && x.data_ == y.data_; + } + + inline bool + operator!= (const value& x, const value& y) {return !(x == y);} + + // lookup + // + // A variable can be undefined, NULL, or contain a (potentially + // empty) value. + // + struct variable_map; - const value_proxy& - operator= (dir_path) const; + template <typename V> + struct lookup + { + V* value; + const variable_map* vars; - const value_proxy& - operator= (std::nullptr_t) const; + bool + defined () const {return value != nullptr;} - // Append. + // Note: returns true if defined and not NULL. // - const value_proxy& - operator+= (const value_proxy&) const; + explicit operator bool () const {return defined () && !value->null ();} - const value_proxy& - operator+= (const list_value&) const; - - const value_proxy& - operator+= (std::string) const; // Append simple name to list_value. + V& operator* () const {return *value;} + V* operator-> () const {return value;} // Return true if this value belongs to the specified scope or target. // Note that it can also be a target type/pattern-specific value. @@ -172,92 +182,395 @@ namespace build bool belongs (const T& x) const {return vars == &x.vars;} - // Implementation details. - // - const variable_map* vars; // Variable map to which this value belongs. - - value_proxy (): vars (nullptr), p (nullptr) {} - value_proxy (value_ptr* p, const variable_map* v) - : vars (p != nullptr ? v : nullptr), p (p) {} + lookup (): value (nullptr), vars (nullptr) {} + lookup (V* v, const variable_map* vs) + : value (v), vars (v != nullptr ? vs : nullptr) {} template <typename T> - value_proxy (value_ptr& p, const T& x) - : value_proxy (&p, &x.vars) {} + lookup (V& v, const T& x): lookup (&v, &x.vars) {} + }; + + // Representation types. + // + template <typename T> struct value_traits; + + // Assign value type to the value. + // + template <typename T> + void assign (value&, const variable&); + void assign (value&, const value_type*, const variable&); - // @@ To do this properly we seem to need ro_value_proxy? + template <typename T> typename value_traits<T>::type as (value&); + template <typename T> typename value_traits<T>::const_type as (const value&); + + // "Assign" simple value type to the value stored in name. Return false + // if the value is not valid for this type. + // + template <typename T> bool assign (name&); + + template <typename T> typename value_traits<T>::type as (name&); + template <typename T> typename value_traits<T>::const_type as (const name&); + + // bool + // + template <typename D> + struct bool_value + { + explicit + operator bool () const {return d->value[0] == 't';} + + bool_value& + operator= (bool v) + { + d->value = v ? "true" : "false"; + return *this; + } + + bool_value& + operator+= (bool v) + { + if (!*this && v) + d->value = "true"; + return *this; + } + + // Implementation details. // - value_proxy (const value_ptr* p, const variable_map* v) - : value_proxy (const_cast<value_ptr*> (p), v) {} + public: + explicit bool_value (D& d): d (&d) {} - template <typename T> - value_proxy (const value_ptr& p, const T& x) - : value_proxy (const_cast<value_ptr&> (p), x) {} + bool_value (const bool_value&) = delete; + bool_value& operator= (const bool_value&) = delete; // Rebind or deep? - void - rebind (const value_proxy& x) {vars = x.vars; p = x.p;} + bool_value (bool_value&&) = default; + bool_value& operator= (bool_value&&) = delete; - private: - value_ptr* p; + D* d; // name }; template <> - inline value& value_proxy:: - as<value&> () const {return **p;} + struct value_traits<bool> + { + using type = bool_value<name>; + using const_type = bool_value<const name>; - template <> - inline const value& value_proxy:: - as<const value&> () const {return **p;} + static type as (name& n) {return type (n);} + static const_type as (const name& n) {return const_type (n);} + + static type as (value&); + static const_type as (const value&); + + static bool assign (name&); + static void assign (value&, bool); + static void append (value&, bool); + + static const build::value_type value_type; + }; + + extern const value_type* bool_type; + // string + // template <> - inline list_value& value_proxy:: - as<list_value&> () const + struct value_traits<std::string> { - list_value* lv (dynamic_cast<list_value*> (p->get ())); - assert (lv != nullptr); - return *lv; - } + using type = std::string&; + using const_type = const std::string&; - template <> - inline const list_value& value_proxy:: - as<const list_value&> () const {return as<list_value&> ();} + static type as (name& n) {return n.value;} + static const_type as (const name& n) {return n.value;} + + static type as (value&); + static const_type as (const value&); + + static bool assign (name&); + static void assign (value&, std::string); + static void append (value&, std::string); + + static const build::value_type value_type; + }; + extern const value_type* string_type; + + // dir_path + // template <> - inline const name* value_proxy:: - as<const name*> () const + struct value_traits<dir_path> { - const auto& lv (as<const list_value&> ()); - assert (lv.size () < 2); - return lv.empty () ? nullptr : &lv.front (); - } + using type = dir_path&; + using const_type = const dir_path&; + + static type as (name& n) {return n.dir;} + static const_type as (const name& n) {return n.dir;} + + static type as (value&); + static const_type as (const value&); + + static bool assign (name&); + static void assign (value&, dir_path); + static void append (value&, dir_path); + static const build::value_type value_type; + }; + + extern const value_type* dir_path_type; + + // name + // template <> - inline const name& value_proxy:: - as<const name&> () const + struct value_traits<name> { - const auto& lv (as<const list_value&> ()); - assert (lv.size () == 1); - return lv.front (); - } + using type = name&; + using const_type = const name&; - template <> - std::string& value_proxy:: - as<std::string&> () const; + static type as (name& n) {return n;} + static const_type as (const name& n) {return n;} - template <> - const std::string& value_proxy:: - as<const std::string&> () const; + static type as (value&); + static const_type as (const value&); - template <> - dir_path& value_proxy:: - as<dir_path&> () const; + static bool assign (name&) {return true;} + static void assign (value&, name); + static void append (value&, name) = delete; - template <> - const dir_path& value_proxy:: - as<const dir_path&> () const; + static const build::value_type value_type; + }; - template <> - bool value_proxy:: - as<bool> () const; + extern const value_type* name_type; + + // vector<T> + // + template <typename T, typename D> + struct vector_value + { + using size_type = typename D::size_type; + + using value_type = typename value_traits<T>::type; + using const_value_type = typename value_traits<T>::const_type; + + template <typename I, typename V, typename R> + struct iterator_impl: I + { + using value_type = V; + using pointer = value_type*; + using reference = R; + using difference_type = typename I::difference_type; + + iterator_impl () = default; + iterator_impl (const I& i): I (i) {} + + // Note: operator->() is unavailable if R is a value. + // + reference operator* () const {return as<T> (I::operator* ());} + pointer operator-> () const {return &as<T> (I::operator* ());} + reference operator[] (difference_type n) const + { + return as<T> (I::operator[] (n)); + } + }; + + // Make iterator the same as const_iterator if our data type is const. + // + using const_iterator = + iterator_impl<names::const_iterator, const T, const_value_type>; + using iterator = typename std::conditional< + std::is_const<D>::value, + const_iterator, + iterator_impl<names::iterator, T, value_type>>::type; + + public: + vector_value& + operator= (std::vector<T> v) {assign (std::move (v)); return *this;} + + vector_value& + assign (std::vector<T>); + + template <typename D1> + vector_value& + assign (const vector_value<T, D1>&); + + template <typename D1> + vector_value& + append (const vector_value<T, D1>&); + + public: + bool empty () const {return d->empty ();} + size_type size () const {return d->size ();} + + value_type operator[] (size_type i) {return as<T> ((*d)[i]);} + const_value_type operator[] (size_type i) const {return as<T> ((*d)[i]);} + + iterator begin () {return iterator (d->begin ());} + iterator end () {return iterator (d->end ());} + + const_iterator begin () const {return const_iterator (d->begin ());} + const_iterator end () const {return const_iterator (d->end ());} + + const_iterator cbegin () const {return const_iterator (d->begin ());} + const_iterator cend () const {return const_iterator (d->end ());} + + // Implementation details. + // + public: + explicit vector_value (D& d): d (&d) {} + + vector_value (const vector_value&) = delete; + vector_value& operator= (const vector_value&) = delete; // Rebind or deep? + + vector_value (vector_value&&) = default; + vector_value& operator= (vector_value&&) = default; //@@ TMP + + explicit vector_value (std::nullptr_t): d (nullptr) {} //@@ TMP + + D* d; // names + }; + + template <typename T> + struct value_traits<std::vector<T>> + { + using type = vector_value<T, names>; + using const_type = vector_value<T, const names>; + + static type as (value&); + static const_type as (const value&); + + template <typename V> static void assign (value&, V); + template <typename V> static void append (value&, V); + + static const build::value_type value_type; + }; + + template <typename T, typename D> + struct value_traits<vector_value<T, D>>: value_traits<std::vector<T>> {}; + + using strings_value = vector_value<std::string, names>; + using const_strings_value = vector_value<std::string, const names>; + + extern const value_type* strings_type; // vector<string> aka strings + extern const value_type* dir_paths_type; // vector<dir_path> aka dir_paths + extern const value_type* names_type; // vector<name> aka names + + // map<K, V> + // + template <typename K, typename V, typename D> + struct map_value + { + template <typename F, typename S> + struct pair + { + using first_type = typename std::conditional< + std::is_reference<F>::value, + std::reference_wrapper<typename std::remove_reference<F>::type>, + F>::type; + + using second_type = typename std::conditional< + std::is_reference<S>::value, + std::reference_wrapper<typename std::remove_reference<S>::type>, + S>::type; + + first_type first; + second_type second; + }; + + template <typename I, typename T> + struct iterator_impl + { + using value_type = T; + using pointer = value_type*; + using reference = value_type; // Note: value. + using difference_type = typename I::difference_type; + using iterator_category = std::bidirectional_iterator_tag; + + iterator_impl () = default; + iterator_impl (const I& i): i_ (i) {} + + pointer operator-> () const = delete; + reference operator* () const + { + return value_type {as<K> (*i_), as<V> (*(i_ + 1))}; + } + + iterator_impl& operator++ () {i_ += 2; return *this;} + iterator_impl operator++ (int) {auto r (*this); operator++ (); return r;} + + iterator_impl& operator-- () {i_ -= 2; return *this;} + iterator_impl operator-- (int) {auto r (*this); operator-- (); return r;} + + bool operator== (const iterator_impl& y) const {return i_ == y.i_;} + bool operator!= (const iterator_impl& y) const {return i_ != y.i_;} + + private: + I i_; + }; + + using size_type = typename D::size_type; + + using value_type = pair<typename value_traits<K>::const_type, + typename value_traits<V>::type>; + + using const_value_type = pair<typename value_traits<K>::const_type, + typename value_traits<V>::const_type>; + + // Make iterator the same as const_iterator if our data type is const. + // + using const_iterator = + iterator_impl<names::const_iterator, const_value_type>; + using iterator = typename std::conditional< + std::is_const<D>::value, + const_iterator, + iterator_impl<names::iterator, value_type>>::type; + + + public: + map_value& + operator= (std::map<K, V> m) {assign (std::move (m)); return *this;} + + map_value& + assign (std::map<K, V>); + + bool empty () const {return d->empty ();} + size_type size () const {return d->size ();} + + iterator find (const K&); + const_iterator find (const K&) const; + + iterator begin () {return iterator (d->begin ());} + iterator end () {return iterator (d->end ());} + + const_iterator begin () const {return const_iterator (d->begin ());} + const_iterator end () const {return const_iterator (d->end ());} + + // Implementation details. + // + public: + explicit map_value (D& d): d (&d) {} + + map_value (const map_value&) = delete; + map_value& operator= (const map_value&) = delete; // Rebind or deep? + + map_value (map_value&&) = default; + map_value& operator= (map_value&&) = delete; + + D* d; // names + }; + + template <typename K, typename V> + struct value_traits<std::map<K, V>> + { + using type = map_value<K, V, names>; + using const_type = map_value<K, V, const names>; + + static type as (value&); + static const_type as (const value&); + + template <typename M> static void assign (value&, M); + template <typename M> static void append (value&, M); + + static const build::value_type value_type; + }; + + template <typename K, typename V, typename D> + struct value_traits<map_value<K, V, D>>: value_traits<std::map<K, V>> {}; } namespace std @@ -301,15 +614,27 @@ namespace build { // variable_pool // - struct variable_set: std::unordered_set<variable> + using variable_set_base = std::unordered_set<variable>; + struct variable_set: private variable_set_base { - // @@ Need to check/set type? - // const variable& - find (std::string name) {return *emplace (std::move (name)).first;} + find (std::string name, const build::value_type* t = nullptr, char p = '\0') + { + auto r (emplace (std::move (name), t, p)); + const variable& v (*r.first); + + // Update type? + // + if (!r.second && t != nullptr && v.type != t) + { + assert (v.type == nullptr); + const_cast<variable&> (v).type = t; // Ok, not changing the key. + } + + return v; + } - const variable& - insert (variable v) {return *emplace (std::move (v)).first;} + using variable_set_base::clear; }; extern variable_set variable_pool; @@ -318,40 +643,92 @@ namespace build // struct variable_map { - using map_type = butl::prefix_map<variable_cref, value_ptr, '.'>; + using map_type = butl::prefix_map<variable_cref, value, '.'>; using size_type = map_type::size_type; - using const_iterator = map_type::const_iterator; - const value_ptr* + template <typename I> + struct iterator_adapter: I + { + iterator_adapter () = default; + iterator_adapter (const I& i): I (i) {} + typename I::reference operator* () const; + typename I::pointer operator-> () const; + }; + + using const_iterator = iterator_adapter<map_type::const_iterator>; + + const value* find (const variable& var) const { auto i (m_.find (var)); - return i != m_.end () ? &i->second : nullptr; + const value* r (i != m_.end () ? &i->second : nullptr); + + // First access after being assigned a type? + // + if (r != nullptr && var.type != nullptr && r->type != var.type) + build::assign (const_cast<value&> (*r), var.type, var); + + return r; } - value_proxy + value* + find (const variable& var) + { + auto i (m_.find (var)); + value* r (i != m_.end () ? &i->second : nullptr); + + // First access after being assigned a type? + // + if (r != nullptr && var.type != nullptr && r->type != var.type) + build::assign (*r, var.type, var); + + return r; + } + + lookup<const value> operator[] (const variable& var) const { - return value_proxy (find (var), this); + return lookup<const value> (find (var), this); } - value_proxy + lookup<const value> operator[] (const std::string& name) const { return operator[] (variable_pool.find (name)); } - // The second member in the pair indicates whether new (NULL) - // value was set. + // Non-const lookup. Only exposed on the map directly. // - std::pair<value_proxy, bool> + lookup<value> + operator[] (const variable& var) + { + return lookup<value> (find (var), this); + } + + lookup<value> + operator[] (const std::string& name) + { + return operator[] (variable_pool.find (name)); + } + + // The second member in the pair indicates whether the new + // value (which will be NULL) was assigned. + // + std::pair<std::reference_wrapper<value>, bool> assign (const variable& var) { - auto r (m_.emplace (var, value_ptr ())); - return std::make_pair (value_proxy (&r.first->second, this), r.second); + auto r (m_.emplace (var, value (var.type))); + value& v (r.first->second); + + // First access after being assigned a type? + // + if (!r.second && var.type != nullptr && v.type != var.type) + build::assign (v, var.type, var); + + return std::make_pair (std::reference_wrapper<value> (v), r.second); } - std::pair<value_proxy, bool> + std::pair<std::reference_wrapper<value>, bool> assign (const std::string& name) { return assign (variable_pool.find (name)); @@ -360,7 +737,9 @@ namespace build std::pair<const_iterator, const_iterator> find_namespace (const std::string& ns) const { - return m_.find_prefix (variable_pool.find (ns)); + auto r (m_.find_prefix (variable_pool.find (ns))); + return std::make_pair (const_iterator (r.first), + const_iterator (r.second)); } const_iterator @@ -381,17 +760,17 @@ namespace build // Target type/pattern-specific variables. // + // @@ In quite a few places we assume that we can store a reference + // to the returned value (e.g., install::lookup_install()). If + // we "instantiate" the value on the fly, then we will need to + // consider its lifetime. + // using variable_pattern_map = std::map<std::string, variable_map>; using variable_type_map = std::map<std::reference_wrapper<const target_type>, variable_pattern_map>; - - //@@ In quite a few places we assume that we can store a reference - // to the returned value (e.g., install::lookup_install()). If - // we "instantiate" the value on the fly, then we will need to - // consider its lifetime. - } #include <build/variable.ixx> +#include <build/variable.txx> #endif // BUILD_VARIABLE diff --git a/build/variable.cxx b/build/variable.cxx index eab77e5..d215b02 100644 --- a/build/variable.cxx +++ b/build/variable.cxx @@ -4,86 +4,317 @@ #include <build/variable> +#include <iterator> // make_move_iterator() + #include <build/utility> +#include <build/diagnostics> using namespace std; namespace build { - variable_set variable_pool; + // value + // + void + assign (value& v, const value_type* t, const variable& var) + { + if (v.type == nullptr) + { + v.type = t; + + if (v && t->assign != nullptr) + v.state_ = t->assign (v.data_, var) + ? value::state_type::filled + : value::state_type::empty; + } + else + fail << "variable '" << var.name << "' type mismatch" << + info << "value '" << v.data_ << "' is " << v.type->name << + info << (t == var.type ? "variable" : "new type") << " is " + << (var.type != nullptr ? var.type->name : "untyped"); + } + + value& value:: + operator= (value&& v) + { + assert (type == nullptr || type == v.type); + + // Since the types are the same, we don't need to call + // the callbacks. + // + type = v.type; + state_ = v.state_; + data_ = move (v.data_); + + return *this; + } + + value& value:: + append (value v, const variable& var) + { + assert (type == v.type); + append (move (v.data_), var); + return *this; + } + + void value:: + append (names v, const variable& var) + { + // Treat append to NULL as assign. + // + if (!null () && type != nullptr && type->append != nullptr) + { + state_ = type->append (data_, move (v), var) + ? state_type::filled + : state_type::empty; + return; + } + + if (data_.empty ()) + data_ = move (v); + else + data_.insert (data_.end (), + make_move_iterator (v.begin ()), + make_move_iterator (v.end ())); - // value_proxy + state_ = (type != nullptr && type->assign != nullptr + ? type->assign (data_, var) + : !data_.empty ()) + ? state_type::filled + : state_type::empty; + } + + // bool value // - template <> - string& value_proxy:: - as<string&> () const - { - list_value& lv (as<list_value&> ()); - assert (lv.size () == 1); - name& n (lv.front ()); - assert (n.simple ()); - return n.value; + bool value_traits<bool>:: + assign (name& n) + { + if (n.simple ()) + { + const string& s (n.value); + + if (s == "true" || s == "false") + return true; + } + + return false; } - template <> - const string& value_proxy:: - as<const string&> () const + static bool + bool_assign (names& v, const variable& var) { - const list_value& lv (as<list_value&> ()); - assert (lv.size () < 2); + // Verify the value is either "true" or "false". + // + if (v.size () == 1) + { + name& n (v.front ()); - if (lv.empty ()) - return empty_string; + if (value_traits<bool>::assign (n)) + return true; + } + + fail << "invalid bool variable '" << var.name << "' value '" << v << "'"; + return false; + } + + static bool + bool_append (names& v, names a, const variable& var) + { + // Translate append to OR. + // + bool_assign (a, var); // Verify "true" or "false". - const name& n (lv.front ()); + if (a.front ().value[0] == 't' && v.front ().value[0] == 'f') + v = move (a); - assert (n.simple ()); - return n.value; + return true; } - template <> - dir_path& value_proxy:: - as<dir_path&> () const + const value_type value_traits<bool>::value_type { - list_value& lv (as<list_value&> ()); - assert (lv.size () == 1); - name& n (lv.front ()); - assert (n.directory ()); - return n.dir; + "bool", + &bool_assign, + &bool_append + }; + + const value_type* bool_type = &value_traits<bool>::value_type; + + // string value + // + bool value_traits<string>:: + assign (name& n) + { + // Convert directory to string. + // + if (n.directory ()) + { + n.value = std::move (n.dir).string (); // Move string out of path. + + // Add / back to the end of the path unless it is already there. + // Note that the string cannot be empty (n.directory () would + // have been false). + // + if (!dir_path::traits::is_separator (n.value[n.value.size () - 1])) + n.value += '/'; + } + + return n.simple (); } - template <> - const dir_path& value_proxy:: - as<const dir_path&> () const + static bool + string_assign (names& v, const variable& var) { - const list_value& lv (as<list_value&> ()); - assert (lv.size () < 2); + // Verify/convert the value is/to a single simple name. + // + if (v.empty ()) + { + v.emplace_back (name ()); // Canonical empty string representation. + return false; + } + else if (v.size () == 1) + { + name& n (v.front ()); - if (lv.empty ()) - return empty_dir_path; + if (value_traits<string>::assign (n)) + return !n.value.empty (); + } + + fail << "invalid string variable '" << var.name << "' value '" << v << "'"; + return false; + } - const name& n (lv.front ()); + static bool + string_append (names& v, names a, const variable& var) + { + // Translate append to string concatenation. + // + string_assign (a, var); // Verify/convert value is/to string. - if (n.empty ()) - return empty_dir_path; + if (v.front ().value.empty ()) + v = move (a); + else + v.front ().value += a.front ().value; - assert (n.directory ()); - return n.dir; + return !v.front ().value.empty (); } - template <> - bool value_proxy:: - as<bool> () const + const value_type value_traits<string>::value_type + { + "string", + &string_assign, + &string_append + }; + + const value_type* string_type = &value_traits<string>::value_type; + + // dir_path value + // + bool value_traits<dir_path>:: + assign (name& n) { - const list_value& lv (as<const list_value&> ()); - assert (lv.size () == 1); - const name& n (lv.front ()); - assert (n.simple ()); - if (n.value == "true") + if (n.directory ()) return true; - else if (n.value == "false") + + if (n.simple ()) + { + try + { + n.dir = n.empty () ? dir_path () : dir_path (move (n.value)); + n.value.clear (); + return true; + } + catch (const invalid_path&) {} // Fall through. + } + + return false; + } + + static bool + dir_path_assign (names& v, const variable& var) + { + // Verify/convert the value is/to a single directory name. + // + if (v.empty ()) + { + v.emplace_back (dir_path ()); // Canonical empty path representation. return false; + } + else if (v.size () == 1) + { + name& n (v.front ()); + + if (value_traits<dir_path>::assign (n)) + return !n.dir.empty (); + } + + fail << "invalid dir_path variable '" << var.name << "' " + << "value '" << v << "'"; + return false; + } + + static bool + dir_path_append (names& v, names a, const variable& var) + { + // Translate append to path concatenation. + // + dir_path_assign (a, var); // Verify/convert value is/to dir_path. + + dir_path& d (a.front ().dir); + if (d.relative ()) + return !(v.front ().dir /= d).empty (); else - assert (false); // Bool value should be 'true' or 'false'. + fail << "append of absolute path '" << d << "' to dir_path variable " + << var.name; + + return false; } + + const value_type value_traits<dir_path>::value_type + { + "dir_path", + &dir_path_assign, + &dir_path_append + }; + + const value_type* dir_path_type = &value_traits<dir_path>::value_type; + + // name value + // + static bool + name_assign (names& v, const variable& var) + { + // Verify the value is a single name. + // + if (v.size () == 1) + return v.front ().empty (); + + fail << "invalid string variable '" << var.name << "' value '" << v << "'"; + return false; + } + + static bool + name_append (names&, names, const variable& var) + { + fail << "append to name variable '" << var.name << "'"; + return false; + } + + const value_type value_traits<name>::value_type + { + "name", + &name_assign, + &name_append + }; + + const value_type* name_type = &value_traits<name>::value_type; + + // vector<T> value + // + const value_type* strings_type = &value_traits<strings>::value_type; + const value_type* dir_paths_type = &value_traits<dir_paths>::value_type; + const value_type* names_type = &value_traits<names>::value_type; + + // variable_set + // + variable_set variable_pool; } diff --git a/build/variable.ixx b/build/variable.ixx index b97815e..16ea7c0 100644 --- a/build/variable.ixx +++ b/build/variable.ixx @@ -4,108 +4,395 @@ namespace build { - // value_proxy + // value // - inline bool value_proxy:: - empty () const {return as<const list_value&> ().empty ();} + template <typename T> + inline void + assign (value& v, const variable& var) + { + auto t (&value_traits<T>::value_type); + + if (v.type != t) + assign (v, t, var); + } + + template <typename T> + inline typename value_traits<T>::type + as (value& v) + { + return value_traits<T>::as (v); + } + + template <typename T> + inline typename value_traits<T>::const_type + as (const value& v) + { + return value_traits<T>::as (v); + } + + template <typename T> + inline bool + assign (name& n) + { + return value_traits<T>::assign (n); + } + + template <typename T> + inline typename value_traits<T>::type + as (name& n) + { + return value_traits<T>::as (n); + } - inline const value_proxy& value_proxy:: - operator= (value_ptr v) const + template <typename T> + inline typename value_traits<T>::const_type + as (const name& n) { - *p = std::move (v); + return value_traits<T>::as (n); + } + + template <typename T> + inline value& value:: + operator= (T v) + { + value_traits<T>::assign (*this, std::move (v)); + return *this; + } + + template <typename T> + inline value& value:: + operator+= (T v) + { + value_traits<T>::append (*this, std::move (v)); return *this; } - inline const value_proxy& value_proxy:: - operator= (const value_proxy& v) const + inline void value:: + assign (names v, const variable& var) + { + data_ = std::move (v); + state_ = (type != nullptr && type->assign != nullptr + ? type->assign (data_, var) + : !data_.empty ()) + ? state_type::filled + : state_type::empty; + } + + // bool value + // + inline bool_value<name> value_traits<bool>:: + as (value& v) + { + assert (v.type == bool_type); + return bool_value<name> (v.data_.front ()); + } + + inline bool_value<const name> value_traits<bool>:: + as (const value& v) { - if (this != &v) + assert (v.type == bool_type); + return bool_value<const name> (v.data_.front ()); + } + + inline void value_traits<bool>:: + assign (value& v, bool x) + { + if (v.null ()) { - if (v) - *p = v.as<const value&> ().clone (); - else - p->reset (); + if (v.type == nullptr) + v.type = bool_type; + v.data_.emplace_back (name ()); + v.state_ = value::state_type::empty; } - return *this; + as (v) = x; + v.state_ = value::state_type::filled; } - inline const value_proxy& value_proxy:: - operator= (list_value v) const + inline void value_traits<bool>:: + append (value& v, bool x) { - if (*p == nullptr) - p->reset (new list_value (std::move (v))); + if (v.null ()) + assign (v, x); else - //@@ Assuming it is a list_value. - // - as<list_value&> () = std::move (v); + as (v) += x; // Cannot be empty. + } - return *this; + // string value + // + inline std::string& value_traits<std::string>:: + as (value& v) + { + assert (v.type == string_type); + return v.data_.front ().value; } - inline const value_proxy& value_proxy:: - operator= (std::string v) const + inline const std::string& value_traits<std::string>:: + as (const value& v) { - // In most cases this is used to initialize a new variable, so - // don't bother trying to optimize for the case where p is not - // NULL. - // - p->reset (new list_value (std::move (v))); + assert (v.type == string_type); + return v.data_.front ().value; + } + + inline void value_traits<std::string>:: + assign (value& v, std::string x) + { + if (v.null ()) + { + if (v.type == nullptr) + v.type = string_type; + v.data_.emplace_back (name ()); + v.state_ = value::state_type::empty; + } + + v.state_ = (as (v) = std::move (x)).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + inline void value_traits<std::string>:: + append (value& v, std::string x) + { + if (v.null ()) + assign (v, std::move (x)); + else + v.state_ = (as (v) += std::move (x)).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + // dir_path value + // + inline dir_path& value_traits<dir_path>:: + as (value& v) + { + assert (v.type == dir_path_type); + return v.data_.front ().dir; + } + + inline const dir_path& value_traits<dir_path>:: + as (const value& v) + { + assert (v.type == dir_path_type); + return v.data_.front ().dir; + } + + inline void value_traits<dir_path>:: + assign (value& v, dir_path x) + { + if (v.null ()) + { + if (v.type == nullptr) + v.type = dir_path_type; + v.data_.emplace_back (name ()); + v.state_ = value::state_type::empty; + } + + v.state_ = (as (v) = std::move (x)).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + inline void value_traits<dir_path>:: + append (value& v, dir_path x) + { + if (v.null ()) + assign (v, std::move (x)); + else + v.state_ = (as (v) /= std::move (x)).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + // name value + // + inline name& value_traits<name>:: + as (value& v) + { + assert (v.type == name_type); + return v.data_.front (); + } + + inline const name& value_traits<name>:: + as (const value& v) + { + assert (v.type == name_type); + return v.data_.front (); + } + + inline void value_traits<name>:: + assign (value& v, name x) + { + if (v.null ()) + { + if (v.type == nullptr) + v.type = name_type; + v.data_.emplace_back (name ()); + v.state_ = value::state_type::empty; + } + + v.state_ = (as (v) = std::move (x)).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + // vector<T> value + // + template <typename T, typename D> + inline vector_value<T, D>& vector_value<T, D>:: + assign (std::vector<T> v) + { + d->clear (); + d->insert (d->end (), + std::make_move_iterator (v.begin ()), + std::make_move_iterator (v.end ())); return *this; } - inline const value_proxy& value_proxy:: - operator= (dir_path v) const + template <typename T, typename D> + template <typename D1> + inline vector_value<T, D>& vector_value<T, D>:: + assign (const vector_value<T, D1>& v) { - p->reset (new list_value (std::move (v))); + d->clear (); + d->insert (d->end (), v.begin (), v.end ()); return *this; } - inline const value_proxy& value_proxy:: - operator= (std::nullptr_t) const + template <typename T, typename D> + template <typename D1> + inline vector_value<T, D>& vector_value<T, D>:: + append (const vector_value<T, D1>& v) { - p->reset (); + d->insert (d->end (), v.begin (), v.end ()); return *this; } - inline const value_proxy& value_proxy:: - operator+= (const value_proxy& v) const + template <typename T> + inline vector_value<T, names> value_traits<std::vector<T>>:: + as (value& v) + { + assert (v.type == &value_traits<std::vector<T>>::value_type); + return vector_value<T, names> (v.data_); + } + + template <typename T> + inline vector_value<T, const names> value_traits<std::vector<T>>:: + as (const value& v) { - if (v && this != &v) + assert (v.type == &value_traits<std::vector<T>>::value_type); + return vector_value<T, const names> (v.data_); + } + + template <typename T> + template <typename V> + inline void value_traits<std::vector<T>>:: + assign (value& v, V x) + { + if (v.null ()) { - if (*p == nullptr) - *this = v; - else - //@@ Assuming it is a list_value. - // - *this += v.as<const list_value&> (); + if (v.type == nullptr) + v.type = &value_traits<std::vector<T>>::value_type; + v.state_ = value::state_type::empty; } - return *this; + v.state_ = (as (v).assign (std::move (x))).empty () + ? value::state_type::empty + : value::state_type::filled; } - inline const value_proxy& value_proxy:: - operator+= (const list_value& v) const + template <typename T> + template <typename V> + inline void value_traits<std::vector<T>>:: + append (value& v, V x) { - if (*p == nullptr) - *this = v; + if (v.null ()) + assign (v, std::move (x)); else + v.state_ = (as (v).append (std::move (x))).empty () + ? value::state_type::empty + : value::state_type::filled; + } + + // map<K, V> value + // + template <typename K, typename V> + inline map_value<K, V, names> value_traits<std::map<K, V>>:: + as (value& v) + { + assert ((v.type == &value_traits<std::map<K, V>>::value_type)); + return map_value<K, V, names> (v.data_); + } + + template <typename K, typename V> + inline map_value<K, V, const names> value_traits<std::map<K, V>>:: + as (const value& v) + { + assert ((v.type == &value_traits<std::map<K, V>>::value_type)); + return map_value<K, V, const names> (v.data_); + } + + template <typename K, typename V> + template <typename M> + inline void value_traits<std::map<K, V>>:: + assign (value& v, M x) + { + if (v.null ()) { - list_value& lv (as<list_value&> ()); - lv.insert (lv.end (), v.begin (), v.end ()); + if (v.type == nullptr) + v.type = &value_traits<std::map<K, V>>::value_type; + v.state_ = value::state_type::empty; } - return *this; + v.state_ = (as (v).assign (std::move (x))).empty () + ? value::state_type::empty + : value::state_type::filled; } - inline const value_proxy& value_proxy:: - operator+= (std::string v) const + template <typename K, typename V> + template <typename M> + inline void value_traits<std::map<K, V>>:: + append (value& v, M x) { - if (*p == nullptr) - *this = v; + if (v.null ()) + assign (v, std::move (x)); else - as<list_value&> ().emplace_back (std::move (v)); + v.state_ = (as (v).append (std::move (x))).empty () + ? value::state_type::empty + : value::state_type::filled; + } - return *this; + // variable_map::iterator_adapter + // + template <typename I> + inline typename I::reference variable_map::iterator_adapter<I>:: + operator* () const + { + auto& r (I::operator* ()); + const variable& var (r.first); + auto& val (r.second); + + // First access after being assigned a type? + // + if (var.type != nullptr && val.type != var.type) + build::assign (const_cast<value&> (val), var.type, var); + + return r; + } + + template <typename I> + inline typename I::pointer variable_map::iterator_adapter<I>:: + operator-> () const + { + auto p (I::operator-> ()); + const variable& var (p->first); + auto& val (p->second); + + // First access after being assigned a type? + // + if (var.type != nullptr && val.type != var.type) + build::assign (const_cast<value&> (val), var.type, var); + + return p; } } diff --git a/build/variable.txx b/build/variable.txx new file mode 100644 index 0000000..1b32584 --- /dev/null +++ b/build/variable.txx @@ -0,0 +1,160 @@ +// file : build/variable.txx -*- C++ -*- +// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <iterator> // make_move_iterator() + +#include <build/diagnostics> + +namespace build +{ + // vector<T> value + // + template <typename T> + bool + vector_assign (names& v, const variable& var) + { + // Verify each element has valid value of T. + // + for (name& n: v) + { + if (!assign<T> (n)) + fail << "invalid " << value_traits<T>::value_type.name << " element " + << "'" << n << "' in variable '" << var.name << "'"; + } + + return !v.empty (); + } + + template <typename T> + bool + vector_append (names& v, names a, const variable& var) + { + // Verify that what we are appending is valid. + // + vector_assign<T> (a, var); + + if (v.empty ()) + v = move (a); + else + v.insert (v.end (), + std::make_move_iterator (a.begin ()), + std::make_move_iterator (a.end ())); + + return !v.empty (); + } + + template <typename T> + const value_type value_traits<std::vector<T>>::value_type + { + value_traits<T>::value_type.name + 's', + &vector_assign<T>, + &vector_append<T> + }; + + // map<K, V> value + // + template <typename K, typename V, typename D> + map_value<K, V, D>& map_value<K, V, D>:: + assign (std::map<K, V> m) + { + d->clear (); + for (auto& p: m) + { + d->emplace_back (p.first); // Const, can't move. + d->back ().pair = '='; + d->emplace_back (std::move (p.second)); + } + + return *this; + } + + template <typename K, typename V, typename D> + auto map_value<K, V, D>:: + find (const K& k) -> iterator + { + // @@ Scan backwards to handle duplicates. + // + for (auto i (d->rbegin ()); i != d->rend (); ++i) + if (as<K> (*++i) == k) + return iterator (--(i.base ())); + + return end (); + } + + template <typename K, typename V, typename D> + auto map_value<K, V, D>:: + find (const K& k) const -> const_iterator + { + // @@ Scan backwards to handle duplicates. + // + for (auto i (d->rbegin ()); i != d->rend (); ++i) + if (as<K> (*++i) == k) + return const_iterator (--(i.base ())); + + return end (); + } + + template <typename K, typename V> + bool + map_assign (names& v, const variable& var) + { + // Verify we have a sequence of pairs and each lhs/rhs is a valid + // value of K/V. + // + for (auto i (v.begin ()); i != v.end (); ++i) + { + if (i->pair == '\0') + fail << value_traits<std::map<K, V>>::value_type.name << " key-value " + << "pair expected instead of '" << *i << "' " + << "in variable '" << var.name << "'"; + + if (!assign<K> (*i)) + fail << "invalid " << value_traits<K>::value_type.name << " key " + << "'" << *i << "' in variable '" << var.name << "'"; + + ++i; // Got to have the second half of the pair. + + if (!assign<V> (*i)) + fail << "invalid " << value_traits<V>::value_type.name << " value " + << "'" << *i << "' in variable '" << var.name << "'"; + } + + //@@ When doing sorting, note that assign() can convert the + // value. + + //@@ Is sorting really the right trade-off (i.e., insertion + // vs search)? Perhaps linear search is ok? + + return !v.empty (); + } + + template <typename K, typename V> + bool + map_append (names& v, names a, const variable& var) + { + //@@ Not weeding out duplicates. + + // Verify that what we are appending is valid. + // + map_assign<K, V> (a, var); + + if (v.empty ()) + v = move (a); + else + v.insert (v.end (), + std::make_move_iterator (a.begin ()), + std::make_move_iterator (a.end ())); + + return !v.empty (); + } + + template <typename K, typename V> + const value_type value_traits<std::map<K, V>>::value_type + { + value_traits<K>::value_type.name + '_' + + value_traits<V>::value_type.name + "_map", + &map_assign<K, V>, + &map_append<K, V> + }; +} |