diff options
| -rw-r--r-- | build2/b.cxx | 16 | ||||
| -rw-r--r-- | build2/buildfile | 1 | ||||
| -rw-r--r-- | build2/regex | 57 | ||||
| -rw-r--r-- | build2/regex.cxx | 42 | ||||
| -rw-r--r-- | build2/regex.txx | 215 | ||||
| -rw-r--r-- | build2/test/script/builtin.cxx | 506 | ||||
| -rw-r--r-- | build2/test/script/regex | 5 | ||||
| -rw-r--r-- | build2/test/script/runner.cxx | 38 | ||||
| -rw-r--r-- | tests/test/script/builtin/buildfile | 2 | ||||
| -rw-r--r-- | tests/test/script/builtin/sed.test | 312 |
10 files changed, 1045 insertions, 149 deletions
diff --git a/build2/b.cxx b/build2/b.cxx index e576435..b06459b 100644 --- a/build2/b.cxx +++ b/build2/b.cxx @@ -2,7 +2,10 @@ // copyright : Copyright (c) 2014-2017 Code Synthesis Ltd // license : MIT; see accompanying LICENSE file -#include <string.h> // strerror() +#ifndef _WIN32 +# include <signal.h> // signal() +#endif + #include <stdlib.h> // getenv() _putenv()(_WIN32) #include <sstream> @@ -82,6 +85,17 @@ main (int argc, char* argv[]) { tracer trace ("main"); + // On POSIX ignore SIGPIPE which is signaled to a pipe-writing process if + // the pipe reading end is closed. Note that by default this signal + // terminates a process. Also note that there is no way to disable this + // behavior on a file descriptor basis or for the write() function call. + // +#ifndef _WIN32 + if (signal (SIGPIPE, SIG_IGN) == SIG_ERR) + fail << "unable to ignore broken pipe (SIGPIPE) signal: " + << system_error (errno, system_category ()); // Sanitize. +#endif + // Parse the command line. We want to be able to specify options, vars, // and buildspecs in any order (it is really handy to just add -v at the // end of the command line). diff --git a/build2/buildfile b/build2/buildfile index 84e2f82..1ee7063 100644 --- a/build2/buildfile +++ b/build2/buildfile @@ -26,6 +26,7 @@ exe{b}: \ {hxx cxx}{ operation } \ {hxx cxx}{ parser } \ {hxx cxx}{ prerequisite } \ + {hxx txx cxx}{ regex } \ {hxx cxx}{ rule } \ {hxx }{ rule-map } \ {hxx txx cxx}{ scheduler } \ diff --git a/build2/regex b/build2/regex new file mode 100644 index 0000000..dc6dc96 --- /dev/null +++ b/build2/regex @@ -0,0 +1,57 @@ +// file : build2/regex -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef BUILD2_REGEX +#define BUILD2_REGEX + +#include <regex> +#include <iosfwd> +#include <string> // basic_string + +#include <build2/types> +#include <build2/utility> + +namespace build2 +{ + // Like std::regex_match() but extends the standard ECMA-262 + // substitution escape sequences with a subset of Perl sequences: + // + // \\, \u, \l, \U, \L, \E, \1, ..., \9 + // + // Also return the resulting string as well as whether the search + // succeeded. + // + // Notes and limitations: + // + // - The only valid regex_constants flags are match_default, + // format_first_only (format_no_copy can easily be supported). + // + // - If backslash doesn't start any of the listed sequences then it is + // silently dropped and the following character is copied as is. + // + // - The character case conversion is performed according to the global + // C++ locale (which is, unless changed, is the same as C locale and + // both default to the POSIX locale aka "C"). + // + template <typename C> + pair<std::basic_string<C>, bool> + regex_replace_ex (const std::basic_string<C>&, + const std::basic_regex<C>&, + const std::basic_string<C>& fmt, + std::regex_constants::match_flag_type = + std::regex_constants::match_default); +} + +namespace std +{ + // Print regex error description but only if it is meaningful (this is also + // why we have to print leading colon). + // + ostream& + operator<< (ostream&, const regex_error&); +} + +#include <build2/regex.txx> + +#endif // BUILD2_REGEX diff --git a/build2/regex.cxx b/build2/regex.cxx new file mode 100644 index 0000000..40347b5 --- /dev/null +++ b/build2/regex.cxx @@ -0,0 +1,42 @@ +// file : build2/regex.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <build2/regex> + +#if defined(_MSC_VER) && _MSC_VER <= 1910 +# include <cstring> // strstr() +#endif + +#include <ostream> +#include <sstream> + +namespace std +{ + // Currently libstdc++ just returns the name of the exception (bug #67361). + // So we check that the description contains at least one space character. + // + // While VC's description is meaningful, it has an undesired prefix that + // resembles the following: 'regex_error(error_badrepeat): '. So we skip it. + // + ostream& + operator<< (ostream& o, const regex_error& e) + { + const char* d (e.what ()); + +#if defined(_MSC_VER) && _MSC_VER <= 1910 + const char* rd (strstr (d, "): ")); + if (rd != nullptr) + d = rd + 3; +#endif + + ostringstream os; + os << runtime_error (d); // Sanitize the description. + + string s (os.str ()); + if (s.find (' ') != string::npos) + o << ": " << s; + + return o; + } +} diff --git a/build2/regex.txx b/build2/regex.txx new file mode 100644 index 0000000..1325de9 --- /dev/null +++ b/build2/regex.txx @@ -0,0 +1,215 @@ +// file : build2/regex.txx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +namespace build2 +{ + template <typename C> + pair<std::basic_string<C>, bool> + regex_replace_ex (const std::basic_string<C>& s, + const std::basic_regex<C>& re, + const std::basic_string<C>& fmt, + std::regex_constants::match_flag_type flags) + { + using namespace std; + + using string_type = basic_string<C>; + using str_it = typename string_type::const_iterator; + using regex_it = regex_iterator<str_it>; + + bool first_only ((flags & std::regex_constants::format_first_only) == + std::regex_constants::format_first_only); + + locale cl; // Copy of the global C++ locale. + string_type r; + + // Beginning of the last unmatched substring. + // + str_it ub (s.begin ()); + + regex_it b (s.begin (), s.end (), re, flags); + regex_it e; + bool match (b != e); + + for (regex_it i (b); i != e; ++i) + { + const match_results<str_it>& m (*i); + + // Copy the preceeding unmatched substring, save the beginning of the + // one that follows. + // + r.append (ub, m.prefix ().second); + ub = m.suffix ().first; + + if (first_only && i != b) + r.append (m[0].first, m[0].second); // Append matched substring. + else + { + // The standard implementation calls m.format() here. We perform our + // own formatting. + // + // Note that we are using char type literals with the assumption that + // being ASCII characters they will be properly "widened" to the + // corresponding literals of the C template parameter type. + // + auto digit = [] (C c) -> int + { + return c >= '0' && c <= '9' ? c - '0' : -1; + }; + + enum class case_conv {none, upper, lower, upper_once, lower_once} + mode (case_conv::none); + + auto conv_chr = [&mode, &cl] (C c) -> C + { + switch (mode) + { + case case_conv::upper_once: mode = case_conv::none; + case case_conv::upper: c = toupper (c, cl); break; + case case_conv::lower_once: mode = case_conv::none; + case case_conv::lower: c = tolower (c, cl); break; + case case_conv::none: break; + } + return c; + }; + + auto append_chr = [&r, &conv_chr] (C c) + { + r.push_back (conv_chr (c)); + }; + + auto append_str = [&r, &mode, &conv_chr] (str_it b, str_it e) + { + // Optimize for the common case. + // + if (mode == case_conv::none) + r.append (b, e); + else + { + for (str_it i (b); i != e; ++i) + r.push_back (conv_chr (*i)); + } + }; + + size_t n (fmt.size ()); + for (size_t i (0); i < n; ++i) + { + C c (fmt[i]); + + switch (c) + { + case '$': + { + // Check if this is a $-based escape sequence. Interpret it + // accordingly if that's the case, treat '$' as a regular + // character otherwise. + // + c = fmt[++i]; // '\0' if last. + + switch (c) + { + case '$': append_chr (c); break; + case '&': append_str (m[0].first, m[0].second); break; + case '`': + { + append_str (m.prefix ().first, m.prefix ().second); + break; + } + case '\'': + { + append_str (m.suffix ().first, m.suffix ().second); + break; + } + default: + { + // Check if this is a sub-expression 1-based index ($n or + // $nn). Append the matching substring if that's the case. + // Treat '$' as a regular character otherwise. Index greater + // than the sub-expression count is silently ignored. + // + int si (digit (c)); + if (si >= 0) + { + int d; + if ((d = digit (fmt[i + 1])) >= 0) // '\0' if last. + { + si = si * 10 + d; + ++i; + } + } + + if (si > 0) + { + // m[0] refers to the matched substring. + // + if (static_cast<size_t> (si) < m.size ()) + append_str (m[si].first, m[si].second); + } + else + { + // Not a $-based escape sequence so treat '$' as a + // regular character. + // + --i; + append_chr ('$'); + } + + break; + } + } + + break; + } + case '\\': + { + c = fmt[++i]; // '\0' if last. + + switch (c) + { + case '\\': append_chr (c); break; + + case 'u': mode = case_conv::upper_once; break; + case 'l': mode = case_conv::lower_once; break; + case 'U': mode = case_conv::upper; break; + case 'L': mode = case_conv::lower; break; + case 'E': mode = case_conv::none; break; + default: + { + // Check if this is a sub-expression 1-based index. Append + // the matching substring if that's the case, Skip '\\' + // otherwise. Index greater than the sub-expression count is + // silently ignored. + // + int si (digit (c)); + if (si > 0) + { + // m[0] refers to the matched substring. + // + if (static_cast<size_t> (si) < m.size ()) + append_str (m[si].first, m[si].second); + } + else + --i; + + break; + } + } + + break; + } + default: + { + // Append a regular character. + // + append_chr (c); + break; + } + } + } + } + } + + r.append (ub, s.end ()); // Append the rightmost non-matched substring. + return make_pair (move (r), match); + } +} diff --git a/build2/test/script/builtin.cxx b/build2/test/script/builtin.cxx index 008ac32..3957adb 100644 --- a/build2/test/script/builtin.cxx +++ b/build2/test/script/builtin.cxx @@ -10,12 +10,17 @@ # include <sys/utime.h> #endif +#include <locale> #include <thread> +#include <ostream> +#include <sstream> #include <butl/path-io> // use default operator<< implementation #include <butl/fdstream> // fdopen_mode, fdstream_mode #include <butl/filesystem> // mkdir_status +#include <build2/regex> + #include <build2/test/script/script> // Strictly speaking a builtin which reads/writes from/to standard streams @@ -51,6 +56,74 @@ namespace build2 // struct failed {}; + // Accumulate an error message, print it atomically in dtor to the + // provided stream and throw failed afterwards if requested. Prefixes + // the message with the builtin name. + // + // Move constructible-only, not assignable (based to diag_record). + // + class error_record + { + public: + template <typename T> + friend const error_record& + operator<< (const error_record& r, const T& x) + { + r.ss_ << x; + return r; + } + + error_record (ostream& o, bool fail, const char* name) + : os_ (o), fail_ (fail), empty_ (false) + { + ss_ << name << ": "; + } + + // Older versions of libstdc++ don't have the ostringstream move + // support. Luckily, GCC doesn't seem to be actually needing move due + // to copy/move elision. + // +#ifdef __GLIBCXX__ + error_record (error_record&&); +#else + error_record (error_record&& r) + : os_ (r.os_), + ss_ (move (r.ss_)), + fail_ (r.fail_), + empty_ (r.empty_) + { + r.empty_ = true; + } +#endif + + ~error_record () noexcept (false) + { + if (!empty_) + { + // The output stream can be in a bad state (for example as a + // result of unsuccessful attempt to report a previous error), so + // we check it. + // + if (os_.good ()) + { + ss_.put ('\n'); + os_ << ss_.str (); + os_.flush (); + } + + if (fail_) + throw failed (); + } + } + + private: + ostream& os_; + mutable ostringstream ss_; + + bool fail_; + bool empty_; + }; + // Parse and normalize a path. Also, unless it is already absolute, make // the path absolute using the specified directory. Throw invalid_path // if the path is empty, and on parsing and normalization failures. @@ -103,6 +176,11 @@ namespace build2 uint8_t r (1); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "cat"); + }; + try { ifdstream cin (move (in), fdstream_mode::binary); @@ -154,15 +232,15 @@ namespace build2 } catch (const io_error& e) { - cerr << "cat: unable to print "; + error_record d (error ()); + d << "unable to print "; if (p.empty ()) - cerr << "stdin"; + d << "stdin"; else - cerr << "'" << p << "'"; + d << "'" << p << "'"; - cerr << ": " << e << endl; - throw failed (); + d << ": " << e; } cin.close (); @@ -171,15 +249,13 @@ namespace build2 } catch (const invalid_path& e) { - cerr << "cat: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing cin, cout or writing to cerr (that's - // why need to check its state before writing). + // Can be thrown while creating/closing cin, cout or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "cat: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -215,8 +291,7 @@ namespace build2 for (auto b (args.begin ()), i (b), e (args.end ()); i != e; ++i) cout << (i != b ? " " : "") << *i; - cout << endl; - + cout << '\n'; cout.close (); r = 0; } @@ -291,6 +366,11 @@ namespace build2 uint8_t r (1); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "mkdir"); + }; + try { in.close (); @@ -317,10 +397,7 @@ namespace build2 // Create directories. // if (i == args.end ()) - { - cerr << "mkdir: missing directory" << endl; - throw failed (); - } + error () << "missing directory"; for (; i != args.end (); ++i) { @@ -337,9 +414,7 @@ namespace build2 } catch (const system_error& e) { - cerr << "mkdir: unable to create directory '" << p << "': " - << e << endl; - throw failed (); + error () << "unable to create directory '" << p << "': " << e; } } @@ -347,15 +422,13 @@ namespace build2 } catch (const invalid_path& e) { - cerr << "mkdir: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing in, out or writing to cerr (that's why - // need to check its state before writing). + // Can be thrown while closing in, out or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "mkdir: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -403,6 +476,11 @@ namespace build2 uint8_t r (1); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "rm"); + }; + try { in.close (); @@ -432,10 +510,7 @@ namespace build2 // Remove entries. // if (i == args.end () && !force) - { - cerr << "rm: missing file" << endl; - throw failed (); - } + error () << "missing file"; const dir_path& wd (sp.wd_path); const dir_path& rwd (sp.root->wd_path); @@ -445,11 +520,8 @@ namespace build2 path p (parse_path (*i, wd)); if (!p.sub (rwd) && !force) - { - cerr << "rm: '" << p << "' is out of working directory '" << rwd - << "'" << endl; - throw failed (); - } + error () << "'" << p << "' is out of working directory '" << rwd + << "'"; try { @@ -458,17 +530,11 @@ namespace build2 if (dir_exists (d)) { if (!dir) - { - cerr << "rm: '" << p << "' is a directory" << endl; - throw failed (); - } + error () << "'" << p << "' is a directory"; if (wd.sub (d)) - { - cerr << "rm: '" << p << "' contains test working directory '" - << wd << "'" << endl; - throw failed (); - } + error () << "'" << p << "' contains test working directory '" + << wd << "'"; // The call can result in rmdir_status::not_exist. That's not // very likelly but there is also nothing bad about it. @@ -480,8 +546,7 @@ namespace build2 } catch (const system_error& e) { - cerr << "rm: unable to remove '" << p << "': " << e << endl; - throw failed (); + error () << "unable to remove '" << p << "': " << e; } } @@ -489,15 +554,13 @@ namespace build2 } catch (const invalid_path& e) { - cerr << "rm: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing in, out or writing to cerr (that's why - // need to check its state before writing). + // Can be thrown while closing in, out or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "rm: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -533,6 +596,11 @@ namespace build2 uint8_t r (1); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "rmdir"); + }; + try { in.close (); @@ -559,10 +627,7 @@ namespace build2 // Remove directories. // if (i == args.end () && !force) - { - cerr << "rmdir: missing directory" << endl; - throw failed (); - } + error () << "missing directory"; const dir_path& wd (sp.wd_path); const dir_path& rwd (sp.root->wd_path); @@ -572,18 +637,12 @@ namespace build2 dir_path p (path_cast<dir_path> (parse_path (*i, wd))); if (wd.sub (p)) - { - cerr << "rmdir: '" << p << "' contains test working directory '" - << wd << "'" << endl; - throw failed (); - } + error () << "'" << p << "' contains test working directory '" + << wd << "'"; if (!p.sub (rwd) && !force) - { - cerr << "rmdir: '" << p << "' is out of working directory '" - << rwd << "'" << endl; - throw failed (); - } + error () << "'" << p << "' is out of working directory '" + << rwd << "'"; try { @@ -596,8 +655,7 @@ namespace build2 } catch (const system_error& e) { - cerr << "rmdir: unable to remove '" << p << "': " << e << endl; - throw failed (); + error () << "unable to remove '" << p << "': " << e; } } @@ -605,15 +663,259 @@ namespace build2 } catch (const invalid_path& e) { - cerr << "rmdir: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; + } + // Can be thrown while closing in, out or writing to cerr. + // + catch (const io_error& e) + { + error (false) << e; + } + catch (const failed&) + { + // Diagnostics has already been issued. + } + + cerr.close (); + return r; + } + catch (const std::exception&) + { + return 1; + } + + // sed [-n] -e <script> [<file>] + // + // Read text from file, make editing changes according to script, and + // write the result to stdout. If file is not specified or is '-', read + // from stdin. + // + // -n + // Suppress automatic printing of the pattern space at the end of the + // script execution. + // + // -e <script> + // Editing commands to be executed (required). + // + // Currently, only single-command scripts using the following editing + // commands are supported. + // + // s/<regex>/<replacement>/<flags> + // The supported flags are 'i' (case-insensitive search), 'g' + // (substitute globally), 'p' (print if a replacement was made). If + // regex starts with ^, then it only matches at the beginning of the + // pattern space. Similarly, if it ends with $, then it only matches + // at the end of the pattern space. + // + // In replacement, besides the standard ECMAScript escape sequences a + // subset of Perl-specific ones is recognized. + // + // For more details read the builtin description in 'The build2 + // Testscript Language'. + // + // Note: must be executed asynchronously. + // + static uint8_t + sed (scope& sp, + const strings& args, + auto_fd in, auto_fd out, auto_fd err) noexcept + try + { + uint8_t r (1); + ofdstream cerr (move (err)); + + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "sed"); + }; + + try + { + // Do not throw when failbit is set (getline() failed to extract any + // character). + // + ifdstream cin (move (in), ifdstream::badbit); + ofdstream cout (move (out)); + + auto i (args.begin ()); + auto e (args.end ()); + + // Process options. + // + bool auto_prn (true); + + struct substitute + { + string regex; + string replacement; + bool icase = false; + bool global = false; + bool print = false; + }; + optional<substitute> subst; + + for (; i != e; ++i) + { + if (*i == "-n") + auto_prn = false; + else if (*i == "-e") + { + // Only a single script is supported. + // + if (subst) + error () << "multiple scripts"; + + // If option has no value then bail out and report. + // + if (++i == e) + break; + + const string& v (*i); + if (v.empty ()) + error () << "empty script"; + + if (v[0] != 's') + error () << "only 's' command supported"; + + // Parse the substitute command. + // + if (v.size () < 2) + error () << "no delimiter for 's' command"; + + char delim (v[1]); + if (delim == '\\' || delim == '\n') + error () << "invalid delimiter for 's' command"; + + size_t p (v.find (delim, 2)); + if (p == string::npos) + error () << "unterminated 's' command regex"; + + subst = substitute (); + subst->regex.assign (v, 2, p - 2); + + // Empty regex matches nothing, so not of much use. + // + if (subst->regex.empty ()) + error () << "empty regex in 's' command"; + + size_t b (p + 1); + p = v.find (delim, b); + if (p == string::npos) + error () << "unterminated 's' command replacement"; + + subst->replacement.assign (v, b, p - b); + + // Parse the substitute command flags. + // + char c; + for (++p; (c = v[p]) != '\0'; ++p) + { + switch (c) + { + case 'i': subst->icase = true; break; + case 'g': subst->global = true; break; + case 'p': subst->print = true; break; + default: + { + error () << "invalid 's' command flag '" << c << "'"; + } + } + } + } + else + { + if (*i == "--") + ++i; + + break; + } + } + + if (!subst) + error () << "missing script"; + + // Path of a file to edit. An empty path represents stdin. + // + path p; + if (i != e) + { + if (*i != "-") + p = parse_path (*i, sp.wd_path); + + ++i; + } + + if (i != e) + error () << "unexpected argument"; + + // Note that ECMAScript is implied if no grammar flag is specified. + // + regex re (subst->regex, + subst->icase ? regex::icase : regex::ECMAScript); + + // Edit a file or STDIN. + // + try + { + // Open a file if specified. + // + if (!p.empty ()) + { + cin.close (); // Flush and close. + cin.open (p); + } + + // Read until failbit is set (throw on badbit). + // + string s; + while (getline (cin, s)) + { + auto r (regex_replace_ex (s, + re, + subst->replacement, + subst->global + ? regex_constants::format_default + : regex_constants::format_first_only)); + + // Add newline regardless whether the source line is newline- + // terminated or not (in accordance with POSIX). + // + if (auto_prn || (r.second && subst->print)) + cout << r.first << '\n'; + } + + cin.close (); + cout.close (); + r = 0; + } + catch (const io_error& e) + { + error_record d (error ()); + d << "unable to edit "; + + if (p.empty ()) + d << "stdin"; + else + d << "'" << p << "'"; + + d << ": " << e; + } + } + catch (const regex_error& e) + { + // Print regex_error description if meaningful (no space). + // + error (false) << "invalid regex" << e; + } + catch (const invalid_path& e) + { + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing in, out or writing to cerr (that's why - // need to check its state before writing). + // Can be thrown while creating cin, cout or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "rmdir: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -654,30 +956,26 @@ namespace build2 uint8_t r (2); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "test"); + }; + try { in.close (); out.close (); if (args.size () < 2) - { - cerr << "test: missing path" << endl; - throw failed (); - } + error () << "missing path"; bool file (args[0] == "-f"); if (!file && args[0] != "-d") - { - cerr << "test: invalid option" << endl; - throw failed (); - } + error () << "invalid option"; if (args.size () > 2) - { - cerr << "test: unexpected argument" << endl; - throw failed (); - } + error () << "unexpected argument"; path p (parse_path (args[1], sp.wd_path)); @@ -687,21 +985,18 @@ namespace build2 } catch (const system_error& e) { - cerr << "test: cannot test '" << p << "': " << e << endl; - throw failed (); + error () << "cannot test '" << p << "': " << e; } } catch (const invalid_path& e) { - cerr << "test: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing in, out or writing to cerr (that's why - // need to check its state before writing). + // Can be thrown while closing in, out or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "test: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -740,16 +1035,18 @@ namespace build2 uint8_t r (1); ofdstream cerr (move (err)); + auto error = [&cerr] (bool fail = true) + { + return error_record (cerr, fail, "touch"); + }; + try { in.close (); out.close (); if (args.empty ()) - { - cerr << "touch: missing file" << endl; - throw failed (); - } + error () << "missing file"; // Create files. // @@ -783,25 +1080,17 @@ namespace build2 } catch (const io_error& e) { - cerr << "touch: cannot create file '" << p << "': " << e - << endl; - throw failed (); + error () << "cannot create file '" << p << "': " << e; } sp.clean ({cleanup_type::always, p}, true); } else - { - cerr << "touch: '" << p << "' exists and is not a file" - << endl; - throw failed (); - } + error () << "'" << p << "' exists and is not a file"; } catch (const system_error& e) { - cerr << "touch: cannot create/update '" << p << "': " << e - << endl; - throw failed (); + error () << "cannot create/update '" << p << "': " << e; } } @@ -809,15 +1098,13 @@ namespace build2 } catch (const invalid_path& e) { - cerr << "touch: invalid path '" << e.path << "'" << endl; + error (false) << "invalid path '" << e.path << "'"; } - // Can be thrown while closing in, out or writing to cerr (that's why - // need to check its state before writing). + // Can be thrown while closing in, out or writing to cerr. // catch (const io_error& e) { - if (cerr.good ()) - cerr << "touch: " << e << endl; + error (false) << e; } catch (const failed&) { @@ -896,6 +1183,7 @@ namespace build2 {"mkdir", &sync_impl<&mkdir>}, {"rm", &sync_impl<&rm>}, {"rmdir", &sync_impl<&rmdir>}, + {"sed", &async_impl<&sed>}, {"test", &sync_impl<&test>}, {"touch", &sync_impl<&touch>}, {"true", &true_} diff --git a/build2/test/script/regex b/build2/test/script/regex index b25c1f1..1170b99 100644 --- a/build2/test/script/regex +++ b/build2/test/script/regex @@ -8,8 +8,9 @@ #include <list> #include <regex> #include <locale> +#include <string> // basic_string #include <cstdint> // uintptr_t -#include <type_traits> // make_unsigned, is_unsigned +#include <type_traits> // make_unsigned, enable_if, is_* #include <unordered_set> #include <build2/types> @@ -25,7 +26,7 @@ namespace build2 { using char_string = std::basic_string<char>; - enum class char_flags: std::uint16_t + enum class char_flags: uint16_t { icase = 0x1, // Case-insensitive match. idot = 0x2, // Invert '.' escaping. diff --git a/build2/test/script/runner.cxx b/build2/test/script/runner.cxx index dcfaec9..751daec 100644 --- a/build2/test/script/runner.cxx +++ b/build2/test/script/runner.cxx @@ -5,12 +5,11 @@ #include <build2/test/script/runner> #include <set> -#include <ios> // streamsize -#include <cstring> // strstr() -#include <sstream> +#include <ios> // streamsize #include <butl/fdstream> // fdopen_mode, fdnull(), fddup() +#include <build2/regex> #include <build2/filesystem> #include <build2/test/common> @@ -21,39 +20,6 @@ using namespace std; using namespace butl; -namespace std -{ - // Print regex error description but only if it is meaningful (this is also - // why we have to print leading colon here). - // - // Currently libstdc++ just returns the name of the exception (bug #67361). - // So we check that the description contains at least one space character. - // - // While VC's description is meaningful, it has an undesired prefix that - // resembles the following: 'regex_error(error_badrepeat): '. So we skip it. - // - static ostream& - operator<< (ostream& o, const regex_error& e) - { - const char* d (e.what ()); - -#if defined(_MSC_VER) && _MSC_VER <= 1910 - const char* rd (strstr (d, "): ")); - if (rd != nullptr) - d = rd + 3; -#endif - - ostringstream os; - os << runtime_error (d); // Sanitize the description. - - string s (os.str ()); - if (s.find (' ') != string::npos) - o << ": " << s; - - return o; - } -} - namespace build2 { namespace test diff --git a/tests/test/script/builtin/buildfile b/tests/test/script/builtin/buildfile index e5bac10..2a57c54 100644 --- a/tests/test/script/builtin/buildfile +++ b/tests/test/script/builtin/buildfile @@ -2,4 +2,4 @@ # copyright : Copyright (c) 2014-2017 Code Synthesis Ltd # license : MIT; see accompanying LICENSE file -./: test{cat echo mkdir rm rmdir test touch} $b +./: test{cat echo mkdir rm rmdir sed test touch} $b diff --git a/tests/test/script/builtin/sed.test b/tests/test/script/builtin/sed.test new file mode 100644 index 0000000..ef99539 --- /dev/null +++ b/tests/test/script/builtin/sed.test @@ -0,0 +1,312 @@ +# file : tests/test/script/builtin/sed.test +# copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +# license : MIT; see accompanying LICENSE file + +.include ../common.test + +: arg +: +{ + : auto-prn + : + { + $c <"sed -n -e 's/fox/bar/' <'foo' " && $b : on + $c <"sed -e 's/fox/bar/' <'foo' >'foo'" && $b : off + } + + : script + : + { + : missed + : + $c <'sed' && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: missing script + EOE + + : missed-val + : + $c <'sed -e' && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: missing script + EOE + + : empty + : + $c <"sed -e ''" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: empty script + EOE + + : multiple + : + $c <"sed -e 's/a//' -e 's/a//'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: multiple scripts + EOE + + : invalid + : + $c <"sed -e 'z'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: only 's' command supported + EOE + } + + : file + : + { + : exist + : + $c <<EOI && $b + cat <'foo' >=f; + sed -e 's/foo/bar/' f >'bar' + EOI + + : none + : + $c <<EOI && $b + sed -e 's/foo/bar/' <'foo' >'bar' + EOI + + : dash + : + $c <<EOI && $b + sed -e 's/foo/bar/' - <'foo' >'bar' + EOI + + : not-exist + : + $c <"sed -e 's/foo/bar/' f" && $b 2>>/~%EOE% != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + %sed: unable to edit '.+/1/f': .+% + EOE + + : empty + : + $c <"sed -e 's/foo/bar/' ''" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: invalid path '' + EOE + } + + : unexpected + : + $c <"sed -e 's/a//' a b" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: unexpected argument + EOE + +} + +: command +: +{ + : subst + : + { + : parsing + : + { + : delim + : + { + : none + : + $c <"sed -e 's'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: no delimiter for 's' command + EOE + + : invalid + : + $c <"sed -e 's\\'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: invalid delimiter for 's' command + EOE + } + + : regex + : + { + : unterminated + : + $c <"sed -e 's/foo'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: unterminated 's' command regex + EOE + + : empty + : + $c <"sed -e 's///'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: empty regex in 's' command + EOE + + : invalid + : + : Note that old versions of libc++ (for example 1.1) do not detect some + : regex errors. For example '*' is parsed successfully. + : + $c <"sed -e 's/foo[/bar/'" && $b 2>>/~%EOE% != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + %sed: invalid regex.*% + EOE + } + + : unterminated-replacement + : + $c <"sed -e 's/foo/bar'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: unterminated 's' command replacement + EOE + + : invalid-flags + : + $c <"sed -e 's/foo/bar/a'" && $b 2>>/EOE != 0 + testscript:1:1: error: sed exit status 1 != 0 + info: stderr: test/1/stderr + sed: invalid 's' command flag 'a' + EOE + } + + : exec + : + { + : flags + : + { + : global + : + { + $c <"sed -e 's/o/a/g' <'foo' >'faa'" && $b : on + $c <"sed -e 's/o/a/' <'foo' >'fao'" && $b : off + } + + : icase + : + { + $c <"sed -e 's/O/a/i' <'foo' >'fao'" && $b : on + $c <"sed -e 's/O/a/' <'foo' >'foo'" && $b : off + } + + : print + : + { + $c <"sed -n -e 's/o/a/p' <'foo' >'fao'" && $b : on-match + $c <"sed -n -e 's/o/a/' <'foo' " && $b : off-match + $c <"sed -n -e 's/u/a/p' <'foo' " && $b : on-no-match + } + } + + : search + { + : anchor + : + { + $c <"sed -n -e 's/^o/a/gp' <'oof' >'aof'" && $b : begin + $c <"sed -n -e 's/o\$/a/gp' <'foo' >'foa'" && $b : end + } + + : match + : Match corner cases + : + { + $c <"sed -n -e 's/a/b/p' <'a' >'b' " && $b : full + $c <"sed -n -e 's/a/b/p' <'ac' >'bc' " && $b : left + $c <"sed -n -e 's/a/b/p' <'ca' >'cb' " && $b : right + $c <"sed -n -e 's/a/b/pg' <'xaax' >'xbbx'" && $b : adjacent + } + } + + : replacement + : + { + : ecma-escape + : + { + $c <"sed <'xay' -e 's/a/\$b/' >'x\$by'" && $b : none + $c <"sed <'xay' -e 's/a/\$/' >'x\$y' " && $b : none-term + $c <"sed <'xay' -e 's/a/\$\$/' >'x\$y' " && $b : self + $c <"sed <'xay' -e 's/a/b\$&c/' >'xbacy'" && $b : match + $c <"sed <'xay' -e 's/a/b\$`c/' >'xbxcy'" && $b : match-precede + $c <"sed <'xay' -e \"s/a/b\\\$'c/\" >'xbycy'" && $b : match-follow + + : capture + : + $c <<EOI && $b + sed <'abcdefghij' -e 's/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)/$1$10/' >'aj' + EOI + } + + : perl-escape + : + { + $c <"sed <'xay' -e 's/a/\\b/' >'xby' " && $b : none + $c <"sed <'xay' -e 's/a/\\/' >'xy' " && $b : none-term + $c <"sed <'xay' -e 's/a/\\\\/' >'x\\y'" && $b : self + + : capture + : + $c <<EOI && $b + sed <'abcdefghij' -e 's/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)/\1\10/' >'aa0' + EOI + + : upper + : + { + $c <"sed <'xay' -e 's/a/\\U/' >'xy' " && $b : none + $c <"sed <'xay' -e 's/a/\\Uvz/' >'xVZy'" && $b : repl + $c <"sed <'xay' -e 's/a/\\Uv\\Ez/' >'xVzy'" && $b : end + $c <"sed <'aa' -e 's/a/v\\Uz/g' >'vZvZ'" && $b : locality + $c <"sed <'xay' -e 's/\(a\)/\\U\\1/' >'xAy' " && $b : capt + $c <"sed <'x-y' -e 's/\(a?\)-/\\U\\1z/' >'xZy' " && $b : capt-empty + $c <"sed <'xay' -e 's/a/\\uvz/' >'xVzy'" && $b : once + } + + : lower + : + { + $c <"sed <'xay' -e 's/a/\\lVZ/' >'xvZy'" && $b : once + } + } + } + + $c <"sed -e 's/a//' <:'b' >'b'" && $b : no-newline + $c <"sed -e 's/a//' <:'' " && $b : empty-stdin + + : empty-file + : + $c <<EOI && $b + touch f; + sed -e 's/a//' f + EOI + } + } +} + +: big +: +: Sed a big file (about 3MB) to test that the builtin is asynchronous. +: +{ + s="------------------------------------------------------------------------" + s="$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s" + s="$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s" + s="$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s" + $c <"cat <'$s' | sed -e 's/^x//' >'$s'" && $b +} |