[mirror_ubuntu-artful-kernel.git] / tools / perf / util / parse-options.c

#include "util.h"
#include "parse-options.h"
#include "cache.h"
#include "header.h"

#define OPT_SHORT 1
#define OPT_UNSET 2

static int opterror(const struct option *opt, const char *reason, int flags)
{
	if (flags & OPT_SHORT)
		return error("switch `%c' %s", opt->short_name, reason);
	if (flags & OPT_UNSET)
		return error("option `no-%s' %s", opt->long_name, reason);
	return error("option `%s' %s", opt->long_name, reason);
}

static int get_arg(struct parse_opt_ctx_t *p, const struct option *opt,
		   int flags, const char **arg)
{
	if (p->opt) {
		*arg = p->opt;
		p->opt = NULL;
	} else if ((opt->flags & PARSE_OPT_LASTARG_DEFAULT) && (p->argc == 1 ||
		    **(p->argv + 1) == '-')) {
		*arg = (const char *)opt->defval;
	} else if (p->argc > 1) {
		p->argc--;
		*arg = *++p->argv;
	} else
		return opterror(opt, "requires a value", flags);
	return 0;
}

static int get_value(struct parse_opt_ctx_t *p,
		     const struct option *opt, int flags)
{
	const char *s, *arg = NULL;
	const int unset = flags & OPT_UNSET;

	if (unset && p->opt)
		return opterror(opt, "takes no value", flags);
	if (unset && (opt->flags & PARSE_OPT_NONEG))
		return opterror(opt, "isn't available", flags);

	if (!(flags & OPT_SHORT) && p->opt) {
		switch (opt->type) {
		case OPTION_CALLBACK:
			if (!(opt->flags & PARSE_OPT_NOARG))
				break;
			/* FALLTHROUGH */
		case OPTION_BOOLEAN:
		case OPTION_INCR:
		case OPTION_BIT:
		case OPTION_SET_UINT:
		case OPTION_SET_PTR:
			return opterror(opt, "takes no value", flags);
		case OPTION_END:
		case OPTION_ARGUMENT:
		case OPTION_GROUP:
		case OPTION_STRING:
		case OPTION_INTEGER:
		case OPTION_UINTEGER:
		case OPTION_LONG:
		case OPTION_U64:
		default:
			break;
		}
	}

	switch (opt->type) {
	case OPTION_BIT:
		if (unset)
			*(int *)opt->value &= ~opt->defval;
		else
			*(int *)opt->value |= opt->defval;
		return 0;

	case OPTION_BOOLEAN:
		*(bool *)opt->value = unset ? false : true;
		if (opt->set)
			*(bool *)opt->set = true;
		return 0;

	case OPTION_INCR:
		*(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
		return 0;

	case OPTION_SET_UINT:
		*(unsigned int *)opt->value = unset ? 0 : opt->defval;
		return 0;

	case OPTION_SET_PTR:
		*(void **)opt->value = unset ? NULL : (void *)opt->defval;
		return 0;

	case OPTION_STRING:
		if (unset)
			*(const char **)opt->value = NULL;
		else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
			*(const char **)opt->value = (const char *)opt->defval;
		else
			return get_arg(p, opt, flags, (const char **)opt->value);
		return 0;

	case OPTION_CALLBACK:
		if (unset)
			return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
		if (opt->flags & PARSE_OPT_NOARG)
			return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
			return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
		if (get_arg(p, opt, flags, &arg))
			return -1;
		return (*opt->callback)(opt, arg, 0) ? (-1) : 0;

	case OPTION_INTEGER:
		if (unset) {
			*(int *)opt->value = 0;
			return 0;
		}
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
			*(int *)opt->value = opt->defval;
			return 0;
		}
		if (get_arg(p, opt, flags, &arg))
			return -1;
		*(int *)opt->value = strtol(arg, (char **)&s, 10);
		if (*s)
			return opterror(opt, "expects a numerical value", flags);
		return 0;

	case OPTION_UINTEGER:
		if (unset) {
			*(unsigned int *)opt->value = 0;
			return 0;
		}
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
			*(unsigned int *)opt->value = opt->defval;
			return 0;
		}
		if (get_arg(p, opt, flags, &arg))
			return -1;
		*(unsigned int *)opt->value = strtol(arg, (char **)&s, 10);
		if (*s)
			return opterror(opt, "expects a numerical value", flags);
		return 0;

	case OPTION_LONG:
		if (unset) {
			*(long *)opt->value = 0;
			return 0;
		}
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
			*(long *)opt->value = opt->defval;
			return 0;
		}
		if (get_arg(p, opt, flags, &arg))
			return -1;
		*(long *)opt->value = strtol(arg, (char **)&s, 10);
		if (*s)
			return opterror(opt, "expects a numerical value", flags);
		return 0;

	case OPTION_U64:
		if (unset) {
			*(u64 *)opt->value = 0;
			return 0;
		}
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
			*(u64 *)opt->value = opt->defval;
			return 0;
		}
		if (get_arg(p, opt, flags, &arg))
			return -1;
		*(u64 *)opt->value = strtoull(arg, (char **)&s, 10);
		if (*s)
			return opterror(opt, "expects a numerical value", flags);
		return 0;

	case OPTION_END:
	case OPTION_ARGUMENT:
	case OPTION_GROUP:
	default:
		die("should not happen, someone must be hit on the forehead");
	}
}

