Add builtins support

7 files changed, 7027 insertions, 2 deletions

diff --git a/libbutl/buildfile b/libbutl/buildfile
index a0b789a..e6841ab 100644
--- a/libbutl/buildfile
+++ b/libbutl/buildfile
@@ -13,8 +13,11 @@
 #
 # @@ If/when going back to using mxx{}, make sure to cleanup explicit .mxx.
 #
-lib{butl}: {hxx ixx txx cxx}{** -uuid-* +uuid-io -win32-utility -version} \
-           hxx{**.mxx} {hxx}{version}
+lib{butl}: {hxx ixx txx cxx}{** -uuid-* +uuid-io            \
+                                -win32-utility              \
+                                -version                    \
+                                -builtin-options}           \
+  hxx{**.mxx} {hxx}{version} {hxx ixx cxx}{builtin-options}
 
 tclass = $cxx.target.class
 tsys   = $cxx.target.system
@@ -93,6 +96,39 @@ if $version.pre_release
 else
   lib{butl}: bin.lib.version = @"-$version.major.$version.minor"
 
+# Generated options parser.
+#
+if $cli.configured
+{
+  cli.cxx{builtin-options}: cli{builtin}
+
+  cli.options += --std c++11 -I $src_root --include-with-brackets \
+--include-prefix libbutl --guard-prefix LIBBUTL --cli-namespace butl::cli \
+--generate-vector-scanner --generate-parse --keep-separator \
+--generate-specifier --suppress-usage
+
+  cli.cxx{*}:
+  {
+    # Include the generated cli files into the distribution and don't remove
+    # them when cleaning in src (so that clean results in a state identical to
+    # distributed). But don't install their headers since they are only used
+    # internally in the builtins implementation.
+    #
+    dist  = true
+    clean = ($src_root != $out_root)
+    install = false
+
+    # We keep the generated code in the repository so copy it back to src in
+    # case of a forwarded configuration.
+    #
+    backlink = overwrite
+  }
+}
+else
+  # No install for the pre-generated case.
+  #
+  hxx{builtin-options}@./ ixx{builtin-options}@./: install = false
+
 # Install into the libbutl/ subdirectory of, say, /usr/include/
 # recreating subdirectories.
 #
