git

1
#include "git-compat-util.h"
2
#include "parse-options.h"
3
#include "abspath.h"
4
#include "parse.h"
5
#include "gettext.h"
6
#include "strbuf.h"
7
#include "string-list.h"
8
#include "utf8.h"
9

10
static int disallow_abbreviated_options;
11

12
enum opt_parsed {
13
	OPT_LONG  = 0,
14
	OPT_SHORT = 1<<0,
15
	OPT_UNSET = 1<<1,
16
};
17

18
static void optbug(const struct option *opt, const char *reason)
19
{
20
	if (opt->long_name && opt->short_name)
21
		bug("switch '%c' (--%s) %s", opt->short_name,
22
		    opt->long_name, reason);
23
	else if (opt->long_name)
24
		bug("option '%s' %s", opt->long_name, reason);
25
	else
26
		bug("switch '%c' %s", opt->short_name, reason);
27
}
28

29
static const char *optname(const struct option *opt, enum opt_parsed flags)
30
{
31
	static struct strbuf sb = STRBUF_INIT;
32

33
	strbuf_reset(&sb);
34
	if (flags & OPT_SHORT)
35
		strbuf_addf(&sb, "switch `%c'", opt->short_name);
36
	else if (flags & OPT_UNSET)
37
		strbuf_addf(&sb, "option `no-%s'", opt->long_name);
38
	else if (flags == OPT_LONG)
39
		strbuf_addf(&sb, "option `%s'", opt->long_name);
40
	else
41
		BUG("optname() got unknown flags %d", flags);
42

43
	return sb.buf;
44
}
45

46
static enum parse_opt_result get_arg(struct parse_opt_ctx_t *p,
47
				     const struct option *opt,
48
				     enum opt_parsed flags, const char **arg)
49
{
50
	if (p->opt) {
51
		*arg = p->opt;
52
		p->opt = NULL;
53
	} else if (p->argc == 1 && (opt->flags & PARSE_OPT_LASTARG_DEFAULT)) {
54
		*arg = (const char *)opt->defval;
55
	} else if (p->argc > 1) {
56
		p->argc--;
57
		*arg = *++p->argv;
58
	} else
59
		return error(_("%s requires a value"), optname(opt, flags));
60
	return 0;
61
}
62

63
static void fix_filename(const char *prefix, char **file)
64
{
65
	if (!file || !*file)
66
		; /* leave as NULL */
67
	else
68
		*file = prefix_filename_except_for_dash(prefix, *file);
69
}
70

71
static enum parse_opt_result do_get_value(struct parse_opt_ctx_t *p,
72
					  const struct option *opt,
73
					  enum opt_parsed flags,
74
					  const char **argp)
75
{
76
	const char *s, *arg;
77
	const int unset = flags & OPT_UNSET;
78
	int err;
79

80
	if (unset && p->opt)
81
		return error(_("%s takes no value"), optname(opt, flags));
82
	if (unset && (opt->flags & PARSE_OPT_NONEG))
83
		return error(_("%s isn't available"), optname(opt, flags));
84
	if (!(flags & OPT_SHORT) && p->opt && (opt->flags & PARSE_OPT_NOARG))
85
		return error(_("%s takes no value"), optname(opt, flags));
86

87
	switch (opt->type) {
88
	case OPTION_LOWLEVEL_CALLBACK:
89
		return opt->ll_callback(p, opt, NULL, unset);
90

91
	case OPTION_BIT:
92
		if (unset)
93
			*(int *)opt->value &= ~opt->defval;
94
		else
95
			*(int *)opt->value |= opt->defval;
96
		return 0;
97

98
	case OPTION_NEGBIT:
99
		if (unset)
100
			*(int *)opt->value |= opt->defval;
101
		else
102
			*(int *)opt->value &= ~opt->defval;
103
		return 0;
104

105
	case OPTION_BITOP:
106
		if (unset)
107
			BUG("BITOP can't have unset form");
108
		*(int *)opt->value &= ~opt->extra;
109
		*(int *)opt->value |= opt->defval;
110
		return 0;
111

112
	case OPTION_COUNTUP:
113
		if (*(int *)opt->value < 0)
114
			*(int *)opt->value = 0;
115
		*(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
116
		return 0;
117

118
	case OPTION_SET_INT:
119
		*(int *)opt->value = unset ? 0 : opt->defval;
120
		return 0;
121

122
	case OPTION_STRING:
123
		if (unset)
124
			*(const char **)opt->value = NULL;
125
		else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
126
			*(const char **)opt->value = (const char *)opt->defval;
127
		else
128
			return get_arg(p, opt, flags, (const char **)opt->value);
129
		return 0;
130

131
	case OPTION_FILENAME:
132
		err = 0;
133
		if (unset)
134
			*(const char **)opt->value = NULL;
135
		else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
136
			*(const char **)opt->value = (const char *)opt->defval;
137
		else
138
			err = get_arg(p, opt, flags, (const char **)opt->value);
139

140
		if (!err)
141
			fix_filename(p->prefix, (char **)opt->value);
142
		return err;
143

144
	case OPTION_CALLBACK:
145
	{
146
		const char *p_arg = NULL;
147
		int p_unset;
148

149
		if (unset)
150
			p_unset = 1;
151
		else if (opt->flags & PARSE_OPT_NOARG)
152
			p_unset = 0;
153
		else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
154
			p_unset = 0;
155
		else if (get_arg(p, opt, flags, &arg))
156
			return -1;
157
		else {
158
			p_unset = 0;
159
			p_arg = arg;
160
		}
161
		if (opt->flags & PARSE_OPT_CMDMODE)
162
			*argp = p_arg;
163
		if (opt->callback)
164
			return (*opt->callback)(opt, p_arg, p_unset) ? (-1) : 0;
165
		else
166
			return (*opt->ll_callback)(p, opt, p_arg, p_unset);
167
	}
168
	case OPTION_INTEGER:
169
		if (unset) {
170
			*(int *)opt->value = 0;
171
			return 0;
172
		}
173
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
174
			*(int *)opt->value = opt->defval;
175
			return 0;
176
		}
177
		if (get_arg(p, opt, flags, &arg))
178
			return -1;
179
		if (!*arg)
180
			return error(_("%s expects a numerical value"),
181
				     optname(opt, flags));
182
		*(int *)opt->value = strtol(arg, (char **)&s, 10);
183
		if (*s)
184
			return error(_("%s expects a numerical value"),
185
				     optname(opt, flags));
186
		return 0;
187

188
	case OPTION_MAGNITUDE:
189
		if (unset) {
190
			*(unsigned long *)opt->value = 0;
191
			return 0;
192
		}
193
		if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
194
			*(unsigned long *)opt->value = opt->defval;
195
			return 0;
196
		}
197
		if (get_arg(p, opt, flags, &arg))
198
			return -1;
199
		if (!git_parse_ulong(arg, opt->value))
200
			return error(_("%s expects a non-negative integer value"
201
				       " with an optional k/m/g suffix"),
202
				     optname(opt, flags));
203
		return 0;
204

205
	default:
206
		BUG("opt->type %d should not happen", opt->type);
207
	}