static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options)
{
	for (; options->type != OPTION_END; options++) {
		if (options->short_name == *p->opt) {
			p->opt = p->opt[1] ? p->opt + 1 : NULL;
			return get_value(p, options, OPT_SHORT);
		}
	}
	return -2;
}

static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg,
                          const struct option *options)
{
	const char *arg_end = strchr(arg, '=');
	const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
	int abbrev_flags = 0, ambiguous_flags = 0;

	if (!arg_end)
		arg_end = arg + strlen(arg);

	for (; options->type != OPTION_END; options++) {
		const char *rest;
		int flags = 0;

		if (!options->long_name)
			continue;

		rest = skip_prefix(arg, options->long_name);
		if (options->type == OPTION_ARGUMENT) {
			if (!rest)
				continue;
			if (*rest == '=')
				return opterror(options, "takes no value", flags);
			if (*rest)
				continue;
			p->out[p->cpidx++] = arg - 2;
			return 0;
		}
		if (!rest) {
			if (!prefixcmp(options->long_name, "no-")) {
				/*
				 * The long name itself starts with "no-", so
				 * accept the option without "no-" so that users
				 * do not have to enter "no-no-" to get the
				 * negation.
				 */
				rest = skip_prefix(arg, options->long_name + 3);
				if (rest) {
					flags |= OPT_UNSET;
					goto match;
				}
				/* Abbreviated case */
				if (!prefixcmp(options->long_name + 3, arg)) {
					flags |= OPT_UNSET;
					goto is_abbreviated;
				}
			}
			/* abbreviated? */
			if (!strncmp(options->long_name, arg, arg_end - arg)) {
is_abbreviated:
				if (abbrev_option) {
					/*
					 * If this is abbreviated, it is
					 * ambiguous. So when there is no
					 * exact match later, we need to
					 * error out.
					 */
					ambiguous_option = abbrev_option;
					ambiguous_flags = abbrev_flags;
				}
				if (!(flags & OPT_UNSET) && *arg_end)
					p->opt = arg_end + 1;
				abbrev_option = options;
				abbrev_flags = flags;
				continue;
			}
			/* negated and abbreviated very much? */
			if (!prefixcmp("no-", arg)) {
				flags |= OPT_UNSET;
				goto is_abbreviated;
			}
			/* negated? */
			if (strncmp(arg, "no-", 3))
				continue;
			flags |= OPT_UNSET;
			rest = skip_prefix(arg + 3, options->long_name);
			/* abbreviated and negated? */
			if (!rest && !prefixcmp(options->long_name, arg + 3))
				goto is_abbreviated;
			if (!rest)
				continue;
		}
match:
		if (*rest) {
			if (*rest != '=')
				continue;
			p->opt = rest + 1;
		}
		return get_value(p, options, flags);
	}

	if (ambiguous_option)
		return error("Ambiguous option: %s "
			"(could be --%s%s or --%s%s)",
			arg,
			(ambiguous_flags & OPT_UNSET) ?  "no-" : "",
			ambiguous_option->long_name,
			(abbrev_flags & OPT_UNSET) ?  "no-" : "",
			abbrev_option->long_name);
	if (abbrev_option)
		return get_value(p, abbrev_option, abbrev_flags);
	return -2;
}

static void check_typos(const char *arg, const struct option *options)
{
	if (strlen(arg) < 3)
		return;

	if (!prefixcmp(arg, "no-")) {
		error ("did you mean `--%s` (with two dashes ?)", arg);
		exit(129);
	}

	for (; options->type != OPTION_END; options++) {
		if (!options->long_name)
			continue;
		if (!prefixcmp(options->long_name, arg)) {
			error ("did you mean `--%s` (with two dashes ?)", arg);
			exit(129);
		}
	}
}

void parse_options_start(struct parse_opt_ctx_t *ctx,
			 int argc, const char **argv, int flags)
{
	memset(ctx, 0, sizeof(*ctx));
	ctx->argc = argc - 1;
	ctx->argv = argv + 1;
	ctx->out  = argv;
	ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
	ctx->flags = flags;
	if ((flags & PARSE_OPT_KEEP_UNKNOWN) &&
	    (flags & PARSE_OPT_STOP_AT_NON_OPTION))
		die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
}

static int usage_with_options_internal(const char * const *,
				       const struct option *, int);

