1#include "util.h"
2#include "parse-options.h"
3#include "cache.h"
4#include "header.h"
5
6#define OPT_SHORT 1
7#define OPT_UNSET 2
8
9static int opterror(const struct option *opt, const char *reason, int flags)
10{
11 if (flags & OPT_SHORT)
12 return error("switch `%c' %s", opt->short_name, reason);
13 if (flags & OPT_UNSET)
14 return error("option `no-%s' %s", opt->long_name, reason);
15 return error("option `%s' %s", opt->long_name, reason);
16}
17
18static int get_arg(struct parse_opt_ctx_t *p, const struct option *opt,
19 int flags, const char **arg)
20{
21 if (p->opt) {
22 *arg = p->opt;
23 p->opt = NULL;
24 } else if ((opt->flags & PARSE_OPT_LASTARG_DEFAULT) && (p->argc == 1 ||
25 **(p->argv + 1) == '-')) {
26 *arg = (const char *)opt->defval;
27 } else if (p->argc > 1) {
28 p->argc--;
29 *arg = *++p->argv;
30 } else
31 return opterror(opt, "requires a value", flags);
32 return 0;
33}
34
35static int get_value(struct parse_opt_ctx_t *p,
36 const struct option *opt, int flags)
37{
38 const char *s, *arg = NULL;
39 const int unset = flags & OPT_UNSET;
40
41 if (unset && p->opt)
42 return opterror(opt, "takes no value", flags);
43 if (unset && (opt->flags & PARSE_OPT_NONEG))
44 return opterror(opt, "isn't available", flags);
45
46 if (!(flags & OPT_SHORT) && p->opt) {
47 switch (opt->type) {
48 case OPTION_CALLBACK:
49 if (!(opt->flags & PARSE_OPT_NOARG))
50 break;
51
52 case OPTION_BOOLEAN:
53 case OPTION_INCR:
54 case OPTION_BIT:
55 case OPTION_SET_UINT:
56 case OPTION_SET_PTR:
57 return opterror(opt, "takes no value", flags);
58 case OPTION_END:
59 case OPTION_ARGUMENT:
60 case OPTION_GROUP:
61 case OPTION_STRING:
62 case OPTION_INTEGER:
63 case OPTION_UINTEGER:
64 case OPTION_LONG:
65 case OPTION_U64:
66 default:
67 break;
68 }
69 }
70
71 switch (opt->type) {
72 case OPTION_BIT:
73 if (unset)
74 *(int *)opt->value &= ~opt->defval;
75 else
76 *(int *)opt->value |= opt->defval;
77 return 0;
78
79 case OPTION_BOOLEAN:
80 *(bool *)opt->value = unset ? false : true;
81 return 0;
82
83 case OPTION_INCR:
84 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
85 return 0;
86
87 case OPTION_SET_UINT:
88 *(unsigned int *)opt->value = unset ? 0 : opt->defval;
89 return 0;
90
91 case OPTION_SET_PTR:
92 *(void **)opt->value = unset ? NULL : (void *)opt->defval;
93 return 0;
94
95 case OPTION_STRING:
96 if (unset)
97 *(const char **)opt->value = NULL;
98 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
99 *(const char **)opt->value = (const char *)opt->defval;
100 else
101 return get_arg(p, opt, flags, (const char **)opt->value);
102 return 0;
103
104 case OPTION_CALLBACK:
105 if (unset)
106 return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
107 if (opt->flags & PARSE_OPT_NOARG)
108 return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
109 if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
110 return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
111 if (get_arg(p, opt, flags, &arg))
112 return -1;
113 return (*opt->callback)(opt, arg, 0) ? (-1) : 0;
114
115 case OPTION_INTEGER:
116 if (unset) {
117 *(int *)opt->value = 0;
118 return 0;
119 }
120 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
121 *(int *)opt->value = opt->defval;
122 return 0;
123 }
124 if (get_arg(p, opt, flags, &arg))
125 return -1;
126 *(int *)opt->value = strtol(arg, (char **)&s, 10);
127 if (*s)
128 return opterror(opt, "expects a numerical value", flags);
129 return 0;
130
131 case OPTION_UINTEGER:
132 if (unset) {
133 *(unsigned int *)opt->value = 0;
134 return 0;
135 }
136 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
137 *(unsigned int *)opt->value = opt->defval;
138 return 0;
139 }
140 if (get_arg(p, opt, flags, &arg))
141 return -1;
142 *(unsigned int *)opt->value = strtol(arg, (char **)&s, 10);
143 if (*s)
144 return opterror(opt, "expects a numerical value", flags);
145 return 0;
146
147 case OPTION_LONG:
148 if (unset) {
149 *(long *)opt->value = 0;
150 return 0;
151 }
152 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
153 *(long *)opt->value = opt->defval;
154 return 0;
155 }
156 if (get_arg(p, opt, flags, &arg))
157 return -1;
158 *(long *)opt->value = strtol(arg, (char **)&s, 10);
159 if (*s)
160 return opterror(opt, "expects a numerical value", flags);
161 return 0;
162
163 case OPTION_U64:
164 if (unset) {
165 *(u64 *)opt->value = 0;
166 return 0;
167 }
168 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
169 *(u64 *)opt->value = opt->defval;
170 return 0;
171 }
172 if (get_arg(p, opt, flags, &arg))
173 return -1;
174 *(u64 *)opt->value = strtoull(arg, (char **)&s, 10);
175 if (*s)
176 return opterror(opt, "expects a numerical value", flags);
177 return 0;
178
179 case OPTION_END:
180 case OPTION_ARGUMENT:
181 case OPTION_GROUP:
182 default:
183 die("should not happen, someone must be hit on the forehead");
184 }
185}
186
187static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options)
188{
189 for (; options->type != OPTION_END; options++) {
190 if (options->short_name == *p->opt) {
191 p->opt = p->opt[1] ? p->opt + 1 : NULL;
192 return get_value(p, options, OPT_SHORT);
193 }
194 }
195 return -2;
196}
197
198static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg,
199 const struct option *options)
200{
201 const char *arg_end = strchr(arg, '=');
202 const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
203 int abbrev_flags = 0, ambiguous_flags = 0;
204
205 if (!arg_end)
206 arg_end = arg + strlen(arg);
207
208 for (; options->type != OPTION_END; options++) {
209 const char *rest;
210 int flags = 0;
211
212 if (!options->long_name)
213 continue;
214
215 rest = skip_prefix(arg, options->long_name);
216 if (options->type == OPTION_ARGUMENT) {
217 if (!rest)
218 continue;
219 if (*rest == '=')
220 return opterror(options, "takes no value", flags);
221 if (*rest)
222 continue;
223 p->out[p->cpidx++] = arg - 2;
224 return 0;
225 }
226 if (!rest) {
227
228 if (!strncmp(options->long_name, arg, arg_end - arg)) {
229is_abbreviated:
230 if (abbrev_option) {
231
232
233
234
235
236
237 ambiguous_option = abbrev_option;
238 ambiguous_flags = abbrev_flags;
239 }
240 if (!(flags & OPT_UNSET) && *arg_end)
241 p->opt = arg_end + 1;
242 abbrev_option = options;
243 abbrev_flags = flags;
244 continue;
245 }
246
247 if (!prefixcmp("no-", arg)) {
248 flags |= OPT_UNSET;
249 goto is_abbreviated;
250 }
251
252 if (strncmp(arg, "no-", 3))
253 continue;
254 flags |= OPT_UNSET;
255 rest = skip_prefix(arg + 3, options->long_name);
256
257 if (!rest && !prefixcmp(options->long_name, arg + 3))
258 goto is_abbreviated;
259 if (!rest)
260 continue;
261 }
262 if (*rest) {
263 if (*rest != '=')
264 continue;
265 p->opt = rest + 1;
266 }
267 return get_value(p, options, flags);
268 }
269
270 if (ambiguous_option)
271 return error("Ambiguous option: %s "
272 "(could be --%s%s or --%s%s)",
273 arg,
274 (ambiguous_flags & OPT_UNSET) ? "no-" : "",
275 ambiguous_option->long_name,
276 (abbrev_flags & OPT_UNSET) ? "no-" : "",
277 abbrev_option->long_name);
278 if (abbrev_option)
279 return get_value(p, abbrev_option, abbrev_flags);
280 return -2;
281}
282
283static void check_typos(const char *arg, const struct option *options)
284{
285 if (strlen(arg) < 3)
286 return;
287
288 if (!prefixcmp(arg, "no-")) {
289 error ("did you mean `--%s` (with two dashes ?)", arg);
290 exit(129);
291 }
292
293 for (; options->type != OPTION_END; options++) {
294 if (!options->long_name)
295 continue;
296 if (!prefixcmp(options->long_name, arg)) {
297 error ("did you mean `--%s` (with two dashes ?)", arg);
298 exit(129);
299 }
300 }
301}
302
303void parse_options_start(struct parse_opt_ctx_t *ctx,
304 int argc, const char **argv, int flags)
305{
306 memset(ctx, 0, sizeof(*ctx));
307 ctx->argc = argc - 1;
308 ctx->argv = argv + 1;
309 ctx->out = argv;
310 ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
311 ctx->flags = flags;
312 if ((flags & PARSE_OPT_KEEP_UNKNOWN) &&
313 (flags & PARSE_OPT_STOP_AT_NON_OPTION))
314 die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
315}
316
317static int usage_with_options_internal(const char * const *,
318 const struct option *, int);
319
320int parse_options_step(struct parse_opt_ctx_t *ctx,
321 const struct option *options,
322 const char * const usagestr[])
323{
324 int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
325
326
327 ctx->opt = NULL;
328
329 for (; ctx->argc; ctx->argc--, ctx->argv++) {
330 const char *arg = ctx->argv[0];
331
332 if (*arg != '-' || !arg[1]) {
333 if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
334 break;
335 ctx->out[ctx->cpidx++] = ctx->argv[0];
336 continue;
337 }
338
339 if (arg[1] != '-') {
340 ctx->opt = arg + 1;
341 if (internal_help && *ctx->opt == 'h')
342 return parse_options_usage(usagestr, options);
343 switch (parse_short_opt(ctx, options)) {
344 case -1:
345 return parse_options_usage(usagestr, options);
346 case -2:
347 goto unknown;
348 default:
349 break;
350 }
351 if (ctx->opt)
352 check_typos(arg + 1, options);
353 while (ctx->opt) {
354 if (internal_help && *ctx->opt == 'h')
355 return parse_options_usage(usagestr, options);
356 switch (parse_short_opt(ctx, options)) {
357 case -1:
358 return parse_options_usage(usagestr, options);
359 case -2:
360
361
362
363
364
365 ctx->argv[0] = strdup(ctx->opt - 1);
366 *(char *)ctx->argv[0] = '-';
367 goto unknown;
368 default:
369 break;
370 }
371 }
372 continue;
373 }
374
375 if (!arg[2]) {
376 if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
377 ctx->argc--;
378 ctx->argv++;
379 }
380 break;
381 }
382
383 if (internal_help && !strcmp(arg + 2, "help-all"))
384 return usage_with_options_internal(usagestr, options, 1);
385 if (internal_help && !strcmp(arg + 2, "help"))
386 return parse_options_usage(usagestr, options);
387 if (!strcmp(arg + 2, "list-opts"))
388 return PARSE_OPT_LIST;
389 switch (parse_long_opt(ctx, arg + 2, options)) {
390 case -1:
391 return parse_options_usage(usagestr, options);
392 case -2:
393 goto unknown;
394 default:
395 break;
396 }
397 continue;
398unknown:
399 if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN))
400 return PARSE_OPT_UNKNOWN;
401 ctx->out[ctx->cpidx++] = ctx->argv[0];
402 ctx->opt = NULL;
403 }
404 return PARSE_OPT_DONE;
405}
406
407int parse_options_end(struct parse_opt_ctx_t *ctx)
408{
409 memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
410 ctx->out[ctx->cpidx + ctx->argc] = NULL;
411 return ctx->cpidx + ctx->argc;
412}
413
414int parse_options(int argc, const char **argv, const struct option *options,
415 const char * const usagestr[], int flags)
416{
417 struct parse_opt_ctx_t ctx;
418
419 perf_header__set_cmdline(argc, argv);
420
421 parse_options_start(&ctx, argc, argv, flags);
422 switch (parse_options_step(&ctx, options, usagestr)) {
423 case PARSE_OPT_HELP:
424 exit(129);
425 case PARSE_OPT_DONE:
426 break;
427 case PARSE_OPT_LIST:
428 while (options->type != OPTION_END) {
429 printf("--%s ", options->long_name);
430 options++;
431 }
432 exit(130);
433 default:
434 if (ctx.argv[0][1] == '-') {
435 error("unknown option `%s'", ctx.argv[0] + 2);
436 } else {
437 error("unknown switch `%c'", *ctx.opt);
438 }
439 usage_with_options(usagestr, options);
440 }
441
442 return parse_options_end(&ctx);
443}
444
445#define USAGE_OPTS_WIDTH 24
446#define USAGE_GAP 2
447
448int usage_with_options_internal(const char * const *usagestr,
449 const struct option *opts, int full)
450{
451 if (!usagestr)
452 return PARSE_OPT_HELP;
453
454 fprintf(stderr, "\n usage: %s\n", *usagestr++);
455 while (*usagestr && **usagestr)
456 fprintf(stderr, " or: %s\n", *usagestr++);
457 while (*usagestr) {
458 fprintf(stderr, "%s%s\n",
459 **usagestr ? " " : "",
460 *usagestr);
461 usagestr++;
462 }
463
464 if (opts->type != OPTION_GROUP)
465 fputc('\n', stderr);
466
467 for (; opts->type != OPTION_END; opts++) {
468 size_t pos;
469 int pad;
470
471 if (opts->type == OPTION_GROUP) {
472 fputc('\n', stderr);
473 if (*opts->help)
474 fprintf(stderr, "%s\n", opts->help);
475 continue;
476 }
477 if (!full && (opts->flags & PARSE_OPT_HIDDEN))
478 continue;
479
480 pos = fprintf(stderr, " ");
481 if (opts->short_name)
482 pos += fprintf(stderr, "-%c", opts->short_name);
483 else
484 pos += fprintf(stderr, " ");
485
486 if (opts->long_name && opts->short_name)
487 pos += fprintf(stderr, ", ");
488 if (opts->long_name)
489 pos += fprintf(stderr, "--%s", opts->long_name);
490
491 switch (opts->type) {
492 case OPTION_ARGUMENT:
493 break;
494 case OPTION_LONG:
495 case OPTION_U64:
496 case OPTION_INTEGER:
497 case OPTION_UINTEGER:
498 if (opts->flags & PARSE_OPT_OPTARG)
499 if (opts->long_name)
500 pos += fprintf(stderr, "[=<n>]");
501 else
502 pos += fprintf(stderr, "[<n>]");
503 else
504 pos += fprintf(stderr, " <n>");
505 break;
506 case OPTION_CALLBACK:
507 if (opts->flags & PARSE_OPT_NOARG)
508 break;
509
510 case OPTION_STRING:
511 if (opts->argh) {
512 if (opts->flags & PARSE_OPT_OPTARG)
513 if (opts->long_name)
514 pos += fprintf(stderr, "[=<%s>]", opts->argh);
515 else
516 pos += fprintf(stderr, "[<%s>]", opts->argh);
517 else
518 pos += fprintf(stderr, " <%s>", opts->argh);
519 } else {
520 if (opts->flags & PARSE_OPT_OPTARG)
521 if (opts->long_name)
522 pos += fprintf(stderr, "[=...]");
523 else
524 pos += fprintf(stderr, "[...]");
525 else
526 pos += fprintf(stderr, " ...");
527 }
528 break;
529 default:
530 case OPTION_END:
531 case OPTION_GROUP:
532 case OPTION_BIT:
533 case OPTION_BOOLEAN:
534 case OPTION_INCR:
535 case OPTION_SET_UINT:
536 case OPTION_SET_PTR:
537 break;
538 }
539
540 if (pos <= USAGE_OPTS_WIDTH)
541 pad = USAGE_OPTS_WIDTH - pos;
542 else {
543 fputc('\n', stderr);
544 pad = USAGE_OPTS_WIDTH;
545 }
546 fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help);
547 }
548 fputc('\n', stderr);
549
550 return PARSE_OPT_HELP;
551}
552
553void usage_with_options(const char * const *usagestr,
554 const struct option *opts)
555{
556 exit_browser(false);
557 usage_with_options_internal(usagestr, opts, 0);
558 exit(129);
559}
560
561int parse_options_usage(const char * const *usagestr,
562 const struct option *opts)
563{
564 return usage_with_options_internal(usagestr, opts, 0);
565}
566
567
568int parse_opt_verbosity_cb(const struct option *opt,
569 const char *arg __maybe_unused,
570 int unset)
571{
572 int *target = opt->value;
573
574 if (unset)
575
576 *target = 0;
577 else if (opt->short_name == 'v') {
578 if (*target >= 0)
579 (*target)++;
580 else
581 *target = 1;
582 } else {
583 if (*target <= 0)
584 (*target)--;
585 else
586 *target = -1;
587 }
588 return 0;
589}
590
