]> git.ipfire.org Git - thirdparty/git.git/blob - parse-options.c
Merge branch 'jk/clone-allow-bare-and-o-together'
[thirdparty/git.git] / parse-options.c
1 #include "git-compat-util.h"
2 #include "parse-options.h"
3 #include "cache.h"
4 #include "config.h"
5 #include "commit.h"
6 #include "color.h"
7 #include "utf8.h"
8
9 static int disallow_abbreviated_options;
10
11 enum opt_parsed {
12 OPT_LONG = 0,
13 OPT_SHORT = 1<<0,
14 OPT_UNSET = 1<<1,
15 };
16
17 static void optbug(const struct option *opt, const char *reason)
18 {
19 if (opt->long_name && opt->short_name)
20 bug("switch '%c' (--%s) %s", opt->short_name,
21 opt->long_name, reason);
22 else if (opt->long_name)
23 bug("option '%s' %s", opt->long_name, reason);
24 else
25 bug("switch '%c' %s", opt->short_name, reason);
26 }
27
28 static const char *optname(const struct option *opt, enum opt_parsed flags)
29 {
30 static struct strbuf sb = STRBUF_INIT;
31
32 strbuf_reset(&sb);
33 if (flags & OPT_SHORT)
34 strbuf_addf(&sb, "switch `%c'", opt->short_name);
35 else if (flags & OPT_UNSET)
36 strbuf_addf(&sb, "option `no-%s'", opt->long_name);
37 else if (flags == OPT_LONG)
38 strbuf_addf(&sb, "option `%s'", opt->long_name);
39 else
40 BUG("optname() got unknown flags %d", flags);
41
42 return sb.buf;
43 }
44
45 static enum parse_opt_result get_arg(struct parse_opt_ctx_t *p,
46 const struct option *opt,
47 enum opt_parsed flags, const char **arg)
48 {
49 if (p->opt) {
50 *arg = p->opt;
51 p->opt = NULL;
52 } else if (p->argc == 1 && (opt->flags & PARSE_OPT_LASTARG_DEFAULT)) {
53 *arg = (const char *)opt->defval;
54 } else if (p->argc > 1) {
55 p->argc--;
56 *arg = *++p->argv;
57 } else
58 return error(_("%s requires a value"), optname(opt, flags));
59 return 0;
60 }
61
62 static void fix_filename(const char *prefix, const char **file)
63 {
64 if (!file || !*file || !prefix || is_absolute_path(*file)
65 || !strcmp("-", *file))
66 return;
67 *file = prefix_filename(prefix, *file);
68 }
69
70 static enum parse_opt_result opt_command_mode_error(
71 const struct option *opt,
72 const struct option *all_opts,
73 enum opt_parsed flags)
74 {
75 const struct option *that;
76 struct strbuf that_name = STRBUF_INIT;
77
78 /*
79 * Find the other option that was used to set the variable
80 * already, and report that this is not compatible with it.
81 */
82 for (that = all_opts; that->type != OPTION_END; that++) {
83 if (that == opt ||
84 !(that->flags & PARSE_OPT_CMDMODE) ||
85 that->value != opt->value ||
86 that->defval != *(int *)opt->value)
87 continue;
88
89 if (that->long_name)
90 strbuf_addf(&that_name, "--%s", that->long_name);
91 else
92 strbuf_addf(&that_name, "-%c", that->short_name);
93 error(_("%s is incompatible with %s"),
94 optname(opt, flags), that_name.buf);
95 strbuf_release(&that_name);
96 return PARSE_OPT_ERROR;
97 }
98 return error(_("%s : incompatible with something else"),
99 optname(opt, flags));
100 }
101
102 static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
103 const struct option *opt,
104 const struct option *all_opts,
105 enum opt_parsed flags)
106 {
107 const char *s, *arg;
108 const int unset = flags & OPT_UNSET;
109 int err;
110
111 if (unset && p->opt)
112 return error(_("%s takes no value"), optname(opt, flags));
113 if (unset && (opt->flags & PARSE_OPT_NONEG))
114 return error(_("%s isn't available"), optname(opt, flags));
115 if (!(flags & OPT_SHORT) && p->opt && (opt->flags & PARSE_OPT_NOARG))
116 return error(_("%s takes no value"), optname(opt, flags));
117
118 /*
119 * Giving the same mode option twice, although unnecessary,
120 * is not a grave error, so let it pass.
121 */
122 if ((opt->flags & PARSE_OPT_CMDMODE) &&
123 *(int *)opt->value && *(int *)opt->value != opt->defval)
124 return opt_command_mode_error(opt, all_opts, flags);
125
126 switch (opt->type) {
127 case OPTION_LOWLEVEL_CALLBACK:
128 return opt->ll_callback(p, opt, NULL, unset);
129
130 case OPTION_BIT:
131 if (unset)
132 *(int *)opt->value &= ~opt->defval;
133 else
134 *(int *)opt->value |= opt->defval;
135 return 0;
136
137 case OPTION_NEGBIT:
138 if (unset)
139 *(int *)opt->value |= opt->defval;
140 else
141 *(int *)opt->value &= ~opt->defval;
142 return 0;
143
144 case OPTION_BITOP:
145 if (unset)
146 BUG("BITOP can't have unset form");
147 *(int *)opt->value &= ~opt->extra;
148 *(int *)opt->value |= opt->defval;
149 return 0;
150
151 case OPTION_COUNTUP:
152 if (*(int *)opt->value < 0)
153 *(int *)opt->value = 0;
154 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
155 return 0;
156
157 case OPTION_SET_INT:
158 *(int *)opt->value = unset ? 0 : opt->defval;
159 return 0;
160
161 case OPTION_STRING:
162 if (unset)
163 *(const char **)opt->value = NULL;
164 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
165 *(const char **)opt->value = (const char *)opt->defval;
166 else
167 return get_arg(p, opt, flags, (const char **)opt->value);
168 return 0;
169
170 case OPTION_FILENAME:
171 err = 0;
172 if (unset)
173 *(const char **)opt->value = NULL;
174 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
175 *(const char **)opt->value = (const char *)opt->defval;
176 else
177 err = get_arg(p, opt, flags, (const char **)opt->value);
178
179 if (!err)
180 fix_filename(p->prefix, (const char **)opt->value);
181 return err;
182
183 case OPTION_CALLBACK:
184 {
185 const char *p_arg = NULL;
186 int p_unset;
187
188 if (unset)
189 p_unset = 1;
190 else if (opt->flags & PARSE_OPT_NOARG)
191 p_unset = 0;
192 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
193 p_unset = 0;
194 else if (get_arg(p, opt, flags, &arg))
195 return -1;
196 else {
197 p_unset = 0;
198 p_arg = arg;
199 }
200 if (opt->callback)
201 return (*opt->callback)(opt, p_arg, p_unset) ? (-1) : 0;
202 else
203 return (*opt->ll_callback)(p, opt, p_arg, p_unset);
204 }
205 case OPTION_INTEGER:
206 if (unset) {
207 *(int *)opt->value = 0;
208 return 0;
209 }
210 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
211 *(int *)opt->value = opt->defval;
212 return 0;
213 }
214 if (get_arg(p, opt, flags, &arg))
215 return -1;
216 if (!*arg)
217 return error(_("%s expects a numerical value"),
218 optname(opt, flags));
219 *(int *)opt->value = strtol(arg, (char **)&s, 10);
220 if (*s)
221 return error(_("%s expects a numerical value"),
222 optname(opt, flags));
223 return 0;
224
225 case OPTION_MAGNITUDE:
226 if (unset) {
227 *(unsigned long *)opt->value = 0;
228 return 0;
229 }
230 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
231 *(unsigned long *)opt->value = opt->defval;
232 return 0;
233 }
234 if (get_arg(p, opt, flags, &arg))
235 return -1;
236 if (!git_parse_ulong(arg, opt->value))
237 return error(_("%s expects a non-negative integer value"
238 " with an optional k/m/g suffix"),
239 optname(opt, flags));
240 return 0;
241
242 default:
243 BUG("opt->type %d should not happen", opt->type);
244 }
245 }
246
247 static enum parse_opt_result parse_short_opt(struct parse_opt_ctx_t *p,
248 const struct option *options)
249 {
250 const struct option *all_opts = options;
251 const struct option *numopt = NULL;
252
253 for (; options->type != OPTION_END; options++) {
254 if (options->short_name == *p->opt) {
255 p->opt = p->opt[1] ? p->opt + 1 : NULL;
256 return get_value(p, options, all_opts, OPT_SHORT);
257 }
258
259 /*
260 * Handle the numerical option later, explicit one-digit
261 * options take precedence over it.
262 */
263 if (options->type == OPTION_NUMBER)
264 numopt = options;
265 }
266 if (numopt && isdigit(*p->opt)) {
267 size_t len = 1;
268 char *arg;
269 int rc;
270
271 while (isdigit(p->opt[len]))
272 len++;
273 arg = xmemdupz(p->opt, len);
274 p->opt = p->opt[len] ? p->opt + len : NULL;
275 if (numopt->callback)
276 rc = (*numopt->callback)(numopt, arg, 0) ? (-1) : 0;
277 else
278 rc = (*numopt->ll_callback)(p, numopt, arg, 0);
279 free(arg);
280 return rc;
281 }
282 return PARSE_OPT_UNKNOWN;
283 }
284
285 static int has_string(const char *it, const char **array)
286 {
287 while (*array)
288 if (!strcmp(it, *(array++)))
289 return 1;
290 return 0;
291 }
292
293 static int is_alias(struct parse_opt_ctx_t *ctx,
294 const struct option *one_opt,
295 const struct option *another_opt)
296 {
297 const char **group;
298
299 if (!ctx->alias_groups)
300 return 0;
301
302 if (!one_opt->long_name || !another_opt->long_name)
303 return 0;
304
305 for (group = ctx->alias_groups; *group; group += 3) {
306 /* it and other are from the same family? */
307 if (has_string(one_opt->long_name, group) &&
308 has_string(another_opt->long_name, group))
309 return 1;
310 }
311 return 0;
312 }
313
314 static enum parse_opt_result parse_long_opt(
315 struct parse_opt_ctx_t *p, const char *arg,
316 const struct option *options)
317 {
318 const struct option *all_opts = options;
319 const char *arg_end = strchrnul(arg, '=');
320 const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
321 enum opt_parsed abbrev_flags = OPT_LONG, ambiguous_flags = OPT_LONG;
322
323 for (; options->type != OPTION_END; options++) {
324 const char *rest, *long_name = options->long_name;
325 enum opt_parsed flags = OPT_LONG, opt_flags = OPT_LONG;
326
327 if (options->type == OPTION_SUBCOMMAND)
328 continue;
329 if (!long_name)
330 continue;
331
332 again:
333 if (!skip_prefix(arg, long_name, &rest))
334 rest = NULL;
335 if (!rest) {
336 /* abbreviated? */
337 if (!(p->flags & PARSE_OPT_KEEP_UNKNOWN_OPT) &&
338 !strncmp(long_name, arg, arg_end - arg)) {
339 is_abbreviated:
340 if (abbrev_option &&
341 !is_alias(p, abbrev_option, options)) {
342 /*
343 * If this is abbreviated, it is
344 * ambiguous. So when there is no
345 * exact match later, we need to
346 * error out.
347 */
348 ambiguous_option = abbrev_option;
349 ambiguous_flags = abbrev_flags;
350 }
351 if (!(flags & OPT_UNSET) && *arg_end)
352 p->opt = arg_end + 1;
353 abbrev_option = options;
354 abbrev_flags = flags ^ opt_flags;
355 continue;
356 }
357 /* negation allowed? */
358 if (options->flags & PARSE_OPT_NONEG)
359 continue;
360 /* negated and abbreviated very much? */
361 if (starts_with("no-", arg)) {
362 flags |= OPT_UNSET;
363 goto is_abbreviated;
364 }
365 /* negated? */
366 if (!starts_with(arg, "no-")) {
367 if (skip_prefix(long_name, "no-", &long_name)) {
368 opt_flags |= OPT_UNSET;
369 goto again;
370 }
371 continue;
372 }
373 flags |= OPT_UNSET;
374 if (!skip_prefix(arg + 3, long_name, &rest)) {
375 /* abbreviated and negated? */
376 if (starts_with(long_name, arg + 3))
377 goto is_abbreviated;
378 else
379 continue;
380 }
381 }
382 if (*rest) {
383 if (*rest != '=')
384 continue;
385 p->opt = rest + 1;
386 }
387 return get_value(p, options, all_opts, flags ^ opt_flags);
388 }
389
390 if (disallow_abbreviated_options && (ambiguous_option || abbrev_option))
391 die("disallowed abbreviated or ambiguous option '%.*s'",
392 (int)(arg_end - arg), arg);
393
394 if (ambiguous_option) {
395 error(_("ambiguous option: %s "
396 "(could be --%s%s or --%s%s)"),
397 arg,
398 (ambiguous_flags & OPT_UNSET) ? "no-" : "",
399 ambiguous_option->long_name,
400 (abbrev_flags & OPT_UNSET) ? "no-" : "",
401 abbrev_option->long_name);
402 return PARSE_OPT_HELP;
403 }
404 if (abbrev_option)
405 return get_value(p, abbrev_option, all_opts, abbrev_flags);
406 return PARSE_OPT_UNKNOWN;
407 }
408
409 static enum parse_opt_result parse_nodash_opt(struct parse_opt_ctx_t *p,
410 const char *arg,
411 const struct option *options)
412 {
413 const struct option *all_opts = options;
414
415 for (; options->type != OPTION_END; options++) {
416 if (!(options->flags & PARSE_OPT_NODASH))
417 continue;
418 if (options->short_name == arg[0] && arg[1] == '\0')
419 return get_value(p, options, all_opts, OPT_SHORT);
420 }
421 return PARSE_OPT_ERROR;
422 }
423
424 static enum parse_opt_result parse_subcommand(const char *arg,
425 const struct option *options)
426 {
427 for (; options->type != OPTION_END; options++)
428 if (options->type == OPTION_SUBCOMMAND &&
429 !strcmp(options->long_name, arg)) {
430 *(parse_opt_subcommand_fn **)options->value = options->subcommand_fn;
431 return PARSE_OPT_SUBCOMMAND;
432 }
433
434 return PARSE_OPT_UNKNOWN;
435 }
436
437 static void check_typos(const char *arg, const struct option *options)
438 {
439 if (strlen(arg) < 3)
440 return;
441
442 if (starts_with(arg, "no-")) {
443 error(_("did you mean `--%s` (with two dashes)?"), arg);
444 exit(129);
445 }
446
447 for (; options->type != OPTION_END; options++) {
448 if (!options->long_name)
449 continue;
450 if (starts_with(options->long_name, arg)) {
451 error(_("did you mean `--%s` (with two dashes)?"), arg);
452 exit(129);
453 }
454 }
455 }
456
457 static void parse_options_check(const struct option *opts)
458 {
459 char short_opts[128];
460 void *subcommand_value = NULL;
461
462 memset(short_opts, '\0', sizeof(short_opts));
463 for (; opts->type != OPTION_END; opts++) {
464 if ((opts->flags & PARSE_OPT_LASTARG_DEFAULT) &&
465 (opts->flags & PARSE_OPT_OPTARG))
466 optbug(opts, "uses incompatible flags "
467 "LASTARG_DEFAULT and OPTARG");
468 if (opts->short_name) {
469 if (0x7F <= opts->short_name)
470 optbug(opts, "invalid short name");
471 else if (short_opts[opts->short_name]++)
472 optbug(opts, "short name already used");
473 }
474 if (opts->flags & PARSE_OPT_NODASH &&
475 ((opts->flags & PARSE_OPT_OPTARG) ||
476 !(opts->flags & PARSE_OPT_NOARG) ||
477 !(opts->flags & PARSE_OPT_NONEG) ||
478 opts->long_name))
479 optbug(opts, "uses feature "
480 "not supported for dashless options");
481 switch (opts->type) {
482 case OPTION_COUNTUP:
483 case OPTION_BIT:
484 case OPTION_NEGBIT:
485 case OPTION_SET_INT:
486 case OPTION_NUMBER:
487 if ((opts->flags & PARSE_OPT_OPTARG) ||
488 !(opts->flags & PARSE_OPT_NOARG))
489 optbug(opts, "should not accept an argument");
490 break;
491 case OPTION_CALLBACK:
492 if (!opts->callback && !opts->ll_callback)
493 optbug(opts, "OPTION_CALLBACK needs one callback");
494 else if (opts->callback && opts->ll_callback)
495 optbug(opts, "OPTION_CALLBACK can't have two callbacks");
496 break;
497 case OPTION_LOWLEVEL_CALLBACK:
498 if (!opts->ll_callback)
499 optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs a callback");
500 if (opts->callback)
501 optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs no high level callback");
502 break;
503 case OPTION_ALIAS:
504 optbug(opts, "OPT_ALIAS() should not remain at this point. "
505 "Are you using parse_options_step() directly?\n"
506 "That case is not supported yet.");
507 break;
508 case OPTION_SUBCOMMAND:
509 if (!opts->value || !opts->subcommand_fn)
510 optbug(opts, "OPTION_SUBCOMMAND needs a value and a subcommand function");
511 if (!subcommand_value)
512 subcommand_value = opts->value;
513 else if (subcommand_value != opts->value)
514 optbug(opts, "all OPTION_SUBCOMMANDs need the same value");
515 break;
516 default:
517 ; /* ok. (usually accepts an argument) */
518 }
519 if (opts->argh &&
520 strcspn(opts->argh, " _") != strlen(opts->argh))
521 optbug(opts, "multi-word argh should use dash to separate words");
522 }
523 BUG_if_bug("invalid 'struct option'");
524 }
525
526 static int has_subcommands(const struct option *options)
527 {
528 for (; options->type != OPTION_END; options++)
529 if (options->type == OPTION_SUBCOMMAND)
530 return 1;
531 return 0;
532 }
533
534 static void parse_options_start_1(struct parse_opt_ctx_t *ctx,
535 int argc, const char **argv, const char *prefix,
536 const struct option *options,
537 enum parse_opt_flags flags)
538 {
539 ctx->argc = argc;
540 ctx->argv = argv;
541 if (!(flags & PARSE_OPT_ONE_SHOT)) {
542 ctx->argc--;
543 ctx->argv++;
544 }
545 ctx->total = ctx->argc;
546 ctx->out = argv;
547 ctx->prefix = prefix;
548 ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
549 ctx->flags = flags;
550 ctx->has_subcommands = has_subcommands(options);
551 if (!ctx->has_subcommands && (flags & PARSE_OPT_SUBCOMMAND_OPTIONAL))
552 BUG("Using PARSE_OPT_SUBCOMMAND_OPTIONAL without subcommands");
553 if (ctx->has_subcommands) {
554 if (flags & PARSE_OPT_STOP_AT_NON_OPTION)
555 BUG("subcommands are incompatible with PARSE_OPT_STOP_AT_NON_OPTION");
556 if (!(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
557 if (flags & PARSE_OPT_KEEP_UNKNOWN_OPT)
558 BUG("subcommands are incompatible with PARSE_OPT_KEEP_UNKNOWN_OPT unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
559 if (flags & PARSE_OPT_KEEP_DASHDASH)
560 BUG("subcommands are incompatible with PARSE_OPT_KEEP_DASHDASH unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
561 }
562 }
563 if ((flags & PARSE_OPT_KEEP_UNKNOWN_OPT) &&
564 (flags & PARSE_OPT_STOP_AT_NON_OPTION) &&
565 !(flags & PARSE_OPT_ONE_SHOT))
566 BUG("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
567 if ((flags & PARSE_OPT_ONE_SHOT) &&
568 (flags & PARSE_OPT_KEEP_ARGV0))
569 BUG("Can't keep argv0 if you don't have it");
570 parse_options_check(options);
571 }
572
573 void parse_options_start(struct parse_opt_ctx_t *ctx,
574 int argc, const char **argv, const char *prefix,
575 const struct option *options,
576 enum parse_opt_flags flags)
577 {
578 memset(ctx, 0, sizeof(*ctx));
579 parse_options_start_1(ctx, argc, argv, prefix, options, flags);
580 }
581
582 static void show_negated_gitcomp(const struct option *opts, int show_all,
583 int nr_noopts)
584 {
585 int printed_dashdash = 0;
586
587 for (; opts->type != OPTION_END; opts++) {
588 int has_unset_form = 0;
589 const char *name;
590
591 if (!opts->long_name)
592 continue;
593 if (!show_all &&
594 (opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE)))
595 continue;
596 if (opts->flags & PARSE_OPT_NONEG)
597 continue;
598
599 switch (opts->type) {
600 case OPTION_STRING:
601 case OPTION_FILENAME:
602 case OPTION_INTEGER:
603 case OPTION_MAGNITUDE:
604 case OPTION_CALLBACK:
605 case OPTION_BIT:
606 case OPTION_NEGBIT:
607 case OPTION_COUNTUP:
608 case OPTION_SET_INT:
609 has_unset_form = 1;
610 break;
611 default:
612 break;
613 }
614 if (!has_unset_form)
615 continue;
616
617 if (skip_prefix(opts->long_name, "no-", &name)) {
618 if (nr_noopts < 0)
619 printf(" --%s", name);
620 } else if (nr_noopts >= 0) {
621 if (nr_noopts && !printed_dashdash) {
622 printf(" --");
623 printed_dashdash = 1;
624 }
625 printf(" --no-%s", opts->long_name);
626 nr_noopts++;
627 }
628 }
629 }
630
631 static int show_gitcomp(const struct option *opts, int show_all)
632 {
633 const struct option *original_opts = opts;
634 int nr_noopts = 0;
635
636 for (; opts->type != OPTION_END; opts++) {
637 const char *prefix = "--";
638 const char *suffix = "";
639
640 if (!opts->long_name)
641 continue;
642 if (!show_all &&
643 (opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE | PARSE_OPT_FROM_ALIAS)))
644 continue;
645
646 switch (opts->type) {
647 case OPTION_SUBCOMMAND:
648 prefix = "";
649 break;
650 case OPTION_GROUP:
651 continue;
652 case OPTION_STRING:
653 case OPTION_FILENAME:
654 case OPTION_INTEGER:
655 case OPTION_MAGNITUDE:
656 case OPTION_CALLBACK:
657 if (opts->flags & PARSE_OPT_NOARG)
658 break;
659 if (opts->flags & PARSE_OPT_OPTARG)
660 break;
661 if (opts->flags & PARSE_OPT_LASTARG_DEFAULT)
662 break;
663 suffix = "=";
664 break;
665 default:
666 break;
667 }
668 if (opts->flags & PARSE_OPT_COMP_ARG)
669 suffix = "=";
670 if (starts_with(opts->long_name, "no-"))
671 nr_noopts++;
672 printf("%s%s%s%s", opts == original_opts ? "" : " ",
673 prefix, opts->long_name, suffix);
674 }
675 show_negated_gitcomp(original_opts, show_all, -1);
676 show_negated_gitcomp(original_opts, show_all, nr_noopts);
677 fputc('\n', stdout);
678 return PARSE_OPT_COMPLETE;
679 }
680
681 /*
682 * Scan and may produce a new option[] array, which should be used
683 * instead of the original 'options'.
684 *
685 * Right now this is only used to preprocess and substitute
686 * OPTION_ALIAS.
687 *
688 * The returned options should be freed using free_preprocessed_options.
689 */
690 static struct option *preprocess_options(struct parse_opt_ctx_t *ctx,
691 const struct option *options)
692 {
693 struct option *newopt;
694 int i, nr, alias;
695 int nr_aliases = 0;
696
697 for (nr = 0; options[nr].type != OPTION_END; nr++) {
698 if (options[nr].type == OPTION_ALIAS)
699 nr_aliases++;
700 }
701
702 if (!nr_aliases)
703 return NULL;
704
705 ALLOC_ARRAY(newopt, nr + 1);
706 COPY_ARRAY(newopt, options, nr + 1);
707
708 /* each alias has two string pointers and NULL */
709 CALLOC_ARRAY(ctx->alias_groups, 3 * (nr_aliases + 1));
710
711 for (alias = 0, i = 0; i < nr; i++) {
712 int short_name;
713 const char *long_name;
714 const char *source;
715 struct strbuf help = STRBUF_INIT;
716 int j;
717
718 if (newopt[i].type != OPTION_ALIAS)
719 continue;
720
721 short_name = newopt[i].short_name;
722 long_name = newopt[i].long_name;
723 source = newopt[i].value;
724
725 if (!long_name)
726 BUG("An alias must have long option name");
727 strbuf_addf(&help, _("alias of --%s"), source);
728
729 for (j = 0; j < nr; j++) {
730 const char *name = options[j].long_name;
731
732 if (!name || strcmp(name, source))
733 continue;
734
735 if (options[j].type == OPTION_ALIAS)
736 BUG("No please. Nested aliases are not supported.");
737
738 memcpy(newopt + i, options + j, sizeof(*newopt));
739 newopt[i].short_name = short_name;
740 newopt[i].long_name = long_name;
741 newopt[i].help = strbuf_detach(&help, NULL);
742 newopt[i].flags |= PARSE_OPT_FROM_ALIAS;
743 break;
744 }
745
746 if (j == nr)
747 BUG("could not find source option '%s' of alias '%s'",
748 source, newopt[i].long_name);
749 ctx->alias_groups[alias * 3 + 0] = newopt[i].long_name;
750 ctx->alias_groups[alias * 3 + 1] = options[j].long_name;
751 ctx->alias_groups[alias * 3 + 2] = NULL;
752 alias++;
753 }
754
755 return newopt;
756 }
757
758 static void free_preprocessed_options(struct option *options)
759 {
760 int i;
761
762 if (!options)
763 return;
764
765 for (i = 0; options[i].type != OPTION_END; i++) {
766 if (options[i].flags & PARSE_OPT_FROM_ALIAS)
767 free((void *)options[i].help);
768 }
769 free(options);
770 }
771
772 static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *,
773 const char * const *,
774 const struct option *,
775 int, int);
776
777 enum parse_opt_result parse_options_step(struct parse_opt_ctx_t *ctx,
778 const struct option *options,
779 const char * const usagestr[])
780 {
781 int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
782
783 /* we must reset ->opt, unknown short option leave it dangling */
784 ctx->opt = NULL;
785
786 for (; ctx->argc; ctx->argc--, ctx->argv++) {
787 const char *arg = ctx->argv[0];
788
789 if (ctx->flags & PARSE_OPT_ONE_SHOT &&
790 ctx->argc != ctx->total)
791 break;
792
793 if (*arg != '-' || !arg[1]) {
794 if (parse_nodash_opt(ctx, arg, options) == 0)
795 continue;
796 if (!ctx->has_subcommands) {
797 if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
798 return PARSE_OPT_NON_OPTION;
799 ctx->out[ctx->cpidx++] = ctx->argv[0];
800 continue;
801 }
802 switch (parse_subcommand(arg, options)) {
803 case PARSE_OPT_SUBCOMMAND:
804 return PARSE_OPT_SUBCOMMAND;
805 case PARSE_OPT_UNKNOWN:
806 if (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
807 /*
808 * arg is neither a short or long
809 * option nor a subcommand. Since
810 * this command has a default
811 * operation mode, we have to treat
812 * this arg and all remaining args
813 * as args meant to that default
814 * operation mode.
815 * So we are done parsing.
816 */
817 return PARSE_OPT_DONE;
818 error(_("unknown subcommand: `%s'"), arg);
819 usage_with_options(usagestr, options);
820 case PARSE_OPT_COMPLETE:
821 case PARSE_OPT_HELP:
822 case PARSE_OPT_ERROR:
823 case PARSE_OPT_DONE:
824 case PARSE_OPT_NON_OPTION:
825 /* Impossible. */
826 BUG("parse_subcommand() cannot return these");
827 }
828 }
829
830 /* lone -h asks for help */
831 if (internal_help && ctx->total == 1 && !strcmp(arg + 1, "h"))
832 goto show_usage;
833
834 /*
835 * lone --git-completion-helper and --git-completion-helper-all
836 * are asked by git-completion.bash
837 */
838 if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper"))
839 return show_gitcomp(options, 0);
840 if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper-all"))
841 return show_gitcomp(options, 1);
842
843 if (arg[1] != '-') {
844 ctx->opt = arg + 1;
845 switch (parse_short_opt(ctx, options)) {
846 case PARSE_OPT_ERROR:
847 return PARSE_OPT_ERROR;
848 case PARSE_OPT_UNKNOWN:
849 if (ctx->opt)
850 check_typos(arg + 1, options);
851 if (internal_help && *ctx->opt == 'h')
852 goto show_usage;
853 goto unknown;
854 case PARSE_OPT_NON_OPTION:
855 case PARSE_OPT_SUBCOMMAND:
856 case PARSE_OPT_HELP:
857 case PARSE_OPT_COMPLETE:
858 BUG("parse_short_opt() cannot return these");
859 case PARSE_OPT_DONE:
860 break;
861 }
862 if (ctx->opt)
863 check_typos(arg + 1, options);
864 while (ctx->opt) {
865 switch (parse_short_opt(ctx, options)) {
866 case PARSE_OPT_ERROR:
867 return PARSE_OPT_ERROR;
868 case PARSE_OPT_UNKNOWN:
869 if (internal_help && *ctx->opt == 'h')
870 goto show_usage;
871
872 /* fake a short option thing to hide the fact that we may have
873 * started to parse aggregated stuff
874 *
875 * This is leaky, too bad.
876 */
877 ctx->argv[0] = xstrdup(ctx->opt - 1);
878 *(char *)ctx->argv[0] = '-';
879 goto unknown;
880 case PARSE_OPT_NON_OPTION:
881 case PARSE_OPT_SUBCOMMAND:
882 case PARSE_OPT_COMPLETE:
883 case PARSE_OPT_HELP:
884 BUG("parse_short_opt() cannot return these");
885 case PARSE_OPT_DONE:
886 break;
887 }
888 }
889 continue;
890 }
891
892 if (!arg[2] /* "--" */ ||
893 !strcmp(arg + 2, "end-of-options")) {
894 if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
895 ctx->argc--;
896 ctx->argv++;
897 }
898 break;
899 }
900
901 if (internal_help && !strcmp(arg + 2, "help-all"))
902 return usage_with_options_internal(ctx, usagestr, options, 1, 0);
903 if (internal_help && !strcmp(arg + 2, "help"))
904 goto show_usage;
905 switch (parse_long_opt(ctx, arg + 2, options)) {
906 case PARSE_OPT_ERROR:
907 return PARSE_OPT_ERROR;
908 case PARSE_OPT_UNKNOWN:
909 goto unknown;
910 case PARSE_OPT_HELP:
911 goto show_usage;
912 case PARSE_OPT_NON_OPTION:
913 case PARSE_OPT_SUBCOMMAND:
914 case PARSE_OPT_COMPLETE:
915 BUG("parse_long_opt() cannot return these");
916 case PARSE_OPT_DONE:
917 break;
918 }
919 continue;
920 unknown:
921 if (ctx->flags & PARSE_OPT_ONE_SHOT)
922 break;
923 if (ctx->has_subcommands &&
924 (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL) &&
925 (ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)) {
926 /*
927 * Found an unknown option given to a command with
928 * subcommands that has a default operation mode:
929 * we treat this option and all remaining args as
930 * arguments meant to that default operation mode.
931 * So we are done parsing.
932 */
933 return PARSE_OPT_DONE;
934 }
935 if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT))
936 return PARSE_OPT_UNKNOWN;
937 ctx->out[ctx->cpidx++] = ctx->argv[0];
938 ctx->opt = NULL;
939 }
940 return PARSE_OPT_DONE;
941
942 show_usage:
943 return usage_with_options_internal(ctx, usagestr, options, 0, 0);
944 }
945
946 int parse_options_end(struct parse_opt_ctx_t *ctx)
947 {
948 if (ctx->flags & PARSE_OPT_ONE_SHOT)
949 return ctx->total - ctx->argc;
950
951 MOVE_ARRAY(ctx->out + ctx->cpidx, ctx->argv, ctx->argc);
952 ctx->out[ctx->cpidx + ctx->argc] = NULL;
953 return ctx->cpidx + ctx->argc;
954 }
955
956 int parse_options(int argc, const char **argv,
957 const char *prefix,
958 const struct option *options,
959 const char * const usagestr[],
960 enum parse_opt_flags flags)
961 {
962 struct parse_opt_ctx_t ctx;
963 struct option *real_options;
964
965 disallow_abbreviated_options =
966 git_env_bool("GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS", 0);
967
968 memset(&ctx, 0, sizeof(ctx));
969 real_options = preprocess_options(&ctx, options);
970 if (real_options)
971 options = real_options;
972 parse_options_start_1(&ctx, argc, argv, prefix, options, flags);
973 switch (parse_options_step(&ctx, options, usagestr)) {
974 case PARSE_OPT_HELP:
975 case PARSE_OPT_ERROR:
976 exit(129);
977 case PARSE_OPT_COMPLETE:
978 exit(0);
979 case PARSE_OPT_NON_OPTION:
980 case PARSE_OPT_SUBCOMMAND:
981 break;
982 case PARSE_OPT_DONE:
983 if (ctx.has_subcommands &&
984 !(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
985 error(_("need a subcommand"));
986 usage_with_options(usagestr, options);
987 }
988 break;
989 case PARSE_OPT_UNKNOWN:
990 if (ctx.argv[0][1] == '-') {
991 error(_("unknown option `%s'"), ctx.argv[0] + 2);
992 } else if (isascii(*ctx.opt)) {
993 error(_("unknown switch `%c'"), *ctx.opt);
994 } else {
995 error(_("unknown non-ascii option in string: `%s'"),
996 ctx.argv[0]);
997 }
998 usage_with_options(usagestr, options);
999 }
1000
1001 precompose_argv_prefix(argc, argv, NULL);
1002 free_preprocessed_options(real_options);
1003 free(ctx.alias_groups);
1004 return parse_options_end(&ctx);
1005 }
1006
1007 static int usage_argh(const struct option *opts, FILE *outfile)
1008 {
1009 const char *s;
1010 int literal = (opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1011 !opts->argh || !!strpbrk(opts->argh, "()<>[]|");
1012 if (opts->flags & PARSE_OPT_OPTARG)
1013 if (opts->long_name)
1014 s = literal ? "[=%s]" : "[=<%s>]";
1015 else
1016 s = literal ? "[%s]" : "[<%s>]";
1017 else
1018 s = literal ? " %s" : " <%s>";
1019 return utf8_fprintf(outfile, s, opts->argh ? _(opts->argh) : _("..."));
1020 }
1021
1022 #define USAGE_OPTS_WIDTH 24
1023 #define USAGE_GAP 2
1024
1025 static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *ctx,
1026 const char * const *usagestr,
1027 const struct option *opts,
1028 int full, int err)
1029 {
1030 FILE *outfile = err ? stderr : stdout;
1031 int need_newline;
1032
1033 const char *usage_prefix = _("usage: %s");
1034 /*
1035 * The translation could be anything, but we can count on
1036 * msgfmt(1)'s --check option to have asserted that "%s" is in
1037 * the translation. So compute the length of the "usage: "
1038 * part. We are assuming that the translator wasn't overly
1039 * clever and used e.g. "%1$s" instead of "%s", there's only
1040 * one "%s" in "usage_prefix" above, so there's no reason to
1041 * do so even with a RTL language.
1042 */
1043 size_t usage_len = strlen(usage_prefix) - strlen("%s");
1044 /*
1045 * TRANSLATORS: the colon here should align with the
1046 * one in "usage: %s" translation.
1047 */
1048 const char *or_prefix = _(" or: %s");
1049 /*
1050 * TRANSLATORS: You should only need to translate this format
1051 * string if your language is a RTL language (e.g. Arabic,
1052 * Hebrew etc.), not if it's a LTR language (e.g. German,
1053 * Russian, Chinese etc.).
1054 *
1055 * When a translated usage string has an embedded "\n" it's
1056 * because options have wrapped to the next line. The line
1057 * after the "\n" will then be padded to align with the
1058 * command name, such as N_("git cmd [opt]\n<8
1059 * spaces>[opt2]"), where the 8 spaces are the same length as
1060 * "git cmd ".
1061 *
1062 * This format string prints out that already-translated
1063 * line. The "%*s" is whitespace padding to account for the
1064 * padding at the start of the line that we add in this
1065 * function. The "%s" is a line in the (hopefully already
1066 * translated) N_() usage string, which contained embedded
1067 * newlines before we split it up.
1068 */
1069 const char *usage_continued = _("%*s%s");
1070 const char *prefix = usage_prefix;
1071 int saw_empty_line = 0;
1072
1073 if (!usagestr)
1074 return PARSE_OPT_HELP;
1075
1076 if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1077 fprintf(outfile, "cat <<\\EOF\n");
1078
1079 while (*usagestr) {
1080 const char *str = _(*usagestr++);
1081 struct string_list list = STRING_LIST_INIT_DUP;
1082 unsigned int j;
1083
1084 if (!saw_empty_line && !*str)
1085 saw_empty_line = 1;
1086
1087 string_list_split(&list, str, '\n', -1);
1088 for (j = 0; j < list.nr; j++) {
1089 const char *line = list.items[j].string;
1090
1091 if (saw_empty_line && *line)
1092 fprintf_ln(outfile, _(" %s"), line);
1093 else if (saw_empty_line)
1094 fputc('\n', outfile);
1095 else if (!j)
1096 fprintf_ln(outfile, prefix, line);
1097 else
1098 fprintf_ln(outfile, usage_continued,
1099 (int)usage_len, "", line);
1100 }
1101 string_list_clear(&list, 0);
1102
1103 prefix = or_prefix;
1104 }
1105
1106 need_newline = 1;
1107
1108 for (; opts->type != OPTION_END; opts++) {
1109 size_t pos;
1110 int pad;
1111
1112 if (opts->type == OPTION_SUBCOMMAND)
1113 continue;
1114 if (opts->type == OPTION_GROUP) {
1115 fputc('\n', outfile);
1116 need_newline = 0;
1117 if (*opts->help)
1118 fprintf(outfile, "%s\n", _(opts->help));
1119 continue;
1120 }
1121 if (!full && (opts->flags & PARSE_OPT_HIDDEN))
1122 continue;
1123
1124 if (need_newline) {
1125 fputc('\n', outfile);
1126 need_newline = 0;
1127 }
1128
1129 pos = fprintf(outfile, " ");
1130 if (opts->short_name) {
1131 if (opts->flags & PARSE_OPT_NODASH)
1132 pos += fprintf(outfile, "%c", opts->short_name);
1133 else
1134 pos += fprintf(outfile, "-%c", opts->short_name);
1135 }
1136 if (opts->long_name && opts->short_name)
1137 pos += fprintf(outfile, ", ");
1138 if (opts->long_name)
1139 pos += fprintf(outfile, "--%s", opts->long_name);
1140 if (opts->type == OPTION_NUMBER)
1141 pos += utf8_fprintf(outfile, _("-NUM"));
1142
1143 if ((opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1144 !(opts->flags & PARSE_OPT_NOARG))
1145 pos += usage_argh(opts, outfile);
1146
1147 if (pos <= USAGE_OPTS_WIDTH)
1148 pad = USAGE_OPTS_WIDTH - pos;
1149 else {
1150 fputc('\n', outfile);
1151 pad = USAGE_OPTS_WIDTH;
1152 }
1153 if (opts->type == OPTION_ALIAS) {
1154 fprintf(outfile, "%*s", pad + USAGE_GAP, "");
1155 fprintf_ln(outfile, _("alias of --%s"),
1156 (const char *)opts->value);
1157 continue;
1158 }
1159 fprintf(outfile, "%*s%s\n", pad + USAGE_GAP, "", _(opts->help));
1160 }
1161 fputc('\n', outfile);
1162
1163 if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1164 fputs("EOF\n", outfile);
1165
1166 return PARSE_OPT_HELP;
1167 }
1168
1169 void NORETURN usage_with_options(const char * const *usagestr,
1170 const struct option *opts)
1171 {
1172 usage_with_options_internal(NULL, usagestr, opts, 0, 1);
1173 exit(129);
1174 }
1175
1176 void NORETURN usage_msg_opt(const char *msg,
1177 const char * const *usagestr,
1178 const struct option *options)
1179 {
1180 die_message("%s\n", msg); /* The extra \n is intentional */
1181 usage_with_options(usagestr, options);
1182 }
1183
1184 void NORETURN usage_msg_optf(const char * const fmt,
1185 const char * const *usagestr,
1186 const struct option *options, ...)
1187 {
1188 struct strbuf msg = STRBUF_INIT;
1189 va_list ap;
1190 va_start(ap, options);
1191 strbuf_vaddf(&msg, fmt, ap);
1192 va_end(ap);
1193
1194 usage_msg_opt(msg.buf, usagestr, options);
1195 }
1196
1197 void die_for_incompatible_opt4(int opt1, const char *opt1_name,
1198 int opt2, const char *opt2_name,
1199 int opt3, const char *opt3_name,
1200 int opt4, const char *opt4_name)
1201 {
1202 int count = 0;
1203 const char *options[4];
1204
1205 if (opt1)
1206 options[count++] = opt1_name;
1207 if (opt2)
1208 options[count++] = opt2_name;
1209 if (opt3)
1210 options[count++] = opt3_name;
1211 if (opt4)
1212 options[count++] = opt4_name;
1213 switch (count) {
1214 case 4:
1215 die(_("options '%s', '%s', '%s', and '%s' cannot be used together"),
1216 opt1_name, opt2_name, opt3_name, opt4_name);
1217 break;
1218 case 3:
1219 die(_("options '%s', '%s', and '%s' cannot be used together"),
1220 options[0], options[1], options[2]);
1221 break;
1222 case 2:
1223 die(_("options '%s' and '%s' cannot be used together"),
1224 options[0], options[1]);
1225 break;
1226 default:
1227 break;
1228 }
1229 }