int parse_options_step(struct parse_opt_ctx_t *ctx,
		       const struct option *options,
		       const char * const usagestr[])
{
	int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);

	/* we must reset ->opt, unknown short option leave it dangling */
	ctx->opt = NULL;

	for (; ctx->argc; ctx->argc--, ctx->argv++) {
		const char *arg = ctx->argv[0];

		if (*arg != '-' || !arg[1]) {
			if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
				break;
			ctx->out[ctx->cpidx++] = ctx->argv[0];
			continue;
		}

		if (arg[1] != '-') {
			ctx->opt = arg + 1;
			if (internal_help && *ctx->opt == 'h')
				return usage_with_options_internal(usagestr, options, 0);
			switch (parse_short_opt(ctx, options)) {
			case -1:
				return parse_options_usage(usagestr, options, arg + 1, 1);
			case -2:
				goto unknown;
			default:
				break;
			}
			if (ctx->opt)
				check_typos(arg + 1, options);
			while (ctx->opt) {
				if (internal_help && *ctx->opt == 'h')
					return usage_with_options_internal(usagestr, options, 0);
				arg = ctx->opt;
				switch (parse_short_opt(ctx, options)) {
				case -1:
					return parse_options_usage(usagestr, options, arg, 1);
				case -2:
					/* fake a short option thing to hide the fact that we may have
					 * started to parse aggregated stuff
					 *
					 * This is leaky, too bad.
					 */
					ctx->argv[0] = strdup(ctx->opt - 1);
					*(char *)ctx->argv[0] = '-';
					goto unknown;
				default:
					break;
				}
			}
			continue;
		}

		if (!arg[2]) { /* "--" */
			if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
				ctx->argc--;
				ctx->argv++;
			}
			break;
		}

		if (internal_help && !strcmp(arg + 2, "help-all"))
			return usage_with_options_internal(usagestr, options, 1);
		if (internal_help && !strcmp(arg + 2, "help"))
			return usage_with_options_internal(usagestr, options, 0);
		if (!strcmp(arg + 2, "list-opts"))
			return PARSE_OPT_LIST_OPTS;
		if (!strcmp(arg + 2, "list-cmds"))
			return PARSE_OPT_LIST_SUBCMDS;
		switch (parse_long_opt(ctx, arg + 2, options)) {
		case -1:
			return parse_options_usage(usagestr, options, arg + 2, 0);
		case -2:
			goto unknown;
		default:
			break;
		}
		continue;
unknown:
		if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN))
			return PARSE_OPT_UNKNOWN;
		ctx->out[ctx->cpidx++] = ctx->argv[0];
		ctx->opt = NULL;
	}
	return PARSE_OPT_DONE;
}

int parse_options_end(struct parse_opt_ctx_t *ctx)
{
	memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
	ctx->out[ctx->cpidx + ctx->argc] = NULL;
	return ctx->cpidx + ctx->argc;
}

int parse_options_subcommand(int argc, const char **argv, const struct option *options,
			const char *const subcommands[], const char *usagestr[], int flags)
{
	struct parse_opt_ctx_t ctx;

	perf_header__set_cmdline(argc, argv);

	/* build usage string if it's not provided */
	if (subcommands && !usagestr[0]) {
		struct strbuf buf = STRBUF_INIT;

		strbuf_addf(&buf, "perf %s [<options>] {", argv[0]);
		for (int i = 0; subcommands[i]; i++) {
			if (i)
				strbuf_addstr(&buf, "|");
			strbuf_addstr(&buf, subcommands[i]);
		}
		strbuf_addstr(&buf, "}");

		usagestr[0] = strdup(buf.buf);
		strbuf_release(&buf);
	}

	parse_options_start(&ctx, argc, argv, flags);
	switch (parse_options_step(&ctx, options, usagestr)) {
	case PARSE_OPT_HELP:
		exit(129);
	case PARSE_OPT_DONE:
		break;
	case PARSE_OPT_LIST_OPTS:
		while (options->type != OPTION_END) {
			printf("--%s ", options->long_name);
			options++;
		}
		exit(130);
	case PARSE_OPT_LIST_SUBCMDS:
		for (int i = 0; subcommands[i]; i++)
			printf("%s ", subcommands[i]);
		exit(130);
	default: /* PARSE_OPT_UNKNOWN */
		if (ctx.argv[0][1] == '-') {
			error("unknown option `%s'", ctx.argv[0] + 2);
		} else {
			error("unknown switch `%c'", *ctx.opt);
		}
		usage_with_options(usagestr, options);
	}

	return parse_options_end(&ctx);
}

int parse_options(int argc, const char **argv, const struct option *options,
		  const char * const usagestr[], int flags)
{
	return parse_options_subcommand(argc, argv, options, NULL,
					(const char **) usagestr, flags);
}

#define USAGE_OPTS_WIDTH 24
#define USAGE_GAP         2

static void print_option_help(const struct option *opts, int full)
{
	size_t pos;
	int pad;

	if (opts->type == OPTION_GROUP) {
		fputc('\n', stderr);
		if (*opts->help)
			fprintf(stderr, "%s\n", opts->help);
		return;
	}
	if (!full && (opts->flags & PARSE_OPT_HIDDEN))
		return;

	pos = fprintf(stderr, "    ");
	if (opts->short_name)
		pos += fprintf(stderr, "-%c", opts->short_name);
	else
		pos += fprintf(stderr, "    ");

	if (opts->long_name && opts->short_name)
		pos += fprintf(stderr, ", ");
	if (opts->long_name)
		pos += fprintf(stderr, "--%s", opts->long_name);

	switch (opts->type) {
	case OPTION_ARGUMENT:
		break;
	case OPTION_LONG:
	case OPTION_U64:
	case OPTION_INTEGER:
	case OPTION_UINTEGER:
		if (opts->flags & PARSE_OPT_OPTARG)
			if (opts->long_name)
				pos += fprintf(stderr, "[=<n>]");
			else
				pos += fprintf(stderr, "[<n>]");
		else
			pos += fprintf(stderr, " <n>");
		break;
	case OPTION_CALLBACK:
		if (opts->flags & PARSE_OPT_NOARG)
			break;
		/* FALLTHROUGH */
	case OPTION_STRING:
		if (opts->argh) {
			if (opts->flags & PARSE_OPT_OPTARG)
				if (opts->long_name)
					pos += fprintf(stderr, "[=<%s>]", opts->argh);
				else
					pos += fprintf(stderr, "[<%s>]", opts->argh);
			else
				pos += fprintf(stderr, " <%s>", opts->argh);
		} else {
			if (opts->flags & PARSE_OPT_OPTARG)
				if (opts->long_name)
					pos += fprintf(stderr, "[=...]");
				else
					pos += fprintf(stderr, "[...]");
			else
				pos += fprintf(stderr, " ...");
		}
		break;
	default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */
	case OPTION_END:
	case OPTION_GROUP:
	case OPTION_BIT:
	case OPTION_BOOLEAN:
	case OPTION_INCR:
	case OPTION_SET_UINT:
	case OPTION_SET_PTR:
		break;
	}

	if (pos <= USAGE_OPTS_WIDTH)
		pad = USAGE_OPTS_WIDTH - pos;
	else {
		fputc('\n', stderr);
		pad = USAGE_OPTS_WIDTH;
	}
	fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help);
}

