1 #include "git-compat-util.h"
2 #include "parse-options.h"
9 static int opterror(const struct option *opt, const char *reason, int flags)
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);
18 static int get_arg(struct parse_opt_ctx_t *p, const struct option *opt,
19 int flags, const char **arg)
24 } else if (p->argc == 1 && (opt->flags & PARSE_OPT_LASTARG_DEFAULT)) {
25 *arg = (const char *)opt->defval;
26 } else if (p->argc > 1) {
30 return opterror(opt, "requires a value", flags);
34 static int get_value(struct parse_opt_ctx_t *p,
35 const struct option *opt, int flags)
38 const int unset = flags & OPT_UNSET;
41 return opterror(opt, "takes no value", flags);
42 if (unset && (opt->flags & PARSE_OPT_NONEG))
43 return opterror(opt, "isn't available", flags);
45 if (!(flags & OPT_SHORT) && p->opt) {
48 if (!(opt->flags & PARSE_OPT_NOARG))
55 return opterror(opt, "takes no value", flags);
64 *(int *)opt->value &= ~opt->defval;
66 *(int *)opt->value |= opt->defval;
70 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
74 *(int *)opt->value = unset ? 0 : opt->defval;
78 *(void **)opt->value = unset ? NULL : (void *)opt->defval;
83 *(const char **)opt->value = NULL;
84 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
85 *(const char **)opt->value = (const char *)opt->defval;
87 return get_arg(p, opt, flags, (const char **)opt->value);
92 return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
93 if (opt->flags & PARSE_OPT_NOARG)
94 return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
95 if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
96 return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
97 if (get_arg(p, opt, flags, &arg))
99 return (*opt->callback)(opt, arg, 0) ? (-1) : 0;
103 *(int *)opt->value = 0;
106 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
107 *(int *)opt->value = opt->defval;
110 if (get_arg(p, opt, flags, &arg))
112 *(int *)opt->value = strtol(arg, (char **)&s, 10);
114 return opterror(opt, "expects a numerical value", flags);
118 die("should not happen, someone must be hit on the forehead");
122 static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options)
124 for (; options->type != OPTION_END; options++) {
125 if (options->short_name == *p->opt) {
126 p->opt = p->opt[1] ? p->opt + 1 : NULL;
127 return get_value(p, options, OPT_SHORT);
133 static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg,
134 const struct option *options)
136 const char *arg_end = strchr(arg, '=');
137 const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
138 int abbrev_flags = 0, ambiguous_flags = 0;
141 arg_end = arg + strlen(arg);
143 for (; options->type != OPTION_END; options++) {
147 if (!options->long_name)
150 rest = skip_prefix(arg, options->long_name);
151 if (options->type == OPTION_ARGUMENT) {
155 return opterror(options, "takes no value", flags);
158 p->out[p->cpidx++] = arg - 2;
163 if (!strncmp(options->long_name, arg, arg_end - arg)) {
167 * If this is abbreviated, it is
168 * ambiguous. So when there is no
169 * exact match later, we need to
172 ambiguous_option = abbrev_option;
173 ambiguous_flags = abbrev_flags;
175 if (!(flags & OPT_UNSET) && *arg_end)
176 p->opt = arg_end + 1;
177 abbrev_option = options;
178 abbrev_flags = flags;
181 /* negated and abbreviated very much? */
182 if (!prefixcmp("no-", arg)) {
187 if (strncmp(arg, "no-", 3))
190 rest = skip_prefix(arg + 3, options->long_name);
191 /* abbreviated and negated? */
192 if (!rest && !prefixcmp(options->long_name, arg + 3))
202 return get_value(p, options, flags);
205 if (ambiguous_option)
206 return error("Ambiguous option: %s "
207 "(could be --%s%s or --%s%s)",
209 (ambiguous_flags & OPT_UNSET) ? "no-" : "",
210 ambiguous_option->long_name,
211 (abbrev_flags & OPT_UNSET) ? "no-" : "",
212 abbrev_option->long_name);
214 return get_value(p, abbrev_option, abbrev_flags);
218 static void check_typos(const char *arg, const struct option *options)
223 if (!prefixcmp(arg, "no-")) {
224 error ("did you mean `--%s` (with two dashes ?)", arg);
228 for (; options->type != OPTION_END; options++) {
229 if (!options->long_name)
231 if (!prefixcmp(options->long_name, arg)) {
232 error ("did you mean `--%s` (with two dashes ?)", arg);
238 void parse_options_start(struct parse_opt_ctx_t *ctx,
239 int argc, const char **argv, int flags)
241 memset(ctx, 0, sizeof(*ctx));
242 ctx->argc = argc - 1;
243 ctx->argv = argv + 1;
245 ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
249 static int usage_with_options_internal(const char * const *,
250 const struct option *, int);
252 int parse_options_step(struct parse_opt_ctx_t *ctx,
253 const struct option *options,
254 const char * const usagestr[])
256 int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
258 /* we must reset ->opt, unknown short option leave it dangling */
261 for (; ctx->argc; ctx->argc--, ctx->argv++) {
262 const char *arg = ctx->argv[0];
264 if (*arg != '-' || !arg[1]) {
265 if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
267 ctx->out[ctx->cpidx++] = ctx->argv[0];
273 if (internal_help && *ctx->opt == 'h')
274 return parse_options_usage(usagestr, options);
275 switch (parse_short_opt(ctx, options)) {
277 return parse_options_usage(usagestr, options);
282 check_typos(arg + 1, options);
284 if (internal_help && *ctx->opt == 'h')
285 return parse_options_usage(usagestr, options);
286 switch (parse_short_opt(ctx, options)) {
288 return parse_options_usage(usagestr, options);
290 /* fake a short option thing to hide the fact that we may have
291 * started to parse aggregated stuff
293 * This is leaky, too bad.
295 ctx->argv[0] = xstrdup(ctx->opt - 1);
296 *(char *)ctx->argv[0] = '-';
303 if (!arg[2]) { /* "--" */
304 if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
311 if (internal_help && !strcmp(arg + 2, "help-all"))
312 return usage_with_options_internal(usagestr, options, 1);
313 if (internal_help && !strcmp(arg + 2, "help"))
314 return parse_options_usage(usagestr, options);
315 switch (parse_long_opt(ctx, arg + 2, options)) {
317 return parse_options_usage(usagestr, options);
323 if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN))
324 return PARSE_OPT_UNKNOWN;
325 ctx->out[ctx->cpidx++] = ctx->argv[0];
328 return PARSE_OPT_DONE;
331 int parse_options_end(struct parse_opt_ctx_t *ctx)
333 memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
334 ctx->out[ctx->cpidx + ctx->argc] = NULL;
335 return ctx->cpidx + ctx->argc;
338 int parse_options(int argc, const char **argv, const struct option *options,
339 const char * const usagestr[], int flags)
341 struct parse_opt_ctx_t ctx;
343 parse_options_start(&ctx, argc, argv, flags);
344 switch (parse_options_step(&ctx, options, usagestr)) {
349 default: /* PARSE_OPT_UNKNOWN */
350 if (ctx.argv[0][1] == '-') {
351 error("unknown option `%s'", ctx.argv[0] + 2);
353 error("unknown switch `%c'", *ctx.opt);
355 usage_with_options(usagestr, options);
358 return parse_options_end(&ctx);
361 #define USAGE_OPTS_WIDTH 24
364 int usage_with_options_internal(const char * const *usagestr,
365 const struct option *opts, int full)
368 return PARSE_OPT_HELP;
370 fprintf(stderr, "usage: %s\n", *usagestr++);
371 while (*usagestr && **usagestr)
372 fprintf(stderr, " or: %s\n", *usagestr++);
374 fprintf(stderr, "%s%s\n",
375 **usagestr ? " " : "",
380 if (opts->type != OPTION_GROUP)
383 for (; opts->type != OPTION_END; opts++) {
387 if (opts->type == OPTION_GROUP) {
390 fprintf(stderr, "%s\n", opts->help);
393 if (!full && (opts->flags & PARSE_OPT_HIDDEN))
396 pos = fprintf(stderr, " ");
397 if (opts->short_name)
398 pos += fprintf(stderr, "-%c", opts->short_name);
399 if (opts->long_name && opts->short_name)
400 pos += fprintf(stderr, ", ");
402 pos += fprintf(stderr, "--%s", opts->long_name);
404 switch (opts->type) {
405 case OPTION_ARGUMENT:
408 if (opts->flags & PARSE_OPT_OPTARG)
410 pos += fprintf(stderr, "[=<n>]");
412 pos += fprintf(stderr, "[<n>]");
414 pos += fprintf(stderr, " <n>");
416 case OPTION_CALLBACK:
417 if (opts->flags & PARSE_OPT_NOARG)
422 if (opts->flags & PARSE_OPT_OPTARG)
424 pos += fprintf(stderr, "[=<%s>]", opts->argh);
426 pos += fprintf(stderr, "[<%s>]", opts->argh);
428 pos += fprintf(stderr, " <%s>", opts->argh);
430 if (opts->flags & PARSE_OPT_OPTARG)
432 pos += fprintf(stderr, "[=...]");
434 pos += fprintf(stderr, "[...]");
436 pos += fprintf(stderr, " ...");
439 default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
443 if (pos <= USAGE_OPTS_WIDTH)
444 pad = USAGE_OPTS_WIDTH - pos;
447 pad = USAGE_OPTS_WIDTH;
449 fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help);
453 return PARSE_OPT_HELP;
456 void usage_with_options(const char * const *usagestr,
457 const struct option *opts)
459 usage_with_options_internal(usagestr, opts, 0);
463 int parse_options_usage(const char * const *usagestr,
464 const struct option *opts)
466 return usage_with_options_internal(usagestr, opts, 0);
470 /*----- some often used options -----*/
473 int parse_opt_abbrev_cb(const struct option *opt, const char *arg, int unset)
478 v = unset ? 0 : DEFAULT_ABBREV;
480 v = strtol(arg, (char **)&arg, 10);
482 return opterror(opt, "expects a numerical value", 0);
483 if (v && v < MINIMUM_ABBREV)
488 *(int *)(opt->value) = v;
492 int parse_opt_approxidate_cb(const struct option *opt, const char *arg,
495 *(unsigned long *)(opt->value) = approxidate(arg);
499 int parse_opt_verbosity_cb(const struct option *opt, const char *arg,
502 int *target = opt->value;
505 /* --no-quiet, --no-verbose */
507 else if (opt->short_name == 'v') {
521 int parse_opt_with_commit(const struct option *opt, const char *arg, int unset)
523 unsigned char sha1[20];
524 struct commit *commit;
528 if (get_sha1(arg, sha1))
529 return error("malformed object name %s", arg);
530 commit = lookup_commit_reference(sha1);
532 return error("no such commit %s", arg);
533 commit_list_insert(commit, opt->value);
538 * This should really be OPTION_FILENAME type as a part of
539 * parse_options that take prefix to do this while parsing.
541 extern const char *parse_options_fix_filename(const char *prefix, const char *file)
543 if (!file || !prefix || is_absolute_path(file) || !strcmp("-", file))
545 return prefix_filename(prefix, strlen(prefix), file);