208
}
209

210
struct parse_opt_cmdmode_list {
211
	int value, *value_ptr;
212
	const struct option *opt;
213
	const char *arg;
214
	enum opt_parsed flags;
215
	struct parse_opt_cmdmode_list *next;
216
};
217

218
static void build_cmdmode_list(struct parse_opt_ctx_t *ctx,
219
			       const struct option *opts)
220
{
221
	ctx->cmdmode_list = NULL;
222

223
	for (; opts->type != OPTION_END; opts++) {
224
		struct parse_opt_cmdmode_list *elem = ctx->cmdmode_list;
225
		int *value_ptr = opts->value;
226

227
		if (!(opts->flags & PARSE_OPT_CMDMODE) || !value_ptr)
228
			continue;
229

230
		while (elem && elem->value_ptr != value_ptr)
231
			elem = elem->next;
232
		if (elem)
233
			continue;
234

235
		CALLOC_ARRAY(elem, 1);
236
		elem->value_ptr = value_ptr;
237
		elem->value = *value_ptr;
238
		elem->next = ctx->cmdmode_list;
239
		ctx->cmdmode_list = elem;
240
	}
241
}
242

243
static char *optnamearg(const struct option *opt, const char *arg,
244
			enum opt_parsed flags)
245
{
246
	if (flags & OPT_SHORT)
247
		return xstrfmt("-%c%s", opt->short_name, arg ? arg : "");
248
	return xstrfmt("--%s%s%s%s", flags & OPT_UNSET ? "no-" : "",
249
		       opt->long_name, arg ? "=" : "", arg ? arg : "");
250
}
251

252
static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
253
				       const struct option *opt,
254
				       enum opt_parsed flags)
255
{
256
	const char *arg = NULL;
257
	enum parse_opt_result result = do_get_value(p, opt, flags, &arg);
258
	struct parse_opt_cmdmode_list *elem = p->cmdmode_list;
259
	char *opt_name, *other_opt_name;
260

261
	for (; elem; elem = elem->next) {
262
		if (*elem->value_ptr == elem->value)
263
			continue;
264

265
		if (elem->opt &&
266
		    (elem->opt->flags | opt->flags) & PARSE_OPT_CMDMODE)
267
			break;
268

269
		elem->opt = opt;
270
		elem->arg = arg;
271
		elem->flags = flags;
272
		elem->value = *elem->value_ptr;
273
	}
274

275
	if (result || !elem)
276
		return result;
277

278
	opt_name = optnamearg(opt, arg, flags);
279
	other_opt_name = optnamearg(elem->opt, elem->arg, elem->flags);
280
	error(_("options '%s' and '%s' cannot be used together"),
281
	      opt_name, other_opt_name);
282
	free(opt_name);
283
	free(other_opt_name);
284
	return -1;
285
}
286

287
static enum parse_opt_result parse_short_opt(struct parse_opt_ctx_t *p,
288
					     const struct option *options)
289
{
290
	const struct option *numopt = NULL;
291

292
	for (; options->type != OPTION_END; options++) {
293
		if (options->short_name == *p->opt) {
294
			p->opt = p->opt[1] ? p->opt + 1 : NULL;
295
			return get_value(p, options, OPT_SHORT);
296
		}
297

298
		/*
299
		 * Handle the numerical option later, explicit one-digit
300
		 * options take precedence over it.
301
		 */
302
		if (options->type == OPTION_NUMBER)
303
			numopt = options;
304
	}
305
	if (numopt && isdigit(*p->opt)) {
306
		size_t len = 1;
307
		char *arg;
308
		int rc;
309

310
		while (isdigit(p->opt[len]))
311
			len++;
312
		arg = xmemdupz(p->opt, len);
313
		p->opt = p->opt[len] ? p->opt + len : NULL;
314
		if (numopt->callback)
315
			rc = (*numopt->callback)(numopt, arg, 0) ? (-1) : 0;
316
		else
317
			rc = (*numopt->ll_callback)(p, numopt, arg, 0);
318
		free(arg);
319
		return rc;
320
	}
321
	return PARSE_OPT_UNKNOWN;
322
}
323

324
static int has_string(const char *it, const char **array)
325
{
326
	while (*array)
327
		if (!strcmp(it, *(array++)))
328
			return 1;
329
	return 0;
330
}
331

332
static int is_alias(struct parse_opt_ctx_t *ctx,
333
		    const struct option *one_opt,
334
		    const struct option *another_opt)
335
{
336
	const char **group;
337

338
	if (!ctx->alias_groups)
339
		return 0;
340

341
	if (!one_opt->long_name || !another_opt->long_name)
342
		return 0;
343

344
	for (group = ctx->alias_groups; *group; group += 3) {
345
		/* it and other are from the same family? */
346
		if (has_string(one_opt->long_name, group) &&
347
		    has_string(another_opt->long_name, group))
348
			return 1;
349
	}
350
	return 0;
351
}
352

353
struct parsed_option {
354
	const struct option *option;
355
	enum opt_parsed flags;
356
};
357

358
static void register_abbrev(struct parse_opt_ctx_t *p,
359
			    const struct option *option, enum opt_parsed flags,
360
			    struct parsed_option *abbrev,
361
			    struct parsed_option *ambiguous)