int usage_with_options_internal(const char * const *usagestr,
				const struct option *opts, int full)
{
	if (!usagestr)
		return PARSE_OPT_HELP;

	fprintf(stderr, "\n usage: %s\n", *usagestr++);
	while (*usagestr && **usagestr)
		fprintf(stderr, "    or: %s\n", *usagestr++);
	while (*usagestr) {
		fprintf(stderr, "%s%s\n",
				**usagestr ? "    " : "",
				*usagestr);
		usagestr++;
	}

	if (opts->type != OPTION_GROUP)
		fputc('\n', stderr);

	for (  ; opts->type != OPTION_END; opts++)
		print_option_help(opts, full);

	fputc('\n', stderr);

	return PARSE_OPT_HELP;
}

void usage_with_options(const char * const *usagestr,
			const struct option *opts)
{
	exit_browser(false);
	usage_with_options_internal(usagestr, opts, 0);
	exit(129);
}

int parse_options_usage(const char * const *usagestr,
			const struct option *opts,
			const char *optstr, bool short_opt)
{
	if (!usagestr)
		goto opt;

	fprintf(stderr, "\n usage: %s\n", *usagestr++);
	while (*usagestr && **usagestr)
		fprintf(stderr, "    or: %s\n", *usagestr++);
	while (*usagestr) {
		fprintf(stderr, "%s%s\n",
				**usagestr ? "    " : "",
				*usagestr);
		usagestr++;
	}
	fputc('\n', stderr);

opt:
	for (  ; opts->type != OPTION_END; opts++) {
		if (short_opt) {
			if (opts->short_name == *optstr)
				break;
			continue;
		}

		if (opts->long_name == NULL)
			continue;

		if (!prefixcmp(optstr, opts->long_name))
			break;
		if (!prefixcmp(optstr, "no-") &&
		    !prefixcmp(optstr + 3, opts->long_name))
			break;
	}

	if (opts->type != OPTION_END)
		print_option_help(opts, 0);

	return PARSE_OPT_HELP;
}


int parse_opt_verbosity_cb(const struct option *opt,
			   const char *arg __maybe_unused,
			   int unset)
{
	int *target = opt->value;

	if (unset)
		/* --no-quiet, --no-verbose */
		*target = 0;
	else if (opt->short_name == 'v') {
		if (*target >= 0)
			(*target)++;
		else
			*target = 1;
	} else {
		if (*target <= 0)
			(*target)--;
		else
			*target = -1;
	}
	return 0;
}
Commit	Line	Data
07800601 IM	1	#include "util.h"
	2	#include "parse-options.h"
	3	#include "cache.h"
56e6f602	4	#include "header.h"
07800601 IM	5
	6	#define OPT_SHORT 1
	7	#define OPT_UNSET 2
	8
	9	static 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
	18	static 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;
