| /** | |
| * @file popt_options.cpp | |
| * option parsing | |
| * | |
| * @remark Copyright 2002 OProfile authors | |
| * @remark Read the file COPYING | |
| * | |
| * @author Philippe Elie | |
| * @author John Levon | |
| */ | |
| #include <iostream> | |
| #include "op_popt.h" | |
| #include "op_version.h" | |
| #include "popt_options.h" | |
| #include "string_manip.h" | |
| using namespace std; | |
| namespace popt { | |
| /** | |
| * option_base - base class for implementation of a command line option | |
| * | |
| * Every command line option added before calling parse_options() | |
| * is of this type. | |
| */ | |
| class option_base { | |
| public: | |
| /** | |
| * option_base - construct an option with the given options. | |
| * @param option_name name part of long form e.g. --option | |
| * @param short_name short form name e.g. -o | |
| * @param help_str short description of the option | |
| * @param arg_help_str short description of the argument (if any) | |
| * @param data a pointer to the data to fill in | |
| * @param popt_flags the popt library data type | |
| */ | |
| option_base(char const * option_name, char short_name, | |
| char const * help_str, char const * arg_help_str, | |
| void * data, int popt_flags); | |
| virtual ~option_base() {} | |
| /** | |
| * post_process - perform any necessary post-processing | |
| */ | |
| virtual void post_process() {} | |
| protected: | |
| char const * option_name; | |
| }; | |
| /** the popt array singleton options */ | |
| static vector<poptOption> & popt_options(void) | |
| { | |
| static vector<poptOption> *x = new(vector<poptOption>); | |
| return *x; | |
| } | |
| static vector<option_base *> & options_list(void) | |
| { | |
| static vector<option_base *> *x = new(vector<option_base *>); | |
| return *x; | |
| } | |
| static int showvers; | |
| static struct poptOption appended_options[] = { | |
| { "version", 'v', POPT_ARG_NONE, &showvers, 0, "show version", NULL, }, | |
| POPT_AUTOHELP | |
| POPT_TABLEEND | |
| }; | |
| /* options parameter can't be a local variable because caller can use the | |
| * returned poptContext which contains pointer inside the options array */ | |
| static poptContext do_parse_options(int argc, char const ** argv, | |
| vector<poptOption> & options, | |
| vector<string> & additional_params) | |
| { | |
| options = popt_options(); | |
| int const nr_appended_options = | |
| sizeof(appended_options) / sizeof(appended_options[0]); | |
| options.insert(options.end(), appended_options, | |
| appended_options + nr_appended_options); | |
| poptContext con = op_poptGetContext(NULL, argc, argv, &options[0], 0); | |
| if (showvers) | |
| show_version(argv[0]); | |
| char const * file; | |
| while ((file = poptGetArg(con)) != 0) | |
| additional_params.push_back(file); | |
| for (size_t i = 0 ; i < options_list().size() ; ++i) | |
| options_list()[i]->post_process(); | |
| return con; | |
| } | |
| void parse_options(int argc, char const ** argv, | |
| vector<string> & additional_params) | |
| { | |
| vector<poptOption> options; | |
| poptContext con = | |
| do_parse_options(argc, argv, options, additional_params); | |
| poptFreeContext(con); | |
| } | |
| template <typename T> class option_imp; | |
| /** | |
| * option<void> - a binary option | |
| * | |
| * Use this option type for constructing specified / not-specified | |
| * options e.g. --frob | |
| */ | |
| template <> class option_imp<void> : public option_base { | |
| public: | |
| option_imp(bool & value, char const * option_name, char short_name, | |
| char const * help_str); | |
| ~option_imp() {} | |
| void post_process(); | |
| private: | |
| bool & value; | |
| int popt_value; | |
| }; | |
| /** | |
| * option<int> - a integer option | |
| * | |
| * Use this for options taking an integer e.g. --frob 6 | |
| */ | |
| template <> class option_imp<int> : public option_base { | |
| public: | |
| option_imp(int & value, char const * option_name, char short_name, | |
| char const * help_str, char const * arg_help_str); | |
| ~option_imp() {} | |
| }; | |
| /** | |
| * option<string> - a string option | |
| * | |
| * Use this for options taking a string e.g. --frob parsley | |
| */ | |
| template <> class option_imp<string> : public option_base { | |
| public: | |
| option_imp(string & value, char const * option_name, | |
| char short_name, char const * help_str, | |
| char const * arg_help_str); | |
| void post_process(); | |
| ~option_imp() {} | |
| private: | |
| // we need an intermediate char array to pass to popt libs | |
| char * popt_value; | |
| string & value; | |
| }; | |
| /** | |
| * option< vector<string> > - a string vector option | |
| * | |
| * Use this for options taking a number of string arguments, | |
| * separated by the given separator. | |
| */ | |
| template <> class option_imp< vector<string> > : public option_base { | |
| public: | |
| option_imp(vector<string> & value, | |
| char const * option_name, char short_name, | |
| char const * help_str, char const * arg_help_str, | |
| char separator = ','); | |
| void post_process(); | |
| ~option_imp() {} | |
| private: | |
| vector<string> & value; | |
| // we need an intermediate char array to pass to popt libs | |
| char * popt_value; | |
| char const separator; | |
| }; | |
| option::~option() | |
| { | |
| delete the_option; | |
| } | |
| /// non templatized ctor for boolean option | |
| option::option(bool & value, char const * name, char short_name, char const * help) | |
| : the_option(new option_imp<void>(value, name, short_name, help)) | |
| { | |
| } | |
| /// specialization of option ctor for integer option | |
| template <> | |
| option::option(int & value, char const * name, char short_name, | |
| char const * help, char const * arg_help) | |
| : the_option(new option_imp<int> | |
| (value, name, short_name, help, arg_help)) | |
| { | |
| } | |
| /// specialization of option ctor for string option | |
| template <> | |
| option::option(string & value, char const * name, char short_name, | |
| char const * help, char const * arg_help) | |
| : the_option(new option_imp<string> | |
| (value, name, short_name, help, arg_help)) | |
| { | |
| } | |
| /// specialization of option ctor for vector<string> option | |
| template <> | |
| option::option(vector<string> & value, char const * name, char short_name, | |
| char const * help, char const * arg_help) | |
| : the_option(new option_imp< vector<string> > | |
| (value, name, short_name, help, arg_help)) | |
| { | |
| } | |
| option_base::option_base(char const * name, char short_name, | |
| char const * help, char const * arg_help, | |
| void * data, int popt_flags) | |
| : option_name(name) | |
| { | |
| poptOption const opt = { name, short_name, popt_flags, | |
| data, 0, help, arg_help }; | |
| popt_options().push_back(opt); | |
| options_list().push_back(this); | |
| } | |
| option_imp<void>::option_imp(bool & val, char const * name, char short_name, | |
| char const * help) | |
| : option_base(name, short_name, help, 0, &popt_value, POPT_ARG_NONE), | |
| value(val), popt_value(0) | |
| { | |
| } | |
| void option_imp<void>::post_process() | |
| { | |
| if (popt_value) { | |
| if (is_prefix(option_name, "no-")) | |
| value = !popt_value; | |
| else | |
| value = popt_value; | |
| } | |
| } | |
| option_imp<int>::option_imp(int & value, char const * name, char short_name, | |
| char const * help, char const * arg_help) | |
| : option_base(name, short_name, help, arg_help, &value, POPT_ARG_INT) | |
| { | |
| } | |
| option_imp<string>::option_imp(string & val, char const * name, char short_name, | |
| char const * help, char const * arg_help) | |
| : option_base(name, short_name, help, arg_help, | |
| &popt_value, POPT_ARG_STRING), | |
| popt_value(0), value(val) | |
| { | |
| } | |
| void option_imp<string>::post_process() | |
| { | |
| if (popt_value) { | |
| value = popt_value; | |
| popt_value = 0; | |
| } | |
| } | |
| option_imp< vector<string> >::option_imp(vector<string> & val, | |
| char const * name, char short_name, | |
| char const * help, | |
| char const * arg_help, char sepchar) | |
| : option_base(name, short_name, help, arg_help, | |
| &popt_value, POPT_ARG_STRING), | |
| value(val), popt_value(0), separator(sepchar) | |
| { | |
| } | |
| void option_imp< vector<string> >::post_process() | |
| { | |
| if (popt_value) { | |
| value = separate_token(popt_value, separator); | |
| popt_value = 0; | |
| } | |
| } | |
| } // namespace popt |