362
{
363
	if (p->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)
364
		return;
365
	if (abbrev->option &&
366
	    !(abbrev->flags == flags && is_alias(p, abbrev->option, option))) {
367
		/*
368
		 * If this is abbreviated, it is
369
		 * ambiguous. So when there is no
370
		 * exact match later, we need to
371
		 * error out.
372
		 */
373
		ambiguous->option = abbrev->option;
374
		ambiguous->flags = abbrev->flags;
375
	}
376
	abbrev->option = option;
377
	abbrev->flags = flags;
378
}
379

380
static enum parse_opt_result parse_long_opt(
381
	struct parse_opt_ctx_t *p, const char *arg,
382
	const struct option *options)
383
{
384
	const char *arg_end = strchrnul(arg, '=');
385
	const char *arg_start = arg;
386
	enum opt_parsed flags = OPT_LONG;
387
	int arg_starts_with_no_no = 0;
388
	struct parsed_option abbrev = { .option = NULL, .flags = OPT_LONG };
389
	struct parsed_option ambiguous = { .option = NULL, .flags = OPT_LONG };
390

391
	if (skip_prefix(arg_start, "no-", &arg_start)) {
392
		if (skip_prefix(arg_start, "no-", &arg_start))
393
			arg_starts_with_no_no = 1;
394
		else
395
			flags |= OPT_UNSET;
396
	}
397

398
	for (; options->type != OPTION_END; options++) {
399
		const char *rest, *long_name = options->long_name;
400
		enum opt_parsed opt_flags = OPT_LONG;
401
		int allow_unset = !(options->flags & PARSE_OPT_NONEG);
402

403
		if (options->type == OPTION_SUBCOMMAND)
404
			continue;
405
		if (!long_name)
406
			continue;
407

408
		if (skip_prefix(long_name, "no-", &long_name))
409
			opt_flags |= OPT_UNSET;
410
		else if (arg_starts_with_no_no)
411
			continue;
412

413
		if (((flags ^ opt_flags) & OPT_UNSET) && !allow_unset)
414
			continue;
415

416
		if (skip_prefix(arg_start, long_name, &rest)) {
417
			if (*rest == '=')
418
				p->opt = rest + 1;
419
			else if (*rest)
420
				continue;
421
			return get_value(p, options, flags ^ opt_flags);
422
		}
423

424
		/* abbreviated? */
425
		if (!strncmp(long_name, arg_start, arg_end - arg_start))
426
			register_abbrev(p, options, flags ^ opt_flags,
427
					&abbrev, &ambiguous);
428

429
		/* negated and abbreviated very much? */
430
		if (allow_unset && starts_with("no-", arg))
431
			register_abbrev(p, options, OPT_UNSET ^ opt_flags,
432
					&abbrev, &ambiguous);
433
	}
434

435
	if (disallow_abbreviated_options && (ambiguous.option || abbrev.option))
436
		die("disallowed abbreviated or ambiguous option '%.*s'",
437
		    (int)(arg_end - arg), arg);
438

439
	if (ambiguous.option) {
440
		error(_("ambiguous option: %s "
441
			"(could be --%s%s or --%s%s)"),
442
			arg,
443
			(ambiguous.flags & OPT_UNSET) ?  "no-" : "",
444
			ambiguous.option->long_name,
445
			(abbrev.flags & OPT_UNSET) ?  "no-" : "",
446
			abbrev.option->long_name);
447
		return PARSE_OPT_HELP;
448
	}
449
	if (abbrev.option) {
450
		if (*arg_end)
451
			p->opt = arg_end + 1;
452
		return get_value(p, abbrev.option, abbrev.flags);
453
	}
454
	return PARSE_OPT_UNKNOWN;
455
}
456

457
static enum parse_opt_result parse_nodash_opt(struct parse_opt_ctx_t *p,
458
					      const char *arg,
459
					      const struct option *options)
460
{
461
	for (; options->type != OPTION_END; options++) {
462
		if (!(options->flags & PARSE_OPT_NODASH))
463
			continue;
464
		if (options->short_name == arg[0] && arg[1] == '\0')
465
			return get_value(p, options, OPT_SHORT);
466
	}
467
	return PARSE_OPT_ERROR;
468
}
469

470
static enum parse_opt_result parse_subcommand(const char *arg,
471
					      const struct option *options)
472
{
473
	for (; options->type != OPTION_END; options++)
474
		if (options->type == OPTION_SUBCOMMAND &&
475
		    !strcmp(options->long_name, arg)) {
476
			*(parse_opt_subcommand_fn **)options->value = options->subcommand_fn;
477
			return PARSE_OPT_SUBCOMMAND;
478
		}
479

480
	return PARSE_OPT_UNKNOWN;
481
}
482

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

488
	if (starts_with(arg, "no-")) {
489
		error(_("did you mean `--%s` (with two dashes)?"), arg);
490
		exit(129);
491
	}
492

493
	for (; options->type != OPTION_END; options++) {
494
		if (!options->long_name)
495
			continue;
496
		if (starts_with(options->long_name, arg)) {
497
			error(_("did you mean `--%s` (with two dashes)?"), arg);
498
			exit(129);
499
		}
500
	}
501
}
502