5a4b1817 FW	24	} else if ((opt->flags & PARSE_OPT_LASTARG_DEFAULT) && (p->argc == 1 \|\|
5a4b1817 FW	25	**(p->argv + 1) == '-')) {
07800601 IM	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
	35	static int get_value(struct parse_opt_ctx_t *p,
	36	const struct option *opt, int flags)
	37	{
233f0b95	38	const char s, arg = NULL;
07800601 IM	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	/* FALLTHROUGH */
	52	case OPTION_BOOLEAN:
c0555642	53	case OPTION_INCR:
07800601	54	case OPTION_BIT:
edb7c60e	55	case OPTION_SET_UINT:
07800601 IM	56	case OPTION_SET_PTR:
07800601 IM	57	return opterror(opt, "takes no value", flags);
83a0944f IM	58	case OPTION_END:
	59	case OPTION_ARGUMENT:
	60	case OPTION_GROUP:
	61	case OPTION_STRING:
	62	case OPTION_INTEGER:
c100edbe	63	case OPTION_UINTEGER:
83a0944f	64	case OPTION_LONG:
6ba85cea	65	case OPTION_U64:
07800601 IM	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:
c0555642	80	(bool )opt->value = unset ? false : true;
167faf32 AH	81	if (opt->set)
167faf32 AH	82	(bool )opt->set = true;
c0555642 IM	83	return 0;
	84
	85	case OPTION_INCR:
07800601 IM	86	(int )opt->value = unset ? 0 : (int )opt->value + 1;
	87	return 0;
	88
edb7c60e ACM	89	case OPTION_SET_UINT:
edb7c60e ACM	90	(unsigned int )opt->value = unset ? 0 : opt->defval;
07800601 IM	91	return 0;
	92
	93	case OPTION_SET_PTR:
	94	(void )opt->value = unset ? NULL : (void )opt->defval;
	95	return 0;
	96
	97	case OPTION_STRING:
	98	if (unset)
	99	(const char *)opt->value = NULL;
	100	else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
	101	(const char )opt->value = (const char )opt->defval;
	102	else
	103	return get_arg(p, opt, flags, (const char **)opt->value);
	104	return 0;
	105
	106	case OPTION_CALLBACK:
	107	if (unset)
	108	return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
	109	if (opt->flags & PARSE_OPT_NOARG)
	110	return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
	111	if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
	112	return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
	113	if (get_arg(p, opt, flags, &arg))
	114	return -1;
	115	return (*opt->callback)(opt, arg, 0) ? (-1) : 0;
	116
	117	case OPTION_INTEGER:
	118	if (unset) {
	119	(int )opt->value = 0;
	120	return 0;
	121	}
	122	if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
	123	(int )opt->value = opt->defval;
	124	return 0;
	125	}
	126	if (get_arg(p, opt, flags, &arg))
	127	return -1;
	128	(int )opt->value = strtol(arg, (char **)&s, 10);
	129	if (*s)
	130	return opterror(opt, "expects a numerical value", flags);
e61078a0 PZ	131	return 0;
e61078a0 PZ	132
c100edbe ACM	133	case OPTION_UINTEGER:
	134	if (unset) {
	135	(unsigned int )opt->value = 0;
	136	return 0;
	137	}
	138	if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
	139	(unsigned int )opt->value = opt->defval;
	140	return 0;
	141	}
	142	if (get_arg(p, opt, flags, &arg))
	143	return -1;
	144	(unsigned int )opt->value = strtol(arg, (char **)&s, 10);
	145	if (*s)
	146	return opterror(opt, "expects a numerical value", flags);
	147	return 0;
	148
e61078a0 PZ	149	case OPTION_LONG:
	150	if (unset) {
	151	(long )opt->value = 0;
	152	return 0;
	153	}
	154	if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
	155	(long )opt->value = opt->defval;
	156	return 0;
	157	}
	158	if (get_arg(p, opt, flags, &arg))
	159	return -1;
	160	(long )opt->value = strtol(arg, (char **)&s, 10);
	161	if (*s)
	162	return opterror(opt, "expects a numerical value", flags);
07800601 IM	163	return 0;
07800601 IM	164
6ba85cea ACM	165	case OPTION_U64:
	166	if (unset) {
	167	(u64 )opt->value = 0;
	168	return 0;
	169	}
	170	if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
	171	(u64 )opt->value = opt->defval;
	172	return 0;
	173	}
	174	if (get_arg(p, opt, flags, &arg))
	175	return -1;
	176	(u64 )opt->value = strtoull(arg, (char **)&s, 10);
	177	if (*s)
	178	return opterror(opt, "expects a numerical value", flags);
	179	return 0;
	180
83a0944f IM	181	case OPTION_END:
	182	case OPTION_ARGUMENT:
	183	case OPTION_GROUP:
