Add generated cli files back to repository

Without them there is no way to bootstrap.

4 files changed, 1665 insertions, 3 deletions

diff --git a/build2/.gitignore b/build2/.gitignore
index 35d9f3d..833a997 100644
--- a/build2/.gitignore
+++ b/build2/.gitignore
@@ -1,4 +1,4 @@
 b
-b-*
-*-options
-*-options.?xx
+b-boot
+#*-options
+#*-options.?xx
diff --git a/build2/b-options b/build2/b-options
new file mode 100644
index 0000000..c641ce0
--- /dev/null
+++ b/build2/b-options
@@ -0,0 +1,471 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BUILD2_B_OPTIONS
+#define BUILD2_B_OPTIONS
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <deque>
+#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 build2
+{
+  namespace cl
+  {
+    class usage_para
+    {
+      public:
+      enum value
+      {
+        none,
+        text,
+        option
+      };
+
+      usage_para (value);
+
+      operator value () const 
+      {
+        return v_;
+      }
+
+      private:
+      value v_;
+    };
+
+    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&
+      option () const;
+
+      const std::string&
+      value () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string option_;
+      std::string value_;
+    };
+
+    class eos_reached: public exception
+    {
+      public:
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class file_io_failure: public exception
+    {
+      public:
+      virtual
+      ~file_io_failure () throw ();
+
+      file_io_failure (const std::string& file);
+
+      const std::string&
+      file () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const throw ();
+
+      private:
+      std::string file_;
+    };
+
+    class unmatched_quote: public exception
+    {
+      public:
+      virtual
+      ~unmatched_quote () throw ();
+
+      unmatched_quote (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 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 argv_file_scanner: public argv_scanner
+    {
+      public:
+      argv_file_scanner (int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false);
+
+      struct option_info
+      {
+        // If search_func is not NULL, it is called, with the arg
+        // value as the second argument, to locate the options file.
+        // If it returns an empty string, then the file is ignored.
+        //
+        const char* option;
+        std::string (*search_func) (const char*, void* arg);
+        void* arg;
+      };
+
+      argv_file_scanner (int& argc,
+                          char** argv,
+                          const option_info* options,
+                          std::size_t options_count,
+                          bool erase = false);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const option_info* options,
+                         std::size_t options_count,
+                         bool erase = false);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      private:
+      const option_info*
+      find (const char*) const;
+
+      void
+      load (const std::string& file);
+
+      typedef argv_scanner base;
+
+      const std::string option_;
+      option_info option_info_;
+      const option_info* options_;
+      std::size_t options_count_;
+
+      std::string hold_;
+      std::deque<std::string> args_;
+      bool skip_;
+    };
+
+    template <typename X>
+    struct parser;
+  }
+}
+
+#include <build2/types>
+
+namespace build2
+{
+  class options
+  {
+    public:
+    options ();
+
+    options (int& argc,
+             char** argv,
+             bool erase = false,
+             ::build2::cl::unknown_mode option = ::build2::cl::unknown_mode::fail,
+             ::build2::cl::unknown_mode argument = ::build2::cl::unknown_mode::stop);
+
+    options (int start,
+             int& argc,
+             char** argv,
+             bool erase = false,
+             ::build2::cl::unknown_mode option = ::build2::cl::unknown_mode::fail,
+             ::build2::cl::unknown_mode argument = ::build2::cl::unknown_mode::stop);
+
+    options (int& argc,
+             char** argv,
+             int& end,
+             bool erase = false,
+             ::build2::cl::unknown_mode option = ::build2::cl::unknown_mode::fail,
+             ::build2::cl::unknown_mode argument = ::build2::cl::unknown_mode::stop);
+
+    options (int start,
+             int& argc,
+             char** argv,
+             int& end,
+             bool erase = false,
+             ::build2::cl::unknown_mode option = ::build2::cl::unknown_mode::fail,
+             ::build2::cl::unknown_mode argument = ::build2::cl::unknown_mode::stop);
+
+    options (::build2::cl::scanner&,
+             ::build2::cl::unknown_mode option = ::build2::cl::unknown_mode::fail,
+             ::build2::cl::unknown_mode argument = ::build2::cl::unknown_mode::stop);
+
+    // Option accessors.
+    //
+    const bool&
+    v () const;
+
+    const bool&
+    q () const;
+
+    const std::uint16_t&
+    verbose () const;
+
+    bool
+    verbose_specified () const;
+
+    const string&
+    pager () const;
+
+    bool
+    pager_specified () const;
+
+    const strings&
+    pager_option () const;
+
+    bool
+    pager_option_specified () const;
+
+    const bool&
+    help () const;
+
+    const bool&
+    version () const;
+
+    // Print usage information.
+    //
+    static ::build2::cl::usage_para
+    print_usage (::std::ostream&,
+                 ::build2::cl::usage_para = ::build2::cl::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::build2::cl::scanner&);
+
+    private:
+    void
+    _parse (::build2::cl::scanner&,
+            ::build2::cl::unknown_mode option,
+            ::build2::cl::unknown_mode argument);
+
+    public:
+    bool v_;
+    bool q_;
+    std::uint16_t verbose_;
+    bool verbose_specified_;
+    string pager_;
+    bool pager_specified_;
+    strings pager_option_;
+    bool pager_option_specified_;
+    bool help_;
+    bool version_;
+  };
+}
+
+// Print page usage information.
+//
+namespace build2
+{
+  ::build2::cl::usage_para
+  print_b_usage (::std::ostream&,
+                 ::build2::cl::usage_para = ::build2::cl::usage_para::none);
+}
+
+#include <build2/b-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BUILD2_B_OPTIONS
diff --git a/build2/b-options.cxx b/build2/b-options.cxx
new file mode 100644
index 0000000..c841f8a
--- /dev/null
+++ b/build2/b-options.cxx
@@ -0,0 +1,908 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <build2/b-options>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <fstream>
+
+namespace build2
+{
+  namespace cl
+  {
+    // 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 () << "'";
+    }
+
+    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";
+    }
+
+    // file_io_failure
+    //
+    file_io_failure::
+    ~file_io_failure () throw ()
+    {
+    }
+
+    void file_io_failure::
+    print (::std::ostream& os) const
+    {
+      os << "unable to open file '" << file ().c_str () << "' or read failure";
+    }
+
+    const char* file_io_failure::
+    what () const throw ()
+    {
+      return "unable to open file or read failure";
+    }
+
+    // unmatched_quote
+    //
+    unmatched_quote::
+    ~unmatched_quote () throw ()
+    {
+    }
+
+    void unmatched_quote::
+    print (::std::ostream& os) const
+    {
+      os << "unmatched quote in argument '" << argument ().c_str () << "'";
+    }
+
+    const char* unmatched_quote::
+    what () const throw ()
+    {
+      return "unmatched quote";
+    }
+
+    // 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 ();
+    }
+
+    // argv_file_scanner
+    //
+    bool argv_file_scanner::
+    more ()
+    {
+      if (!args_.empty ())
+        return true;
+
+      while (base::more ())
+      {
+        // See if the next argument is the file option.
+        //
+        const char* a (base::peek ());
+        const option_info* oi;
+
+        if (!skip_ && (oi = find (a)))
+        {
+          base::next ();
+
+          if (!base::more ())
+            throw missing_value (oi->option);
+
+          if (oi->search_func != 0)
+          {
+            std::string f (oi->search_func (base::next (), oi->arg));
+
+            if (!f.empty ())
+              load (f);
+          }
+          else
+            load (base::next ());
+
+          if (!args_.empty ())
+            return true;
+        }
+        else
+        {
+          if (!skip_)
+            skip_ = (std::strcmp (a, "--") == 0);
+
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    const char* argv_file_scanner::
+    peek ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      return args_.empty () ? base::peek () : args_.front ().c_str ();
+    }
+
+    const char* argv_file_scanner::
+    next ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      if (args_.empty ())
+        return base::next ();
+      else
+      {
+        hold_.swap (args_.front ());
+        args_.pop_front ();
+        return hold_.c_str ();
+      }
+    }
+
+    void argv_file_scanner::
+    skip ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      if (args_.empty ())
+        return base::skip ();
+      else
+        args_.pop_front ();
+    }
+
+    const argv_file_scanner::option_info* argv_file_scanner::
+    find (const char* a) const
+    {
+      for (std::size_t i (0); i < options_count_; ++i)
+        if (std::strcmp (a, options_[i].option) == 0)
+          return &options_[i];
+
+      return 0;
+    }
+
+    void argv_file_scanner::
+    load (const std::string& file)
+    {
+      using namespace std;
+
+      ifstream is (file.c_str ());
+
+      if (!is.is_open ())
+        throw file_io_failure (file);
+
+      while (!is.eof ())
+      {
+        string line;
+        getline (is, line);
+
+        if (is.fail () && !is.eof ())
+          throw file_io_failure (file);
+
+        string::size_type n (line.size ());
+
+        // Trim the line from leading and trailing whitespaces.
+        //
+        if (n != 0)
+        {
+          const char* f (line.c_str ());
+          const char* l (f + n);
+
+          const char* of (f);
+          while (f < l && (*f == ' ' || *f == '\t' || *f == '\r'))
+            ++f;
+
+          --l;
+
+          const char* ol (l);
+          while (l > f && (*l == ' ' || *l == '\t' || *l == '\r'))
+            --l;
+
+          if (f != of || l != ol)
+            line = f <= l ? string (f, l - f + 1) : string ();
+        }
+
+        // Ignore empty lines, those that start with #.
+        //
+        if (line.empty () || line[0] == '#')
+          continue;
+
+        string::size_type p (line.find (' '));
+
+        if (p == string::npos)
+        {
+          if (!skip_)
+            skip_ = (line == "--");
+
+          args_.push_back (line);
+        }
+        else
+        {
+          string s1 (line, 0, p);
+
+          // Skip leading whitespaces in the argument.
+          //
+          n = line.size ();
+          for (++p; p < n; ++p)
+          {
+            char c (line[p]);
+
+            if (c != ' ' && c != '\t' && c != '\r')
+              break;
+          }
+
+          string s2 (line, p);
+
+          // If the string is wrapped in quotes, remove them.
+          //
+          n = s2.size ();
+          char cf (s2[0]), cl (s2[n - 1]);
+
+          if (cf == '"' || cf == '\'' || cl == '"' || cl == '\'')
+          {
+            if (n == 1 || cf != cl)
+              throw unmatched_quote (s2);
+
+            s2 = string (s2, 1, n - 2);
+          }
+
+          const option_info* oi;
+          if (!skip_ && (oi = find (s1.c_str ())))
+          {
+            if (s2.empty ())
+              throw missing_value (oi->option);
+
+            if (oi->search_func != 0)
+            {
+              std::string f (oi->search_func (s2.c_str (), oi->arg));
+
+              if (!f.empty ())
+                load (f);
+            }
+            else
+              load (s2);
+          }
+          else
+          {
+            args_.push_back (s1);
+            args_.push_back (s2);
+          }
+        }
+      }
+    }
+
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        std::string o (s.next ());
+
+        if (s.more ())
+        {
+          std::string v (s.next ());
+          std::istringstream is (v);
+          if (!(is >> x && is.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 build2
+{
+  // options
+  //
+
+  options::
+  options ()
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+  }
+
+  options::
+  options (int& argc,
+           char** argv,
+           bool erase,
+           ::build2::cl::unknown_mode opt,
+           ::build2::cl::unknown_mode arg)
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+    ::build2::cl::argv_scanner s (argc, argv, erase);
+    _parse (s, opt, arg);
+  }
+
+  options::
+  options (int start,
+           int& argc,
+           char** argv,
+           bool erase,
+           ::build2::cl::unknown_mode opt,
+           ::build2::cl::unknown_mode arg)
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+    ::build2::cl::argv_scanner s (start, argc, argv, erase);
+    _parse (s, opt, arg);
+  }
+
+  options::
+  options (int& argc,
+           char** argv,
+           int& end,
+           bool erase,
+           ::build2::cl::unknown_mode opt,
+           ::build2::cl::unknown_mode arg)
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+    ::build2::cl::argv_scanner s (argc, argv, erase);
+    _parse (s, opt, arg);
+    end = s.end ();
+  }
+
+  options::
+  options (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase,
+           ::build2::cl::unknown_mode opt,
+           ::build2::cl::unknown_mode arg)
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+    ::build2::cl::argv_scanner s (start, argc, argv, erase);
+    _parse (s, opt, arg);
+    end = s.end ();
+  }
+
+  options::
+  options (::build2::cl::scanner& s,
+           ::build2::cl::unknown_mode opt,
+           ::build2::cl::unknown_mode arg)
+  : v_ (),
+    q_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    help_ (),
+    version_ ()
+  {
+    _parse (s, opt, arg);
+  }
+
+  ::build2::cl::usage_para options::
+  print_usage (::std::ostream& os, ::build2::cl::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::build2::cl::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mOPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m-v\033[0m                   Print actual commands being executed. This is equivalent" << ::std::endl
+       << "                     to \033[1m--verbose 2\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m-q\033[0m                   Run quietly, only printing error messages. This is" << ::std::endl
+       << "                     equivalent to \033[1m--verbose 0\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--verbose\033[0m \033[4mlevel\033[0m      Set the diagnostics verbosity to \033[4mlevel\033[0m between 0 and 6." << ::std::endl
+       << "                     Level 0 disables any non-error messages while level 6" << ::std::endl
+       << "                     produces lots of information, with level 1 being the" << ::std::endl
+       << "                     default. The following additional types of diagnostics are" << ::std::endl
+       << "                     produced at each level:" << ::std::endl
+       << ::std::endl
+       << "                     1. High-level information messages." << ::std::endl
+       << "                     2. Essential underlying commands being executed." << ::std::endl
+       << "                     3. All underlying commands being executed." << ::std::endl
+       << "                     4. Information that could be helpful to the user." << ::std::endl
+       << "                     5. Information that could be helpful to the developer." << ::std::endl
+       << "                     6. Even more detailed information, including state dumps." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--pager\033[0m \033[4mpath\033[0m         The pager program to be used to show long text. Commonly" << ::std::endl
+       << "                     used pager programs are \033[1mless\033[0m and \033[1mmore\033[0m. You can also" << ::std::endl
+       << "                     specify additional options that should be passed to the" << ::std::endl
+       << "                     pager program with \033[1m--pager-option\033[0m. If an empty string is" << ::std::endl
+       << "                     specified as the pager program, then no pager will be" << ::std::endl
+       << "                     used. If the pager program is not explicitly specified," << ::std::endl
+       << "                     then \033[1mb\033[0m will try to use \033[1mless\033[0m. If it is not available, then" << ::std::endl
+       << "                     no pager will be used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--pager-option\033[0m \033[4mopt\033[0m   Additional option to be passed to the pager program. See" << ::std::endl
+       << "                     \033[1m--pager\033[0m for more information on the pager program. Repeat" << ::std::endl
+       << "                     this option to specify multiple pager options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--help\033[0m               Print usage information and exit." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--version\033[0m            Print version and exit." << ::std::endl;
+
+    p = ::build2::cl::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (options&, ::build2::cl::scanner&)>
+  _cli_options_map;
+
+  static _cli_options_map _cli_options_map_;
+
+  struct _cli_options_map_init
+  {
+    _cli_options_map_init ()
+    {
+      _cli_options_map_["-v"] = 
+      &::build2::cl::thunk< options, bool, &options::v_ >;
+      _cli_options_map_["-q"] = 
+      &::build2::cl::thunk< options, bool, &options::q_ >;
+      _cli_options_map_["--verbose"] = 
+      &::build2::cl::thunk< options, std::uint16_t, &options::verbose_,
+        &options::verbose_specified_ >;
+      _cli_options_map_["--pager"] = 
+      &::build2::cl::thunk< options, string, &options::pager_,
+        &options::pager_specified_ >;
+      _cli_options_map_["--pager-option"] = 
+      &::build2::cl::thunk< options, strings, &options::pager_option_,
+        &options::pager_option_specified_ >;
+      _cli_options_map_["--help"] = 
+      &::build2::cl::thunk< options, bool, &options::help_ >;
+      _cli_options_map_["--version"] = 
+      &::build2::cl::thunk< options, bool, &options::version_ >;
+    }
+  };
+
+  static _cli_options_map_init _cli_options_map_init_;
+
+  bool options::
+  _parse (const char* o, ::build2::cl::scanner& s)
+  {
+    _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+    if (i != _cli_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  void options::
+  _parse (::build2::cl::scanner& s,
+          ::build2::cl::unknown_mode opt_mode,
+          ::build2::cl::unknown_mode arg_mode)
+  {
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        s.skip ();
+        opt = false;
+        continue;
+      }
+
+      if (opt && _parse (o, s));
+      else if (opt && std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+      {
+        switch (opt_mode)
+        {
+          case ::build2::cl::unknown_mode::skip:
+          {
+            s.skip ();
+            continue;
+          }
+          case ::build2::cl::unknown_mode::stop:
+          {
+            break;
+          }
+          case ::build2::cl::unknown_mode::fail:
+          {
+            throw ::build2::cl::unknown_option (o);
+          }
+        }
+
+        break;
+      }
+      else
+      {
+        switch (arg_mode)
+        {
+          case ::build2::cl::unknown_mode::skip:
+          {
+            s.skip ();
+            continue;
+          }
+          case ::build2::cl::unknown_mode::stop:
+          {
+            break;
+          }
+          case ::build2::cl::unknown_mode::fail:
+          {
+            throw ::build2::cl::unknown_argument (o);
+          }
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+namespace build2
+{
+  ::build2::cl::usage_para
+  print_b_usage (::std::ostream& os, ::build2::cl::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::build2::cl::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mb --help\033[0m" << ::std::endl
+       << "\033[1mb --version\033[0m" << ::std::endl
+       << "\033[1mb\033[0m [\033[4moptions\033[0m] [\033[4mvariables\033[0m] [\033[4mbuildspec\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mbuild2\033[0m driver performs a set of meta-operations on operations on targets" << ::std::endl
+       << "according to the build specification, or \033[4mbuildspec\033[0m for short. Before \033[4mbuildspec\033[0m" << ::std::endl
+       << "(but after \033[4moptions\033[0m) you can set one or more \033[1mbuild2\033[0m \033[4mvariables\033[0m." << ::std::endl;
+
+    p = ::build2::options::print_usage (os, ::build2::cl::usage_para::text);
+
+    if (p != ::build2::cl::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mEXIT STATUS\033[0m" << ::std::endl
+       << ::std::endl
+       << "Non-zero exit status is returned in case of an error." << ::std::endl;
+
+    os << std::endl
+       << "\033[1mENVIRONMENT\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mHOME\033[0m environment variable is used to determine the user's home directory." << ::std::endl
+       << "If it is not set, then \033[1mgetpwuid(3)\033[0m is used instead. This value is used to" << ::std::endl
+       << "shorten paths printed in diagnostics by replacing the home directory with \033[1m~/\033[0m." << ::std::endl
+       << "It is also made available to \033[1mbuildfile\033[0m's as the \033[1mbuild.home\033[0m variable." << ::std::endl;
+
+    p = ::build2::cl::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/build2/b-options.ixx b/build2/b-options.ixx
new file mode 100644
index 0000000..7f4ab2a
--- /dev/null
+++ b/build2/b-options.ixx
@@ -0,0 +1,283 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace build2
+{
+  namespace cl
+  {
+    // usage_para
+    //
+    inline usage_para::
+    usage_para (value v)
+    : v_ (v)
+    {
+    }
+
+    // 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)
+    : option_ (option),  value_ (value)
+    {
+    }
+
+    inline const std::string& invalid_value::
+    option () const
+    {
+      return option_;
+    }
+
+    inline const std::string& invalid_value::
+    value () const
+    {
+      return value_;
+    }
+
+    // file_io_failure
+    //
+    inline file_io_failure::
+    file_io_failure (const std::string& file)
+    : file_ (file)
+    {
+    }
+
+    inline const std::string& file_io_failure::
+    file () const
+    {
+      return file_;
+    }
+
+    // unmatched_quote
+    //
+    inline unmatched_quote::
+    unmatched_quote (const std::string& argument)
+    : argument_ (argument)
+    {
+    }
+
+    inline const std::string& unmatched_quote::
+    argument () const
+    {
+      return argument_;
+    }
+
+    // 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_;
+    }
+
+    // argv_file_scanner
+    //
+    inline argv_file_scanner::
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase)
+    : argv_scanner (argc, argv, erase),
+      option_ (option),
+      options_ (&option_info_),
+      options_count_ (1),
+      skip_ (false)
+    {
+      option_info_.option = option_.c_str ();
+      option_info_.search_func = 0;
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase)
+    : argv_scanner (start, argc, argv, erase),
+      option_ (option),
+      options_ (&option_info_),
+      options_count_ (1),
+      skip_ (false)
+    {
+      option_info_.option = option_.c_str ();
+      option_info_.search_func = 0;
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase)
+    : argv_scanner (argc, argv, erase),
+      options_ (options),
+      options_count_ (options_count),
+      skip_ (false)
+    {
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase)
+    : argv_scanner (start, argc, argv, erase),
+      options_ (options),
+      options_count_ (options_count),
+      skip_ (false)
+    {
+    }
+  }
+}
+
+namespace build2
+{
+  // options
+  //
+
+  inline const bool& options::
+  v () const
+  {
+    return this->v_;
+  }
+
+  inline const bool& options::
+  q () const
+  {
+    return this->q_;
+  }
+
+  inline const std::uint16_t& options::
+  verbose () const
+  {
+    return this->verbose_;
+  }
+
+  inline bool options::
+  verbose_specified () const
+  {
+    return this->verbose_specified_;
+  }
+
+  inline const string& options::
+  pager () const
+  {
+    return this->pager_;
+  }
+
+  inline bool options::
+  pager_specified () const
+  {
+    return this->pager_specified_;
+  }
+
+  inline const strings& options::
+  pager_option () const
+  {
+    return this->pager_option_;
+  }
+
+  inline bool options::
+  pager_option_specified () const
+  {
+    return this->pager_option_specified_;
+  }
+
+  inline const bool& options::
+  help () const
+  {
+    return this->help_;
+  }
+
+  inline const bool& options::
+  version () const
+  {
+    return this->version_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.