503
static void parse_options_check(const struct option *opts)
504
{
505
	char short_opts[128];
506
	void *subcommand_value = NULL;
507

508
	memset(short_opts, '\0', sizeof(short_opts));
509
	for (; opts->type != OPTION_END; opts++) {
510
		if ((opts->flags & PARSE_OPT_LASTARG_DEFAULT) &&
511
		    (opts->flags & PARSE_OPT_OPTARG))
512
			optbug(opts, "uses incompatible flags "
513
			       "LASTARG_DEFAULT and OPTARG");
514
		if (opts->short_name) {
515
			if (0x7F <= opts->short_name)
516
				optbug(opts, "invalid short name");
517
			else if (short_opts[opts->short_name]++)
518
				optbug(opts, "short name already used");
519
		}
520
		if (opts->flags & PARSE_OPT_NODASH &&
521
		    ((opts->flags & PARSE_OPT_OPTARG) ||
522
		     !(opts->flags & PARSE_OPT_NOARG) ||
523
		     !(opts->flags & PARSE_OPT_NONEG) ||
524
		     opts->long_name))
525
			optbug(opts, "uses feature "
526
			       "not supported for dashless options");
527
		if (opts->type == OPTION_SET_INT && !opts->defval &&
528
		    opts->long_name && !(opts->flags & PARSE_OPT_NONEG))
529
			optbug(opts, "OPTION_SET_INT 0 should not be negatable");
530
		switch (opts->type) {
531
		case OPTION_COUNTUP:
532
		case OPTION_BIT:
533
		case OPTION_NEGBIT:
534
		case OPTION_SET_INT:
535
		case OPTION_NUMBER:
536
			if ((opts->flags & PARSE_OPT_OPTARG) ||
537
			    !(opts->flags & PARSE_OPT_NOARG))
538
				optbug(opts, "should not accept an argument");
539
			break;
540
		case OPTION_CALLBACK:
541
			if (!opts->callback && !opts->ll_callback)
542
				optbug(opts, "OPTION_CALLBACK needs one callback");
543
			else if (opts->callback && opts->ll_callback)
544
				optbug(opts, "OPTION_CALLBACK can't have two callbacks");
545
			break;
546
		case OPTION_LOWLEVEL_CALLBACK:
547
			if (!opts->ll_callback)
548
				optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs a callback");
549
			if (opts->callback)
550
				optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs no high level callback");
551
			break;
552
		case OPTION_ALIAS:
553
			optbug(opts, "OPT_ALIAS() should not remain at this point. "
554
			       "Are you using parse_options_step() directly?\n"
555
			       "That case is not supported yet.");
556
			break;
557
		case OPTION_SUBCOMMAND:
558
			if (!opts->value || !opts->subcommand_fn)
559
				optbug(opts, "OPTION_SUBCOMMAND needs a value and a subcommand function");
560
			if (!subcommand_value)
561
				subcommand_value = opts->value;
562
			else if (subcommand_value != opts->value)
563
				optbug(opts, "all OPTION_SUBCOMMANDs need the same value");
564
			break;
565
		default:
566
			; /* ok. (usually accepts an argument) */
567
		}
568
		if (opts->argh &&
569
		    strcspn(opts->argh, " _") != strlen(opts->argh))
570
			optbug(opts, "multi-word argh should use dash to separate words");
571
	}
572
	BUG_if_bug("invalid 'struct option'");
573
}
574

575
static int has_subcommands(const struct option *options)
576
{
577
	for (; options->type != OPTION_END; options++)
578
		if (options->type == OPTION_SUBCOMMAND)
579
			return 1;
580
	return 0;
581
}
582

583
static void parse_options_start_1(struct parse_opt_ctx_t *ctx,
584
				  int argc, const char **argv, const char *prefix,
585
				  const struct option *options,
586
				  enum parse_opt_flags flags)
