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