07800601 IM	184	default:
	185	die("should not happen, someone must be hit on the forehead");
	186	}
	187	}
	188
	189	static int parse_short_opt(struct parse_opt_ctx_t p, const struct option options)
	190	{
	191	for (; options->type != OPTION_END; options++) {
	192	if (options->short_name == *p->opt) {
	193	p->opt = p->opt[1] ? p->opt + 1 : NULL;
	194	return get_value(p, options, OPT_SHORT);
	195	}
	196	}
	197	return -2;
	198	}
	199
	200	static int parse_long_opt(struct parse_opt_ctx_t p, const char arg,
	201	const struct option *options)
	202	{
	203	const char *arg_end = strchr(arg, '=');
	204	const struct option abbrev_option = NULL, ambiguous_option = NULL;
	205	int abbrev_flags = 0, ambiguous_flags = 0;
	206
	207	if (!arg_end)
	208	arg_end = arg + strlen(arg);
	209
	210	for (; options->type != OPTION_END; options++) {
	211	const char *rest;
	212	int flags = 0;
	213
	214	if (!options->long_name)
	215	continue;
	216
	217	rest = skip_prefix(arg, options->long_name);
	218	if (options->type == OPTION_ARGUMENT) {
	219	if (!rest)
	220	continue;
	221	if (*rest == '=')
	222	return opterror(options, "takes no value", flags);
	223	if (*rest)
	224	continue;
	225	p->out[p->cpidx++] = arg - 2;
	226	return 0;
	227	}
	228	if (!rest) {
4bc43796 AH	229	if (!prefixcmp(options->long_name, "no-")) {
	230	/*
	231	* The long name itself starts with "no-", so
	232	* accept the option without "no-" so that users
	233	* do not have to enter "no-no-" to get the
	234	* negation.
	235	*/
	236	rest = skip_prefix(arg, options->long_name + 3);
	237	if (rest) {
	238	flags \|= OPT_UNSET;
	239	goto match;
	240	}
	241	/* Abbreviated case */
	242	if (!prefixcmp(options->long_name + 3, arg)) {
	243	flags \|= OPT_UNSET;
	244	goto is_abbreviated;
	245	}
	246	}
07800601 IM	247	/* abbreviated? */
	248	if (!strncmp(options->long_name, arg, arg_end - arg)) {
	249	is_abbreviated:
	250	if (abbrev_option) {
	251	/*
	252	* If this is abbreviated, it is
	253	* ambiguous. So when there is no
	254	* exact match later, we need to
	255	* error out.
	256	*/
	257	ambiguous_option = abbrev_option;
	258	ambiguous_flags = abbrev_flags;
	259	}
	260	if (!(flags & OPT_UNSET) && *arg_end)
	261	p->opt = arg_end + 1;
	262	abbrev_option = options;
	263	abbrev_flags = flags;
	264	continue;
	265	}
	266	/* negated and abbreviated very much? */
	267	if (!prefixcmp("no-", arg)) {
	268	flags \|= OPT_UNSET;
	269	goto is_abbreviated;
	270	}
	271	/* negated? */
	272	if (strncmp(arg, "no-", 3))
	273	continue;
	274	flags \|= OPT_UNSET;
	275	rest = skip_prefix(arg + 3, options->long_name);
	276	/* abbreviated and negated? */
	277	if (!rest && !prefixcmp(options->long_name, arg + 3))
	278	goto is_abbreviated;
	279	if (!rest)
	280	continue;
	281	}
4bc43796	282	match:
07800601 IM	283	if (*rest) {
	284	if (*rest != '=')
	285	continue;
	286	p->opt = rest + 1;
	287	}
	288	return get_value(p, options, flags);
	289	}
	290
	291	if (ambiguous_option)
	292	return error("Ambiguous option: %s "
	293	"(could be --%s%s or --%s%s)",
	294	arg,
	295	(ambiguous_flags & OPT_UNSET) ? "no-" : "",
	296	ambiguous_option->long_name,
	297	(abbrev_flags & OPT_UNSET) ? "no-" : "",
	298	abbrev_option->long_name);
	299	if (abbrev_option)
	300	return get_value(p, abbrev_option, abbrev_flags);
	301	return -2;
	302	}
	303
	304	static void check_typos(const char arg, const struct option options)
	305	{
	306	if (strlen(arg) < 3)
	307	return;
	308
	309	if (!prefixcmp(arg, "no-")) {
	310	error ("did you mean `--%s` (with two dashes ?)", arg);
	311	exit(129);
	312	}
	313
	314	for (; options->type != OPTION_END; options++) {
	315	if (!options->long_name)
	316	continue;
	317	if (!prefixcmp(options->long_name, arg)) {
	318	error ("did you mean `--%s` (with two dashes ?)", arg);
	319	exit(129);
	320	}
	321	}
	322	}
	323
	324	void parse_options_start(struct parse_opt_ctx_t *ctx,
	325	int argc, const char **argv, int flags)
	326	{
	327	memset(ctx, 0, sizeof(*ctx));
	328	ctx->argc = argc - 1;
	329	ctx->argv = argv + 1;
	330	ctx->out = argv;
	331	ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
	332	ctx->flags = flags;
	333	if ((flags & PARSE_OPT_KEEP_UNKNOWN) &&
	334	(flags & PARSE_OPT_STOP_AT_NON_OPTION))
	335	die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
	336	}
	337
	338	static int usage_with_options_internal(const char * const *,
	339	const struct option *, int);
	340
	341	int parse_options_step(struct parse_opt_ctx_t *ctx,
	342	const struct option *options,
	343	const char * const usagestr[])
	344	{
	345	int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
	346
347	/* we must reset ->opt, unknown short option leave it dangling */
348	ctx->opt = NULL;
349
350	for (; ctx->argc; ctx->argc--, ctx->argv++) {
351	const char *arg = ctx->argv[0];
352
353	if (*arg != '-' \|\| !arg[1]) {
354	if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
355	break;
356	ctx->out[ctx->cpidx++] = ctx->argv[0];
357	continue;
358	}
359
360	if (arg[1] != '-') {
361	ctx->opt = arg + 1;
362	if (internal_help && *ctx->opt == 'h')
ac697625	363	return usage_with_options_internal(usagestr, options, 0);
07800601 IM	364	switch (parse_short_opt(ctx, options)) {
07800601 IM	365	case -1:
ac697625	366	return parse_options_usage(usagestr, options, arg + 1, 1);
07800601 IM	367	case -2:
07800601 IM	368	goto unknown;
83a0944f IM	369	default:
83a0944f IM	370	break;
07800601 IM	371	}
	372	if (ctx->opt)
	373	check_typos(arg + 1, options);
	374	while (ctx->opt) {
	375	if (internal_help && *ctx->opt == 'h')
ac697625 NK	376	return usage_with_options_internal(usagestr, options, 0);
ac697625 NK	377	arg = ctx->opt;
07800601 IM	378	switch (parse_short_opt(ctx, options)) {
07800601 IM	379	case -1:
ac697625	380	return parse_options_usage(usagestr, options, arg, 1);
07800601 IM	381	case -2:
	382	/* fake a short option thing to hide the fact that we may have
	383	* started to parse aggregated stuff
	384	*
	385	* This is leaky, too bad.
	386	*/
	387	ctx->argv[0] = strdup(ctx->opt - 1);
	388	(char )ctx->argv[0] = '-';
	389	goto unknown;
83a0944f IM	390	default:
83a0944f IM	391	break;
07800601 IM	392	}
	393	}
	394	continue;
	395	}
	396
	397	if (!arg[2]) { /* "--" */
	398	if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
	399	ctx->argc--;
	400	ctx->argv++;
	401	}
	402	break;
	403	}
	404
	405	if (internal_help && !strcmp(arg + 2, "help-all"))
	406	return usage_with_options_internal(usagestr, options, 1);
	407	if (internal_help && !strcmp(arg + 2, "help"))
ac697625	408	return usage_with_options_internal(usagestr, options, 0);
4d8061fa	409	if (!strcmp(arg + 2, "list-opts"))
09a71b97 RR	410	return PARSE_OPT_LIST_OPTS;
	411	if (!strcmp(arg + 2, "list-cmds"))
	412	return PARSE_OPT_LIST_SUBCMDS;
07800601 IM	413	switch (parse_long_opt(ctx, arg + 2, options)) {
07800601 IM	414	case -1:
ac697625	415	return parse_options_usage(usagestr, options, arg + 2, 0);
07800601 IM	416	case -2:
07800601 IM	417	goto unknown;
83a0944f IM	418	default:
83a0944f IM	419	break;
07800601 IM	420	}
	421	continue;
	422	unknown:
	423	if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN))
	424	return PARSE_OPT_UNKNOWN;
	425	ctx->out[ctx->cpidx++] = ctx->argv[0];
	426	ctx->opt = NULL;
	427	}
	428	return PARSE_OPT_DONE;
	429	}
	430
	431	int parse_options_end(struct parse_opt_ctx_t *ctx)
	432	{
	433	memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
	434	ctx->out[ctx->cpidx + ctx->argc] = NULL;
	435	return ctx->cpidx + ctx->argc;
	436	}
	437