587
{
588
	ctx->argc = argc;
589
	ctx->argv = argv;
590
	if (!(flags & PARSE_OPT_ONE_SHOT)) {
591
		ctx->argc--;
592
		ctx->argv++;
593
	}
594
	ctx->total = ctx->argc;
595
	ctx->out   = argv;
596
	ctx->prefix = prefix;
597
	ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
598
	ctx->flags = flags;
599
	ctx->has_subcommands = has_subcommands(options);
600
	if (!ctx->has_subcommands && (flags & PARSE_OPT_SUBCOMMAND_OPTIONAL))
601
		BUG("Using PARSE_OPT_SUBCOMMAND_OPTIONAL without subcommands");
602
	if (ctx->has_subcommands) {
603
		if (flags & PARSE_OPT_STOP_AT_NON_OPTION)
604
			BUG("subcommands are incompatible with PARSE_OPT_STOP_AT_NON_OPTION");
605
		if (!(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
606
			if (flags & PARSE_OPT_KEEP_UNKNOWN_OPT)
607
				BUG("subcommands are incompatible with PARSE_OPT_KEEP_UNKNOWN_OPT unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
608
			if (flags & PARSE_OPT_KEEP_DASHDASH)
609
				BUG("subcommands are incompatible with PARSE_OPT_KEEP_DASHDASH unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
610
		}
611
	}
612
	if ((flags & PARSE_OPT_KEEP_UNKNOWN_OPT) &&
613
	    (flags & PARSE_OPT_STOP_AT_NON_OPTION) &&
614
	    !(flags & PARSE_OPT_ONE_SHOT))
615
		BUG("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
616
	if ((flags & PARSE_OPT_ONE_SHOT) &&
617
	    (flags & PARSE_OPT_KEEP_ARGV0))
618
		BUG("Can't keep argv0 if you don't have it");
619
	parse_options_check(options);
620
	build_cmdmode_list(ctx, options);
621
}
622

623
void parse_options_start(struct parse_opt_ctx_t *ctx,
624
			 int argc, const char **argv, const char *prefix,
625
			 const struct option *options,
626
			 enum parse_opt_flags flags)
627
{
628
	memset(ctx, 0, sizeof(*ctx));
629
	parse_options_start_1(ctx, argc, argv, prefix, options, flags);
630
}
631

632
static void show_negated_gitcomp(const struct option *opts, int show_all,
633
				 int nr_noopts)
634
{
635
	int printed_dashdash = 0;
636

637
	for (; opts->type != OPTION_END; opts++) {
638
		int has_unset_form = 0;
639
		const char *name;
640

641
		if (!opts->long_name)
642
			continue;
643
		if (!show_all &&
644
			(opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE)))
645
			continue;
646
		if (opts->flags & PARSE_OPT_NONEG)
647
			continue;
648

649
		switch (opts->type) {
650
		case OPTION_STRING:
651
		case OPTION_FILENAME:
652
		case OPTION_INTEGER:
653
		case OPTION_MAGNITUDE:
654
		case OPTION_CALLBACK:
655
		case OPTION_BIT:
656
		case OPTION_NEGBIT:
657
		case OPTION_COUNTUP:
658
		case OPTION_SET_INT:
659
			has_unset_form = 1;
660
			break;
661
		default:
662
			break;
663
		}
664
		if (!has_unset_form)
665
			continue;
666

667
		if (skip_prefix(opts->long_name, "no-", &name)) {
668
			if (nr_noopts < 0)
669
				printf(" --%s", name);
670
		} else if (nr_noopts >= 0) {
671
			if (nr_noopts && !printed_dashdash) {
672
				printf(" --");
673
				printed_dashdash = 1;
674
			}
675
			printf(" --no-%s", opts->long_name);
676
			nr_noopts++;
677
		}
678
	}
679
}
680

681
static int show_gitcomp(const struct option *opts, int show_all)
682
{
683
	const struct option *original_opts = opts;
684
	int nr_noopts = 0;
685

686
	for (; opts->type != OPTION_END; opts++) {
687
		const char *prefix = "--";
688
		const char *suffix = "";
689

690
		if (!opts->long_name)
691
			continue;
692
		if (!show_all &&
693
			(opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE | PARSE_OPT_FROM_ALIAS)))
694
			continue;
695

696
		switch (opts->type) {
697
		case OPTION_SUBCOMMAND:
698
			prefix = "";
699
			break;
700
		case OPTION_GROUP:
701
			continue;
702
		case OPTION_STRING:
703
		case OPTION_FILENAME:
704
		case OPTION_INTEGER:
705
		case OPTION_MAGNITUDE:
706
		case OPTION_CALLBACK:
707
			if (opts->flags & PARSE_OPT_NOARG)
708
				break;
709
			if (opts->flags & PARSE_OPT_OPTARG)
710
				break;
711
			if (opts->flags & PARSE_OPT_LASTARG_DEFAULT)
712
				break;
713
			suffix = "=";
714
			break;
715
		default:
716
			break;
717
		}
718
		if (opts->flags & PARSE_OPT_COMP_ARG)
719
			suffix = "=";
720
		if (starts_with(opts->long_name, "no-"))
721
			nr_noopts++;
722
		printf("%s%s%s%s", opts == original_opts ? "" : " ",
723
		       prefix, opts->long_name, suffix);
724
	}
725
	show_negated_gitcomp(original_opts, show_all, -1);
726
	show_negated_gitcomp(original_opts, show_all, nr_noopts);
727
	fputc('\n', stdout);
728
	return PARSE_OPT_COMPLETE;
729
}
730

731
/*
732
 * Scan and may produce a new option[] array, which should be used
733
 * instead of the original 'options'.
734
 *
735
 * Right now this is only used to preprocess and substitute
736
 * OPTION_ALIAS.
737
 *
738
 * The returned options should be freed using free_preprocessed_options.
739
 */
740
static struct option *preprocess_options(struct parse_opt_ctx_t *ctx,
741
					 const struct option *options)
742
{
743
	struct option *newopt;
744
	int i, nr, alias;
745
	int nr_aliases = 0;
746

747
	for (nr = 0; options[nr].type != OPTION_END; nr++) {
748
		if (options[nr].type == OPTION_ALIAS)
749
			nr_aliases++;
750
	}
751

752
	if (!nr_aliases)
753
		return NULL;
754

755
	DUP_ARRAY(newopt, options, nr + 1);
756

757
	/* each alias has two string pointers and NULL */
758
	CALLOC_ARRAY(ctx->alias_groups, 3 * (nr_aliases + 1));
759

760
	for (alias = 0, i = 0; i < nr; i++) {
761
		int short_name;
762
		const char *long_name;
763
		const char *source;
764
		struct strbuf help = STRBUF_INIT;
765
		int j;
766

767
		if (newopt[i].type != OPTION_ALIAS)
768
			continue;
769

770
		short_name = newopt[i].short_name;
771
		long_name = newopt[i].long_name;
772
		source = newopt[i].value;
773

774
		if (!long_name)
775
			BUG("An alias must have long option name");
776
		strbuf_addf(&help, _("alias of --%s"), source);
777

778
		for (j = 0; j < nr; j++) {
779
			const char *name = options[j].long_name;
780

781
			if (!name || strcmp(name, source))
782
				continue;
783

784
			if (options[j].type == OPTION_ALIAS)
785
				BUG("No please. Nested aliases are not supported.");
786

787
			memcpy(newopt + i, options + j, sizeof(*newopt));
788
			newopt[i].short_name = short_name;
789
			newopt[i].long_name = long_name;
790
			newopt[i].help = strbuf_detach(&help, NULL);
791
			newopt[i].flags |= PARSE_OPT_FROM_ALIAS;
792
			break;
793
		}
794

795
		if (j == nr)
796
			BUG("could not find source option '%s' of alias '%s'",
797
			    source, newopt[i].long_name);
798
		ctx->alias_groups[alias * 3 + 0] = newopt[i].long_name;
799
		ctx->alias_groups[alias * 3 + 1] = options[j].long_name;
800
		ctx->alias_groups[alias * 3 + 2] = NULL;
801
		alias++;
802
	}
803

804
	return newopt;
805
}
806

807
static void free_preprocessed_options(struct option *options)
808
{
809
	int i;
810

811
	if (!options)
812
		return;
813

814
	for (i = 0; options[i].type != OPTION_END; i++) {
815
		if (options[i].flags & PARSE_OPT_FROM_ALIAS)
816
			free((void *)options[i].help);
817
	}
818
	free(options);
819
}
820

821
static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *,
822
							 const char * const *,
823
							 const struct option *,
824
							 int, int);
825

826
enum parse_opt_result parse_options_step(struct parse_opt_ctx_t *ctx,
827
					 const struct option *options,
828
					 const char * const usagestr[])
829
{
830
	int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
831

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

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

838
		if (ctx->flags & PARSE_OPT_ONE_SHOT &&
839
		    ctx->argc != ctx->total)
840
			break;
841

842
		if (*arg != '-' || !arg[1]) {
843
			if (parse_nodash_opt(ctx, arg, options) == 0)
844
				continue;
845
			if (!ctx->has_subcommands) {
846
				if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
847
					return PARSE_OPT_NON_OPTION;
848
				ctx->out[ctx->cpidx++] = ctx->argv[0];
849
				continue;
850
			}
851
			switch (parse_subcommand(arg, options)) {
852
			case PARSE_OPT_SUBCOMMAND:
853
				return PARSE_OPT_SUBCOMMAND;
854
			case PARSE_OPT_UNKNOWN:
855
				if (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
856
					/*
857
					 * arg is neither a short or long
858
					 * option nor a subcommand.  Since
859
					 * this command has a default
860
					 * operation mode, we have to treat
861
					 * this arg and all remaining args
862
					 * as args meant to that default
863
					 * operation mode.
864
					 * So we are done parsing.
865
					 */
866
					return PARSE_OPT_DONE;
867
				error(_("unknown subcommand: `%s'"), arg);
868
				usage_with_options(usagestr, options);
869
			case PARSE_OPT_COMPLETE:
870
			case PARSE_OPT_HELP:
871
			case PARSE_OPT_ERROR:
872
			case PARSE_OPT_DONE:
873
			case PARSE_OPT_NON_OPTION:
874
				/* Impossible. */
875
				BUG("parse_subcommand() cannot return these");
876
			}
877
		}
878

879
		/* lone -h asks for help */
880
		if (internal_help && ctx->total == 1 && !strcmp(arg + 1, "h"))
881
			goto show_usage;
882

883
		/*
884
		 * lone --git-completion-helper and --git-completion-helper-all
885
		 * are asked by git-completion.bash
886
		 */
887
		if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper"))
888
			return show_gitcomp(options, 0);
889
		if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper-all"))
890
			return show_gitcomp(options, 1);
891

892
		if (arg[1] != '-') {
893
			ctx->opt = arg + 1;
894
			switch (parse_short_opt(ctx, options)) {
895
			case PARSE_OPT_ERROR:
896
				return PARSE_OPT_ERROR;
897
			case PARSE_OPT_UNKNOWN:
898
				if (ctx->opt)
899
					check_typos(arg + 1, options);
900
				if (internal_help && *ctx->opt == 'h')
901
					goto show_usage;
902
				goto unknown;
903
			case PARSE_OPT_NON_OPTION:
904
			case PARSE_OPT_SUBCOMMAND:
905
			case PARSE_OPT_HELP:
906
			case PARSE_OPT_COMPLETE:
907
				BUG("parse_short_opt() cannot return these");
908
			case PARSE_OPT_DONE:
909
				break;
910
			}
911
			if (ctx->opt)
912
				check_typos(arg + 1, options);
913
			while (ctx->opt) {
914
				switch (parse_short_opt(ctx, options)) {
915
				case PARSE_OPT_ERROR:
916
					return PARSE_OPT_ERROR;
917
				case PARSE_OPT_UNKNOWN:
918
					if (internal_help && *ctx->opt == 'h')
919
						goto show_usage;
920

921
					/* fake a short option thing to hide the fact that we may have
922
					 * started to parse aggregated stuff
923
					 *
924
					 * This is leaky, too bad.
925
					 */
926
					ctx->argv[0] = xstrdup(ctx->opt - 1);
927
					*(char *)ctx->argv[0] = '-';
928
					goto unknown;
929
				case PARSE_OPT_NON_OPTION:
930
				case PARSE_OPT_SUBCOMMAND:
931
				case PARSE_OPT_COMPLETE:
932
				case PARSE_OPT_HELP:
933
					BUG("parse_short_opt() cannot return these");
934
				case PARSE_OPT_DONE:
935
					break;
936
				}
937
			}
938
			continue;
939
		}
940

941
		if (!arg[2] /* "--" */) {
942
			if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
943
				ctx->argc--;
944
				ctx->argv++;
945
			}
946
			break;
947
		} else if (!strcmp(arg + 2, "end-of-options")) {
948
			if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)) {
949
				ctx->argc--;
950
				ctx->argv++;
951
			}
952
			break;
953
		}
