From 9bf09e30c79877714e7f73313296370e26afefb6 Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Tue, 23 Apr 2024 14:47:04 +0300
Subject: Make changes required for CI

---
 bpkg/common-options.hxx | 1235 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1235 insertions(+)
 create mode 100644 bpkg/common-options.hxx

(limited to 'bpkg/common-options.hxx')

diff --git a/bpkg/common-options.hxx b/bpkg/common-options.hxx
new file mode 100644
index 0000000..0df9871
--- /dev/null
+++ b/bpkg/common-options.hxx
@@ -0,0 +1,1235 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_COMMON_OPTIONS_HXX
+#define BPKG_COMMON_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <list>
+#include <deque>
+#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 bpkg
+{
+  namespace cli
+  {
+    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 () noexcept;
+
+      unknown_option (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string option_;
+    };
+
+    class unknown_argument: public exception
+    {
+      public:
+      virtual
+      ~unknown_argument () noexcept;
+
+      unknown_argument (const std::string& argument);
+
+      const std::string&
+      argument () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+    };
+
+    class missing_value: public exception
+    {
+      public:
+      virtual
+      ~missing_value () noexcept;
+
+      missing_value (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string option_;
+    };
+
+    class invalid_value: public exception
+    {
+      public:
+      virtual
+      ~invalid_value () noexcept;
+
+      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 noexcept;
+
+      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 noexcept;
+    };
+
+    class file_io_failure: public exception
+    {
+      public:
+      virtual
+      ~file_io_failure () noexcept;
+
+      file_io_failure (const std::string& file);
+
+      const std::string&
+      file () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string file_;
+    };
+
+    class unmatched_quote: public exception
+    {
+      public:
+      virtual
+      ~unmatched_quote () noexcept;
+
+      unmatched_quote (const std::string& argument);
+
+      const std::string&
+      argument () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+    };
+
+    class unexpected_group: public exception
+    {
+      public:
+      virtual
+      ~unexpected_group () noexcept;
+
+      unexpected_group (const std::string& argument,
+                        const std::string& group);
+
+      const std::string&
+      argument () const;
+
+      const std::string&
+      group () const;
+
+      virtual void
+      print (std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+      std::string group_;
+    };
+
+    class group_separator: public exception
+    {
+      public:
+      virtual
+      ~group_separator () noexcept;
+
+      // Note: either (but not both) can be empty.
+      //
+      group_separator (const std::string& encountered,
+                       const std::string& expected);
+
+      const std::string&
+      encountered () const;
+
+      const std::string&
+      expected () const;
+
+      virtual void
+      print (std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string encountered_;
+      std::string expected_;
+    };
+
+    // 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().
+    //
+    // The position() function returns a monotonically-increasing
+    // number which, if stored, can later be used to determine the
+    // relative position of the argument returned by the following
+    // call to next(). Note that if multiple scanners are used to
+    // extract arguments from multiple sources, then the end
+    // position of the previous scanner should be used as the
+    // start position of the next.
+    //
+    class scanner
+    {
+      public:
+      virtual
+      ~scanner ();
+
+      virtual bool
+      more () = 0;
+
+      virtual const char*
+      peek () = 0;
+
+      virtual const char*
+      next () = 0;
+
+      virtual void
+      skip () = 0;
+
+      virtual std::size_t
+      position () = 0;
+    };
+
+    class argv_scanner: public scanner
+    {
+      public:
+      argv_scanner (int& argc,
+                    char** argv,
+                    bool erase = false,
+                    std::size_t start_position = 0);
+
+      argv_scanner (int start,
+                    int& argc,
+                    char** argv,
+                    bool erase = false,
+                    std::size_t start_position = 0);
+
+      int
+      end () const;
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      protected:
+      std::size_t start_position_;
+      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 start_position = 0);
+
+      std::size_t
+      end () const;
+
+      void
+      reset (std::size_t start = 0, std::size_t start_position = 0);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      private:
+      std::size_t start_position_;
+      const std::vector<std::string>& v_;
+      std::size_t i_;
+    };
+
+    class argv_file_scanner: public argv_scanner
+    {
+      public:
+      argv_file_scanner (int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (const std::string& file,
+                         const std::string& option,
+                         std::size_t start_position = 0);
+
+      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,
+                          std::size_t start_position = 0);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const option_info* options,
+                         std::size_t options_count,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (const std::string& file,
+                         const option_info* options = 0,
+                         std::size_t options_count = 0,
+                         std::size_t start_position = 0);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      // Return the file path if the peeked at argument came from a file and
+      // the empty string otherwise. The reference is guaranteed to be valid
+      // till the end of the scanner lifetime.
+      //
+      const std::string&
+      peek_file ();
+
+      // Return the 1-based line number if the peeked at argument came from
+      // a file and zero otherwise.
+      //
+      std::size_t
+      peek_line ();
+
+      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_;
+
+      struct arg
+      {
+        std::string value;
+        const std::string* file;
+        std::size_t line;
+      };
+
+      std::deque<arg> args_;
+      std::list<std::string> files_;
+
+      // Circular buffer of two arguments.
+      //
+      std::string hold_[2];
+      std::size_t i_;
+
+      bool skip_;
+
+      static int zero_argc_;
+      static std::string empty_string_;
+    };
+
+    class group_scanner: public scanner
+    {
+      public:
+      group_scanner (scanner&);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      // The group is only available after the call to next()
+      // (and skip() -- in case one needs to make sure the group
+      // was empty, or some such) and is only valid (and must be
+      // handled) until the next call to any of the scanner
+      // functions (including more()).
+      //
+      // Note also that argument positions within each group start
+      // from 0.
+      //
+      scanner&
+      group ();
+
+      // Escape an argument that is a group separator. Return the
+      // passed string if no escaping is required.
+      //
+      static const char*
+      escape (const char*);
+
+      private:
+      enum state
+      {
+        peeked,  // Argument peeked at with peek().
+        scanned, // Argument scanned with next().
+        skipped, // Argument skipped with skip()/initial.
+      };
+
+      enum separator
+      {
+        none,
+        open,      // {
+        close,     // }
+        open_plus, // +{
+        close_plus // }+
+      };
+
+      static separator
+      sense (const char*);
+
+      // Scan the leading groups, the next argument/argument pack,
+      // and the trailing groups.
+      //
+      void
+      scan_group ();
+
+      scanner& scan_;
+      state state_;
+
+      // Circular buffer of two arguments.
+      //
+      std::vector<std::string> arg_[2];
+      std::size_t i_, j_, pos_;
+
+      std::vector<std::string> group_;
+      vector_scanner group_scan_;
+    };
+
+    template <typename X>
+    struct parser;
+  }
+}
+
+#include <set>
+
+#include <bpkg/types.hxx>
+
+#include <bpkg/options-types.hxx>
+
+namespace bpkg
+{
+  class common_options
+  {
+    public:
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const common_options&);
+
+    // Option accessors and modifiers.
+    //
+    const bool&
+    v () const;
+
+    bool&
+    v ();
+
+    void
+    v (const bool&);
+
+    const bool&
+    V () const;
+
+    bool&
+    V ();
+
+    void
+    V (const bool&);
+
+    const bool&
+    quiet () const;
+
+    bool&
+    quiet ();
+
+    void
+    quiet (const bool&);
+
+    const uint16_t&
+    verbose () const;
+
+    uint16_t&
+    verbose ();
+
+    void
+    verbose (const uint16_t&);
+
+    bool
+    verbose_specified () const;
+
+    void
+    verbose_specified (bool);
+
+    const bpkg::stdout_format&
+    stdout_format () const;
+
+    bpkg::stdout_format&
+    stdout_format ();
+
+    void
+    stdout_format (const bpkg::stdout_format&);
+
+    bool
+    stdout_format_specified () const;
+
+    void
+    stdout_format_specified (bool);
+
+    const size_t&
+    jobs () const;
+
+    size_t&
+    jobs ();
+
+    void
+    jobs (const size_t&);
+
+    bool
+    jobs_specified () const;
+
+    void
+    jobs_specified (bool);
+
+    const bool&
+    no_result () const;
+
+    bool&
+    no_result ();
+
+    void
+    no_result (const bool&);
+
+    const string&
+    structured_result () const;
+
+    string&
+    structured_result ();
+
+    void
+    structured_result (const string&);
+
+    bool
+    structured_result_specified () const;
+
+    void
+    structured_result_specified (bool);
+
+    const bool&
+    progress () const;
+
+    bool&
+    progress ();
+
+    void
+    progress (const bool&);
+
+    const bool&
+    no_progress () const;
+
+    bool&
+    no_progress ();
+
+    void
+    no_progress (const bool&);
+
+    const bool&
+    diag_color () const;
+
+    bool&
+    diag_color ();
+
+    void
+    diag_color (const bool&);
+
+    const bool&
+    no_diag_color () const;
+
+    bool&
+    no_diag_color ();
+
+    void
+    no_diag_color (const bool&);
+
+    const path&
+    build () const;
+
+    path&
+    build ();
+
+    void
+    build (const path&);
+
+    bool
+    build_specified () const;
+
+    void
+    build_specified (bool);
+
+    const strings&
+    build_option () const;
+
+    strings&
+    build_option ();
+
+    void
+    build_option (const strings&);
+
+    bool
+    build_option_specified () const;
+
+    void
+    build_option_specified (bool);
+
+    const path&
+    fetch () const;
+
+    path&
+    fetch ();
+
+    void
+    fetch (const path&);
+
+    bool
+    fetch_specified () const;
+
+    void
+    fetch_specified (bool);
+
+    const strings&
+    fetch_option () const;
+
+    strings&
+    fetch_option ();
+
+    void
+    fetch_option (const strings&);
+
+    bool
+    fetch_option_specified () const;
+
+    void
+    fetch_option_specified (bool);
+
+    const path&
+    curl () const;
+
+    path&
+    curl ();
+
+    void
+    curl (const path&);
+
+    bool
+    curl_specified () const;
+
+    void
+    curl_specified (bool);
+
+    const strings&
+    curl_option () const;
+
+    strings&
+    curl_option ();
+
+    void
+    curl_option (const strings&);
+
+    bool
+    curl_option_specified () const;
+
+    void
+    curl_option_specified (bool);
+
+    const size_t&
+    fetch_timeout () const;
+
+    size_t&
+    fetch_timeout ();
+
+    void
+    fetch_timeout (const size_t&);
+
+    bool
+    fetch_timeout_specified () const;
+
+    void
+    fetch_timeout_specified (bool);
+
+    const butl::url&
+    pkg_proxy () const;
+
+    butl::url&
+    pkg_proxy ();
+
+    void
+    pkg_proxy (const butl::url&);
+
+    bool
+    pkg_proxy_specified () const;
+
+    void
+    pkg_proxy_specified (bool);
+
+    const path&
+    git () const;
+
+    path&
+    git ();
+
+    void
+    git (const path&);
+
+    bool
+    git_specified () const;
+
+    void
+    git_specified (bool);
+
+    const strings&
+    git_option () const;
+
+    strings&
+    git_option ();
+
+    void
+    git_option (const strings&);
+
+    bool
+    git_option_specified () const;
+
+    void
+    git_option_specified (bool);
+
+    const path&
+    sha256 () const;
+
+    path&
+    sha256 ();
+
+    void
+    sha256 (const path&);
+
+    bool
+    sha256_specified () const;
+
+    void
+    sha256_specified (bool);
+
+    const strings&
+    sha256_option () const;
+
+    strings&
+    sha256_option ();
+
+    void
+    sha256_option (const strings&);
+
+    bool
+    sha256_option_specified () const;
+
+    void
+    sha256_option_specified (bool);
+
+    const path&
+    tar () const;
+
+    path&
+    tar ();
+
+    void
+    tar (const path&);
+
+    bool
+    tar_specified () const;
+
+    void
+    tar_specified (bool);
+
+    const strings&
+    tar_option () const;
+
+    strings&
+    tar_option ();
+
+    void
+    tar_option (const strings&);
+
+    bool
+    tar_option_specified () const;
+
+    void
+    tar_option_specified (bool);
+
+    const qualified_option<openssl_commands, path>&
+    openssl () const;
+
+    qualified_option<openssl_commands, path>&
+    openssl ();
+
+    void
+    openssl (const qualified_option<openssl_commands, path>&);
+
+    bool
+    openssl_specified () const;
+
+    void
+    openssl_specified (bool);
+
+    const qualified_option<openssl_commands, strings>&
+    openssl_option () const;
+
+    qualified_option<openssl_commands, strings>&
+    openssl_option ();
+
+    void
+    openssl_option (const qualified_option<openssl_commands, strings>&);
+
+    bool
+    openssl_option_specified () const;
+
+    void
+    openssl_option_specified (bool);
+
+    const bpkg::auth&
+    auth () const;
+
+    bpkg::auth&
+    auth ();
+
+    void
+    auth (const bpkg::auth&);
+
+    bool
+    auth_specified () const;
+
+    void
+    auth_specified (bool);
+
+    const std::set<string, icase_compare_string>&
+    trust () const;
+
+    std::set<string, icase_compare_string>&
+    trust ();
+
+    void
+    trust (const std::set<string, icase_compare_string>&);
+
+    bool
+    trust_specified () const;
+
+    void
+    trust_specified (bool);
+
+    const bool&
+    trust_yes () const;
+
+    bool&
+    trust_yes ();
+
+    void
+    trust_yes (const bool&);
+
+    const bool&
+    trust_no () const;
+
+    bool&
+    trust_no ();
+
+    void
+    trust_no (const bool&);
+
+    const git_capabilities_map&
+    git_capabilities () const;
+
+    git_capabilities_map&
+    git_capabilities ();
+
+    void
+    git_capabilities (const git_capabilities_map&);
+
+    bool
+    git_capabilities_specified () const;
+
+    void
+    git_capabilities_specified (bool);
+
+    const string&
+    pager () const;
+
+    string&
+    pager ();
+
+    void
+    pager (const string&);
+
+    bool
+    pager_specified () const;
+
+    void
+    pager_specified (bool);
+
+    const strings&
+    pager_option () const;
+
+    strings&
+    pager_option ();
+
+    void
+    pager_option (const strings&);
+
+    bool
+    pager_option_specified () const;
+
+    void
+    pager_option_specified (bool);
+
+    const string&
+    options_file () const;
+
+    string&
+    options_file ();
+
+    void
+    options_file (const string&);
+
+    bool
+    options_file_specified () const;
+
+    void
+    options_file_specified (bool);
+
+    const dir_path&
+    default_options () const;
+
+    dir_path&
+    default_options ();
+
+    void
+    default_options (const dir_path&);
+
+    bool
+    default_options_specified () const;
+
+    void
+    default_options_specified (bool);
+
+    const bool&
+    no_default_options () const;
+
+    bool&
+    no_default_options ();
+
+    void
+    no_default_options (const bool&);
+
+    const bool&
+    keep_tmp () const;
+
+    bool&
+    keep_tmp ();
+
+    void
+    keep_tmp (const bool&);
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    static ::bpkg::cli::usage_para
+    print_long_usage (::std::ostream&,
+                      ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    common_options ();
+
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    public:
+    bool v_;
+    bool V_;
+    bool quiet_;
+    uint16_t verbose_;
+    bool verbose_specified_;
+    bpkg::stdout_format stdout_format_;
+    bool stdout_format_specified_;
+    size_t jobs_;
+    bool jobs_specified_;
+    bool no_result_;
+    string structured_result_;
+    bool structured_result_specified_;
+    bool progress_;
+    bool no_progress_;
+    bool diag_color_;
+    bool no_diag_color_;
+    path build_;
+    bool build_specified_;
+    strings build_option_;
+    bool build_option_specified_;
+    path fetch_;
+    bool fetch_specified_;
+    strings fetch_option_;
+    bool fetch_option_specified_;
+    path curl_;
+    bool curl_specified_;
+    strings curl_option_;
+    bool curl_option_specified_;
+    size_t fetch_timeout_;
+    bool fetch_timeout_specified_;
+    butl::url pkg_proxy_;
+    bool pkg_proxy_specified_;
+    path git_;
+    bool git_specified_;
+    strings git_option_;
+    bool git_option_specified_;
+    path sha256_;
+    bool sha256_specified_;
+    strings sha256_option_;
+    bool sha256_option_specified_;
+    path tar_;
+    bool tar_specified_;
+    strings tar_option_;
+    bool tar_option_specified_;
+    qualified_option<openssl_commands, path> openssl_;
+    bool openssl_specified_;
+    qualified_option<openssl_commands, strings> openssl_option_;
+    bool openssl_option_specified_;
+    bpkg::auth auth_;
+    bool auth_specified_;
+    std::set<string, icase_compare_string> trust_;
+    bool trust_specified_;
+    bool trust_yes_;
+    bool trust_no_;
+    git_capabilities_map git_capabilities_;
+    bool git_capabilities_specified_;
+    string pager_;
+    bool pager_specified_;
+    strings pager_option_;
+    bool pager_option_specified_;
+    string options_file_;
+    bool options_file_specified_;
+    dir_path default_options_;
+    bool default_options_specified_;
+    bool no_default_options_;
+    bool keep_tmp_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_usage (::std::ostream&,
+                                   ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_long_usage (::std::ostream&,
+                                        ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/common-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_COMMON_OPTIONS_HXX
-- 
cgit v1.1