diff options
Diffstat (limited to 'bpkg/common-options.hxx')
| -rw-r--r-- | bpkg/common-options.hxx | 1235 |
1 files changed, 1235 insertions, 0 deletions
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 |