09a71b97 RR	438	int parse_options_subcommand(int argc, const char *argv, const struct option options,
09a71b97 RR	439	const char const subcommands[], const char usagestr[], int flags)
07800601 IM	440	{
	441	struct parse_opt_ctx_t ctx;
	442
56e6f602 DA	443	perf_header__set_cmdline(argc, argv);
56e6f602 DA	444
09a71b97 RR	445	/* build usage string if it's not provided */
	446	if (subcommands && !usagestr[0]) {
	447	struct strbuf buf = STRBUF_INIT;
	448
	449	strbuf_addf(&buf, "perf %s [<options>] {", argv[0]);
	450	for (int i = 0; subcommands[i]; i++) {
	451	if (i)
	452	strbuf_addstr(&buf, "\|");
	453	strbuf_addstr(&buf, subcommands[i]);
	454	}
	455	strbuf_addstr(&buf, "}");
	456
	457	usagestr[0] = strdup(buf.buf);
	458	strbuf_release(&buf);
	459	}
	460
07800601 IM	461	parse_options_start(&ctx, argc, argv, flags);
	462	switch (parse_options_step(&ctx, options, usagestr)) {
	463	case PARSE_OPT_HELP:
	464	exit(129);
	465	case PARSE_OPT_DONE:
	466	break;
09a71b97	467	case PARSE_OPT_LIST_OPTS:
4d8061fa NK	468	while (options->type != OPTION_END) {
	469	printf("--%s ", options->long_name);
	470	options++;
	471	}
	472	exit(130);
09a71b97 RR	473	case PARSE_OPT_LIST_SUBCMDS:
	474	for (int i = 0; subcommands[i]; i++)
	475	printf("%s ", subcommands[i]);
	476	exit(130);
07800601 IM	477	default: /* PARSE_OPT_UNKNOWN */
	478	if (ctx.argv[0][1] == '-') {
	479	error("unknown option `%s'", ctx.argv[0] + 2);
	480	} else {
	481	error("unknown switch `%c'", *ctx.opt);
	482	}
	483	usage_with_options(usagestr, options);
	484	}
	485
	486	return parse_options_end(&ctx);
	487	}
	488
09a71b97 RR	489	int parse_options(int argc, const char *argv, const struct option options,
	490	const char * const usagestr[], int flags)
	491	{
	492	return parse_options_subcommand(argc, argv, options, NULL,
	493	(const char **) usagestr, flags);
	494	}
	495
07800601 IM	496	#define USAGE_OPTS_WIDTH 24
	497	#define USAGE_GAP 2
	498
