John Kacur | 8b40f52 | 2009-09-24 18:02:18 +0200 | [diff] [blame] | 1 | #ifndef __PERF_PARSE_OPTIONS_H |
| 2 | #define __PERF_PARSE_OPTIONS_H |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 3 | |
Arnaldo Carvalho de Melo | 1967936 | 2010-05-17 15:39:16 -0300 | [diff] [blame] | 4 | #include <linux/kernel.h> |
Arnaldo Carvalho de Melo | 8035458 | 2010-05-17 15:51:10 -0300 | [diff] [blame] | 5 | #include <stdbool.h> |
Arnaldo Carvalho de Melo | 1967936 | 2010-05-17 15:39:16 -0300 | [diff] [blame] | 6 | |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 7 | enum parse_opt_type { |
| 8 | /* special types */ |
| 9 | OPTION_END, |
| 10 | OPTION_ARGUMENT, |
| 11 | OPTION_GROUP, |
| 12 | /* options with no arguments */ |
| 13 | OPTION_BIT, |
Ian Munsie | c055564 | 2010-04-13 18:37:33 +1000 | [diff] [blame] | 14 | OPTION_BOOLEAN, |
| 15 | OPTION_INCR, |
Arnaldo Carvalho de Melo | edb7c60 | 2010-05-17 16:22:41 -0300 | [diff] [blame] | 16 | OPTION_SET_UINT, |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 17 | OPTION_SET_PTR, |
| 18 | /* options with arguments (usually) */ |
| 19 | OPTION_STRING, |
| 20 | OPTION_INTEGER, |
Peter Zijlstra | e61078a | 2009-06-03 11:24:33 +0200 | [diff] [blame] | 21 | OPTION_LONG, |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 22 | OPTION_CALLBACK, |
Arnaldo Carvalho de Melo | 6ba85ce | 2010-05-17 12:16:48 -0300 | [diff] [blame] | 23 | OPTION_U64, |
Arnaldo Carvalho de Melo | c100edb | 2010-05-17 15:30:00 -0300 | [diff] [blame] | 24 | OPTION_UINTEGER, |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 25 | }; |
| 26 | |
| 27 | enum parse_opt_flags { |
| 28 | PARSE_OPT_KEEP_DASHDASH = 1, |
| 29 | PARSE_OPT_STOP_AT_NON_OPTION = 2, |
| 30 | PARSE_OPT_KEEP_ARGV0 = 4, |
| 31 | PARSE_OPT_KEEP_UNKNOWN = 8, |
| 32 | PARSE_OPT_NO_INTERNAL_HELP = 16, |
| 33 | }; |
| 34 | |
| 35 | enum parse_opt_option_flags { |
| 36 | PARSE_OPT_OPTARG = 1, |
| 37 | PARSE_OPT_NOARG = 2, |
| 38 | PARSE_OPT_NONEG = 4, |
| 39 | PARSE_OPT_HIDDEN = 8, |
| 40 | PARSE_OPT_LASTARG_DEFAULT = 16, |
| 41 | }; |
| 42 | |
| 43 | struct option; |
| 44 | typedef int parse_opt_cb(const struct option *, const char *arg, int unset); |
| 45 | |
| 46 | /* |
| 47 | * `type`:: |
| 48 | * holds the type of the option, you must have an OPTION_END last in your |
| 49 | * array. |
| 50 | * |
| 51 | * `short_name`:: |
| 52 | * the character to use as a short option name, '\0' if none. |
| 53 | * |
| 54 | * `long_name`:: |
| 55 | * the long option name, without the leading dashes, NULL if none. |
| 56 | * |
| 57 | * `value`:: |
| 58 | * stores pointers to the values to be filled. |
| 59 | * |
| 60 | * `argh`:: |
| 61 | * token to explain the kind of argument this option wants. Keep it |
| 62 | * homogenous across the repository. |
| 63 | * |
| 64 | * `help`:: |
| 65 | * the short help associated to what the option does. |
| 66 | * Must never be NULL (except for OPTION_END). |
| 67 | * OPTION_GROUP uses this pointer to store the group header. |
| 68 | * |
| 69 | * `flags`:: |
| 70 | * mask of parse_opt_option_flags. |
| 71 | * PARSE_OPT_OPTARG: says that the argument is optionnal (not for BOOLEANs) |
| 72 | * PARSE_OPT_NOARG: says that this option takes no argument, for CALLBACKs |
| 73 | * PARSE_OPT_NONEG: says that this option cannot be negated |
| 74 | * PARSE_OPT_HIDDEN this option is skipped in the default usage, showed in |
| 75 | * the long one. |
| 76 | * |
| 77 | * `callback`:: |
| 78 | * pointer to the callback to use for OPTION_CALLBACK. |
| 79 | * |
| 80 | * `defval`:: |
| 81 | * default value to fill (*->value) with for PARSE_OPT_OPTARG. |
Arnaldo Carvalho de Melo | edb7c60 | 2010-05-17 16:22:41 -0300 | [diff] [blame] | 82 | * OPTION_{BIT,SET_UINT,SET_PTR} store the {mask,integer,pointer} to put in |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 83 | * the value when met. |
| 84 | * CALLBACKS can use it like they want. |
Adrian Hunter | 167faf3 | 2013-11-18 11:55:56 +0200 | [diff] [blame] | 85 | * |
| 86 | * `set`:: |
| 87 | * whether an option was set by the user |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 88 | */ |
| 89 | struct option { |
| 90 | enum parse_opt_type type; |
| 91 | int short_name; |
| 92 | const char *long_name; |
| 93 | void *value; |
| 94 | const char *argh; |
| 95 | const char *help; |
| 96 | |
| 97 | int flags; |
| 98 | parse_opt_cb *callback; |
| 99 | intptr_t defval; |
Adrian Hunter | 167faf3 | 2013-11-18 11:55:56 +0200 | [diff] [blame] | 100 | bool *set; |
Adrian Hunter | ea8e08a | 2014-07-14 13:02:54 +0300 | [diff] [blame] | 101 | void *data; |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 102 | }; |
| 103 | |
Arnaldo Carvalho de Melo | 1967936 | 2010-05-17 15:39:16 -0300 | [diff] [blame] | 104 | #define check_vtype(v, type) ( BUILD_BUG_ON_ZERO(!__builtin_types_compatible_p(typeof(v), type)) + v ) |
| 105 | |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 106 | #define OPT_END() { .type = OPTION_END } |
| 107 | #define OPT_ARGUMENT(l, h) { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) } |
| 108 | #define OPT_GROUP(h) { .type = OPTION_GROUP, .help = (h) } |
Arnaldo Carvalho de Melo | edb7c60 | 2010-05-17 16:22:41 -0300 | [diff] [blame] | 109 | #define OPT_BIT(s, l, v, h, b) { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h), .defval = (b) } |
Arnaldo Carvalho de Melo | 8035458 | 2010-05-17 15:51:10 -0300 | [diff] [blame] | 110 | #define OPT_BOOLEAN(s, l, v, h) { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = check_vtype(v, bool *), .help = (h) } |
Adrian Hunter | 167faf3 | 2013-11-18 11:55:56 +0200 | [diff] [blame] | 111 | #define OPT_BOOLEAN_SET(s, l, v, os, h) \ |
| 112 | { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), \ |
| 113 | .value = check_vtype(v, bool *), .help = (h), \ |
| 114 | .set = check_vtype(os, bool *)} |
Arnaldo Carvalho de Melo | edb7c60 | 2010-05-17 16:22:41 -0300 | [diff] [blame] | 115 | #define OPT_INCR(s, l, v, h) { .type = OPTION_INCR, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) } |
| 116 | #define OPT_SET_UINT(s, l, v, h, i) { .type = OPTION_SET_UINT, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h), .defval = (i) } |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 117 | #define OPT_SET_PTR(s, l, v, h, p) { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) } |
Arnaldo Carvalho de Melo | 1967936 | 2010-05-17 15:39:16 -0300 | [diff] [blame] | 118 | #define OPT_INTEGER(s, l, v, h) { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) } |
| 119 | #define OPT_UINTEGER(s, l, v, h) { .type = OPTION_UINTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h) } |
Arnaldo Carvalho de Melo | edb7c60 | 2010-05-17 16:22:41 -0300 | [diff] [blame] | 120 | #define OPT_LONG(s, l, v, h) { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) } |
| 121 | #define OPT_U64(s, l, v, h) { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) } |
| 122 | #define OPT_STRING(s, l, v, a, h) { .type = OPTION_STRING, .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) } |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 123 | #define OPT_DATE(s, l, v, h) \ |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 124 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb } |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 125 | #define OPT_CALLBACK(s, l, v, a, h, f) \ |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 126 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f) } |
Arjan van de Ven | a79d7db | 2009-09-12 07:52:54 +0200 | [diff] [blame] | 127 | #define OPT_CALLBACK_NOOPT(s, l, v, a, h, f) \ |
| 128 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f), .flags = PARSE_OPT_NOARG } |
Frederic Weisbecker | 5a4b181 | 2009-07-02 17:58:20 +0200 | [diff] [blame] | 129 | #define OPT_CALLBACK_DEFAULT(s, l, v, a, h, f, d) \ |
| 130 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f), .defval = (intptr_t)d, .flags = PARSE_OPT_LASTARG_DEFAULT } |
Akihiro Nagai | e4e18d5 | 2010-12-03 12:58:53 +0900 | [diff] [blame] | 131 | #define OPT_CALLBACK_DEFAULT_NOOPT(s, l, v, a, h, f, d) \ |
| 132 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l),\ |
| 133 | .value = (v), (a), .help = (h), .callback = (f), .defval = (intptr_t)d,\ |
| 134 | .flags = PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NOARG} |
Adrian Hunter | ea8e08a | 2014-07-14 13:02:54 +0300 | [diff] [blame] | 135 | #define OPT_CALLBACK_OPTARG(s, l, v, d, a, h, f) \ |
| 136 | { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), \ |
| 137 | .value = (v), (a), .help = (h), .callback = (f), \ |
| 138 | .flags = PARSE_OPT_OPTARG, .data = (d) } |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 139 | |
| 140 | /* parse_options() will filter out the processed options and leave the |
| 141 | * non-option argments in argv[]. |
| 142 | * Returns the number of arguments left in argv[]. |
| 143 | */ |
| 144 | extern int parse_options(int argc, const char **argv, |
| 145 | const struct option *options, |
| 146 | const char * const usagestr[], int flags); |
| 147 | |
Ramkumar Ramachandra | 09a71b9 | 2014-03-03 20:26:36 -0500 | [diff] [blame] | 148 | extern int parse_options_subcommand(int argc, const char **argv, |
| 149 | const struct option *options, |
| 150 | const char *const subcommands[], |
| 151 | const char *usagestr[], int flags); |
| 152 | |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 153 | extern NORETURN void usage_with_options(const char * const *usagestr, |
| 154 | const struct option *options); |
| 155 | |
| 156 | /*----- incremantal advanced APIs -----*/ |
| 157 | |
| 158 | enum { |
| 159 | PARSE_OPT_HELP = -1, |
| 160 | PARSE_OPT_DONE, |
Ramkumar Ramachandra | 09a71b9 | 2014-03-03 20:26:36 -0500 | [diff] [blame] | 161 | PARSE_OPT_LIST_OPTS, |
| 162 | PARSE_OPT_LIST_SUBCMDS, |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 163 | PARSE_OPT_UNKNOWN, |
| 164 | }; |
| 165 | |
| 166 | /* |
| 167 | * It's okay for the caller to consume argv/argc in the usual way. |
| 168 | * Other fields of that structure are private to parse-options and should not |
| 169 | * be modified in any way. |
| 170 | */ |
| 171 | struct parse_opt_ctx_t { |
| 172 | const char **argv; |
| 173 | const char **out; |
| 174 | int argc, cpidx; |
| 175 | const char *opt; |
| 176 | int flags; |
| 177 | }; |
| 178 | |
| 179 | extern int parse_options_usage(const char * const *usagestr, |
Namhyung Kim | ac69762 | 2013-11-01 16:33:11 +0900 | [diff] [blame] | 180 | const struct option *opts, |
| 181 | const char *optstr, |
| 182 | bool short_opt); |
Ingo Molnar | 0780060 | 2009-04-20 15:00:56 +0200 | [diff] [blame] | 183 | |
| 184 | extern void parse_options_start(struct parse_opt_ctx_t *ctx, |
| 185 | int argc, const char **argv, int flags); |
| 186 | |
| 187 | extern int parse_options_step(struct parse_opt_ctx_t *ctx, |
| 188 | const struct option *options, |
| 189 | const char * const usagestr[]); |
| 190 | |
| 191 | extern int parse_options_end(struct parse_opt_ctx_t *ctx); |
| 192 | |
| 193 | |
| 194 | /*----- some often used options -----*/ |
| 195 | extern int parse_opt_abbrev_cb(const struct option *, const char *, int); |
| 196 | extern int parse_opt_approxidate_cb(const struct option *, const char *, int); |
| 197 | extern int parse_opt_verbosity_cb(const struct option *, const char *, int); |
| 198 | |
| 199 | #define OPT__VERBOSE(var) OPT_BOOLEAN('v', "verbose", (var), "be verbose") |
| 200 | #define OPT__QUIET(var) OPT_BOOLEAN('q', "quiet", (var), "be quiet") |
| 201 | #define OPT__VERBOSITY(var) \ |
| 202 | { OPTION_CALLBACK, 'v', "verbose", (var), NULL, "be more verbose", \ |
| 203 | PARSE_OPT_NOARG, &parse_opt_verbosity_cb, 0 }, \ |
| 204 | { OPTION_CALLBACK, 'q', "quiet", (var), NULL, "be more quiet", \ |
| 205 | PARSE_OPT_NOARG, &parse_opt_verbosity_cb, 0 } |
| 206 | #define OPT__DRY_RUN(var) OPT_BOOLEAN('n', "dry-run", (var), "dry run") |
| 207 | #define OPT__ABBREV(var) \ |
| 208 | { OPTION_CALLBACK, 0, "abbrev", (var), "n", \ |
| 209 | "use <n> digits to display SHA-1s", \ |
| 210 | PARSE_OPT_OPTARG, &parse_opt_abbrev_cb, 0 } |
| 211 | |
| 212 | extern const char *parse_options_fix_filename(const char *prefix, const char *file); |
| 213 | |
John Kacur | 8b40f52 | 2009-09-24 18:02:18 +0200 | [diff] [blame] | 214 | #endif /* __PERF_PARSE_OPTIONS_H */ |