1 #include "git-compat-util.h"
2 #include "parse-options.h"
7 static int parse_options_usage(struct parse_opt_ctx_t
*ctx
,
8 const char * const *usagestr
,
9 const struct option
*opts
, int err
);
14 static int optbug(const struct option
*opt
, const char *reason
)
17 return error("BUG: option '%s' %s", opt
->long_name
, reason
);
18 return error("BUG: switch '%c' %s", opt
->short_name
, reason
);
21 static int opterror(const struct option
*opt
, const char *reason
, int flags
)
23 if (flags
& OPT_SHORT
)
24 return error("switch `%c' %s", opt
->short_name
, reason
);
25 if (flags
& OPT_UNSET
)
26 return error("option `no-%s' %s", opt
->long_name
, reason
);
27 return error("option `%s' %s", opt
->long_name
, reason
);
30 static int get_arg(struct parse_opt_ctx_t
*p
, const struct option
*opt
,
31 int flags
, const char **arg
)
36 } else if (p
->argc
== 1 && (opt
->flags
& PARSE_OPT_LASTARG_DEFAULT
)) {
37 *arg
= (const char *)opt
->defval
;
38 } else if (p
->argc
> 1) {
42 return opterror(opt
, "requires a value", flags
);
46 static void fix_filename(const char *prefix
, const char **file
)
48 if (!file
|| !*file
|| !prefix
|| is_absolute_path(*file
)
49 || !strcmp("-", *file
))
51 *file
= xstrdup(prefix_filename(prefix
, strlen(prefix
), *file
));
54 static int get_value(struct parse_opt_ctx_t
*p
,
55 const struct option
*opt
, int flags
)
58 const int unset
= flags
& OPT_UNSET
;
62 return opterror(opt
, "takes no value", flags
);
63 if (unset
&& (opt
->flags
& PARSE_OPT_NONEG
))
64 return opterror(opt
, "isn't available", flags
);
65 if (!(flags
& OPT_SHORT
) && p
->opt
&& (opt
->flags
& PARSE_OPT_NOARG
))
66 return opterror(opt
, "takes no value", flags
);
69 case OPTION_LOWLEVEL_CALLBACK
:
70 return (*(parse_opt_ll_cb
*)opt
->callback
)(p
, opt
, unset
);
74 *(int *)opt
->value
&= ~opt
->defval
;
76 *(int *)opt
->value
|= opt
->defval
;
81 *(int *)opt
->value
|= opt
->defval
;
83 *(int *)opt
->value
&= ~opt
->defval
;
87 *(int *)opt
->value
= unset
? 0 : *(int *)opt
->value
+ 1;
91 *(int *)opt
->value
= unset
? 0 : opt
->defval
;
95 *(void **)opt
->value
= unset
? NULL
: (void *)opt
->defval
;
100 *(const char **)opt
->value
= NULL
;
101 else if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
)
102 *(const char **)opt
->value
= (const char *)opt
->defval
;
104 return get_arg(p
, opt
, flags
, (const char **)opt
->value
);
107 case OPTION_FILENAME
:
110 *(const char **)opt
->value
= NULL
;
111 else if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
)
112 *(const char **)opt
->value
= (const char *)opt
->defval
;
114 err
= get_arg(p
, opt
, flags
, (const char **)opt
->value
);
117 fix_filename(p
->prefix
, (const char **)opt
->value
);
120 case OPTION_CALLBACK
:
122 return (*opt
->callback
)(opt
, NULL
, 1) ? (-1) : 0;
123 if (opt
->flags
& PARSE_OPT_NOARG
)
124 return (*opt
->callback
)(opt
, NULL
, 0) ? (-1) : 0;
125 if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
)
126 return (*opt
->callback
)(opt
, NULL
, 0) ? (-1) : 0;
127 if (get_arg(p
, opt
, flags
, &arg
))
129 return (*opt
->callback
)(opt
, arg
, 0) ? (-1) : 0;
133 *(int *)opt
->value
= 0;
136 if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
) {
137 *(int *)opt
->value
= opt
->defval
;
140 if (get_arg(p
, opt
, flags
, &arg
))
142 *(int *)opt
->value
= strtol(arg
, (char **)&s
, 10);
144 return opterror(opt
, "expects a numerical value", flags
);
148 die("should not happen, someone must be hit on the forehead");
152 static int parse_short_opt(struct parse_opt_ctx_t
*p
, const struct option
*options
)
154 const struct option
*numopt
= NULL
;
156 for (; options
->type
!= OPTION_END
; options
++) {
157 if (options
->short_name
== *p
->opt
) {
158 p
->opt
= p
->opt
[1] ? p
->opt
+ 1 : NULL
;
159 return get_value(p
, options
, OPT_SHORT
);
163 * Handle the numerical option later, explicit one-digit
164 * options take precedence over it.
166 if (options
->type
== OPTION_NUMBER
)
169 if (numopt
&& isdigit(*p
->opt
)) {
174 while (isdigit(p
->opt
[len
]))
176 arg
= xmemdupz(p
->opt
, len
);
177 p
->opt
= p
->opt
[len
] ? p
->opt
+ len
: NULL
;
178 rc
= (*numopt
->callback
)(numopt
, arg
, 0) ? (-1) : 0;
185 static int parse_long_opt(struct parse_opt_ctx_t
*p
, const char *arg
,
186 const struct option
*options
)
188 const char *arg_end
= strchr(arg
, '=');
189 const struct option
*abbrev_option
= NULL
, *ambiguous_option
= NULL
;
190 int abbrev_flags
= 0, ambiguous_flags
= 0;
193 arg_end
= arg
+ strlen(arg
);
195 for (; options
->type
!= OPTION_END
; options
++) {
199 if (!options
->long_name
)
202 rest
= skip_prefix(arg
, options
->long_name
);
203 if (options
->type
== OPTION_ARGUMENT
) {
207 return opterror(options
, "takes no value", flags
);
210 p
->out
[p
->cpidx
++] = arg
- 2;
215 if (!strncmp(options
->long_name
, arg
, arg_end
- arg
)) {
219 * If this is abbreviated, it is
220 * ambiguous. So when there is no
221 * exact match later, we need to
224 ambiguous_option
= abbrev_option
;
225 ambiguous_flags
= abbrev_flags
;
227 if (!(flags
& OPT_UNSET
) && *arg_end
)
228 p
->opt
= arg_end
+ 1;
229 abbrev_option
= options
;
230 abbrev_flags
= flags
;
233 /* negation allowed? */
234 if (options
->flags
& PARSE_OPT_NONEG
)
236 /* negated and abbreviated very much? */
237 if (!prefixcmp("no-", arg
)) {
242 if (strncmp(arg
, "no-", 3))
245 rest
= skip_prefix(arg
+ 3, options
->long_name
);
246 /* abbreviated and negated? */
247 if (!rest
&& !prefixcmp(options
->long_name
, arg
+ 3))
257 return get_value(p
, options
, flags
);
260 if (ambiguous_option
)
261 return error("Ambiguous option: %s "
262 "(could be --%s%s or --%s%s)",
264 (ambiguous_flags
& OPT_UNSET
) ? "no-" : "",
265 ambiguous_option
->long_name
,
266 (abbrev_flags
& OPT_UNSET
) ? "no-" : "",
267 abbrev_option
->long_name
);
269 return get_value(p
, abbrev_option
, abbrev_flags
);
273 static int parse_nodash_opt(struct parse_opt_ctx_t
*p
, const char *arg
,
274 const struct option
*options
)
276 for (; options
->type
!= OPTION_END
; options
++) {
277 if (!(options
->flags
& PARSE_OPT_NODASH
))
279 if (options
->short_name
== arg
[0] && arg
[1] == '\0')
280 return get_value(p
, options
, OPT_SHORT
);
285 static void check_typos(const char *arg
, const struct option
*options
)
290 if (!prefixcmp(arg
, "no-")) {
291 error ("did you mean `--%s` (with two dashes ?)", arg
);
295 for (; options
->type
!= OPTION_END
; options
++) {
296 if (!options
->long_name
)
298 if (!prefixcmp(options
->long_name
, arg
)) {
299 error ("did you mean `--%s` (with two dashes ?)", arg
);
305 static void parse_options_check(const struct option
*opts
)
309 for (; opts
->type
!= OPTION_END
; opts
++) {
310 if ((opts
->flags
& PARSE_OPT_LASTARG_DEFAULT
) &&
311 (opts
->flags
& PARSE_OPT_OPTARG
))
312 err
|= optbug(opts
, "uses incompatible flags "
313 "LASTARG_DEFAULT and OPTARG");
314 if (opts
->flags
& PARSE_OPT_NODASH
&&
315 ((opts
->flags
& PARSE_OPT_OPTARG
) ||
316 !(opts
->flags
& PARSE_OPT_NOARG
) ||
317 !(opts
->flags
& PARSE_OPT_NONEG
) ||
319 err
|= optbug(opts
, "uses feature "
320 "not supported for dashless options");
321 switch (opts
->type
) {
328 if ((opts
->flags
& PARSE_OPT_OPTARG
) ||
329 !(opts
->flags
& PARSE_OPT_NOARG
))
330 err
|= optbug(opts
, "should not accept an argument");
332 ; /* ok. (usually accepts an argument) */
339 void parse_options_start(struct parse_opt_ctx_t
*ctx
,
340 int argc
, const char **argv
, const char *prefix
,
341 const struct option
*options
, int flags
)
343 memset(ctx
, 0, sizeof(*ctx
));
344 ctx
->argc
= argc
- 1;
345 ctx
->argv
= argv
+ 1;
347 ctx
->prefix
= prefix
;
348 ctx
->cpidx
= ((flags
& PARSE_OPT_KEEP_ARGV0
) != 0);
350 if ((flags
& PARSE_OPT_KEEP_UNKNOWN
) &&
351 (flags
& PARSE_OPT_STOP_AT_NON_OPTION
))
352 die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
353 parse_options_check(options
);
356 static int usage_with_options_internal(struct parse_opt_ctx_t
*,
357 const char * const *,
358 const struct option
*, int, int);
360 int parse_options_step(struct parse_opt_ctx_t
*ctx
,
361 const struct option
*options
,
362 const char * const usagestr
[])
364 int internal_help
= !(ctx
->flags
& PARSE_OPT_NO_INTERNAL_HELP
);
366 /* we must reset ->opt, unknown short option leave it dangling */
369 for (; ctx
->argc
; ctx
->argc
--, ctx
->argv
++) {
370 const char *arg
= ctx
->argv
[0];
372 if (*arg
!= '-' || !arg
[1]) {
373 if (parse_nodash_opt(ctx
, arg
, options
) == 0)
375 if (ctx
->flags
& PARSE_OPT_STOP_AT_NON_OPTION
)
376 return PARSE_OPT_NON_OPTION
;
377 ctx
->out
[ctx
->cpidx
++] = ctx
->argv
[0];
383 if (internal_help
&& *ctx
->opt
== 'h')
384 return parse_options_usage(ctx
, usagestr
, options
, 0);
385 switch (parse_short_opt(ctx
, options
)) {
387 return parse_options_usage(ctx
, usagestr
, options
, 1);
392 check_typos(arg
+ 1, options
);
394 if (internal_help
&& *ctx
->opt
== 'h')
395 return parse_options_usage(ctx
, usagestr
, options
, 0);
396 switch (parse_short_opt(ctx
, options
)) {
398 return parse_options_usage(ctx
, usagestr
, options
, 1);
400 /* fake a short option thing to hide the fact that we may have
401 * started to parse aggregated stuff
403 * This is leaky, too bad.
405 ctx
->argv
[0] = xstrdup(ctx
->opt
- 1);
406 *(char *)ctx
->argv
[0] = '-';
413 if (!arg
[2]) { /* "--" */
414 if (!(ctx
->flags
& PARSE_OPT_KEEP_DASHDASH
)) {
421 if (internal_help
&& !strcmp(arg
+ 2, "help-all"))
422 return usage_with_options_internal(ctx
, usagestr
, options
, 1, 0);
423 if (internal_help
&& !strcmp(arg
+ 2, "help"))
424 return parse_options_usage(ctx
, usagestr
, options
, 0);
425 switch (parse_long_opt(ctx
, arg
+ 2, options
)) {
427 return parse_options_usage(ctx
, usagestr
, options
, 1);
433 if (!(ctx
->flags
& PARSE_OPT_KEEP_UNKNOWN
))
434 return PARSE_OPT_UNKNOWN
;
435 ctx
->out
[ctx
->cpidx
++] = ctx
->argv
[0];
438 return PARSE_OPT_DONE
;
441 int parse_options_end(struct parse_opt_ctx_t
*ctx
)
443 memmove(ctx
->out
+ ctx
->cpidx
, ctx
->argv
, ctx
->argc
* sizeof(*ctx
->out
));
444 ctx
->out
[ctx
->cpidx
+ ctx
->argc
] = NULL
;
445 return ctx
->cpidx
+ ctx
->argc
;
448 int parse_options(int argc
, const char **argv
, const char *prefix
,
449 const struct option
*options
, const char * const usagestr
[],
452 struct parse_opt_ctx_t ctx
;
454 parse_options_start(&ctx
, argc
, argv
, prefix
, options
, flags
);
455 switch (parse_options_step(&ctx
, options
, usagestr
)) {
458 case PARSE_OPT_NON_OPTION
:
461 default: /* PARSE_OPT_UNKNOWN */
462 if (ctx
.argv
[0][1] == '-') {
463 error("unknown option `%s'", ctx
.argv
[0] + 2);
465 error("unknown switch `%c'", *ctx
.opt
);
467 usage_with_options(usagestr
, options
);
470 return parse_options_end(&ctx
);
473 static int usage_argh(const struct option
*opts
, FILE *outfile
)
476 int literal
= (opts
->flags
& PARSE_OPT_LITERAL_ARGHELP
) || !opts
->argh
;
477 if (opts
->flags
& PARSE_OPT_OPTARG
)
479 s
= literal
? "[=%s]" : "[=<%s>]";
481 s
= literal
? "[%s]" : "[<%s>]";
483 s
= literal
? " %s" : " <%s>";
484 return fprintf(outfile
, s
, opts
->argh
? opts
->argh
: "...");
487 #define USAGE_OPTS_WIDTH 24
490 static int usage_with_options_internal(struct parse_opt_ctx_t
*ctx
,
491 const char * const *usagestr
,
492 const struct option
*opts
, int full
, int err
)
494 FILE *outfile
= err
? stderr
: stdout
;
497 return PARSE_OPT_HELP
;
499 if (!err
&& ctx
&& ctx
->flags
& PARSE_OPT_SHELL_EVAL
)
500 fprintf(outfile
, "cat <<\\EOF\n");
502 fprintf(outfile
, "usage: %s\n", *usagestr
++);
503 while (*usagestr
&& **usagestr
)
504 fprintf(outfile
, " or: %s\n", *usagestr
++);
506 fprintf(outfile
, "%s%s\n",
507 **usagestr
? " " : "",
512 if (opts
->type
!= OPTION_GROUP
)
513 fputc('\n', outfile
);
515 for (; opts
->type
!= OPTION_END
; opts
++) {
519 if (opts
->type
== OPTION_GROUP
) {
520 fputc('\n', outfile
);
522 fprintf(outfile
, "%s\n", opts
->help
);
525 if (!full
&& (opts
->flags
& PARSE_OPT_HIDDEN
))
528 pos
= fprintf(outfile
, " ");
529 if (opts
->short_name
&& !(opts
->flags
& PARSE_OPT_NEGHELP
)) {
530 if (opts
->flags
& PARSE_OPT_NODASH
)
531 pos
+= fprintf(outfile
, "%c", opts
->short_name
);
533 pos
+= fprintf(outfile
, "-%c", opts
->short_name
);
535 if (opts
->long_name
&& opts
->short_name
)
536 pos
+= fprintf(outfile
, ", ");
538 pos
+= fprintf(outfile
, "--%s%s",
539 (opts
->flags
& PARSE_OPT_NEGHELP
) ? "no-" : "",
541 if (opts
->type
== OPTION_NUMBER
)
542 pos
+= fprintf(outfile
, "-NUM");
544 if ((opts
->flags
& PARSE_OPT_LITERAL_ARGHELP
) ||
545 !(opts
->flags
& PARSE_OPT_NOARG
))
546 pos
+= usage_argh(opts
, outfile
);
548 if (pos
<= USAGE_OPTS_WIDTH
)
549 pad
= USAGE_OPTS_WIDTH
- pos
;
551 fputc('\n', outfile
);
552 pad
= USAGE_OPTS_WIDTH
;
554 fprintf(outfile
, "%*s%s\n", pad
+ USAGE_GAP
, "", opts
->help
);
556 fputc('\n', outfile
);
558 if (!err
&& ctx
&& ctx
->flags
& PARSE_OPT_SHELL_EVAL
)
559 fputs("EOF\n", outfile
);
561 return PARSE_OPT_HELP
;
564 void NORETURN
usage_with_options(const char * const *usagestr
,
565 const struct option
*opts
)
567 usage_with_options_internal(NULL
, usagestr
, opts
, 0, 1);
571 void NORETURN
usage_msg_opt(const char *msg
,
572 const char * const *usagestr
,
573 const struct option
*options
)
575 fprintf(stderr
, "%s\n\n", msg
);
576 usage_with_options(usagestr
, options
);
579 static int parse_options_usage(struct parse_opt_ctx_t
*ctx
,
580 const char * const *usagestr
,
581 const struct option
*opts
, int err
)
583 return usage_with_options_internal(ctx
, usagestr
, opts
, 0, err
);
587 /*----- some often used options -----*/
590 int parse_opt_abbrev_cb(const struct option
*opt
, const char *arg
, int unset
)
595 v
= unset
? 0 : DEFAULT_ABBREV
;
597 v
= strtol(arg
, (char **)&arg
, 10);
599 return opterror(opt
, "expects a numerical value", 0);
600 if (v
&& v
< MINIMUM_ABBREV
)
605 *(int *)(opt
->value
) = v
;
609 int parse_opt_approxidate_cb(const struct option
*opt
, const char *arg
,
612 *(unsigned long *)(opt
->value
) = approxidate(arg
);
616 int parse_opt_color_flag_cb(const struct option
*opt
, const char *arg
,
622 arg
= unset
? "never" : (const char *)opt
->defval
;
623 value
= git_config_colorbool(NULL
, arg
, -1);
626 "expects \"always\", \"auto\", or \"never\"", 0);
627 *(int *)opt
->value
= value
;
631 int parse_opt_verbosity_cb(const struct option
*opt
, const char *arg
,
634 int *target
= opt
->value
;
637 /* --no-quiet, --no-verbose */
639 else if (opt
->short_name
== 'v') {
653 int parse_opt_with_commit(const struct option
*opt
, const char *arg
, int unset
)
655 unsigned char sha1
[20];
656 struct commit
*commit
;
660 if (get_sha1(arg
, sha1
))
661 return error("malformed object name %s", arg
);
662 commit
= lookup_commit_reference(sha1
);
664 return error("no such commit %s", arg
);
665 commit_list_insert(commit
, opt
->value
);
669 int parse_opt_tertiary(const struct option
*opt
, const char *arg
, int unset
)
671 int *target
= opt
->value
;
672 *target
= unset
? 2 : 1;
676 int parse_options_concat(struct option
*dst
, size_t dst_size
, struct option
*src
)
680 for (i
= 0; i
< dst_size
; i
++)
681 if (dst
[i
].type
== OPTION_END
)
683 for (j
= 0; i
< dst_size
; i
++, j
++) {
685 if (src
[j
].type
== OPTION_END
)