diff options
| -rw-r--r-- | libbuild2/bin/functions.cxx | 4 | ||||
| -rw-r--r-- | libbuild2/cc/functions.cxx | 18 | ||||
| -rw-r--r-- | libbuild2/config/functions.cxx | 4 | ||||
| -rw-r--r-- | libbuild2/function.cxx | 111 | ||||
| -rw-r--r-- | libbuild2/function.hxx | 143 | ||||
| -rw-r--r-- | libbuild2/function.test.cxx | 42 | ||||
| -rw-r--r-- | libbuild2/functions-builtin.cxx | 30 | ||||
| -rw-r--r-- | libbuild2/functions-filesystem.cxx | 42 | ||||
| -rw-r--r-- | libbuild2/functions-name.cxx | 34 | ||||
| -rw-r--r-- | libbuild2/functions-path.cxx | 83 | ||||
| -rw-r--r-- | libbuild2/functions-process-path.cxx | 8 | ||||
| -rw-r--r-- | libbuild2/functions-process.cxx | 65 | ||||
| -rw-r--r-- | libbuild2/functions-project-name.cxx | 18 | ||||
| -rw-r--r-- | libbuild2/functions-regex.cxx | 36 | ||||
| -rw-r--r-- | libbuild2/functions-string.cxx | 30 | ||||
| -rw-r--r-- | libbuild2/functions-target-triplet.cxx | 12 | ||||
| -rw-r--r-- | libbuild2/install/functions.cxx | 4 |
17 files changed, 385 insertions, 299 deletions
diff --git a/libbuild2/bin/functions.cxx b/libbuild2/bin/functions.cxx index 59fcdf2..1c6c0f4 100644 --- a/libbuild2/bin/functions.cxx +++ b/libbuild2/bin/functions.cxx @@ -24,12 +24,14 @@ namespace build2 // bin.lib value on. As a result, it can be omitted in which case the // function call scope is used (covers project-local lib{} targets). // + // Note that this function is not pure. + // // @@ TODO: support for target (note that if it's out of project, then // it's imported, which means it might still be qualified.) // // @@ TODO: support utility libraries (see link_member()). // - f[".link_member"] = [] (const scope* bs, names ns) + f.insert (".link_member", false) += [] (const scope* bs, names ns) { string t (convert<string> (move (ns))); diff --git a/libbuild2/cc/functions.cxx b/libbuild2/cc/functions.cxx index 98f7f97..c8b9d09 100644 --- a/libbuild2/cc/functions.cxx +++ b/libbuild2/cc/functions.cxx @@ -150,8 +150,10 @@ namespace build2 // after all the specified library targets have been matched. Normally // it is used in ad hoc recipes to implement custom compilation. // + // Note that this function is not pure. // - f[".lib_poptions"].insert<lib_data, names, names> ( + f.insert (".lib_poptions", false). + insert<lib_data, names, names> ( &lib_thunk<appended_libraries>, lib_data { x, @@ -189,8 +191,10 @@ namespace build2 // after all the specified library targets have been matched. Normally // it is used in ad hoc recipes to implement custom linking. // - f[".lib_libs"].insert<lib_data, - names, names, optional<names>, optional<names>> ( + // Note that this function is not pure. + // + f.insert (".lib_libs", false). + insert<lib_data, names, names, optional<names>, optional<names>> ( &lib_thunk<appended_libraries>, lib_data { x, @@ -237,13 +241,15 @@ namespace build2 // // Note that passing multiple targets at once is not a mere convenience: // this also allows for more effective duplicate suppression. - + // // Note also that this function can only be called during execution // after all the specified library targets have been matched. Normally // it is used in ad hoc recipes to implement custom linking. // - f[".lib_rpaths"].insert<lib_data, - names, names, optional<names>, optional<names>> ( + // Note that this function is not pure. + // + f.insert (".lib_rpaths", false). + insert<lib_data, names, names, optional<names>, optional<names>> ( &lib_thunk<rpathed_libraries>, lib_data { x, diff --git a/libbuild2/config/functions.cxx b/libbuild2/config/functions.cxx index aaf74ec..5e85238 100644 --- a/libbuild2/config/functions.cxx +++ b/libbuild2/config/functions.cxx @@ -27,7 +27,9 @@ namespace build2 // config module creation was requested for other meta-operations with // config.config.module=true in bootstrap.build. // - f[".save"] = [] (const scope* s) + // Note that this function is not pure. + // + f.insert (".save", false) += [] (const scope* s) { if (s == nullptr) fail << "config.save() called out of scope" << endf; diff --git a/libbuild2/function.cxx b/libbuild2/function.cxx index 25dacf9..eaf3f9e 100644 --- a/libbuild2/function.cxx +++ b/libbuild2/function.cxx @@ -80,21 +80,6 @@ namespace build2 return i != map_.end () && i->first.compare (0, n, name) == 0; } - auto function_map:: - insert (string name, function_overload f) -> iterator - { - // Sanity checks. - // - assert (f.arg_min <= f.arg_max && - f.arg_types.size () <= f.arg_max && - f.impl != nullptr); - - auto i (map_.emplace (move (name), move (f))); - - i->second.name = i->first.c_str (); - return i; - } - pair<value, bool> function_map:: call (const scope* base, const string& name, @@ -120,16 +105,17 @@ namespace build2 // See the overall function machinery description for the ranking // semantics. // - auto ip (map_.equal_range (name)); + const function_overloads* all_ovls (find (name)); size_t rank (~0); small_vector<const function_overload*, 2> ovls; + if (all_ovls != nullptr) { size_t count (args.size ()); - for (auto it (ip.first); it != ip.second; ++it) + for (auto it (all_ovls->begin ()); it != all_ovls->end (); ++it) { - const function_overload& f (it->second); + const function_overload& f (*it); // Argument count match. // @@ -257,8 +243,11 @@ namespace build2 dr << fail (loc) << "unmatched call to "; print_call (dr.os); - for (auto i (ip.first); i != ip.second; ++i) - dr << info << "candidate: " << i->second; + if (all_ovls != nullptr) + { + for (auto i (all_ovls->begin ()); i != all_ovls->end (); ++i) + dr << info << "candidate: " << *i; + } // If this is an unqualified name, then also print qualified // functions that end with this name. But skip functions that we @@ -271,14 +260,20 @@ namespace build2 for (auto i (begin ()); i != end (); ++i) { const string& q (i->first); - const function_overload& f (i->second); - if ((f.alt_name == nullptr || f.alt_name != name) && - q.size () > n) + if (q.size () > n) { - size_t p (q.size () - n); - if (q[p - 1] == '.' && q.compare (p, n, name) == 0) - dr << info << "candidate: " << i->second; + for (auto j (i->second.begin ()); j != i->second.end (); ++j) + { + const function_overload& f (*j); + + if (f.alt_name == nullptr || f.alt_name != name) + { + size_t p (q.size () - n); + if (q[p - 1] == '.' && q.compare (p, n, name) == 0) + dr << info << "candidate: " << f; + } + } } } } @@ -300,30 +295,8 @@ namespace build2 } } - value function_family:: - default_thunk (const scope* base, - vector_view<value> args, - const function_overload& f) - { - // Call the cast thunk. - // - struct cast_data // Prefix of function_cast::data. - { - value (*const thunk) (const scope*, vector_view<value>, const void*); - }; - - auto d (reinterpret_cast<const cast_data*> (&f.data)); - return d->thunk (base, move (args), d); - } - -#if !defined(_WIN32) - constexpr const optional<const value_type*>* function_args<>::types; -#else - const optional<const value_type*>* const function_args<>::types = nullptr; -#endif - - void function_family::entry:: - insert (string n, function_overload f) const + auto function_family:: + insert (string n, bool pure) const -> entry { // Figure out qualification. // @@ -332,31 +305,47 @@ namespace build2 if (p == string::npos) { - if (!qual.empty ()) + if (!qual_.empty ()) { - qn = qual; + qn = qual_; qn += '.'; qn += n; } } else if (p == 0) { - assert (!qual.empty ()); - n.insert (0, qual); + assert (!qual_.empty ()); + n.insert (0, qual_); } - auto i (qn.empty () ? map_.end () : map_.insert (move (qn), f)); - auto j (map_.insert (move (n), move (f))); + return entry { + map_.insert (move (n), pure), + qn.empty () ? nullptr : &map_.insert (move (qn), pure), + thunk_}; + } - // If we have both, then set alternative names. + value function_family:: + default_thunk (const scope* base, + vector_view<value> args, + const function_overload& f) + { + // Call the cast thunk. // - if (i != map_.end ()) + struct cast_data // Prefix of function_cast::data. { - i->second.alt_name = j->first.c_str (); - j->second.alt_name = i->first.c_str (); - } + value (*const thunk) (const scope*, vector_view<value>, const void*); + }; + + auto d (reinterpret_cast<const cast_data*> (&f.data)); + return d->thunk (base, move (args), d); } +#if !defined(_WIN32) + constexpr const optional<const value_type*>* function_args<>::types; +#else + const optional<const value_type*>* const function_args<>::types = nullptr; +#endif + // Static-initialize the function map and populate with builtin functions. // diff --git a/libbuild2/function.hxx b/libbuild2/function.hxx index 43b8024..8fdf8f4 100644 --- a/libbuild2/function.hxx +++ b/libbuild2/function.hxx @@ -75,14 +75,15 @@ namespace build2 // // // Register length() and string.length(). // // - // f["length"] = &string::size; + // f["length"] += &string::size; // // // Register string.max_size(). // // - // f[".max_size"] = []() {return string ().max_size ();}; + // f[".max_size"] += []() {return string ().max_size ();}; // - // For more examples/ideas, study the existing function families (reside - // in the functions-*.cxx files). + // The use of += instead of = is meant to suggest that we are adding an + // overload. For more examples/ideas, study the existing function families + // (reside in the functions-*.cxx files). // // Note that normally there will be a function overload that has all the // parameters untyped with an implementation that falls back to one of the @@ -90,6 +91,12 @@ namespace build2 // from the argument value "syntax" (e.g., presence of a trailing slash for // a directory path). // + // A function is pure if for the same set of arguments it always produces + // the same result and has no (observable) side effects. Those functions + // that are not pure should be explicitly marked as such, for example: + // + // f.insert ("date", false /* pure */) += &date; + // struct function_overload; using function_impl = value (const scope*, @@ -116,13 +123,13 @@ namespace build2 using types = vector_view<const optional<const value_type*>>; - const size_t arg_min; - const size_t arg_max; - const types arg_types; + size_t arg_min; + size_t arg_max; + types arg_types; // Function implementation. // - function_impl* const impl; + function_impl* impl; // Auxiliary data storage. Note that it is expected to be trivially // copyable and destructible. @@ -166,18 +173,57 @@ namespace build2 LIBBUILD2_SYMEXPORT ostream& operator<< (ostream&, const function_overload&); // Print signature. + struct function_overloads: small_vector<function_overload, 8> + { + const char* name; // Set to point to key by function_map::insert() below. + bool pure = true; + + function_overload& + insert (function_overload f) + { + // Sanity checks. + // + assert (f.arg_min <= f.arg_max && + f.arg_types.size () <= f.arg_max && + f.impl != nullptr); + + push_back (move (f)); + back ().name = name; + return back (); + } + }; + class LIBBUILD2_SYMEXPORT function_map { public: - using map_type = std::multimap<string, function_overload>; + using map_type = std::map<string, function_overloads>; using iterator = map_type::iterator; using const_iterator = map_type::const_iterator; - iterator - insert (string name, function_overload); + function_overloads& + insert (string name, bool pure) + { + auto p (map_.emplace (move (name), function_overloads ())); - void - erase (iterator i) {map_.erase (i);} + function_overloads& r (p.first->second); + + if (p.second) + { + r.name = p.first->first.c_str (); + r.pure = pure; + } + else + assert (r.pure == pure); + + return r; + } + + const function_overloads* + find (const string& name) const + { + auto i (map_.find (name)); + return i != map_.end () ? &i->second : nullptr; + } value call (const scope* base, @@ -263,6 +309,9 @@ namespace build2 entry operator[] (string name) const; + entry + insert (string name, bool pure = true) const; + static bool defined (function_map& map, string qual) { @@ -762,20 +811,18 @@ namespace build2 struct LIBBUILD2_SYMEXPORT function_family::entry { - function_map& map_; - string name; - const string& qual; - function_impl* thunk; + function_overloads& overloads; + function_overloads* alt_overloads; + function_impl* thunk; template <typename R, typename... A> void - operator= (R (*impl) (A...)) && + operator+= (R (*impl) (A...)) const { using args = function_args<A...>; using cast = function_cast_func<R, A...>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -786,13 +833,12 @@ namespace build2 template <typename R, typename... A> void - operator= (R (*impl) (const scope*, A...)) && + operator+= (R (*impl) (const scope*, A...)) const { using args = function_args<A...>; using cast = function_cast_func<R, const scope*, A...>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -812,20 +858,19 @@ namespace build2 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 6 template <typename L> void - operator= (const L&) && + operator+= (const L&) const { - move (*this).coerce_lambda (&L::operator()); + this->coerce_lambda (&L::operator()); } template <typename L, typename R, typename... A> void - coerce_lambda (R (L::*op) (A...) const) && + coerce_lambda (R (L::*op) (A...) const) const { using args = function_args<A...>; using cast = function_cast_lamb<L, R, A...>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -836,13 +881,12 @@ namespace build2 template <typename L, typename R, typename... A> void - coerce_lambda (R (L::*op) (const scope*, A...) const) && + coerce_lambda (R (L::*op) (const scope*, A...) const) const { using args = function_args<A...>; using cast = function_cast_lamb<L, R, const scope*, A...>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -853,9 +897,9 @@ namespace build2 #else template <typename L> void - operator= (const L& l) && + operator+= (const L& l) const { - move (*this).operator= (decay_lambda (&L::operator(), l)); + this->operator+= (decay_lambda (&L::operator(), l)); } template <typename L, typename R, typename... A> @@ -875,13 +919,12 @@ namespace build2 // template <typename R, typename T> void - operator= (R (T::*mf) () const) && + operator+= (R (T::*mf) () const) const { using args = function_args<T>; using cast = function_cast_memf<R, T>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -894,13 +937,12 @@ namespace build2 // template <typename R, typename T> void - operator= (R T::*dm) && + operator+= (R T::*dm) const { using args = function_args<T>; using cast = function_cast_memd<R, T>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -915,12 +957,11 @@ namespace build2 // template <typename D, typename... A> void - insert (function_impl* i, D d) && + insert (function_impl* i, D d) const { using args = function_args<A...>; - insert (move (name), - function_overload ( + insert (function_overload ( nullptr, args::min, args::max, @@ -931,13 +972,27 @@ namespace build2 private: void - insert (string, function_overload) const; + insert (function_overload f) const + { + function_overload* f1 (alt_overloads != nullptr + ? &alt_overloads->insert (f) + : nullptr); + function_overload& f2 (overloads.insert (move (f))); + + // If we have both, then set alternative names. + // + if (f1 != nullptr) + { + f1->alt_name = f2.name; + f2.alt_name = f1->name; + } + } }; inline auto function_family:: operator[] (string name) const -> entry { - return entry {map_, move (name), qual_, thunk_}; + return insert (move (name)); } } diff --git a/libbuild2/function.test.cxx b/libbuild2/function.test.cxx index 514ac1e..f8a2c16 100644 --- a/libbuild2/function.test.cxx +++ b/libbuild2/function.test.cxx @@ -52,38 +52,37 @@ namespace build2 function_family f (functions, "dummy"); - f["fail"] = []() {fail << "failed" << endf;}; - f["fail_arg"] = [](names a) {return convert<uint64_t> (move (a[0]));}; + f["fail"] += []() {fail << "failed" << endf;}; + f["fail_arg"] += [](names a) {return convert<uint64_t> (move (a[0]));}; - f["nullable"] = [](names* a) {return a == nullptr;}; - f["optional"] = [](optional<names> a) {return !a;}; + f["nullable"] += [](names* a) {return a == nullptr;}; + f["optional"] += [](optional<names> a) {return !a;}; - f["dummy0"] = []() {return "abc";}; - f["dummy1"] = [](string s) {return s;}; - f["dummy2"] = [](uint64_t x, uint64_t y) {return x + y;}; + f["dummy0"] += []() {return "abc";}; + f["dummy1"] += [](string s) {return s;}; + f["dummy2"] += [](uint64_t x, uint64_t y) {return x + y;}; - f["ambig"] = [](names a, optional<string>) {return a;}; - f["ambig"] = [](names a, optional<uint64_t>) {return a;}; + f["ambig"] += [](names a, optional<string>) {return a;}; + f["ambig"] += [](names a, optional<uint64_t>) {return a;}; - f["reverse"] = [](names a) {return a;}; + f["reverse"] += [](names a) {return a;}; - f["scoped"] = [](const scope*, names a) {return a;}; - f["scoped_void"] = [](const scope*, names) {}; - f["scoped"] = &scoped; - f["scoped_void"] = &scoped_void; + f["scoped"] += [](const scope*, names a) {return a;}; + f["scoped_void"] += [](const scope*, names) {}; + f["scoped"] += &scoped; + f["scoped_void"] += &scoped_void; - f[".qual"] = []() {return "abc";}; + f[".qual"] += []() {return "abc";}; - f[".length"] = &path::size; // Member function. - f[".type"] = &name::type; // Data member. + f[".length"] += &path::size; // Member function. + f[".type"] += &name::type; // Data member. - f[".abs"] = [](dir_path d) {return d.absolute ();}; + f[".abs"] += [](dir_path d) {return d.absolute ();}; // Variadic function with first required argument of type bool. Returns // number of arguments passed. // - functions.insert ( - "variadic", + functions.insert ("variadic", true).insert ( function_overload ( nullptr, 1, @@ -96,8 +95,7 @@ namespace build2 // Dump arguments. // - functions.insert ( - "dump", + functions.insert ("dump", true).insert ( function_overload ( nullptr, 0, diff --git a/libbuild2/functions-builtin.cxx b/libbuild2/functions-builtin.cxx index 97cc449..4689ac2 100644 --- a/libbuild2/functions-builtin.cxx +++ b/libbuild2/functions-builtin.cxx @@ -19,7 +19,9 @@ namespace build2 // Note that we may want to extend the scope argument to a more general // notion of "lookup context" (scope, target, prerequisite). // - f["defined"] = [](const scope* s, names name) + // Note that this function is not pure. + // + f.insert ("defined", false) += [](const scope* s, names name) { if (s == nullptr) fail << "defined() called out of scope" << endf; @@ -29,7 +31,9 @@ namespace build2 // Return variable visibility if it has been entered and NULL otherwise. // - f["visibility"] = [](const scope* s, names name) + // Note that this function is not pure. + // + f.insert ("visibility", false) += [](const scope* s, names name) { if (s == nullptr) fail << "visibility() called out of scope" << endf; @@ -42,25 +46,25 @@ namespace build2 : nullopt); }; - f["type"] = [](value* v) {return v->type != nullptr ? v->type->name : "";}; - f["null"] = [](value* v) {return v->null;}; - f["empty"] = [](value* v) {return v->null || v->empty ();}; + f["type"] += [](value* v) {return v->type != nullptr ? v->type->name : "";}; + f["null"] += [](value* v) {return v->null;}; + f["empty"] += [](value* v) {return v->null || v->empty ();}; - f["identity"] = [](value* v) {return move (*v);}; + f["identity"] += [](value* v) {return move (*v);}; // string // - f["string"] = [](bool b) {return b ? "true" : "false";}; - f["string"] = [](int64_t i) {return to_string (i);}; - f["string"] = [](uint64_t i) {return to_string (i);}; - f["string"] = [](name n) {return to_string (n);}; + f["string"] += [](bool b) {return b ? "true" : "false";}; + f["string"] += [](int64_t i) {return to_string (i);}; + f["string"] += [](uint64_t i) {return to_string (i);}; + f["string"] += [](name n) {return to_string (n);}; // Quote a value returning its string representation. If escape is true, // then also escape (with a backslash) the quote characters being added // (this is useful if the result will be re-parsed, for example as a // Testscript command line). // - f["quote"] = [](value* v, optional<value> escape) + f["quote"] += [](value* v, optional<value> escape) { if (v->null) return string (); @@ -81,7 +85,9 @@ namespace build2 // Return NULL if the environment variable is not set, untyped value // otherwise. // - f["getenv"] = [](names name) + // Note that this function is not pure. + // + f.insert ("getenv", false) += [](names name) { optional<string> v (getenv (convert<string> (move (name)))); diff --git a/libbuild2/functions-filesystem.cxx b/libbuild2/functions-filesystem.cxx index 54c5315..696b1cf 100644 --- a/libbuild2/functions-filesystem.cxx +++ b/libbuild2/functions-filesystem.cxx @@ -78,6 +78,9 @@ namespace build2 void filesystem_functions (function_map& m) { + // @@ Maybe we should have the ability to mark the whole family as not + // pure? + function_family f (m, "filesystem"); // path_search @@ -86,25 +89,32 @@ namespace build2 // absolute path, then the start directory is ignored (if present). // Otherwise, the start directory must be specified and be absolute. // - f["path_search"] = [](path pattern, optional<dir_path> start) + // Note that this function is not pure. + // { - return path_search (pattern, start); - }; + auto e (f.insert ("path_search", false)); - f["path_search"] = [](path pattern, names start) - { - return path_search (pattern, convert<dir_path> (move (start))); - }; + e += [](path pattern, optional<dir_path> start) + { + return path_search (pattern, start); + }; - f["path_search"] = [](names pattern, optional<dir_path> start) - { - return path_search (convert<path> (move (pattern)), start); - }; + e += [](path pattern, names start) + { + return path_search (pattern, convert<dir_path> (move (start))); + }; + + e += [](names pattern, optional<dir_path> start) + { + return path_search (convert<path> (move (pattern)), start); + }; + + e += [](names pattern, names start) + { + return path_search (convert<path> (move (pattern)), + convert<dir_path> (move (start))); + }; + } - f["path_search"] = [](names pattern, names start) - { - return path_search (convert<path> (move (pattern)), - convert<dir_path> (move (start))); - }; } } diff --git a/libbuild2/functions-name.cxx b/libbuild2/functions-name.cxx index 8b61c81..e821e52 100644 --- a/libbuild2/functions-name.cxx +++ b/libbuild2/functions-name.cxx @@ -59,11 +59,11 @@ namespace build2 // function_family fn (m, "name"); - fn["name"] = [](const scope* s, name n) + fn["name"] += [](const scope* s, name n) { return to_target_name (s, move (n)).first.value; }; - fn["name"] = [](const scope* s, names ns) + fn["name"] += [](const scope* s, names ns) { return to_target_name (s, convert<name> (move (ns))).first.value; }; @@ -71,40 +71,40 @@ namespace build2 // Note: returns NULL if extension is unspecified (default) and empty if // specified as no extension. // - fn["extension"] = [](const scope* s, name n) + fn["extension"] += [](const scope* s, name n) { return to_target_name (s, move (n)).second; }; - fn["extension"] = [](const scope* s, names ns) + fn["extension"] += [](const scope* s, names ns) { return to_target_name (s, convert<name> (move (ns))).second; }; - fn["directory"] = [](const scope* s, name n) + fn["directory"] += [](const scope* s, name n) { return to_target_name (s, move (n)).first.dir; }; - fn["directory"] = [](const scope* s, names ns) + fn["directory"] += [](const scope* s, names ns) { return to_target_name (s, convert<name> (move (ns))).first.dir; }; - fn["target_type"] = [](const scope* s, name n) + fn["target_type"] += [](const scope* s, name n) { return to_target_name (s, move (n)).first.type; }; - fn["target_type"] = [](const scope* s, names ns) + fn["target_type"] += [](const scope* s, names ns) { return to_target_name (s, convert<name> (move (ns))).first.type; }; // Note: returns NULL if no project specified. // - fn["project"] = [](const scope* s, name n) + fn["project"] += [](const scope* s, name n) { return to_target_name (s, move (n)).first.proj; }; - fn["project"] = [](const scope* s, names ns) + fn["project"] += [](const scope* s, names ns) { return to_target_name (s, convert<name> (move (ns))).first.proj; }; @@ -113,7 +113,12 @@ namespace build2 // function_family ft (m, "target"); - ft["path"] = [](const scope* s, names ns) + // Note that while this function is not technically pure, we don't mark it + // as such since it can only be called (normally form a recipe) after the + // target has been matched, meaning that this target is a prerequisite and + // therefore this impurity has been accounted for. + // + ft["path"] += [](const scope* s, names ns) { if (s == nullptr) fail << "target.path() called out of scope"; @@ -155,7 +160,10 @@ namespace build2 // This one can only be called on a single target since we don't support // containers of process_path's (though we probably could). // - fn["process_path"] = [](const scope* s, names ns) + // Note that while this function is not technically pure, we don't mark it + // as such for the same reasons as $path() above. + // + fn["process_path"] += [](const scope* s, names ns) { if (s == nullptr) fail << "target.process_path() called out of scope"; @@ -184,7 +192,7 @@ namespace build2 // function_family fb (m, "builtin"); - fb[".concat"] = [](dir_path d, name n) + fb[".concat"] += [](dir_path d, name n) { d /= n.dir; n.dir = move (d); diff --git a/libbuild2/functions-path.cxx b/libbuild2/functions-path.cxx index 2d5fad4..fdf712c 100644 --- a/libbuild2/functions-path.cxx +++ b/libbuild2/functions-path.cxx @@ -144,9 +144,9 @@ namespace build2 // string // - f["string"] = [](path p) {return move (p).string ();}; + f["string"] += [](path p) {return move (p).string ();}; - f["string"] = [](paths v) + f["string"] += [](paths v) { strings r; for (auto& p: v) @@ -154,7 +154,7 @@ namespace build2 return r; }; - f["string"] = [](dir_paths v) + f["string"] += [](dir_paths v) { strings r; for (auto& p: v) @@ -164,9 +164,9 @@ namespace build2 // representation // - f["representation"] = [](path p) {return move (p).representation ();}; + f["representation"] += [](path p) {return move (p).representation ();}; - f["representation"] = [](paths v) + f["representation"] += [](paths v) { strings r; for (auto& p: v) @@ -174,7 +174,7 @@ namespace build2 return r; }; - f["representation"] = [](dir_paths v) + f["representation"] += [](dir_paths v) { strings r; for (auto& p: v) @@ -186,24 +186,24 @@ namespace build2 // // @@ TODO: add ability to specify alternative separator. // - f["canonicalize"] = [](path p) {p.canonicalize (); return p;}; - f["canonicalize"] = [](dir_path p) {p.canonicalize (); return p;}; + f["canonicalize"] += [](path p) {p.canonicalize (); return p;}; + f["canonicalize"] += [](dir_path p) {p.canonicalize (); return p;}; - f["canonicalize"] = [](paths v) + f["canonicalize"] += [](paths v) { for (auto& p: v) p.canonicalize (); return v; }; - f["canonicalize"] = [](dir_paths v) + f["canonicalize"] += [](dir_paths v) { for (auto& p: v) p.canonicalize (); return v; }; - f[".canonicalize"] = [](names ns) + f[".canonicalize"] += [](names ns) { // For each path decide based on the presence of a trailing slash // whether it is a directory. Return as untyped list of (potentially @@ -221,19 +221,22 @@ namespace build2 // normalize // - f["normalize"] = [](path p, optional<value> a) + // @@ TODO: normalize(true) is not pure, redo as a separate actualize() + // function. + // + f["normalize"] += [](path p, optional<value> a) { p.normalize (a && convert<bool> (move (*a))); return p; }; - f["normalize"] = [](dir_path p, optional<value> a) + f["normalize"] += [](dir_path p, optional<value> a) { p.normalize (a && convert<bool> (move (*a))); return p; }; - f["normalize"] = [](paths v, optional<value> a) + f["normalize"] += [](paths v, optional<value> a) { bool act (a && convert<bool> (move (*a))); @@ -242,7 +245,7 @@ namespace build2 return v; }; - f["normalize"] = [](dir_paths v, optional<value> a) + f["normalize"] += [](dir_paths v, optional<value> a) { bool act (a && convert<bool> (move (*a))); @@ -251,7 +254,7 @@ namespace build2 return v; }; - f[".normalize"] = [](names ns, optional<value> a) + f[".normalize"] += [](names ns, optional<value> a) { bool act (a && convert<bool> (move (*a))); @@ -271,9 +274,9 @@ namespace build2 // directory // - f["directory"] = &path::directory; + f["directory"] += &path::directory; - f["directory"] = [](paths v) + f["directory"] += [](paths v) { dir_paths r; for (const path& p: v) @@ -281,14 +284,14 @@ namespace build2 return r; }; - f["directory"] = [](dir_paths v) + f["directory"] += [](dir_paths v) { for (dir_path& p: v) p = p.directory (); return v; }; - f[".directory"] = [](names ns) + f[".directory"] += [](names ns) { // For each path decide based on the presence of a trailing slash // whether it is a directory. Return as list of directory names. @@ -305,23 +308,23 @@ namespace build2 // base // - f["base"] = &path::base; + f["base"] += &path::base; - f["base"] = [](paths v) + f["base"] += [](paths v) { for (path& p: v) p = p.base (); return v; }; - f["base"] = [](dir_paths v) + f["base"] += [](dir_paths v) { for (dir_path& p: v) p = p.base (); return v; }; - f[".base"] = [](names ns) + f[".base"] += [](names ns) { // For each path decide based on the presence of a trailing slash // whether it is a directory. Return as untyped list of (potentially @@ -339,28 +342,28 @@ namespace build2 // leaf // - f["leaf"] = &path::leaf; + f["leaf"] += &path::leaf; - f["leaf"] = [](path p, dir_path d) + f["leaf"] += [](path p, dir_path d) { return leaf (p, move (d)); }; - f["leaf"] = [](paths v, optional<dir_path> d) + f["leaf"] += [](paths v, optional<dir_path> d) { for (path& p: v) p = leaf (p, d); return v; }; - f["leaf"] = [](dir_paths v, optional<dir_path> d) + f["leaf"] += [](dir_paths v, optional<dir_path> d) { for (dir_path& p: v) p = leaf (p, d); return v; }; - f[".leaf"] = [](names ns, optional<dir_path> d) + f[".leaf"] += [](names ns, optional<dir_path> d) { // For each path decide based on the presence of a trailing slash // whether it is a directory. Return as untyped list of (potentially @@ -378,9 +381,9 @@ namespace build2 // extension // - f["extension"] = &extension; + f["extension"] += &extension; - f[".extension"] = [](names ns) + f[".extension"] += [](names ns) { return extension (convert<path> (move (ns))); }; @@ -415,19 +418,19 @@ namespace build2 // // Name matching. // - f[".match"] = [](string name, string pattern) + f[".match"] += [](string name, string pattern) { return path_match (name, pattern); }; // Path matching. // - f["match"] = [](path ent, path pat, optional<dir_path> start) + f["match"] += [](path ent, path pat, optional<dir_path> start) { return path_match (ent, pat, start); }; - f["match"] = [](path ent, names pat, optional<names> start) + f["match"] += [](path ent, names pat, optional<names> start) { return path_match (ent, convert<path> (move (pat)), @@ -436,7 +439,7 @@ namespace build2 : optional<dir_path> ()); }; - f["match"] = [](names ent, path pat, optional<names> start) + f["match"] += [](names ent, path pat, optional<names> start) { return path_match (convert<path> (move (ent)), pat, @@ -448,7 +451,7 @@ namespace build2 // The semantics depends on the presence of the start directory or the // first two argument syntactic representation. // - f[".match"] = [](names ent, names pat, optional<names> start) + f[".match"] += [](names ent, names pat, optional<names> start) { auto path_arg = [] (const names& a) -> bool { @@ -472,15 +475,15 @@ namespace build2 // function_family b (m, "builtin", &path_thunk); - b[".concat"] = &concat_path_string; - b[".concat"] = &concat_dir_path_string; + b[".concat"] += &concat_path_string; + b[".concat"] += &concat_dir_path_string; - b[".concat"] = [](path l, names ur) + b[".concat"] += [](path l, names ur) { return concat_path_string (move (l), convert<string> (move (ur))); }; - b[".concat"] = [](dir_path l, names ur) + b[".concat"] += [](dir_path l, names ur) { return concat_dir_path_string (move (l), convert<string> (move (ur))); }; diff --git a/libbuild2/functions-process-path.cxx b/libbuild2/functions-process-path.cxx index 86d4445..199ad0d 100644 --- a/libbuild2/functions-process-path.cxx +++ b/libbuild2/functions-process-path.cxx @@ -16,8 +16,8 @@ namespace build2 // As discussed in value_traits<process_path>, we always have recall. // - f["recall"] = &process_path::recall; - f["effect"] = [](process_path p) + f["recall"] += &process_path::recall; + f["effect"] += [](process_path p) { return move (p.effect.empty () ? p.recall : p.effect); }; @@ -26,8 +26,8 @@ namespace build2 { function_family f (m, "process_path_ex"); - f["name"] = &process_path_ex::name; - f["checksum"] = &process_path_ex::checksum; + f["name"] += &process_path_ex::name; + f["checksum"] += &process_path_ex::checksum; } } } diff --git a/libbuild2/functions-process.cxx b/libbuild2/functions-process.cxx index 73ca916..0870874 100644 --- a/libbuild2/functions-process.cxx +++ b/libbuild2/functions-process.cxx @@ -414,12 +414,14 @@ namespace build2 // // Run builtin or external program and return trimmed stdout. // - f[".run"] = [](const scope* s, names args) + // Note that this function is not pure. + // + f.insert (".run", false) += [](const scope* s, names args) { return run (s, move (args)); }; - f["run"] = [](const scope* s, process_path pp) + f.insert ("run", false) += [](const scope* s, process_path pp) { return run_process (s, pp, strings ()); }; @@ -433,38 +435,41 @@ namespace build2 // (as a whole) against <pat> and, if successful, returned, optionally // processed with <fmt>, as an element of a list. // - f[".run_regex"] = [](const scope* s, names a, string p, optional<string> f) + // Note that this function is not pure. + // { - return run_regex (s, move (a), p, f); - }; + auto e (f.insert (".run_regex", false)); - f[".run_regex"] = [] (const scope* s, names a, names p, optional<names> f) - { - return run_regex (s, - move (a), - convert<string> (move (p)), - f ? convert<string> (move (*f)) : nullopt_string); - }; + e += [](const scope* s, names a, string p, optional<string> f) + { + return run_regex (s, move (a), p, f); + }; - f["run_regex"] = [](const scope* s, - process_path pp, - string p, - optional<string> f) + e += [] (const scope* s, names a, names p, optional<names> f) + { + return run_regex (s, + move (a), + convert<string> (move (p)), + f ? convert<string> (move (*f)) : nullopt_string); + }; + } { - return run_process_regex (s, pp, strings (), p, f); - }; + auto e (f.insert ("run_regex", false)); - f["run_regex"] = [](const scope* s, - process_path pp, - names p, - optional<names> f) - { - return run_process_regex (s, - pp, strings (), - convert<string> (move (p)), - (f - ? convert<string> (move (*f)) - : nullopt_string)); - }; + e += [](const scope* s, process_path pp, string p, optional<string> f) + { + return run_process_regex (s, pp, strings (), p, f); + }; + + e += [](const scope* s, process_path pp, names p, optional<names> f) + { + return run_process_regex (s, + pp, strings (), + convert<string> (move (p)), + (f + ? convert<string> (move (*f)) + : nullopt_string)); + }; + } } } diff --git a/libbuild2/functions-project-name.cxx b/libbuild2/functions-project-name.cxx index 86206b0..145e62c 100644 --- a/libbuild2/functions-project-name.cxx +++ b/libbuild2/functions-project-name.cxx @@ -13,46 +13,46 @@ namespace build2 { function_family f (m, "project_name"); - f["string"] = [](project_name p) {return move (p).string ();}; + f["string"] += [](project_name p) {return move (p).string ();}; - f["base"] = [](project_name p, optional<string> ext) + f["base"] += [](project_name p, optional<string> ext) { return ext ? p.base (ext->c_str ()) : p.base (); }; - f["base"] = [](project_name p, names ext) + f["base"] += [](project_name p, names ext) { return p.base (convert<string> (move (ext)).c_str ()); }; - f["extension"] = &project_name::extension; - f["variable"] = &project_name::variable; + f["extension"] += &project_name::extension; + f["variable"] += &project_name::variable; // Project name-specific overloads from builtins. // function_family b (m, "builtin"); - b[".concat"] = [](project_name n, string s) + b[".concat"] += [](project_name n, string s) { string r (move (n).string ()); r += s; return r; }; - b[".concat"] = [](string s, project_name n) + b[".concat"] += [](string s, project_name n) { s += n.string (); return s; }; - b[".concat"] = [](project_name n, names ns) + b[".concat"] += [](project_name n, names ns) { string r (move (n).string ()); r += convert<string> (move (ns)); return r; }; - b[".concat"] = [](names ns, project_name n) + b[".concat"] += [](names ns, project_name n) { string r (convert<string> (move (ns))); r += n.string (); diff --git a/libbuild2/functions-regex.cxx b/libbuild2/functions-regex.cxx index a59d808..46d71ba 100644 --- a/libbuild2/functions-regex.cxx +++ b/libbuild2/functions-regex.cxx @@ -521,12 +521,12 @@ namespace build2 // sub-strings that match the marked sub-expressions and // NULL if no match // - f[".match"] = [](value s, string re, optional<names> flags) + f[".match"] += [](value s, string re, optional<names> flags) { return match (move (s), re, move (flags)); }; - f[".match"] = [](value s, names re, optional<names> flags) + f[".match"] += [](value s, names re, optional<names> flags) { return match (move (s), convert<string> (move (re)), move (flags)); }; @@ -540,12 +540,12 @@ namespace build2 // // icase - match ignoring case // - f[".find_match"] = [](names s, string re, optional<names> flags) + f[".find_match"] += [](names s, string re, optional<names> flags) { return find_match (move (s), re, move (flags)); }; - f[".find_match"] = [](names s, names re, optional<names> flags) + f[".find_match"] += [](names s, names re, optional<names> flags) { return find_match (move (s), convert<string> (move (re)), move (flags)); }; @@ -573,12 +573,12 @@ namespace build2 // If both return_match and return_subs flags are specified then the // sub-string that matches the whole regular expression comes first. // - f[".search"] = [](value s, string re, optional<names> flags) + f[".search"] += [](value s, string re, optional<names> flags) { return search (move (s), re, move (flags)); }; - f[".search"] = [](value s, names re, optional<names> flags) + f[".search"] += [](value s, names re, optional<names> flags) { return search (move (s), convert<string> (move (re)), move (flags)); }; @@ -593,12 +593,12 @@ namespace build2 // // icase - match ignoring case // - f[".find_search"] = [](names s, string re, optional<names> flags) + f[".find_search"] += [](names s, string re, optional<names> flags) { return find_search (move (s), re, move (flags)); }; - f[".find_search"] = [](names s, names re, optional<names> flags) + f[".find_search"] += [](names s, names re, optional<names> flags) { return find_search (move (s), convert<string> (move (re)), @@ -625,12 +625,12 @@ namespace build2 // If both format_first_only and format_no_copy flags are specified then // the result will only contain the replacement of the first match. // - f[".replace"] = [](value s, string re, string fmt, optional<names> flags) + f[".replace"] += [](value s, string re, string fmt, optional<names> flags) { return replace (move (s), re, fmt, move (flags)); }; - f[".replace"] = [](value s, names re, names fmt, optional<names> flags) + f[".replace"] += [](value s, names re, names fmt, optional<names> flags) { return replace (move (s), convert<string> (move (re)), @@ -658,7 +658,7 @@ namespace build2 // Note that if format_no_copy is specified, unmatched lines are not // copied either. // - f[".replace_lines"] = [](value s, + f[".replace_lines"] += [](value s, string re, string fmt, optional<names> flags) @@ -666,7 +666,7 @@ namespace build2 return replace_lines (move (s), re, move (fmt), move (flags)); }; - f[".replace_lines"] = [](value s, + f[".replace_lines"] += [](value s, names re, names* fmt, optional<names> flags) @@ -695,12 +695,12 @@ namespace build2 // // format_no_copy - do not copy unmatched value parts into the result // - f[".split"] = [](value s, string re, string fmt, optional<names> flags) + f[".split"] += [](value s, string re, string fmt, optional<names> flags) { return split (move (s), re, fmt, move (flags)); }; - f[".split"] = [](value s, names re, names fmt, optional<names> flags) + f[".split"] += [](value s, names re, names fmt, optional<names> flags) { return split (move (s), convert<string> (move (re)), @@ -730,7 +730,7 @@ namespace build2 // the result will be a concatenation of only the first match // replacements. // - f[".merge"] = [](names s, + f[".merge"] += [](names s, string re, string fmt, optional<string> delim, @@ -739,7 +739,7 @@ namespace build2 return merge (move (s), re, fmt, move (delim), move (flags)); }; - f[".merge"] = [](names s, + f[".merge"] += [](names s, names re, names fmt, optional<names> delim, @@ -775,12 +775,12 @@ namespace build2 // the result elements will only contain the replacement of the first // match. // - f[".apply"] = [](names s, string re, string fmt, optional<names> flags) + f[".apply"] += [](names s, string re, string fmt, optional<names> flags) { return apply (move (s), re, fmt, move (flags)); }; - f[".apply"] = [](names s, names re, names fmt, optional<names> flags) + f[".apply"] += [](names s, names re, names fmt, optional<names> flags) { return apply (move (s), convert<string> (move (re)), diff --git a/libbuild2/functions-string.cxx b/libbuild2/functions-string.cxx index c5cb216..b430ebf 100644 --- a/libbuild2/functions-string.cxx +++ b/libbuild2/functions-string.cxx @@ -13,31 +13,31 @@ namespace build2 { function_family f (m, "string"); - f["string"] = [](string s) {return s;}; + f["string"] += [](string s) {return s;}; // @@ Shouldn't it concatenate elements into the single string? // @@ Doesn't seem to be used so far. Can consider removing. // - // f["string"] = [](strings v) {return v;}; + // f["string"] += [](strings v) {return v;}; // Compare ASCII strings ignoring case and returning the boolean value. // - f["icasecmp"] = [](string x, string y) + f["icasecmp"] += [](string x, string y) { return icasecmp (x, y) == 0; }; - f["icasecmp"] = [](string x, names y) + f["icasecmp"] += [](string x, names y) { return icasecmp (x, convert<string> (move (y))) == 0; }; - f["icasecmp"] = [](names x, string y) + f["icasecmp"] += [](names x, string y) { return icasecmp (convert<string> (move (x)), y) == 0; }; - f[".icasecmp"] = [](names x, names y) + f[".icasecmp"] += [](names x, names y) { return icasecmp (convert<string> (move (x)), convert<string> (move (y))) == 0; @@ -45,34 +45,34 @@ namespace build2 // Trim. // - f["trim"] = [](string s) + f["trim"] += [](string s) { return trim (move (s)); }; - f[".trim"] = [](names s) + f[".trim"] += [](names s) { return names {name (trim (convert<string> (move (s))))}; }; // Convert ASCII strings into lower/upper case. // - f["lcase"] = [](string s) + f["lcase"] += [](string s) { return lcase (move (s)); }; - f[".lcase"] = [](names s) + f[".lcase"] += [](names s) { return names {name (lcase (convert<string> (move (s))))}; }; - f["ucase"] = [](string s) + f["ucase"] += [](string s) { return ucase (move (s)); }; - f[".ucase"] = [](names s) + f[".ucase"] += [](names s) { return names {name (ucase (convert<string> (move (s))))}; }; @@ -81,15 +81,15 @@ namespace build2 // function_family b (m, "builtin"); - b[".concat"] = [](string l, string r) {l += r; return l;}; + b[".concat"] += [](string l, string r) {l += r; return l;}; - b[".concat"] = [](string l, names ur) + b[".concat"] += [](string l, names ur) { l += convert<string> (move (ur)); return l; }; - b[".concat"] = [](names ul, string r) + b[".concat"] += [](names ul, string r) { string l (convert<string> (move (ul))); l += r; diff --git a/libbuild2/functions-target-triplet.cxx b/libbuild2/functions-target-triplet.cxx index ff9a15d..4b0ec02 100644 --- a/libbuild2/functions-target-triplet.cxx +++ b/libbuild2/functions-target-triplet.cxx @@ -13,22 +13,22 @@ namespace build2 { function_family f (m, "target_triplet"); - f["string"] = [](target_triplet t) {return t.string ();}; - f["representation"] = [](target_triplet t) {return t.representation ();}; + f["string"] += [](target_triplet t) {return t.string ();}; + f["representation"] += [](target_triplet t) {return t.representation ();}; // Target triplet-specific overloads from builtins. // function_family b (m, "builtin"); - b[".concat"] = [](target_triplet l, string sr) {return l.string () + sr;}; - b[".concat"] = [](string sl, target_triplet r) {return sl + r.string ();}; + b[".concat"] += [](target_triplet l, string sr) {return l.string () + sr;}; + b[".concat"] += [](string sl, target_triplet r) {return sl + r.string ();}; - b[".concat"] = [](target_triplet l, names ur) + b[".concat"] += [](target_triplet l, names ur) { return l.string () + convert<string> (move (ur)); }; - b[".concat"] = [](names ul, target_triplet r) + b[".concat"] += [](names ul, target_triplet r) { return convert<string> (move (ul)) + r.string (); }; diff --git a/libbuild2/install/functions.cxx b/libbuild2/install/functions.cxx index c780061..5668efe 100644 --- a/libbuild2/install/functions.cxx +++ b/libbuild2/install/functions.cxx @@ -18,7 +18,9 @@ namespace build2 // Resolve potentially relative install.* value to an absolute directory // based on (other) install.* values visible from the calling scope. // - f[".resolve"] = [] (const scope* s, dir_path d) + // Note that this function is not pure. + // + f.insert (".resolve", false) += [] (const scope* s, dir_path d) { if (s == nullptr) fail << "install.resolve() called out of scope" << endf; |