954

955
		if (internal_help && !strcmp(arg + 2, "help-all"))
956
			return usage_with_options_internal(ctx, usagestr, options, 1, 0);
957
		if (internal_help && !strcmp(arg + 2, "help"))
958
			goto show_usage;
959
		switch (parse_long_opt(ctx, arg + 2, options)) {
960
		case PARSE_OPT_ERROR:
961
			return PARSE_OPT_ERROR;
962
		case PARSE_OPT_UNKNOWN:
963
			goto unknown;
964
		case PARSE_OPT_HELP:
965
			goto show_usage;
966
		case PARSE_OPT_NON_OPTION:
967
		case PARSE_OPT_SUBCOMMAND:
968
		case PARSE_OPT_COMPLETE:
969
			BUG("parse_long_opt() cannot return these");
970
		case PARSE_OPT_DONE:
971
			break;
972
		}
973
		continue;
974
unknown:
975
		if (ctx->flags & PARSE_OPT_ONE_SHOT)
976
			break;
977
		if (ctx->has_subcommands &&
978
		    (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL) &&
979
		    (ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)) {
980
			/*
981
			 * Found an unknown option given to a command with
982
			 * subcommands that has a default operation mode:
983
			 * we treat this option and all remaining args as
984
			 * arguments meant to that default operation mode.
985
			 * So we are done parsing.
986
			 */
987
			return PARSE_OPT_DONE;
988
		}
989
		if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT))
990
			return PARSE_OPT_UNKNOWN;
991
		ctx->out[ctx->cpidx++] = ctx->argv[0];
992
		ctx->opt = NULL;
993
	}
994
	return PARSE_OPT_DONE;
995

996
 show_usage:
997
	return usage_with_options_internal(ctx, usagestr, options, 0, 0);
998
}
999

1000
int parse_options_end(struct parse_opt_ctx_t *ctx)
1001
{
1002
	if (ctx->flags & PARSE_OPT_ONE_SHOT)
1003
		return ctx->total - ctx->argc;
1004

1005
	MOVE_ARRAY(ctx->out + ctx->cpidx, ctx->argv, ctx->argc);
1006
	ctx->out[ctx->cpidx + ctx->argc] = NULL;
1007
	return ctx->cpidx + ctx->argc;
1008
}
1009

1010
int parse_options(int argc, const char **argv,
1011
		  const char *prefix,
1012
		  const struct option *options,
1013
		  const char * const usagestr[],
1014
		  enum parse_opt_flags flags)