ac697625 NK	499	static void print_option_help(const struct option *opts, int full)
	500	{
	501	size_t pos;
	502	int pad;
	503
	504	if (opts->type == OPTION_GROUP) {
	505	fputc('\n', stderr);
	506	if (*opts->help)
	507	fprintf(stderr, "%s\n", opts->help);
	508	return;
	509	}
	510	if (!full && (opts->flags & PARSE_OPT_HIDDEN))
	511	return;
	512
	513	pos = fprintf(stderr, " ");
	514	if (opts->short_name)
	515	pos += fprintf(stderr, "-%c", opts->short_name);
	516	else
	517	pos += fprintf(stderr, " ");
	518
	519	if (opts->long_name && opts->short_name)
	520	pos += fprintf(stderr, ", ");
	521	if (opts->long_name)
	522	pos += fprintf(stderr, "--%s", opts->long_name);
	523
	524	switch (opts->type) {
	525	case OPTION_ARGUMENT:
	526	break;
	527	case OPTION_LONG:
	528	case OPTION_U64:
	529	case OPTION_INTEGER:
	530	case OPTION_UINTEGER:
	531	if (opts->flags & PARSE_OPT_OPTARG)
	532	if (opts->long_name)
	533	pos += fprintf(stderr, "[=<n>]");
	534	else
	535	pos += fprintf(stderr, "[<n>]");
	536	else
	537	pos += fprintf(stderr, " <n>");
	538	break;
	539	case OPTION_CALLBACK:
	540	if (opts->flags & PARSE_OPT_NOARG)
	541	break;
	542	/* FALLTHROUGH */
	543	case OPTION_STRING:
	544	if (opts->argh) {
	545	if (opts->flags & PARSE_OPT_OPTARG)
	546	if (opts->long_name)
	547	pos += fprintf(stderr, "[=<%s>]", opts->argh);
	548	else
	549	pos += fprintf(stderr, "[<%s>]", opts->argh);
	550	else
	551	pos += fprintf(stderr, " <%s>", opts->argh);
	552	} else {
	553	if (opts->flags & PARSE_OPT_OPTARG)
	554	if (opts->long_name)
	555	pos += fprintf(stderr, "[=...]");
	556	else
	557	pos += fprintf(stderr, "[...]");
	558	else
	559	pos += fprintf(stderr, " ...");
	560	}
	561	break;
	562	default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */
563	case OPTION_END:
564	case OPTION_GROUP:
565	case OPTION_BIT:
566	case OPTION_BOOLEAN:
567	case OPTION_INCR:
568	case OPTION_SET_UINT:
569	case OPTION_SET_PTR:
570	break;
571	}
572
573	if (pos <= USAGE_OPTS_WIDTH)
574	pad = USAGE_OPTS_WIDTH - pos;
575	else {
576	fputc('\n', stderr);
577	pad = USAGE_OPTS_WIDTH;
578	}
579	fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help);
580	}
581
07800601 IM	582	int usage_with_options_internal(const char * const *usagestr,
	583	const struct option *opts, int full)
	584	{
	585	if (!usagestr)
	586	return PARSE_OPT_HELP;
	587
502fc5c7	588	fprintf(stderr, "\n usage: %s\n", *usagestr++);
07800601	589	while (usagestr && *usagestr)
6e6b754f	590	fprintf(stderr, " or: %s\n", *usagestr++);
07800601 IM	591	while (*usagestr) {
	592	fprintf(stderr, "%s%s\n",
	593	**usagestr ? " " : "",
	594	*usagestr);
	595	usagestr++;
	596	}
	597
	598	if (opts->type != OPTION_GROUP)
	599	fputc('\n', stderr);
	600
ac697625 NK	601	for ( ; opts->type != OPTION_END; opts++)
ac697625 NK	602	print_option_help(opts, full);
07800601	603
07800601 IM	604	fputc('\n', stderr);
	605
	606	return PARSE_OPT_HELP;
	607	}
	608
	609	void usage_with_options(const char * const *usagestr,
	610	const struct option *opts)
	611	{
478b0973	612	exit_browser(false);
07800601 IM	613	usage_with_options_internal(usagestr, opts, 0);
	614	exit(129);
	615	}
	616
	617	int parse_options_usage(const char * const *usagestr,
ac697625 NK	618	const struct option *opts,
ac697625 NK	619	const char *optstr, bool short_opt)
07800601	620	{
ac697625	621	if (!usagestr)
cc03c542	622	goto opt;
ac697625 NK	623
	624	fprintf(stderr, "\n usage: %s\n", *usagestr++);
	625	while (usagestr && *usagestr)
	626	fprintf(stderr, " or: %s\n", *usagestr++);
	627	while (*usagestr) {
	628	fprintf(stderr, "%s%s\n",
	629	**usagestr ? " " : "",
	630	*usagestr);
	631	usagestr++;
	632	}
	633	fputc('\n', stderr);
	634
cc03c542	635	opt:
ac697625 NK	636	for ( ; opts->type != OPTION_END; opts++) {
	637	if (short_opt) {
	638	if (opts->short_name == *optstr)
	639	break;
	640	continue;
	641	}
	642
	643	if (opts->long_name == NULL)
	644	continue;
	645
	646	if (!prefixcmp(optstr, opts->long_name))
	647	break;
	648	if (!prefixcmp(optstr, "no-") &&
	649	!prefixcmp(optstr + 3, opts->long_name))
	650	break;
	651	}
	652
	653	if (opts->type != OPTION_END)
	654	print_option_help(opts, 0);
	655
	656	return PARSE_OPT_HELP;
07800601 IM	657	}
	658
	659
1d037ca1 IT	660	int parse_opt_verbosity_cb(const struct option *opt,
1d037ca1 IT	661	const char *arg __maybe_unused,
07800601 IM	662	int unset)
	663	{
	664	int *target = opt->value;
	665
	666	if (unset)
	667	/* --no-quiet, --no-verbose */
	668	*target = 0;
	669	else if (opt->short_name == 'v') {
	670	if (*target >= 0)
	671	(*target)++;
	672	else
	673	*target = 1;
	674	} else {
	675	if (*target <= 0)
	676	(*target)--;
	677	else
	678	*target = -1;
	679	}
	680	return 0;
	681	}