diff --git a/libbutl/builtin-options.cxx b/libbutl/builtin-options.cxx
new file mode 100644
index 0000000..70d56c1
--- /dev/null
+++ b/libbutl/builtin-options.cxx
@@ -0,0 +1,3332 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <libbutl/builtin-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+
+namespace butl
+{
+  namespace cli
+  {
+    // unknown_option
+    //
+    unknown_option::
+    ~unknown_option () throw ()
+    {
+    }
+
+    void unknown_option::
+    print (::std::ostream& os) const
+    {
+      os << "unknown option '" << option ().c_str () << "'";
+    }
+
+    const char* unknown_option::
+    what () const throw ()
+    {
+      return "unknown option";
+    }
+
+    // unknown_argument
+    //
+    unknown_argument::
+    ~unknown_argument () throw ()
+    {
+    }
+
+    void unknown_argument::
+    print (::std::ostream& os) const
+    {
+      os << "unknown argument '" << argument ().c_str () << "'";
+    }
+
+    const char* unknown_argument::
+    what () const throw ()
+    {
+      return "unknown argument";
+    }
+
+    // missing_value
+    //
+    missing_value::
+    ~missing_value () throw ()
+    {
+    }
+
+    void missing_value::
+    print (::std::ostream& os) const
+    {
+      os << "missing value for option '" << option ().c_str () << "'";
+    }
+
+    const char* missing_value::
+    what () const throw ()
+    {
+      return "missing option value";
+    }
+
+    // invalid_value
+    //
+    invalid_value::
+    ~invalid_value () throw ()
+    {
+    }
+
+    void invalid_value::
+    print (::std::ostream& os) const
+    {
+      os << "invalid value '" << value ().c_str () << "' for option '"
+         << option ().c_str () << "'";
+
+      if (!message ().empty ())
+        os << ": " << message ().c_str ();
+    }
+
+    const char* invalid_value::
+    what () const throw ()
+    {
+      return "invalid option value";
+    }
+
+    // eos_reached
+    //
+    void eos_reached::
+    print (::std::ostream& os) const
+    {
+      os << what ();
+    }
+
+    const char* eos_reached::
+    what () const throw ()
+    {
+      return "end of argument stream reached";
+    }
+
+    // scanner
+    //
+    scanner::
+    ~scanner ()
+    {
+    }
+
+    // argv_scanner
+    //
+    bool argv_scanner::
+    more ()
+    {
+      return i_ < argc_;
+    }
+
+    const char* argv_scanner::
+    peek ()
+    {
+      if (i_ < argc_)
+        return argv_[i_];
+      else
+        throw eos_reached ();
+    }
+
+    const char* argv_scanner::
+    next ()
+    {
+      if (i_ < argc_)
+      {
+        const char* r (argv_[i_]);
+
+        if (erase_)
+        {
+          for (int i (i_ + 1); i < argc_; ++i)
+            argv_[i - 1] = argv_[i];
+
+          --argc_;
+          argv_[argc_] = 0;
+        }
+        else
+          ++i_;
+
+        return r;
+      }
+      else
+        throw eos_reached ();
+    }
+
+    void argv_scanner::
+    skip ()
+    {
+      if (i_ < argc_)
+        ++i_;
+      else
+        throw eos_reached ();
+    }
+
+    // vector_scanner
+    //
+    bool vector_scanner::
+    more ()
+    {
+      return i_ < v_.size ();
+    }
+
+    const char* vector_scanner::
+    peek ()
+    {
+      if (i_ < v_.size ())
+        return v_[i_].c_str ();
+      else
+        throw eos_reached ();
+    }
+
+    const char* vector_scanner::
+    next ()
+    {
+      if (i_ < v_.size ())
+        return v_[i_++].c_str ();
+      else
+        throw eos_reached ();
+    }
+
+    void vector_scanner::
+    skip ()
+    {
+      if (i_ < v_.size ())
+        ++i_;
+      else
+        throw eos_reached ();
+    }
+
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, scanner& s)
+      {
+        s.next ();
+        x = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::set<X> >
+    {
+      static void
+      parse (std::set<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+    };
+
+    template <typename K, typename V>
+    struct parser<std::map<K, V> >
+    {
+      static void
+      parse (std::map<K, V>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] = 
+          {
+            const_cast<char*> (o), 0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+#include <cstring>
+
+namespace butl
+{
+  // cat_options
+  //
+
+  cat_options::
+  cat_options ()
+  {
+  }
+
+  bool cat_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cat_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cat_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cat_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cat_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cat_options&, ::butl::cli::scanner&)>
+  _cli_cat_options_map;
+
+  static _cli_cat_options_map _cli_cat_options_map_;
+
+  struct _cli_cat_options_map_init
+  {
+    _cli_cat_options_map_init ()
+    {
+    }
+  };
+
+  static _cli_cat_options_map_init _cli_cat_options_map_init_;
+
+  bool cat_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_cat_options_map::const_iterator i (_cli_cat_options_map_.find (o));
+
+    if (i != _cli_cat_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool cat_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // cp_options
+  //
+
+  cp_options::
+  cp_options ()
+  : recursive_ (),
+    preserve_ ()
+  {
+  }
+
+  bool cp_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cp_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cp_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cp_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cp_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cp_options&, ::butl::cli::scanner&)>
+  _cli_cp_options_map;
+
+  static _cli_cp_options_map _cli_cp_options_map_;
+
+  struct _cli_cp_options_map_init
+  {
+    _cli_cp_options_map_init ()
+    {
+      _cli_cp_options_map_["--recursive"] = 
+      &::butl::cli::thunk< cp_options, bool, &cp_options::recursive_ >;
+      _cli_cp_options_map_["-R"] = 
+      &::butl::cli::thunk< cp_options, bool, &cp_options::recursive_ >;
+      _cli_cp_options_map_["-r"] = 
+      &::butl::cli::thunk< cp_options, bool, &cp_options::recursive_ >;
+      _cli_cp_options_map_["--preserve"] = 
+      &::butl::cli::thunk< cp_options, bool, &cp_options::preserve_ >;
+      _cli_cp_options_map_["-p"] = 
+      &::butl::cli::thunk< cp_options, bool, &cp_options::preserve_ >;
+    }
+  };
+
+  static _cli_cp_options_map_init _cli_cp_options_map_init_;
+
+  bool cp_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_cp_options_map::const_iterator i (_cli_cp_options_map_.find (o));
+
+    if (i != _cli_cp_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool cp_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // ln_options
+  //
+
+  ln_options::
+  ln_options ()
+  : symbolic_ ()
+  {
+  }
+
+  bool ln_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool ln_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool ln_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool ln_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool ln_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (ln_options&, ::butl::cli::scanner&)>
+  _cli_ln_options_map;
+
+  static _cli_ln_options_map _cli_ln_options_map_;
+
+  struct _cli_ln_options_map_init
+  {
+    _cli_ln_options_map_init ()
+    {
+      _cli_ln_options_map_["--symbolic"] = 
+      &::butl::cli::thunk< ln_options, bool, &ln_options::symbolic_ >;
+      _cli_ln_options_map_["-s"] = 
+      &::butl::cli::thunk< ln_options, bool, &ln_options::symbolic_ >;
+    }
+  };
+
+  static _cli_ln_options_map_init _cli_ln_options_map_init_;
+
+  bool ln_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_ln_options_map::const_iterator i (_cli_ln_options_map_.find (o));
+
+    if (i != _cli_ln_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool ln_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // mkdir_options
+  //
+
+  mkdir_options::
+  mkdir_options ()
+  : parents_ ()
+  {
+  }
+
+  bool mkdir_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool mkdir_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool mkdir_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool mkdir_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool mkdir_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (mkdir_options&, ::butl::cli::scanner&)>
+  _cli_mkdir_options_map;
+
+  static _cli_mkdir_options_map _cli_mkdir_options_map_;
+
+  struct _cli_mkdir_options_map_init
+  {
+    _cli_mkdir_options_map_init ()
+    {
+      _cli_mkdir_options_map_["--parents"] = 
+      &::butl::cli::thunk< mkdir_options, bool, &mkdir_options::parents_ >;
+      _cli_mkdir_options_map_["-p"] = 
+      &::butl::cli::thunk< mkdir_options, bool, &mkdir_options::parents_ >;
+    }
+  };
+
+  static _cli_mkdir_options_map_init _cli_mkdir_options_map_init_;
+
+  bool mkdir_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_mkdir_options_map::const_iterator i (_cli_mkdir_options_map_.find (o));
+
+    if (i != _cli_mkdir_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool mkdir_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // mv_options
+  //
+
+  mv_options::
+  mv_options ()
+  : force_ ()
+  {
+  }
+
+  bool mv_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool mv_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool mv_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool mv_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool mv_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (mv_options&, ::butl::cli::scanner&)>
+  _cli_mv_options_map;
+
+  static _cli_mv_options_map _cli_mv_options_map_;
+
+  struct _cli_mv_options_map_init
+  {
+    _cli_mv_options_map_init ()
+    {
+      _cli_mv_options_map_["--force"] = 
+      &::butl::cli::thunk< mv_options, bool, &mv_options::force_ >;
+      _cli_mv_options_map_["-f"] = 
+      &::butl::cli::thunk< mv_options, bool, &mv_options::force_ >;
+    }
+  };
+
+  static _cli_mv_options_map_init _cli_mv_options_map_init_;
+
+  bool mv_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_mv_options_map::const_iterator i (_cli_mv_options_map_.find (o));
+
+    if (i != _cli_mv_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool mv_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // rm_options
+  //
+
+  rm_options::
+  rm_options ()
+  : recursive_ (),
+    force_ ()
+  {
+  }
+
+  bool rm_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rm_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rm_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rm_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rm_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rm_options&, ::butl::cli::scanner&)>
+  _cli_rm_options_map;
+
+  static _cli_rm_options_map _cli_rm_options_map_;
+
+  struct _cli_rm_options_map_init
+  {
+    _cli_rm_options_map_init ()
+    {
+      _cli_rm_options_map_["--recursive"] = 
+      &::butl::cli::thunk< rm_options, bool, &rm_options::recursive_ >;
+      _cli_rm_options_map_["-r"] = 
+      &::butl::cli::thunk< rm_options, bool, &rm_options::recursive_ >;
+      _cli_rm_options_map_["--force"] = 
+      &::butl::cli::thunk< rm_options, bool, &rm_options::force_ >;
+      _cli_rm_options_map_["-f"] = 
+      &::butl::cli::thunk< rm_options, bool, &rm_options::force_ >;
+    }
+  };
+
+  static _cli_rm_options_map_init _cli_rm_options_map_init_;
+
+  bool rm_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_rm_options_map::const_iterator i (_cli_rm_options_map_.find (o));
+
+    if (i != _cli_rm_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool rm_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // rmdir_options
+  //
+
+  rmdir_options::
+  rmdir_options ()
+  : force_ ()
+  {
+  }
+
+  bool rmdir_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rmdir_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rmdir_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rmdir_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rmdir_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rmdir_options&, ::butl::cli::scanner&)>
+  _cli_rmdir_options_map;
+
+  static _cli_rmdir_options_map _cli_rmdir_options_map_;
+
+  struct _cli_rmdir_options_map_init
+  {
+    _cli_rmdir_options_map_init ()
+    {
+      _cli_rmdir_options_map_["--force"] = 
+      &::butl::cli::thunk< rmdir_options, bool, &rmdir_options::force_ >;
+      _cli_rmdir_options_map_["-f"] = 
+      &::butl::cli::thunk< rmdir_options, bool, &rmdir_options::force_ >;
+    }
+  };
+
+  static _cli_rmdir_options_map_init _cli_rmdir_options_map_init_;
+
+  bool rmdir_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_rmdir_options_map::const_iterator i (_cli_rmdir_options_map_.find (o));
+
+    if (i != _cli_rmdir_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool rmdir_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // sed_options
+  //
+
+  sed_options::
+  sed_options ()
+  : quiet_ (),
+    in_place_ (),
+    expression_ (),
+    expression_specified_ (false)
+  {
+  }
+
+  bool sed_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool sed_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool sed_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool sed_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool sed_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (sed_options&, ::butl::cli::scanner&)>
+  _cli_sed_options_map;
+
+  static _cli_sed_options_map _cli_sed_options_map_;
+
+  struct _cli_sed_options_map_init
+  {
+    _cli_sed_options_map_init ()
+    {
+      _cli_sed_options_map_["--quiet"] = 
+      &::butl::cli::thunk< sed_options, bool, &sed_options::quiet_ >;
+      _cli_sed_options_map_["-n"] = 
+      &::butl::cli::thunk< sed_options, bool, &sed_options::quiet_ >;
+      _cli_sed_options_map_["--in-place"] = 
+      &::butl::cli::thunk< sed_options, bool, &sed_options::in_place_ >;
+      _cli_sed_options_map_["-i"] = 
+      &::butl::cli::thunk< sed_options, bool, &sed_options::in_place_ >;
+      _cli_sed_options_map_["--expression"] = 
+      &::butl::cli::thunk< sed_options, std::vector<std::string>, &sed_options::expression_,
+        &sed_options::expression_specified_ >;
+      _cli_sed_options_map_["-e"] = 
+      &::butl::cli::thunk< sed_options, std::vector<std::string>, &sed_options::expression_,
+        &sed_options::expression_specified_ >;
+    }
+  };
+
+  static _cli_sed_options_map_init _cli_sed_options_map_init_;
+
+  bool sed_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_sed_options_map::const_iterator i (_cli_sed_options_map_.find (o));
+
+    if (i != _cli_sed_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool sed_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // sleep_options
+  //
+
+  sleep_options::
+  sleep_options ()
+  {
+  }
+
+  bool sleep_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool sleep_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool sleep_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool sleep_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool sleep_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (sleep_options&, ::butl::cli::scanner&)>
+  _cli_sleep_options_map;
+
+  static _cli_sleep_options_map _cli_sleep_options_map_;
+
+  struct _cli_sleep_options_map_init
+  {
+    _cli_sleep_options_map_init ()
+    {
+    }
+  };
+
+  static _cli_sleep_options_map_init _cli_sleep_options_map_init_;
+
+  bool sleep_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_sleep_options_map::const_iterator i (_cli_sleep_options_map_.find (o));
+
+    if (i != _cli_sleep_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool sleep_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // test_options
+  //
+
+  test_options::
+  test_options ()
+  : file_ (),
+    directory_ ()
+  {
+  }
+
+  bool test_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool test_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool test_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool test_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool test_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (test_options&, ::butl::cli::scanner&)>
+  _cli_test_options_map;
+
+  static _cli_test_options_map _cli_test_options_map_;
+
+  struct _cli_test_options_map_init
+  {
+    _cli_test_options_map_init ()
+    {
+      _cli_test_options_map_["--file"] = 
+      &::butl::cli::thunk< test_options, bool, &test_options::file_ >;
+      _cli_test_options_map_["-f"] = 
+      &::butl::cli::thunk< test_options, bool, &test_options::file_ >;
+      _cli_test_options_map_["--directory"] = 
+      &::butl::cli::thunk< test_options, bool, &test_options::directory_ >;
+      _cli_test_options_map_["-d"] = 
+      &::butl::cli::thunk< test_options, bool, &test_options::directory_ >;
+    }
+  };
+
+  static _cli_test_options_map_init _cli_test_options_map_init_;
+
+  bool test_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_test_options_map::const_iterator i (_cli_test_options_map_.find (o));
+
+    if (i != _cli_test_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool test_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // touch_options
+  //
+
+  touch_options::
+  touch_options ()
+  : after_ (),
+    after_specified_ (false)
+  {
+  }
+
+  bool touch_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool touch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool touch_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool touch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    ::butl::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool touch_options::
+  parse (::butl::cli::scanner& s,
+         ::butl::cli::unknown_mode opt,
+         ::butl::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  typedef
+  std::map<std::string, void (*) (touch_options&, ::butl::cli::scanner&)>
+  _cli_touch_options_map;
+
+  static _cli_touch_options_map _cli_touch_options_map_;
+
+  struct _cli_touch_options_map_init
+  {
+    _cli_touch_options_map_init ()
+    {
+      _cli_touch_options_map_["--after"] = 
+      &::butl::cli::thunk< touch_options, std::string, &touch_options::after_,
+        &touch_options::after_specified_ >;
+    }
+  };
+
+  static _cli_touch_options_map_init _cli_touch_options_map_init_;
+
+  bool touch_options::
+  _parse (const char* o, ::butl::cli::scanner& s)
+  {
+    _cli_touch_options_map::const_iterator i (_cli_touch_options_map_.find (o));
+
+    if (i != _cli_touch_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool touch_options::
+  _parse (::butl::cli::scanner& s,
+          ::butl::cli::unknown_mode opt_mode,
+          ::butl::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::butl::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::butl::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::butl::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] = 
+                {
+                  cf
+                };
+
+                ::butl::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::butl::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::butl::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::butl::cli::unknown_mode::fail:
+            {
+              throw ::butl::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::butl::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::butl::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::butl::cli::unknown_mode::fail:
+        {
+          throw ::butl::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/libbutl/builtin-options.hxx b/libbutl/builtin-options.hxx
new file mode 100644
index 0000000..99d955d
--- /dev/null
+++ b/libbutl/builtin-options.hxx
@@ -0,0 +1,1006 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef LIBBUTL_BUILTIN_OPTIONS_HXX
+#define LIBBUTL_BUILTIN_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <vector>
+#include <iosfwd>
+#include <string>
+#include <cstddef>
+#include <exception>
+
+#ifndef CLI_POTENTIALLY_UNUSED
+#  if defined(_MSC_VER) || defined(__xlC__)
+#    define CLI_POTENTIALLY_UNUSED(x) (void*)&x
+#  else
+#    define CLI_POTENTIALLY_UNUSED(x) (void)x
+#  endif
+#endif
+
+namespace butl
+{
+  namespace cli
+  {
+    class unknown_mode
+    {
+      public:
+      enum value
+      {
+        skip,
+        stop,
+        fail
+      };
+
+      unknown_mode (value);
+
+      operator value () const 
+      {
+        return v_;
+      }
+
+      private:
+      value v_;
+    };
+
+    // Exceptions.
+    //
+
+    class exception: public std::exception
+    {
+      public:
+      virtual void
+      print (::std::ostream&) const = 0;
+    };
+
+    ::std::ostream&
+    operator<< (::std::ostream&, const exception&);
+
+    class unknown_option: public exception
+    {
+      public:
+      virtual
+      ~unknown_option () throw ();
+
+      unknown_option (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string option_;
+    };
+
+    class unknown_argument: public exception
+    {
+      public:
+      virtual
+      ~unknown_argument () throw ();
+
+      unknown_argument (const std::string& argument);
+
+      const std::string&
+      argument () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string argument_;
+    };
+
+    class missing_value: public exception
+    {
+      public:
+      virtual
+      ~missing_value () throw ();
+
+      missing_value (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string option_;
+    };
+
+    class invalid_value: public exception
+    {
+      public:
+      virtual
+      ~invalid_value () throw ();
+
+      invalid_value (const std::string& option,
+                     const std::string& value,
+                     const std::string& message = std::string ());
+
+      const std::string&
+      option () const;
+
+      const std::string&
+      value () const;
+
+      const std::string&
+      message () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string option_;
+      std::string value_;
+      std::string message_;
+    };
+
+    class eos_reached: public exception
+    {
+      public:
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    // Command line argument scanner interface.
+    //
+    // The values returned by next() are guaranteed to be valid
+    // for the two previous arguments up until a call to a third
+    // peek() or next().
+    //
+    class scanner
+    {
+      public:
+      virtual
+      ~scanner ();
+
+      virtual bool
+      more () = 0;
+
+      virtual const char*
+      peek () = 0;
+
+      virtual const char*
+      next () = 0;
+
+      virtual void
+      skip () = 0;
+    };
+
+    class argv_scanner: public scanner
+    {
+      public:
+      argv_scanner (int& argc, char** argv, bool erase = false);
+      argv_scanner (int start, int& argc, char** argv, bool erase = false);
+
+      int
+      end () const;
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      private:
+      int i_;
+      int& argc_;
+      char** argv_;
+      bool erase_;
+    };
+
+    class vector_scanner: public scanner
+    {
+      public:
+      vector_scanner (const std::vector<std::string>&, std::size_t start = 0);
+
+      std::size_t
+      end () const;
+
+      void
+      reset (std::size_t start = 0);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      private:
+      const std::vector<std::string>& v_;
+      std::size_t i_;
+    };
+
+    template <typename X>
+    struct parser;
+  }
+}
+
+#include <string>
+
+#include <vector>
+
+namespace butl
+{
+  class cat_options
+  {
+    public:
+    cat_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+  };
+
+  class cp_options
+  {
+    public:
+    cp_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    recursive () const;
+
+    const bool&
+    preserve () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool recursive_;
+    bool preserve_;
+  };
+
+  class ln_options
+  {
+    public:
+    ln_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    symbolic () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool symbolic_;
+  };
+
+  class mkdir_options
+  {
+    public:
+    mkdir_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    parents () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool parents_;
+  };
+
+  class mv_options
+  {
+    public:
+    mv_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    force () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool force_;
+  };
+
+  class rm_options
+  {
+    public:
+    rm_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    recursive () const;
+
+    const bool&
+    force () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool recursive_;
+    bool force_;
+  };
+
+  class rmdir_options
+  {
+    public:
+    rmdir_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    force () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool force_;
+  };
+
+  class sed_options
+  {
+    public:
+    sed_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    quiet () const;
+
+    const bool&
+    in_place () const;
+
+    const std::vector<std::string>&
+    expression () const;
+
+    bool
+    expression_specified () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool quiet_;
+    bool in_place_;
+    std::vector<std::string> expression_;
+    bool expression_specified_;
+  };
+
+  class sleep_options
+  {
+    public:
+    sleep_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+  };
+
+  class test_options
+  {
+    public:
+    test_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    file () const;
+
+    const bool&
+    directory () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    bool file_;
+    bool directory_;
+  };
+
+  class touch_options
+  {
+    public:
+    touch_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    bool
+    parse (::butl::cli::scanner&,
+           ::butl::cli::unknown_mode option = ::butl::cli::unknown_mode::fail,
+           ::butl::cli::unknown_mode argument = ::butl::cli::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const std::string&
+    after () const;
+
+    bool
+    after_specified () const;
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::butl::cli::scanner&);
+
+    private:
+    bool
+    _parse (::butl::cli::scanner&,
+            ::butl::cli::unknown_mode option,
+            ::butl::cli::unknown_mode argument);
+
+    public:
+    std::string after_;
+    bool after_specified_;
+  };
+}
+
+#include <libbutl/builtin-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // LIBBUTL_BUILTIN_OPTIONS_HXX
diff --git a/libbutl/builtin-options.ixx b/libbutl/builtin-options.ixx
new file mode 100644
index 0000000..b2275c6
--- /dev/null
+++ b/libbutl/builtin-options.ixx
@@ -0,0 +1,284 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cassert>
+
+namespace butl
+{
+  namespace cli
+  {
+    // unknown_mode
+    //
+    inline unknown_mode::
+    unknown_mode (value v)
+    : v_ (v)
+    {
+    }
+
+    // exception
+    //
+    inline ::std::ostream&
+    operator<< (::std::ostream& os, const exception& e)
+    {
+      e.print (os);
+      return os;
+    }
+
+    // unknown_option
+    //
+    inline unknown_option::
+    unknown_option (const std::string& option)
+    : option_ (option)
+    {
+    }
+
+    inline const std::string& unknown_option::
+    option () const
+    {
+      return option_;
+    }
+
+    // unknown_argument
+    //
+    inline unknown_argument::
+    unknown_argument (const std::string& argument)
+    : argument_ (argument)
+    {
+    }
+
+    inline const std::string& unknown_argument::
+    argument () const
+    {
+      return argument_;
+    }
+
+    // missing_value
+    //
+    inline missing_value::
+    missing_value (const std::string& option)
+    : option_ (option)
+    {
+    }
+
+    inline const std::string& missing_value::
+    option () const
+    {
+      return option_;
+    }
+
+    // invalid_value
+    //
+    inline invalid_value::
+    invalid_value (const std::string& option,
+                   const std::string& value,
+                   const std::string& message)
+    : option_ (option),
+      value_ (value),
+      message_ (message)
+    {
+    }
+
+    inline const std::string& invalid_value::
+    option () const
+    {
+      return option_;
+    }
+
+    inline const std::string& invalid_value::
+    value () const
+    {
+      return value_;
+    }
+
+    inline const std::string& invalid_value::
+    message () const
+    {
+      return message_;
+    }
+
+    // argv_scanner
+    //
+    inline argv_scanner::
+    argv_scanner (int& argc, char** argv, bool erase)
+    : i_ (1), argc_ (argc), argv_ (argv), erase_ (erase)
+    {
+    }
+
+    inline argv_scanner::
+    argv_scanner (int start, int& argc, char** argv, bool erase)
+    : i_ (start), argc_ (argc), argv_ (argv), erase_ (erase)
+    {
+    }
+
+    inline int argv_scanner::
+    end () const
+    {
+      return i_;
+    }
+
+    // vector_scanner
+    //
+    inline vector_scanner::
+    vector_scanner (const std::vector<std::string>& v, std::size_t i)
+    : v_ (v), i_ (i)
+    {
+    }
+
+    inline std::size_t vector_scanner::
+    end () const
+    {
+      return i_;
+    }
+
+    inline void vector_scanner::
+    reset (std::size_t i)
+    {
+      i_ = i;
+    }
+  }
+}
+
+namespace butl
+{
+  // cat_options
+  //
+
+  // cp_options
+  //
+
+  inline const bool& cp_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline const bool& cp_options::
+  preserve () const
+  {
+    return this->preserve_;
+  }
+
+  // ln_options
+  //
+
+  inline const bool& ln_options::
+  symbolic () const
+  {
+    return this->symbolic_;
+  }
+
+  // mkdir_options
+  //
+
+  inline const bool& mkdir_options::
+  parents () const
+  {
+    return this->parents_;
+  }
+
+  // mv_options
+  //
+
+  inline const bool& mv_options::
+  force () const
+  {
+    return this->force_;
+  }
+
+  // rm_options
+  //
+
+  inline const bool& rm_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline const bool& rm_options::
+  force () const
+  {
+    return this->force_;
+  }
+
+  // rmdir_options
+  //
+
+  inline const bool& rmdir_options::
+  force () const
+  {
+    return this->force_;
+  }
+
+  // sed_options
+  //
+
+  inline const bool& sed_options::
+  quiet () const
+  {
+    return this->quiet_;
+  }
+
+  inline const bool& sed_options::
+  in_place () const
+  {
+    return this->in_place_;
+  }
+
+  inline const std::vector<std::string>& sed_options::
+  expression () const
+  {
+    return this->expression_;
+  }
+
+  inline bool sed_options::
+  expression_specified () const
+  {
+    return this->expression_specified_;
+  }
+
+  // sleep_options
+  //
+
+  // test_options
+  //
+
+  inline const bool& test_options::
+  file () const
+  {
+    return this->file_;
+  }
+
+  inline const bool& test_options::
+  directory () const
+  {
+    return this->directory_;
+  }
+
+  // touch_options
+  //
+
+  inline const std::string& touch_options::
+  after () const
+  {
+    return this->after_;
+  }
+
+  inline bool touch_options::
+  after_specified () const
+  {
+    return this->after_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/libbutl/builtin.cli b/libbutl/builtin.cli
new file mode 100644
index 0000000..284a111
--- /dev/null
+++ b/libbutl/builtin.cli
@@ -0,0 +1,82 @@
+// file      : libbutl/builtin.cli
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+include <string>;
+include <vector>;
+
+// Note that options in this file are undocumented because we generate neither
+// the usage printing code nor man pages. Instead, they are documented in the
+// Testscript Language Manual's builtin descriptions.
+//
+// @@ Update the above reference when the documentation is moved to another
+//    place.
+//
+// Also note that the string type is used for the path options because their
+// parsing depends on the working directory (see parse_path() for details) and
+// passing this information to the CLI custom parser would not be easy.
+//
+namespace butl
+{
+  class cat_options
+  {
+    // No options so far.
+    //
+  };
+
+  class cp_options
+  {
+    bool --recursive|-R|-r;
+    bool --preserve|-p;
+  };
+
+  class ln_options
+  {
+    bool --symbolic|-s;
+  };
+
+  class mkdir_options
+  {
+    bool --parents|-p;
+  };
+
+  class mv_options
+  {
+    bool --force|-f;
+  };
+
+  class rm_options
+  {
+    bool --recursive|-r;
+    bool --force|-f;
+  };
+
+  class rmdir_options
+  {
+    bool --force|-f;
+  };
+
+  class sed_options
+  {
+    bool --quiet|-n;
+    bool --in-place|-i;
+    std::vector<std::string> --expression|-e;
+  };
+
+  class sleep_options
+  {
+    // No options so far.
+    //
+  };
+
+  class test_options
+  {
+    bool --file|-f;
+    bool --directory|-d;
+  };
+
+  class touch_options
+  {
+    std::string --after; // Path (see above).
+  };
+}
diff --git a/libbutl/builtin.cxx b/libbutl/builtin.cxx
new file mode 100644
index 0000000..3340271
--- /dev/null
+++ b/libbutl/builtin.cxx
@@ -0,0 +1,2111 @@
+// file      : libbutl/builtin.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef __cpp_modules_ts
+#include <libbutl/builtin.mxx>
+#endif
+
+#ifdef _WIN32
+#  include <libbutl/win32-utility.hxx>
+#endif
+
+#include <cassert>
+
+#ifndef __cpp_lib_modules_ts
+#include <map>
+#include <string>
+#include <vector>
+#include <thread>
+#include <utility>    // move(), forward()
+#include <cstdint>    // uint*_t
+#include <functional>
+
+#include <ios>
+#include <chrono>
+#include <cerrno>
+#include <ostream>
+#include <sstream>
+#include <cstdlib>      // strtoull()
+#include <cstring>      // strcmp()
+#include <exception>
+#include <system_error>
+
+#endif
+
+#include <libbutl/builtin-options.hxx>
+
+#ifdef __cpp_modules_ts
+module butl.builtin;
+
+// Only imports additional to interface.
+#ifdef __clang__
+#ifdef __cpp_lib_modules_ts
+import std.core;
+import std.io;
+import std.threading;
+#endif
+import butl.path;
+import butl.fdstream;
+import butl.timestamp;
+#endif
+
+import butl.regex;
+import butl.path_io;
+import butl.optional;
+import butl.filesystem;
+import butl.small_vector;
+#else
+#include <libbutl/regex.mxx>
+#include <libbutl/path-io.mxx>
+#include <libbutl/optional.mxx>
+#include <libbutl/filesystem.mxx>
+#include <libbutl/small-vector.mxx>
+#endif
+
+// Strictly speaking a builtin which reads/writes from/to standard streams
+// must be asynchronous so that the caller can communicate with it through
+// pipes without being blocked on I/O operations. However, as an optimization,
+// we allow builtins that only print diagnostics to STDERR to be synchronous
+// assuming that their output will always fit the pipe buffer. Synchronous
+// builtins must not read from STDIN and write to STDOUT. Later we may relax
+// this rule to allow a "short" output for such builtins.
+//
+using namespace std;
+
+namespace butl
+{
+  using strings = vector<string>;
+  using io_error = ios_base::failure;
+
+  using builtin_impl = uint8_t (const strings& args,
+                                auto_fd in, auto_fd out, auto_fd err,
+                                const dir_path& cwd,
+                                const builtin_callbacks&);
+
+  // Operation failed, diagnostics has already been issued.
+  //
+  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_;
+  };
+
+  // Call a function returning its resulting value. Fail if an exception is
+  // thrown by the function.
+  //
+  template <typename F, typename... A>
+  static inline auto
+  call (const function<error_record ()>& fail,
+        const function<F>& fn,
+        A&&... args) -> decltype (fn (forward<A> (args)...))
+  {
+    assert (fn);
+
+    try
+    {
+      return fn (forward<A> (args)...);
+    }
+    catch (const std::exception& e)
+    {
+      fail () << e;
+    }
+    catch (...)
+    {
+      fail () << "unknown error";
+    }
+
+    assert (false); // Can't be here.
+    throw failed ();
+  }
+
+  // Parse builtin options. Call the callback to parse unknown options and
+  // throw cli::unknown_option if the callback is not specified or doesn't
+  // parse the option.
+  //
+  template <typename O>
+  static O
+  parse (cli::vector_scanner& scan,
+         const strings& args,
+         const function<builtin_callbacks::parse_option_function>& parse,
+         const function<error_record ()>& fail)
+  {
+    O ops;
+
+    while (true)
+    {
+      // Parse the next chunk of options until we reach an argument, --,
+      // unknown option, or eos.
+      //
+      ops.parse (scan, cli::unknown_mode::stop);
+
+      // Bail out on eos.
+      //
+      if (!scan.more ())
+        break;
+
+      const char* o (scan.peek ());
+
+      // Bail out on --.
+      //
+      if (strcmp (o, "--") == 0)
+      {
+        scan.next (); // Skip --.
+        break;
+      }
+
+      // Bail out on an argument.
+      //
+      if (!(o[0] == '-' && o[1] != '\0'))
+        break;
+
+      // Parse the unknown option if the callback is specified and fail if
+      // that's not the case or the callback doesn't recognize the option
+      // either.
+      //
+      size_t n (parse ? call (fail, parse, args, scan.end ()) : 0);
+
+      if (n == 0)
+        throw cli::unknown_option (o);
+
+      // Skip the parsed arguments and continue.
+      //
+      assert (scan.end () + n <= args.size ());
+      scan.reset (scan.end () + n);
+    }
+
+    return ops;
+  }
+
+  // Parse and normalize a path. Also, unless it is already absolute, make the
+  // path absolute using the specified directory (must be an absolute path).
+  // Fail if the path is empty, and on parsing and normalization errors.
+  //
+  static path
+  parse_path (string s,
+              const dir_path& d,
+              const function<error_record ()>& fail)
+  {
+    assert (d.absolute ());
+
+    try
+    {
+      path p (move (s));
+
+      if (p.empty ())
+        throw invalid_path ("");
+
+      if (p.relative ())
+        p = d / move (p);
+
+      p.normalize ();
+      return p;
+    }
+    catch (const invalid_path& e)
+    {
+      fail () << "invalid path '" << e.path << "'";
+    }
+
+    assert (false); // Can't be here.
+    return path ();
+  }
+
+  // Return the current working directory if wd is empty and wd otherwise,
+  // completed against the current directory if it is relative. Fail if
+  // std::system_error is thrown by the underlying function call.
+  //
+  dir_path
+  current_directory (const dir_path& wd, const function<error_record ()>& fail)
+  {
+    try
+    {
+      if (wd.empty ())
+        return dir_path::current_directory ();
+
+      if (wd.relative ())
+        return move (dir_path (wd).complete ());
+    }
+    catch (const system_error& e)
+    {
+      fail () << "unable to obtain current directory: " << e;
+    }
+
+    return wd;
+  }
+
+  // Builtin commands functions.
+  //
+
+  // cat <file>...
+  //
+  // Note that POSIX doesn't specify if after I/O operation failure the
+  // command should proceed with the rest of the arguments. The current
+  // implementation exits immediatelly in such a case.
+  //
+  // @@ Shouldn't we check that we don't print a nonempty regular file to
+  //    itself, as that would merely exhaust the output device? POSIX allows
+  //    (but not requires) such a check and some implementations do this. That
+  //    would require to fstat() file descriptors and complicate the code a
+  //    bit. Was able to reproduce on a big file (should be bigger than the
+  //    stream buffer size) with the test `cat file >+file`.
+  //
+  // Note: must be executed asynchronously.
+  //
+  static uint8_t
+  cat (const strings& args,
+       auto_fd in, auto_fd out, auto_fd err,
+       const dir_path& cwd,
+       const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "cat");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      ifdstream cin (in != nullfd ? move (in) : fddup (stdin_fd ()),
+                     fdstream_mode::binary);
+
+      ofdstream cout (out != nullfd ? move (out) : fddup (stdout_fd ()),
+                      fdstream_mode::binary);
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      parse<cat_options> (scan, args, cbs.parse_option, fail);
+
+      // Print files.
+      //
+      // Copy input stream to STDOUT.
+      //
+      auto copy = [&cout] (istream& is)
+      {
+        if (is.peek () != ifdstream::traits_type::eof ())
+          cout << is.rdbuf ();
+
+        is.clear (istream::eofbit); // Sets eofbit.
+      };
+
+      // Path of a file being printed to STDOUT. An empty path represents
+      // STDIN. Used in diagnostics.
+      //
+      path p;
+
+      try
+      {
+        // Print STDIN.
+        //
+        if (!scan.more ())
+          copy (cin);
+
+        dir_path wd;
+
+        // Print files.
+        //
+        while (scan.more ())
+        {
+          string f (scan.next ());
+
+          if (f == "-")
+          {
+            if (!cin.eof ())
+            {
+              p.clear ();
+              copy (cin);
+            }
+
+            continue;
+          }
+
+          if (wd.empty () && cwd.relative ())
+            wd = current_directory (cwd, fail);
+
+          p = parse_path (move (f), !wd.empty () ? wd : cwd, fail);
+
+          ifdstream is (p, fdopen_mode::binary);
+          copy (is);
+          is.close ();
+        }
+      }
+      catch (const io_error& e)
+      {
+        error_record d (fail ());
+        d << "unable to print ";
+
+        if (p.empty ())
+          d << "stdin";
+        else
+          d << "'" << p << "'";
+
+        d << ": " << e;
+      }
+
+      cin.close ();
+      cout.close ();
+      r = 0;
+    }
+    // Can be thrown while creating/closing cin, cout or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // Make a copy of a file at the specified path, preserving permissions, and
+  // calling the hook for a newly created file. The file paths must be
+  // absolute and normalized. Fail if an exception is thrown by the underlying
+  // copy operation.
+  //
+  static void
+  cpfile (const path& from, const path& to,
+          bool overwrite,
+          bool attrs,
+          const builtin_callbacks& cbs,
+          const function<error_record ()>& fail)
+  {
+    assert (from.absolute () && from.normalized ());
+    assert (to.absolute () && to.normalized ());
+
+    try
+    {
+      if (cbs.create)
+        call (fail, cbs.create, to, true /* pre */);
+
+      cpflags f (overwrite
+                 ? cpflags::overwrite_permissions | cpflags::overwrite_content
+                 : cpflags::none);
+
+      if (attrs)
+        f |= cpflags::overwrite_permissions | cpflags::copy_timestamps;
+
+      cpfile (from, to, f);
+
+      if (cbs.create)
+        call (fail, cbs.create, to, false /* pre */);
+    }
+    catch (const system_error& e)
+    {
+      fail () << "unable to copy file '" << from << "' to '" << to << "': "
+              << e;
+    }
+  }
+
+  // Make a copy of a directory at the specified path, calling the hook for
+  // the created filesystem entries. The directory paths must be absolute and
+  // normalized. Fail if the destination directory already exists or an
+  // exception is thrown by the underlying copy operation.
+  //
+  static void
+  cpdir (const dir_path& from, const dir_path& to,
+         bool attrs,
+         const builtin_callbacks& cbs,
+         const function<error_record ()>& fail)
+  {
+    assert (from.absolute () && from.normalized ());
+    assert (to.absolute () && to.normalized ());
+
+    try
+    {
+      if (cbs.create)
+        call (fail, cbs.create, to, true /* pre */);
+
+      if (try_mkdir (to) == mkdir_status::already_exists)
+        throw_generic_error (EEXIST);
+
+      if (cbs.create)
+        call (fail, cbs.create, to, false /* pre */);
+
+      for (const auto& de: dir_iterator (from, false /* ignore_dangling */))
+      {
+        path f (from / de.path ());
+        path t (to / de.path ());
+
+        if (de.type () == entry_type::directory)
+          cpdir (path_cast<dir_path> (move (f)),
+                 path_cast<dir_path> (move (t)),
+                 attrs,
+                 cbs,
+                 fail);
+        else
+          cpfile (f, t, false /* overwrite */, attrs, cbs, fail);
+      }
+
+      // Note that it is essential to copy timestamps and permissions after
+      // the directory content is copied.
+      //
+      if (attrs)
+      {
+        path_permissions (to, path_permissions (from));
+        dir_time (to, dir_time (from));
+      }
+    }
+    catch (const system_error& e)
+    {
+      fail () << "unable to copy directory '" << from << "' to '" << to
+              << "': " << e;
+    }
+  }
+
+  // cp [-p|--preserve]                   <src-file>    <dst-file>
+  // cp [-p|--preserve] -R|-r|--recursive <src-dir>     <dst-dir>
+  // cp [-p|--preserve]                   <src-file>... <dst-dir>/
+  // cp [-p|--preserve] -R|-r|--recursive <src-path>... <dst-dir>/
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  cp (const strings& args,
+      auto_fd in, auto_fd out, auto_fd err,
+      const dir_path& cwd,
+      const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "cp");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      cp_options ops (parse<cp_options> (scan, args, cbs.parse_option, fail));
+
+      // Copy files or directories.
+      //
+      if (!scan.more ())
+        fail () << "missing arguments";
+
+      // Note that the arguments semantics depends on the last argument, so we
+      // read out and cache them.
+      //
+      small_vector<string, 2> args;
+      while (scan.more ())
+        args.push_back (scan.next ());
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      auto i (args.begin ());
+      auto j (args.rbegin ());
+      path dst (parse_path (move (*j++), wd, fail));
+      auto e (j.base ());
+
+      if (i == e)
+        fail () << "missing source path";
+
+      // If destination is not a directory path (no trailing separator) then
+      // make a copy of the filesystem entry at the specified path (the only
+      // source path is allowed in such a case). Otherwise copy the source
+      // filesystem entries into the destination directory.
+      //
+      if (!dst.to_directory ())
+      {
+        path src (parse_path (move (*i++), wd, fail));
+
+        // If there are multiple sources but no trailing separator for the
+        // destination, then, most likelly, it is missing.
+        //
+        if (i != e)
+          fail () << "multiple source paths without trailing separator for "
+                  << "destination directory";
+
+        if (!ops.recursive ())
+          // Synopsis 1: make a file copy at the specified path.
+          //
+          cpfile (src, dst, true /* overwrite */, ops.preserve (), cbs, fail);
+        else
+          // Synopsis 2: make a directory copy at the specified path.
+          //
+          cpdir (path_cast<dir_path> (src), path_cast<dir_path> (dst),
+                 ops.preserve (),
+                 cbs,
+                 fail);
+      }
+      else
+      {
+        for (; i != e; ++i)
+        {
+          path src (parse_path (move (*i), wd, fail));
+
+          if (ops.recursive () && dir_exists (src))
+            // Synopsis 4: copy a filesystem entry into the specified
+            // directory. Note that we handle only source directories here.
+            // Source files are handled below.
+            //
+            cpdir (path_cast<dir_path> (src),
+                   path_cast<dir_path> (dst / src.leaf ()),
+                   ops.preserve (),
+                   cbs,
+                   fail);
+          else
+            // Synopsis 3: copy a file into the specified directory. Also,
+            // here we cover synopsis 4 for the source path being a file.
+            //
+            cpfile (src, dst / src.leaf (),
+                    true /* overwrite */,
+                    ops.preserve (),
+                    cbs,
+                    fail);
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // echo <string>...
+  //
+  // Note: must be executed asynchronously.
+  //
+  static uint8_t
+  echo (const strings& args,
+        auto_fd in, auto_fd out, auto_fd err,
+        const dir_path&,
+        const builtin_callbacks&) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    try
+    {
+      in.close ();
+      ofdstream cout (out != nullfd ? move (out) : fddup (stdout_fd ()));
+
+      for (auto b (args.begin ()), i (b), e (args.end ()); i != e; ++i)
+        cout << (i != b ? " " : "") << *i;
+
+      cout << '\n';
+      cout.close ();
+      r = 0;
+    }
+    // Can be thrown while closing cin or creating, writing to, or closing
+    // cout.
+    //
+    catch (const io_error& e)
+    {
+      cerr << "echo: " << e << endl;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // false
+  //
+  // Failure to close the file descriptors is silently ignored.
+  //
+  // Note: can be executed synchronously.
+  //
+  static builtin
+  false_ (uint8_t& r,
+          const strings&,
+          auto_fd, auto_fd, auto_fd,
+          const dir_path&,
+          const builtin_callbacks&)
+  {
+    return builtin (r = 1);
+  }
+
+  // true
+  //
+  // Failure to close the file descriptors is silently ignored.
+  //
+  // Note: can be executed synchronously.
+  //
+  static builtin
+  true_ (uint8_t& r,
+         const strings&,
+         auto_fd, auto_fd, auto_fd,
+         const dir_path&,
+         const builtin_callbacks&)
+  {
+    return builtin (r = 0);
+  }
+
+  // Create a symlink to a file or directory at the specified path and calling
+  // the hook for the created filesystem entries. The paths must be absolute
+  // and normalized. Fall back to creating a hardlink, if symlink creation is
+  // not supported for the link path. If hardlink creation is not supported
+  // either, then fall back to copies. Fail if the target filesystem entry
+  // doesn't exist or an exception is thrown by the underlying filesystem
+  // operation (specifically for an already existing filesystem entry at the
+  // link path).
+  //
+  // Note that supporting optional removal of an existing filesystem entry at
+  // the link path (the -f option) tends to get hairy. Also removing non-empty
+  // directories doesn't look very natural, but would be required if we want
+  // the behavior on POSIX and Windows to be consistent.
+  //
+  static void
+  mksymlink (const path& target, const path& link,
+             const builtin_callbacks& cbs,
+             const function<error_record ()>& fail)
+  {
+    assert (target.absolute () && target.normalized ());
+    assert (link.absolute () && link.normalized ());
+
+    // Determine the target type, fail if the target doesn't exist.
+    //
+    bool dir (false);
+
+    try
+    {
+      pair<bool, entry_stat> pe (path_entry (target));
+
+      if (!pe.first)
+        fail () << "unable to create symlink to '" << target << "': no such "
+                << "file or directory";
+
+      dir = pe.second.type == entry_type::directory;
+    }
+    catch (const system_error& e)
+    {
+      fail () << "unable to stat '" << target << "': " << e;
+    }
+
+    // First we try to create a symlink. If that fails (e.g., "Windows
+    // happens"), then we resort to hard links. If that doesn't work out
+    // either (e.g., not on the same filesystem), then we fall back to copies.
+    // So things are going to get a bit nested.
+    //
+    // Note: similar to mkanylink() but with support for directories.
+    //
+    try
+    {
+      if (cbs.create)
+        call (fail, cbs.create, link, true /* pre */);
+
+      mksymlink (target, link, dir);
+
+      if (cbs.create)
+        call (fail, cbs.create, link, false /* pre */);
+    }
+    catch (const system_error& e)
+    {
+      // Note that we are not guaranteed (here and below) that the
+      // system_error exception is of the generic category.
+      //
+      int c (e.code ().value ());
+      if (!(e.code ().category () == generic_category () &&
+            (c == ENOSYS || // Not implemented.
+             c == EPERM)))  // Not supported by the filesystem(s).
+        fail () << "unable to create symlink '" << link << "' to '"
+                << target << "': " << e;
+
+      try
+      {
+        mkhardlink (target, link, dir);
+
+        if (cbs.create)
+          call (fail, cbs.create, link, false /* pre */);
+      }
+      catch (const system_error& e)
+      {
+        c = e.code ().value ();
+        if (!(e.code ().category () == generic_category () &&
+              (c == ENOSYS || // Not implemented.
+               c == EPERM  || // Not supported by the filesystem(s).
+               c == EXDEV)))  // On different filesystems.
+          fail () << "unable to create hardlink '" << link << "' to '"
+                  << target << "': " << e;
+
+        if (dir)
+          cpdir (path_cast<dir_path> (target), path_cast<dir_path> (link),
+                 false /* attrs */,
+                 cbs,
+                 fail);
+        else
+          cpfile (target, link,
+                  false /* overwrite */,
+                  true /* attrs */,
+                  cbs,
+                  fail);
+      }
+    }
+  }
+
+  // ln -s|--symbolic <target-path>    <link-path>
+  // ln -s|--symbolic <target-path>... <link-dir>/
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  ln (const strings& args,
+      auto_fd in, auto_fd out, auto_fd err,
+      const dir_path& cwd,
+      const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "ln");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      ln_options ops (parse<ln_options> (scan, args, cbs.parse_option, fail));
+
+      if (!ops.symbolic ())
+        fail () << "missing -s|--symbolic option";
+
+      // Create file or directory symlinks.
+      //
+      if (!scan.more ())
+        fail () << "missing arguments";
+
+      // Note that the arguments semantics depends on the last argument, so we
+      // read out and cache them.
+      //
+      small_vector<string, 2> args;
+      while (scan.more ())
+        args.push_back (scan.next ());
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      auto i (args.begin ());
+      auto j (args.rbegin ());
+      path link (parse_path (move (*j++), wd, fail));
+      auto e (j.base ());
+
+      if (i == e)
+        fail () << "missing target path";
+
+      // If link is not a directory path (no trailing separator), then create
+      // a symlink to the target path at the specified link path (the only
+      // target path is allowed in such a case). Otherwise create links to the
+      // target paths inside the specified directory.
+      //
+      if (!link.to_directory ())
+      {
+        path target (parse_path (move (*i++), wd, fail));
+
+        // If there are multiple targets but no trailing separator for the
+        // link, then, most likelly, it is missing.
+        //
+        if (i != e)
+          fail () << "multiple target paths with non-directory link path";
+
+        // Synopsis 1: create a target path symlink at the specified path.
+        //
+        mksymlink (target, link, cbs, fail);
+      }
+      else
+      {
+        for (; i != e; ++i)
+        {
+          path target (parse_path (move (*i), wd, fail));
+
+          // Synopsis 2: create a target path symlink in the specified
+          // directory.
+          //
+          mksymlink (target, link / target.leaf (), cbs, fail);
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // Create a directory if not exist and its parent directories if necessary,
+  // calling the hook for the created directories. The directory path must be
+  // absolute and normalized. Throw system_error on failure.
+  //
+  static void
+  mkdir_p (const dir_path& p,
+           const builtin_callbacks& cbs,
+           const function<error_record ()>& fail)
+  {
+    assert (p.absolute () && p.normalized ());
+
+    if (!dir_exists (p))
+    {
+      if (!p.root ())
+        mkdir_p (p.directory (), cbs, fail);
+
+      if (cbs.create)
+        call (fail, cbs.create, p, true /* pre */);
+
+      try_mkdir (p); // Returns success or throws.
+
+      if (cbs.create)
+        call (fail, cbs.create, p, false /* pre */);
+    }
+  }
+
+  // mkdir [-p|--parents] <dir>...
+  //
+  // Note that POSIX doesn't specify if after a directory creation failure the
+  // command should proceed with the rest of the arguments. The current
+  // implementation exits immediatelly in such a case.
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  mkdir (const strings& args,
+         auto_fd in, auto_fd out, auto_fd err,
+         const dir_path& cwd,
+         const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "mkdir");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+
+      mkdir_options ops (
+        parse<mkdir_options> (scan, args, cbs.parse_option, fail));
+
+      // Create directories.
+      //
+      if (!scan.more ())
+        fail () << "missing directory";
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      while (scan.more ())
+      {
+        dir_path p (
+          path_cast<dir_path> (parse_path (scan.next (), wd, fail)));
+
+        try
+        {
+          if (ops.parents ())
+            mkdir_p (p, cbs, fail);
+          else
+          {
+            if (cbs.create)
+              call (fail, cbs.create, p, true /* pre */);
+
+            if (try_mkdir (p) == mkdir_status::success)
+            {
+              if (cbs.create)
+                call (fail, cbs.create, p, false /* pre */);
+            }
+            else //           == mkdir_status::already_exists
+              throw_generic_error (EEXIST);
+          }
+        }
+        catch (const system_error& e)
+        {
+          fail () << "unable to create directory '" << p << "': " << e;
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // mv [-f|--force] <src-path>    <dst-path>
+  // mv [-f|--force] <src-path>... <dst-dir>/
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  mv (const strings& args,
+      auto_fd in, auto_fd out, auto_fd err,
+      const dir_path& cwd,
+      const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "mv");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      mv_options ops (parse<mv_options> (scan, args, cbs.parse_option, fail));
+
+      // Move filesystem entries.
+      //
+      if (!scan.more ())
+        fail () << "missing arguments";
+
+      // Note that the arguments semantics depends on the last argument, so we
+      // read out and cache them.
+      //
+      small_vector<string, 2> args;
+      while (scan.more ())
+        args.push_back (scan.next ());
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      auto i (args.begin ());
+      auto j (args.rbegin ());
+      path dst (parse_path (move (*j++), wd, fail));
+      auto e (j.base ());
+
+      if (i == e)
+        fail () << "missing source path";
+
+      auto mv = [ops, &fail, cbs] (const path& from, const path& to)
+      {
+        if (cbs.move)
+          call (fail, cbs.move, from, to, ops.force (), true /* pre */);
+
+        try
+        {
+          bool exists (entry_exists (to));
+
+          // Fail if the source and destination paths are the same.
+          //
+          // Note that for mventry() function (that is based on the POSIX
+          // rename() function) this is a noop.
+          //
+          if (exists && to == from)
+            fail () << "unable to move entity '" << from << "' to itself";
+
+          // Rename/move the filesystem entry, replacing an existing one.
+          //
+          mventry (from, to,
+                   cpflags::overwrite_permissions |
+                   cpflags::overwrite_content);
+
+          if (cbs.move)
+            call (fail, cbs.move, from, to, ops.force (), false /* pre */);
+        }
+        catch (const system_error& e)
+        {
+          fail () << "unable to move entity '" << from << "' to '" << to
+                  << "': " << e;
+        }
+      };
+
+      // If destination is not a directory path (no trailing separator) then
+      // move the filesystem entry to the specified path (the only source path
+      // is allowed in such a case). Otherwise move the source filesystem
+      // entries into the destination directory.
+      //
+      if (!dst.to_directory ())
+      {
+        path src (parse_path (move (*i++), wd, fail));
+
+        // If there are multiple sources but no trailing separator for the
+        // destination, then, most likelly, it is missing.
+        //
+        if (i != e)
+          fail () << "multiple source paths without trailing separator for "
+                  << "destination directory";
+
+        // Synopsis 1: move an entity to the specified path.
+        //
+        mv (src, dst);
+      }
+      else
+      {
+        // Synopsis 2: move entities into the specified directory.
+        //
+        for (; i != e; ++i)
+        {
+          path src (parse_path (move (*i), wd, fail));
+          mv (src, dst / src.leaf ());
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // rm [-r|--recursive] [-f|--force] <path>...
+  //
+  // The implementation deviates from POSIX in a number of ways. It doesn't
+  // interact with a user and fails immediatelly if unable to process an
+  // argument. It doesn't check for dots containment in the path, and doesn't
+  // consider files and directory permissions in any way just trying to remove
+  // a filesystem entry. Always fails if empty path is specified.
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  rm (const strings& args,
+      auto_fd in, auto_fd out, auto_fd err,
+      const dir_path& cwd,
+      const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "rm");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      rm_options ops (parse<rm_options> (scan, args, cbs.parse_option, fail));
+
+      // Remove entries.
+      //
+      if (!scan.more () && !ops.force ())
+        fail () << "missing file";
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      while (scan.more ())
+      {
+        path p (parse_path (scan.next (), wd, fail));
+
+        if (cbs.remove)
+          call (fail, cbs.remove, p, ops.force (), true /* pre */);
+
+        try
+        {
+          dir_path d (path_cast<dir_path> (p));
+
+          pair<bool, entry_stat> es (path_entry (d));
+          if (es.first && es.second.type == entry_type::directory)
+          {
+            if (!ops.recursive ())
+              fail () << "'" << p << "' is a directory";
+
+            // The call can result in rmdir_status::not_exist. That's not very
+            // likelly but there is also nothing bad about it.
+            //
+            try_rmdir_r (d);
+          }
+          else if (try_rmfile (p) == rmfile_status::not_exist &&
+                   !ops.force ())
+            throw_generic_error (ENOENT);
+
+          if (cbs.remove)
+            call (fail, cbs.remove, p, ops.force (), false /* pre */);
+        }
+        catch (const system_error& e)
+        {
+          fail () << "unable to remove '" << p << "': " << e;
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // rmdir [-f|--force] <path>...
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  rmdir (const strings& args,
+         auto_fd in, auto_fd out, auto_fd err,
+         const dir_path& cwd,
+         const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "rmdir");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+
+      rmdir_options ops (
+        parse<rmdir_options> (scan, args, cbs.parse_option, fail));
+
+      // Remove directories.
+      //
+      if (!scan.more () && !ops.force ())
+        fail () << "missing directory";
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      while (scan.more ())
+      {
+        dir_path p (
+          path_cast<dir_path> (parse_path (scan.next (), wd, fail)));
+
+        if (cbs.remove)
+          call (fail, cbs.remove, p, ops.force (), true /* pre */);
+
+        try
+        {
+          rmdir_status s (try_rmdir (p));
+
+          if (s == rmdir_status::not_empty)
+            throw_generic_error (ENOTEMPTY);
+          else if (s == rmdir_status::not_exist && !ops.force ())
+            throw_generic_error (ENOENT);
+
+          if (cbs.remove)
+            call (fail, cbs.remove, p, ops.force (), false /* pre */);
+        }
+        catch (const system_error& e)
+        {
+          fail () << "unable to remove '" << p << "': " << e;
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // sed [-n|--quiet] [-i|--in-place] -e|--expression <script> [<file>]
+  //
+  // Note: must be executed asynchronously.
+  //
+  static uint8_t
+  sed (const strings& args,
+       auto_fd in, auto_fd out, auto_fd err,
+       const dir_path& cwd,
+       const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "sed");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      // Automatically remove a temporary file (used for in place editing) on
+      // failure.
+      //
+      auto_rmfile rm;
+
+      // Do not throw when failbit is set (getline() failed to extract any
+      // character).
+      //
+      ifdstream cin (in != nullfd ? move (in) : fddup (stdin_fd ()),
+                     ifdstream::badbit);
+
+      ofdstream cout (out != nullfd ? move (out) : fddup (stdout_fd ()));
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+
+      sed_options ops (
+        parse<sed_options> (scan, args, cbs.parse_option, fail));
+
+      if (ops.expression ().empty ())
+        fail () << "missing script";
+
+      // Only a single script is supported.
+      //
+      if (ops.expression ().size () != 1)
+        fail () << "multiple scripts";
+
+      struct
+      {
+        string regex;
+        string replacement;
+        bool icase  = false;
+        bool global = false;
+        bool print  = false;
+      } subst;
+
+      {
+        const string& v (ops.expression ()[0]);
+        if (v.empty ())
+          fail () << "empty script";
+
+        if (v[0] != 's')
+          fail () << "only 's' command supported";
+
+        // Parse the substitute command.
+        //
+        if (v.size () < 2)
+          fail () << "no delimiter for 's' command";
+
+        char delim (v[1]);
+        if (delim == '\\' || delim == '\n')
+          fail () << "invalid delimiter for 's' command";
+
+        size_t p (v.find (delim, 2));
+        if (p == string::npos)
+          fail () << "unterminated 's' command regex";
+
+        subst.regex.assign (v, 2, p - 2);
+
+        // Empty regex matches nothing, so not of much use.
+        //
+        if (subst.regex.empty ())
+          fail () << "empty regex in 's' command";
+
+        size_t b (p + 1);
+        p = v.find (delim, b);
+        if (p == string::npos)
+          fail () << "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:
+            {
+              fail () << "invalid 's' command flag '" << c << "'";
+            }
+          }
+        }
+      }
+
+      // Path of a file to edit. An empty path represents stdin.
+      //
+      path p;
+      if (scan.more ())
+      {
+        string f (scan.next ());
+
+        if (f != "-")
+          p = parse_path (move (f),
+                          (cwd.absolute ()
+                           ? cwd
+                           : current_directory (cwd, fail)),
+                          fail);
+      }
+
+      if (scan.more ())
+        fail () << "unexpected argument '" << scan.next () << "'";
+
+      // Edit file.
+      //
+      // If we edit file in place make sure that the file path is specified
+      // and obtain a temporary file path. We will be writing to the temporary
+      // file (rather than to stdout) and will move it to the original file
+      // path afterwards.
+      //
+      path tp;
+      if (ops.in_place ())
+      {
+        if (p.empty ())
+          fail () << "-i|--in-place option specified while reading from "
+                  << "stdin";
+
+        try
+        {
+          tp = path::temp_path ("build2-sed");
+
+          cout.close ();  // Flush and close.
+
+          cout.open (fdopen (tp,
+                             fdopen_mode::out      |
+                             fdopen_mode::truncate |
+                             fdopen_mode::create,
+                             path_permissions (p)));
+        }
+        catch (const io_error& e)
+        {
+          fail () << "unable to open '" << tp << "': " << e;
+        }
+        catch (const system_error& e)
+        {
+          fail () << "unable to obtain temporary file: " << e;
+        }
+
+        rm = auto_rmfile (tp);
+      }
+
+      // 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_search (
+                    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 (!ops.quiet () || (r.second && subst.print))
+            cout << r.first << '\n';
+        }
+
+        cin.close ();
+        cout.close ();
+
+        if (ops.in_place ())
+        {
+          mvfile (tp, p,
+                  cpflags::overwrite_content |
+                  cpflags::overwrite_permissions);
+
+          rm.cancel ();
+        }
+
+        r = 0;
+      }
+      catch (const io_error& e)
+      {
+        error_record d (fail ());
+        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 () << "invalid regex" << e;
+    }
+    // Can be thrown while creating cin, cout or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const system_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // sleep <seconds>
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  sleep (const strings& args,
+         auto_fd in, auto_fd out, auto_fd err,
+         const dir_path&,
+         const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "sleep");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+      parse<sleep_options> (scan, args, cbs.parse_option, fail);
+
+      if (!scan.more ())
+        fail () << "missing time interval";
+
+      uint64_t n;
+
+      for (;;) // Breakout loop.
+      {
+        string a (scan.next ());
+
+        // Note: strtoull() allows these.
+        //
+        if (!a.empty () && a[0] != '-' && a[0] != '+')
+        {
+          char* e (nullptr);
+          n = strtoull (a.c_str (), &e, 10); // Can't throw.
+
+          if (errno != ERANGE && e == a.c_str () + a.size ())
+            break;
+        }
+
+        fail () << "invalid time interval '" << a << "'";
+      }
+
+      if (scan.more ())
+        fail () << "unexpected argument '" << scan.next () << "'";
+
+      // Sleep.
+      //
+      using namespace chrono;
+
+      seconds d (n);
+
+      if (cbs.sleep)
+        call (fail, cbs.sleep, d);
+      else
+      {
+        // MinGW GCC 4.9 doesn't implement this_thread so use Win32 Sleep().
+        //
+#ifndef _WIN32
+        this_thread::sleep_for (d);
+#else
+        Sleep (static_cast<DWORD> (duration_cast<milliseconds> (d).count ()));
+#endif
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // test (-f|--file)|(-d|--directory) <path>
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  test (const strings& args,
+        auto_fd in, auto_fd out, auto_fd err,
+        const dir_path& cwd,
+        const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (2);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "test");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+
+      test_options ops (
+        parse<test_options> (scan, args, cbs.parse_option, fail));
+
+      if (!ops.file () && !ops.directory ())
+        fail () << "either -f|--file or -d|--directory must be specified";
+
+      if (ops.file () && ops.directory ())
+        fail () << "both -f|--file and -d|--directory specified";
+
+      if (!scan.more ())
+        fail () << "missing path";
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      path p (parse_path (scan.next (), wd, fail));
+
+      if (scan.more ())
+        fail () << "unexpected argument '" << scan.next () << "'";
+
+      try
+      {
+        r = (ops.file () ? file_exists (p) : dir_exists (p)) ? 0 : 1;
+      }
+      catch (const system_error& e)
+      {
+        fail () << "cannot test '" << p << "': " << e;
+      }
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 2;
+  }
+
+  // touch [--after <ref-file>] <file>...
+  //
+  // Note that POSIX doesn't specify the behavior for touching an entry other
+  // than file.
+  //
+  // Also note that POSIX doesn't specify if after a file touch failure the
+  // command should proceed with the rest of the arguments. The current
+  // implementation exits immediatelly in such a case.
+  //
+  // Note: can be executed synchronously.
+  //
+  static uint8_t
+  touch (const strings& args,
+         auto_fd in, auto_fd out, auto_fd err,
+         const dir_path& cwd,
+         const builtin_callbacks& cbs) noexcept
+  try
+  {
+    uint8_t r (1);
+    ofdstream cerr (err != nullfd ? move (err) : fddup (stderr_fd ()));
+
+    auto error = [&cerr] (bool fail = false)
+    {
+      return error_record (cerr, fail, "touch");
+    };
+
+    auto fail = [&error] () {return error (true /* fail */);};
+
+    try
+    {
+      in.close ();
+      out.close ();
+
+      // Parse arguments.
+      //
+      cli::vector_scanner scan (args);
+
+      touch_options ops (
+        parse<touch_options> (scan, args, cbs.parse_option, fail));
+
+      auto mtime = [&fail] (const path& p) -> timestamp
+      {
+        try
+        {
+          timestamp t (file_mtime (p));
+
+          if (t == timestamp_nonexistent)
+            throw_generic_error (ENOENT);
+
+          return t;
+        }
+        catch (const system_error& e)
+        {
+          fail () << "cannot obtain file '" << p << "' modification time: "
+                  << e;
+        }
+        assert (false); // Can't be here.
+        return timestamp ();
+      };
+
+      const dir_path& wd (cwd.absolute ()
+                          ? cwd
+                          : current_directory (cwd, fail));
+
+      optional<timestamp> after;
+      if (ops.after_specified ())
+        after = mtime (parse_path (ops.after (), wd, fail));
+
+      if (!scan.more ())
+        fail () << "missing file";
+
+      // Create files.
+      //
+      while (scan.more ())
+      {
+        path p (parse_path (scan.next (), wd, fail));
+
+        try
+        {
+          if (cbs.create)
+            call (fail, cbs.create, p, true /* pre */);
+
+          touch_file (p);
+
+          if (cbs.create)
+            call (fail, cbs.create, p, false /* pre */);
+
+          if (after)
+          {
+            while (mtime (p) <= *after)
+              touch_file (p, false /* create */);
+          }
+        }
+        catch (const system_error& e)
+        {
+          fail () << "cannot create/update '" << p << "': " << e;
+        }
+      }
+
+      r = 0;
+    }
+    // Can be thrown while closing in, out or writing to cerr.
+    //
+    catch (const io_error& e)
+    {
+      error () << e;
+    }
+    catch (const failed&)
+    {
+      // Diagnostics has already been issued.
+    }
+    catch (const cli::exception& e)
+    {
+      error () << e;
+    }
+
+    cerr.close ();
+    return r;
+  }
+  // In particular, handles io_error exception potentially thrown while
+  // creating, writing to, or closing cerr.
+  //
+  catch (const std::exception&)
+  {
+    return 1;
+  }
+
+  // Run builtin implementation asynchronously.
+  //
+  static builtin
+  async_impl (builtin_impl* fn,
+              uint8_t& r,
+              const strings& args,
+              auto_fd in, auto_fd out, auto_fd err,
+              const dir_path& cwd,
+              const builtin_callbacks& cbs)
+  {
+    return builtin (
+      r,
+      thread ([fn, &r, &args,
+               in  = move (in),
+               out = move (out),
+               err = move (err),
+               &cwd,
+               &cbs] () mutable noexcept
+              {
+                r = fn (args, move (in), move (out), move (err), cwd, cbs);
+              }));
+  }
+
+  template <builtin_impl fn>
+  static builtin
+  async_impl (uint8_t& r,
+              const strings& args,
+              auto_fd in, auto_fd out, auto_fd err,
+              const dir_path& cwd,
+              const builtin_callbacks& cbs)
+  {
+    return async_impl (
+      fn, r, args, move (in), move (out), move (err), cwd, cbs);
+  }
+
+  // Run builtin implementation synchronously.
+  //
+  template <builtin_impl fn>
+  static builtin
+  sync_impl (uint8_t& r,
+             const strings& args,
+             auto_fd in, auto_fd out, auto_fd err,
+             const dir_path& cwd,
+             const builtin_callbacks& cbs)
+  {
+    r = fn (args, move (in), move (out), move (err), cwd, cbs);
+    return builtin (r, thread ());
+  }
+
+  const builtin_map builtins
+  {
+    {"cat",   &async_impl<&cat>},
+    {"cp",    &sync_impl<&cp>},
+    {"echo",  &async_impl<&echo>},
+    {"false", &false_},
+    {"ln",    &sync_impl<&ln>},
+    {"mkdir", &sync_impl<&mkdir>},
+    {"mv",    &sync_impl<&mv>},
+    {"rm",    &sync_impl<&rm>},
+    {"rmdir", &sync_impl<&rmdir>},
+    {"sed",   &async_impl<&sed>},
+    {"sleep", &sync_impl<&sleep>},
+    {"test",  &sync_impl<&test>},
+    {"touch", &sync_impl<&touch>},
+    {"true",  &true_}
+  };
+}
diff --git a/libbutl/builtin.mxx b/libbutl/builtin.mxx
new file mode 100644
index 0000000..8c9d295
--- /dev/null
+++ b/libbutl/builtin.mxx
@@ -0,0 +1,174 @@
+// file      : libbutl/builtin.mxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef __cpp_modules_ts
+#pragma once
+#endif
+
+// C includes.
+
+#ifndef __cpp_lib_modules_ts
+#include <map>
+#include <string>
+#include <vector>
+#include <thread>
+#include <cstddef>    // size_t
+#include <utility>    // move()
+#include <cstdint>    // uint8_t
+#include <functional>
+#endif
+
+// Other includes.
+
+#ifdef __cpp_modules_ts
+export module butl.builtin;
+#ifdef __cpp_lib_modules_ts
+import std.core;
+import std.threading;
+#endif
+import butl.path;
+import butl.fdstream;
+import butl.timestamp;
+#else
+#include <libbutl/path.mxx>
+#include <libbutl/fdstream.mxx>
+#include <libbutl/timestamp.mxx>
+#endif
+
+#include <libbutl/export.hxx>
+
+LIBBUTL_MODEXPORT namespace butl
+{
+  // A process/thread-like object representing a running builtin.
+  //
+  // For now, instead of allocating the result storage dynamically, we
+  // expect it to be provided by the caller.
+  //
+  class builtin
+  {
+  public:
+    std::uint8_t
+    wait () {if (t_.joinable ()) t_.join (); return r_;}
+
+    ~builtin () {wait ();}
+
+  public:
+    builtin (std::uint8_t& r, std::thread&& t = std::thread ())
+        : r_ (r), t_ (move (t)) {}
+
+    builtin (builtin&&) = default;
+
+  private:
+    std::uint8_t& r_;
+    std::thread t_;
+  };
+
+  // Builtin execution callbacks that can be used for checking/handling the
+  // filesystem entries being acted upon (enforcing that they are sub-entries
+  // of some "working" directory, registering cleanups for new entries, etc)
+  // and for providing custom implementations for some functions used by
+  // builtins.
+  //
+  // Note that the filesystem paths passed to the callbacks are absolute and
+  // normalized with directories distinguished from non-directories based on
+  // the lexical representation (presence of the trailing directory separator;
+  // use path::to_directory() to check).
+  //
+  // Also note that builtins catch any exceptions that may be thrown by the
+  // callbacks and, if that's the case, issue diagnostics and exit with the
+  // non-zero status.
+  //
+  struct builtin_callbacks
+  {
+    // If specified, called before (pre is true) and after (pre is false) a
+    // new filesystem entry is created or an existing one is re-created or
+    // updated.
+    //
+    using create_hook = void (const path&, bool pre);
+
+    std::function<create_hook> create;
+
+    // If specified, called before (pre is true) and after (pre is false) a
+    // filesystem entry is moved. The force argument is true if the builtin is
+    // executed with the --force option.
+    //
+    using move_hook = void (const path& from,
+                            const path& to,
+                            bool force,
+                            bool pre);
+
+    std::function<move_hook> move;
+
+    // If specified, called before (pre is true) and after (pre is false) a
+    // filesystem entry is removed. The force argument is true if the builtin
+    // is executed with the --force option.
+    //
+    using remove_hook = void (const path&, bool force, bool pre);
+
+    std::function<remove_hook> remove;
+
+    // If specified, called on encountering an unknown option passing the
+    // argument list and the position of the option in question. Return the
+    // number of parsed arguments.
+    //
+    using parse_option_function =
+      std::size_t (const std::vector<std::string>&, std::size_t);
+
+    std::function<parse_option_function> parse_option;
+
+    // If specified, called by the sleep builtin instead of the default
+    // implementation.
+    //
+    using sleep_function = void (const duration&);
+
+    std::function<sleep_function> sleep;
+
+    explicit
+    builtin_callbacks (std::function<create_hook>           c = {},
+                       std::function<move_hook>             m = {},
+                       std::function<remove_hook>           r = {},
+                       std::function<parse_option_function> p = {},
+                       std::function<sleep_function>        s = {})
+        : create (std::move (c)),
+          move (std::move (m)),
+          remove (std::move (r)),
+          parse_option (std::move (p)),
+          sleep (std::move (s)) {}
+
+    explicit
+    builtin_callbacks (std::function<sleep_function> sl)
+        : sleep (std::move (sl)) {}
+  };
+
+  // Start a builtin command. Use the current process' standard streams for
+  // the unopened in, out, and err file descriptors. Use the process' current
+  // working directory unless an alternative is specified. Throw
+  // std::system_error on failure.
+  //
+  // Note that unlike argc/argv, args don't include the program name.
+  //
+  using builtin_function = builtin (std::uint8_t& result,
+                                    const std::vector<std::string>& args,
+                                    auto_fd in, auto_fd out, auto_fd err,
+                                    const dir_path& cwd,
+                                    const builtin_callbacks&);
+
+  class builtin_map: public std::map<std::string, builtin_function*>
+  {
+  public:
+    using base = std::map<std::string, builtin_function*>;
+    using base::base;
+
+    // Return NULL if not a builtin.
+    //
+    builtin_function*
+    find (const std::string& n) const
+    {
+      auto i (base::find (n));
+      return i != end () ? i->second : nullptr;
+    }
+  };
+
+  LIBBUTL_SYMEXPORT extern const builtin_map builtins;
+}