1015
{
1016
	struct parse_opt_ctx_t ctx;
1017
	struct option *real_options;
1018

1019
	disallow_abbreviated_options =
1020
		git_env_bool("GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS", 0);
1021

1022
	memset(&ctx, 0, sizeof(ctx));
1023
	real_options = preprocess_options(&ctx, options);
1024
	if (real_options)
1025
		options = real_options;
1026
	parse_options_start_1(&ctx, argc, argv, prefix, options, flags);
1027
	switch (parse_options_step(&ctx, options, usagestr)) {
1028
	case PARSE_OPT_HELP:
1029
	case PARSE_OPT_ERROR:
1030
		exit(129);
1031
	case PARSE_OPT_COMPLETE:
1032
		exit(0);
1033
	case PARSE_OPT_NON_OPTION:
1034
	case PARSE_OPT_SUBCOMMAND:
1035
		break;
1036
	case PARSE_OPT_DONE:
1037
		if (ctx.has_subcommands &&
1038
		    !(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
1039
			error(_("need a subcommand"));
1040
			usage_with_options(usagestr, options);
1041
		}
1042
		break;
1043
	case PARSE_OPT_UNKNOWN:
1044
		if (ctx.argv[0][1] == '-') {
1045
			error(_("unknown option `%s'"), ctx.argv[0] + 2);
1046
		} else if (isascii(*ctx.opt)) {
1047
			error(_("unknown switch `%c'"), *ctx.opt);
1048
		} else {
1049
			error(_("unknown non-ascii option in string: `%s'"),
1050
			      ctx.argv[0]);
1051
		}
1052
		usage_with_options(usagestr, options);
1053
	}
1054

1055
	precompose_argv_prefix(argc, argv, NULL);
1056
	free_preprocessed_options(real_options);
1057
	free(ctx.alias_groups);
1058
	for (struct parse_opt_cmdmode_list *elem = ctx.cmdmode_list; elem;) {
1059
		struct parse_opt_cmdmode_list *next = elem->next;
1060
		free(elem);
1061
		elem = next;
1062
	}
1063
	return parse_options_end(&ctx);
1064
}
1065

1066
static int usage_argh(const struct option *opts, FILE *outfile)
1067
{
1068
	const char *s;
1069
	int literal = (opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1070
		!opts->argh || !!strpbrk(opts->argh, "()<>[]|");
1071
	if (opts->flags & PARSE_OPT_OPTARG)
1072
		if (opts->long_name)
1073
			s = literal ? "[=%s]" : "[=<%s>]";
1074
		else
1075
			s = literal ? "[%s]" : "[<%s>]";
1076
	else
1077
		s = literal ? " %s" : " <%s>";
1078
	return utf8_fprintf(outfile, s, opts->argh ? _(opts->argh) : _("..."));
1079
}
1080

1081
static int usage_indent(FILE *outfile)
1082
{
1083
	return fprintf(outfile, "    ");
1084
}
1085

1086
#define USAGE_OPTS_WIDTH 26
1087

1088
static void usage_padding(FILE *outfile, size_t pos)
1089
{
1090
	if (pos < USAGE_OPTS_WIDTH)
1091
		fprintf(outfile, "%*s", USAGE_OPTS_WIDTH - (int)pos, "");
1092
	else
1093
		fprintf(outfile, "\n%*s", USAGE_OPTS_WIDTH, "");
1094
}
1095

1096
static const struct option *find_option_by_long_name(const struct option *opts,
1097
						     const char *long_name)
1098
{
1099
	for (; opts->type != OPTION_END; opts++) {
1100
		if (opts->long_name && !strcmp(opts->long_name, long_name))
1101
			return opts;
1102
	}
1103
	return NULL;
1104
}
1105

1106
static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *ctx,
1107
							 const char * const *usagestr,
1108
							 const struct option *opts,
1109
							 int full, int err)
1110
{
1111
	const struct option *all_opts = opts;
1112
	FILE *outfile = err ? stderr : stdout;
1113
	int need_newline;
1114

1115
	const char *usage_prefix = _("usage: %s");
1116
	/*
1117
	 * The translation could be anything, but we can count on
1118
	 * msgfmt(1)'s --check option to have asserted that "%s" is in
1119
	 * the translation. So compute the length of the "usage: "
1120
	 * part. We are assuming that the translator wasn't overly
1121
	 * clever and used e.g. "%1$s" instead of "%s", there's only
1122
	 * one "%s" in "usage_prefix" above, so there's no reason to
1123
	 * do so even with a RTL language.
1124
	 */
1125
	size_t usage_len = strlen(usage_prefix) - strlen("%s");
1126
	/*
1127
	 * TRANSLATORS: the colon here should align with the
1128
	 * one in "usage: %s" translation.
1129
	 */
1130
	const char *or_prefix = _("   or: %s");
1131
	/*
1132
	 * TRANSLATORS: You should only need to translate this format
1133
	 * string if your language is a RTL language (e.g. Arabic,
1134
	 * Hebrew etc.), not if it's a LTR language (e.g. German,
1135
	 * Russian, Chinese etc.).
1136
	 *
1137
	 * When a translated usage string has an embedded "\n" it's
1138
	 * because options have wrapped to the next line. The line
1139
	 * after the "\n" will then be padded to align with the
1140
	 * command name, such as N_("git cmd [opt]\n<8
1141
	 * spaces>[opt2]"), where the 8 spaces are the same length as
1142
	 * "git cmd ".
1143
	 *
1144
	 * This format string prints out that already-translated
1145
	 * line. The "%*s" is whitespace padding to account for the
1146
	 * padding at the start of the line that we add in this
1147
	 * function. The "%s" is a line in the (hopefully already
1148
	 * translated) N_() usage string, which contained embedded
1149
	 * newlines before we split it up.
1150
	 */
1151
	const char *usage_continued = _("%*s%s");
1152
	const char *prefix = usage_prefix;
1153
	int saw_empty_line = 0;
1154

1155
	if (!usagestr)
1156
		return PARSE_OPT_HELP;
1157

1158
	if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1159
		fprintf(outfile, "cat <<\\EOF\n");
1160

1161
	while (*usagestr) {
1162
		const char *str = _(*usagestr++);
1163
		struct string_list list = STRING_LIST_INIT_DUP;
1164
		unsigned int j;
1165

1166
		if (!saw_empty_line && !*str)
1167
			saw_empty_line = 1;
1168

1169
		string_list_split(&list, str, '\n', -1);
1170
		for (j = 0; j < list.nr; j++) {
1171
			const char *line = list.items[j].string;
1172

1173
			if (saw_empty_line && *line)
1174
				fprintf_ln(outfile, _("    %s"), line);
1175
			else if (saw_empty_line)
1176
				fputc('\n', outfile);
1177
			else if (!j)
1178
				fprintf_ln(outfile, prefix, line);
1179
			else
1180
				fprintf_ln(outfile, usage_continued,
1181
					   (int)usage_len, "", line);
1182
		}
1183
		string_list_clear(&list, 0);
1184

1185
		prefix = or_prefix;
1186
	}
1187

1188
	need_newline = 1;
1189

1190
	for (; opts->type != OPTION_END; opts++) {
1191
		size_t pos;
1192
		const char *cp, *np;
1193
		const char *positive_name = NULL;
1194

1195
		if (opts->type == OPTION_SUBCOMMAND)
1196
			continue;
1197
		if (opts->type == OPTION_GROUP) {
1198
			fputc('\n', outfile);
1199
			need_newline = 0;
1200
			if (*opts->help)
1201
				fprintf(outfile, "%s\n", _(opts->help));
1202
			continue;
1203
		}
1204
		if (!full && (opts->flags & PARSE_OPT_HIDDEN))
1205
			continue;
1206

1207
		if (need_newline) {
1208
			fputc('\n', outfile);
1209
			need_newline = 0;
1210
		}
1211

1212
		pos = usage_indent(outfile);
1213
		if (opts->short_name) {
1214
			if (opts->flags & PARSE_OPT_NODASH)
1215
				pos += fprintf(outfile, "%c", opts->short_name);
1216
			else
1217
				pos += fprintf(outfile, "-%c", opts->short_name);
1218
		}
1219
		if (opts->long_name && opts->short_name)
1220
			pos += fprintf(outfile, ", ");
1221
		if (opts->long_name) {
1222
			const char *long_name = opts->long_name;
1223
			if ((opts->flags & PARSE_OPT_NONEG) ||
1224
			    skip_prefix(long_name, "no-", &positive_name))
1225
				pos += fprintf(outfile, "--%s", long_name);
1226
			else
1227
				pos += fprintf(outfile, "--[no-]%s", long_name);
1228
		}
1229

1230
		if (opts->type == OPTION_NUMBER)
1231
			pos += utf8_fprintf(outfile, _("-NUM"));
1232

1233
		if ((opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1234
		    !(opts->flags & PARSE_OPT_NOARG))
1235
			pos += usage_argh(opts, outfile);
1236

1237
		if (opts->type == OPTION_ALIAS) {
1238
			usage_padding(outfile, pos);
1239
			fprintf_ln(outfile, _("alias of --%s"),
1240
				   (const char *)opts->value);
1241
			continue;
1242
		}
1243

1244
		for (cp = opts->help ? _(opts->help) : ""; *cp; cp = np) {
1245
			np = strchrnul(cp, '\n');
1246
			if (*np)
1247
				np++;
1248
			usage_padding(outfile, pos);
1249
			fwrite(cp, 1, np - cp, outfile);
1250
			pos = 0;
1251
		}
1252
		fputc('\n', outfile);
1253

1254
		if (positive_name) {
1255
			if (find_option_by_long_name(all_opts, positive_name))
1256
				continue;
1257
			pos = usage_indent(outfile);
1258
			pos += fprintf(outfile, "--%s", positive_name);
1259
			usage_padding(outfile, pos);
1260
			fprintf_ln(outfile, _("opposite of --no-%s"),
1261
				   positive_name);
1262
		}
1263
	}
1264
	fputc('\n', outfile);
1265

1266
	if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1267
		fputs("EOF\n", outfile);
1268

1269
	return PARSE_OPT_HELP;
1270
}
1271

1272
void NORETURN usage_with_options(const char * const *usagestr,
1273
			const struct option *opts)
1274
{
1275
	usage_with_options_internal(NULL, usagestr, opts, 0, 1);
1276
	exit(129);
1277
}
1278

1279
void NORETURN usage_msg_opt(const char *msg,
1280
		   const char * const *usagestr,
1281
		   const struct option *options)
1282
{
1283
	die_message("%s\n", msg); /* The extra \n is intentional */
1284
	usage_with_options(usagestr, options);
1285
}
1286

1287
void NORETURN usage_msg_optf(const char * const fmt,
1288
			     const char * const *usagestr,
1289
			     const struct option *options, ...)
1290
{
1291
	struct strbuf msg = STRBUF_INIT;
1292
	va_list ap;
1293
	va_start(ap, options);
1294
	strbuf_vaddf(&msg, fmt, ap);
1295
	va_end(ap);
1296

1297
	usage_msg_opt(msg.buf, usagestr, options);
1298
}
1299

1300
void die_for_incompatible_opt4(int opt1, const char *opt1_name,
1301
			       int opt2, const char *opt2_name,
1302
			       int opt3, const char *opt3_name,
1303
			       int opt4, const char *opt4_name)
1304
{
1305
	int count = 0;
1306
	const char *options[4];
1307

1308
	if (opt1)
1309
		options[count++] = opt1_name;
1310
	if (opt2)
1311
		options[count++] = opt2_name;
1312
	if (opt3)
1313
		options[count++] = opt3_name;
1314
	if (opt4)
1315
		options[count++] = opt4_name;
1316
	switch (count) {
1317
	case 4:
1318
		die(_("options '%s', '%s', '%s', and '%s' cannot be used together"),
1319
		    opt1_name, opt2_name, opt3_name, opt4_name);
1320
		break;
1321
	case 3:
1322
		die(_("options '%s', '%s', and '%s' cannot be used together"),
1323
		    options[0], options[1], options[2]);
1324
		break;
1325
	case 2:
1326
		die(_("options '%s' and '%s' cannot be used together"),
1327
		    options[0], options[1]);
1328
		break;
1329
	default:
1330
		break;
1331
	}
1332
}
1333