parse-options.c

   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 static enum parse_opt_result parse_long_opt(
 354         struct parse_opt_ctx_t *p, const char *arg,
 355         const struct option *options)
 356 {
 357         const char *arg_end = strchrnul(arg, '=');
 358         const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
 359         enum opt_parsed abbrev_flags = OPT_LONG, ambiguous_flags = OPT_LONG;
 360
 361         for (; options->type != OPTION_END; options++) {
 362                 const char *rest, *long_name = options->long_name;
 363                 enum opt_parsed flags = OPT_LONG, opt_flags = OPT_LONG;
 364
 365                 if (options->type == OPTION_SUBCOMMAND)
 366                         continue;
 367                 if (!long_name)
 368                         continue;
 369
 370 again:
 371                 if (!skip_prefix(arg, long_name, &rest))
 372                         rest = NULL;
 373                 if (!rest) {
 374                         /* abbreviated? */
 375                         if (!(p->flags & PARSE_OPT_KEEP_UNKNOWN_OPT) &&
 376                             !strncmp(long_name, arg, arg_end - arg)) {
 377 is_abbreviated:
 378                                 if (abbrev_option &&
 379                                     !is_alias(p, abbrev_option, options)) {
 380                                         /*
 381                                          * If this is abbreviated, it is
 382                                          * ambiguous. So when there is no
 383                                          * exact match later, we need to
 384                                          * error out.
 385                                          */
 386                                         ambiguous_option = abbrev_option;
 387                                         ambiguous_flags = abbrev_flags;
 388                                 }
 389                                 if (!(flags & OPT_UNSET) && *arg_end)
 390                                         p->opt = arg_end + 1;
 391                                 abbrev_option = options;
 392                                 abbrev_flags = flags ^ opt_flags;
 393                                 continue;
 394                         }
 395                         /* negation allowed? */
 396                         if (options->flags & PARSE_OPT_NONEG)
 397                                 continue;
 398                         /* negated and abbreviated very much? */
 399                         if (starts_with("no-", arg)) {
 400                                 flags |= OPT_UNSET;
 401                                 goto is_abbreviated;
 402                         }
 403                         /* negated? */
 404                         if (!starts_with(arg, "no-")) {
 405                                 if (skip_prefix(long_name, "no-", &long_name)) {
 406                                         opt_flags |= OPT_UNSET;
 407                                         goto again;
 408                                 }
 409                                 continue;
 410                         }
 411                         flags |= OPT_UNSET;
 412                         if (!skip_prefix(arg + 3, long_name, &rest)) {
 413                                 /* abbreviated and negated? */
 414                                 if (starts_with(long_name, arg + 3))
 415                                         goto is_abbreviated;
 416                                 else
 417                                         continue;
 418                         }
 419                 }
 420                 if (*rest) {
 421                         if (*rest != '=')
 422                                 continue;
 423                         p->opt = rest + 1;
 424                 }
 425                 return get_value(p, options, flags ^ opt_flags);
 426         }
 427
 428         if (disallow_abbreviated_options && (ambiguous_option || abbrev_option))
 429                 die("disallowed abbreviated or ambiguous option '%.*s'",
 430                     (int)(arg_end - arg), arg);
 431
 432         if (ambiguous_option) {
 433                 error(_("ambiguous option: %s "
 434                         "(could be --%s%s or --%s%s)"),
 435                         arg,
 436                         (ambiguous_flags & OPT_UNSET) ?  "no-" : "",
 437                         ambiguous_option->long_name,
 438                         (abbrev_flags & OPT_UNSET) ?  "no-" : "",
 439                         abbrev_option->long_name);
 440                 return PARSE_OPT_HELP;
 441         }
 442         if (abbrev_option)
 443                 return get_value(p, abbrev_option, abbrev_flags);
 444         return PARSE_OPT_UNKNOWN;
 445 }
 446
 447 static enum parse_opt_result parse_nodash_opt(struct parse_opt_ctx_t *p,
 448                                               const char *arg,
 449                                               const struct option *options)
 450 {
 451         for (; options->type != OPTION_END; options++) {
 452                 if (!(options->flags & PARSE_OPT_NODASH))
 453                         continue;
 454                 if (options->short_name == arg[0] && arg[1] == '\0')
 455                         return get_value(p, options, OPT_SHORT);
 456         }
 457         return PARSE_OPT_ERROR;
 458 }
 459
 460 static enum parse_opt_result parse_subcommand(const char *arg,
 461                                               const struct option *options)
 462 {
 463         for (; options->type != OPTION_END; options++)
 464                 if (options->type == OPTION_SUBCOMMAND &&
 465                     !strcmp(options->long_name, arg)) {
 466                         *(parse_opt_subcommand_fn **)options->value = options->subcommand_fn;
 467                         return PARSE_OPT_SUBCOMMAND;
 468                 }
 469
 470         return PARSE_OPT_UNKNOWN;
 471 }
 472
 473 static void check_typos(const char *arg, const struct option *options)
 474 {
 475         if (strlen(arg) < 3)
 476                 return;
 477
 478         if (starts_with(arg, "no-")) {
 479                 error(_("did you mean `--%s` (with two dashes)?"), arg);
 480                 exit(129);
 481         }
 482
 483         for (; options->type != OPTION_END; options++) {
 484                 if (!options->long_name)
 485                         continue;
 486                 if (starts_with(options->long_name, arg)) {
 487                         error(_("did you mean `--%s` (with two dashes)?"), arg);
 488                         exit(129);
 489                 }
 490         }
 491 }
 492
 493 static void parse_options_check(const struct option *opts)
 494 {
 495         char short_opts[128];
 496         void *subcommand_value = NULL;
 497
 498         memset(short_opts, '\0', sizeof(short_opts));
 499         for (; opts->type != OPTION_END; opts++) {
 500                 if ((opts->flags & PARSE_OPT_LASTARG_DEFAULT) &&
 501                     (opts->flags & PARSE_OPT_OPTARG))
 502                         optbug(opts, "uses incompatible flags "
 503                                "LASTARG_DEFAULT and OPTARG");
 504                 if (opts->short_name) {
 505                         if (0x7F <= opts->short_name)
 506                                 optbug(opts, "invalid short name");
 507                         else if (short_opts[opts->short_name]++)
 508                                 optbug(opts, "short name already used");
 509                 }
 510                 if (opts->flags & PARSE_OPT_NODASH &&
 511                     ((opts->flags & PARSE_OPT_OPTARG) ||
 512                      !(opts->flags & PARSE_OPT_NOARG) ||
 513                      !(opts->flags & PARSE_OPT_NONEG) ||
 514                      opts->long_name))
 515                         optbug(opts, "uses feature "
 516                                "not supported for dashless options");
 517                 if (opts->type == OPTION_SET_INT && !opts->defval &&
 518                     opts->long_name && !(opts->flags & PARSE_OPT_NONEG))
 519                         optbug(opts, "OPTION_SET_INT 0 should not be negatable");
 520                 switch (opts->type) {
 521                 case OPTION_COUNTUP:
 522                 case OPTION_BIT:
 523                 case OPTION_NEGBIT:
 524                 case OPTION_SET_INT:
 525                 case OPTION_NUMBER:
 526                         if ((opts->flags & PARSE_OPT_OPTARG) ||
 527                             !(opts->flags & PARSE_OPT_NOARG))
 528                                 optbug(opts, "should not accept an argument");
 529                         break;
 530                 case OPTION_CALLBACK:
 531                         if (!opts->callback && !opts->ll_callback)
 532                                 optbug(opts, "OPTION_CALLBACK needs one callback");
 533                         else if (opts->callback && opts->ll_callback)
 534                                 optbug(opts, "OPTION_CALLBACK can't have two callbacks");
 535                         break;
 536                 case OPTION_LOWLEVEL_CALLBACK:
 537                         if (!opts->ll_callback)
 538                                 optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs a callback");
 539                         if (opts->callback)
 540                                 optbug(opts, "OPTION_LOWLEVEL_CALLBACK needs no high level callback");
 541                         break;
 542                 case OPTION_ALIAS:
 543                         optbug(opts, "OPT_ALIAS() should not remain at this point. "
 544                                "Are you using parse_options_step() directly?\n"
 545                                "That case is not supported yet.");
 546                         break;
 547                 case OPTION_SUBCOMMAND:
 548                         if (!opts->value || !opts->subcommand_fn)
 549                                 optbug(opts, "OPTION_SUBCOMMAND needs a value and a subcommand function");
 550                         if (!subcommand_value)
 551                                 subcommand_value = opts->value;
 552                         else if (subcommand_value != opts->value)
 553                                 optbug(opts, "all OPTION_SUBCOMMANDs need the same value");
 554                         break;
 555                 default:
 556                         ; /* ok. (usually accepts an argument) */
 557                 }
 558                 if (opts->argh &&
 559                     strcspn(opts->argh, " _") != strlen(opts->argh))
 560                         optbug(opts, "multi-word argh should use dash to separate words");
 561         }
 562         BUG_if_bug("invalid 'struct option'");
 563 }
 564
 565 static int has_subcommands(const struct option *options)
 566 {
 567         for (; options->type != OPTION_END; options++)
 568                 if (options->type == OPTION_SUBCOMMAND)
 569                         return 1;
 570         return 0;
 571 }
 572
 573 static void parse_options_start_1(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         ctx->argc = argc;
 579         ctx->argv = argv;
 580         if (!(flags & PARSE_OPT_ONE_SHOT)) {
 581                 ctx->argc--;
 582                 ctx->argv++;
 583         }
 584         ctx->total = ctx->argc;
 585         ctx->out   = argv;
 586         ctx->prefix = prefix;
 587         ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
 588         ctx->flags = flags;
 589         ctx->has_subcommands = has_subcommands(options);
 590         if (!ctx->has_subcommands && (flags & PARSE_OPT_SUBCOMMAND_OPTIONAL))
 591                 BUG("Using PARSE_OPT_SUBCOMMAND_OPTIONAL without subcommands");
 592         if (ctx->has_subcommands) {
 593                 if (flags & PARSE_OPT_STOP_AT_NON_OPTION)
 594                         BUG("subcommands are incompatible with PARSE_OPT_STOP_AT_NON_OPTION");
 595                 if (!(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
 596                         if (flags & PARSE_OPT_KEEP_UNKNOWN_OPT)
 597                                 BUG("subcommands are incompatible with PARSE_OPT_KEEP_UNKNOWN_OPT unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
 598                         if (flags & PARSE_OPT_KEEP_DASHDASH)
 599                                 BUG("subcommands are incompatible with PARSE_OPT_KEEP_DASHDASH unless in combination with PARSE_OPT_SUBCOMMAND_OPTIONAL");
 600                 }
 601         }
 602         if ((flags & PARSE_OPT_KEEP_UNKNOWN_OPT) &&
 603             (flags & PARSE_OPT_STOP_AT_NON_OPTION) &&
 604             !(flags & PARSE_OPT_ONE_SHOT))
 605                 BUG("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
 606         if ((flags & PARSE_OPT_ONE_SHOT) &&
 607             (flags & PARSE_OPT_KEEP_ARGV0))
 608                 BUG("Can't keep argv0 if you don't have it");
 609         parse_options_check(options);
 610         build_cmdmode_list(ctx, options);
 611 }
 612
 613 void parse_options_start(struct parse_opt_ctx_t *ctx,
 614                          int argc, const char **argv, const char *prefix,
 615                          const struct option *options,
 616                          enum parse_opt_flags flags)
 617 {
 618         memset(ctx, 0, sizeof(*ctx));
 619         parse_options_start_1(ctx, argc, argv, prefix, options, flags);
 620 }
 621
 622 static void show_negated_gitcomp(const struct option *opts, int show_all,
 623                                  int nr_noopts)
 624 {
 625         int printed_dashdash = 0;
 626
 627         for (; opts->type != OPTION_END; opts++) {
 628                 int has_unset_form = 0;
 629                 const char *name;
 630
 631                 if (!opts->long_name)
 632                         continue;
 633                 if (!show_all &&
 634                         (opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE)))
 635                         continue;
 636                 if (opts->flags & PARSE_OPT_NONEG)
 637                         continue;
 638
 639                 switch (opts->type) {
 640                 case OPTION_STRING:
 641                 case OPTION_FILENAME:
 642                 case OPTION_INTEGER:
 643                 case OPTION_MAGNITUDE:
 644                 case OPTION_CALLBACK:
 645                 case OPTION_BIT:
 646                 case OPTION_NEGBIT:
 647                 case OPTION_COUNTUP:
 648                 case OPTION_SET_INT:
 649                         has_unset_form = 1;
 650                         break;
 651                 default:
 652                         break;
 653                 }
 654                 if (!has_unset_form)
 655                         continue;
 656
 657                 if (skip_prefix(opts->long_name, "no-", &name)) {
 658                         if (nr_noopts < 0)
 659                                 printf(" --%s", name);
 660                 } else if (nr_noopts >= 0) {
 661                         if (nr_noopts && !printed_dashdash) {
 662                                 printf(" --");
 663                                 printed_dashdash = 1;
 664                         }
 665                         printf(" --no-%s", opts->long_name);
 666                         nr_noopts++;
 667                 }
 668         }
 669 }
 670
 671 static int show_gitcomp(const struct option *opts, int show_all)
 672 {
 673         const struct option *original_opts = opts;
 674         int nr_noopts = 0;
 675
 676         for (; opts->type != OPTION_END; opts++) {
 677                 const char *prefix = "--";
 678                 const char *suffix = "";
 679
 680                 if (!opts->long_name)
 681                         continue;
 682                 if (!show_all &&
 683                         (opts->flags & (PARSE_OPT_HIDDEN | PARSE_OPT_NOCOMPLETE | PARSE_OPT_FROM_ALIAS)))
 684                         continue;
 685
 686                 switch (opts->type) {
 687                 case OPTION_SUBCOMMAND:
 688                         prefix = "";
 689                         break;
 690                 case OPTION_GROUP:
 691                         continue;
 692                 case OPTION_STRING:
 693                 case OPTION_FILENAME:
 694                 case OPTION_INTEGER:
 695                 case OPTION_MAGNITUDE:
 696                 case OPTION_CALLBACK:
 697                         if (opts->flags & PARSE_OPT_NOARG)
 698                                 break;
 699                         if (opts->flags & PARSE_OPT_OPTARG)
 700                                 break;
 701                         if (opts->flags & PARSE_OPT_LASTARG_DEFAULT)
 702                                 break;
 703                         suffix = "=";
 704                         break;
 705                 default:
 706                         break;
 707                 }
 708                 if (opts->flags & PARSE_OPT_COMP_ARG)
 709                         suffix = "=";
 710                 if (starts_with(opts->long_name, "no-"))
 711                         nr_noopts++;
 712                 printf("%s%s%s%s", opts == original_opts ? "" : " ",
 713                        prefix, opts->long_name, suffix);
 714         }
 715         show_negated_gitcomp(original_opts, show_all, -1);
 716         show_negated_gitcomp(original_opts, show_all, nr_noopts);
 717         fputc('\n', stdout);
 718         return PARSE_OPT_COMPLETE;
 719 }
 720
 721 /*
 722  * Scan and may produce a new option[] array, which should be used
 723  * instead of the original 'options'.
 724  *
 725  * Right now this is only used to preprocess and substitute
 726  * OPTION_ALIAS.
 727  *
 728  * The returned options should be freed using free_preprocessed_options.
 729  */
 730 static struct option *preprocess_options(struct parse_opt_ctx_t *ctx,
 731                                          const struct option *options)
 732 {
 733         struct option *newopt;
 734         int i, nr, alias;
 735         int nr_aliases = 0;
 736
 737         for (nr = 0; options[nr].type != OPTION_END; nr++) {
 738                 if (options[nr].type == OPTION_ALIAS)
 739                         nr_aliases++;
 740         }
 741
 742         if (!nr_aliases)
 743                 return NULL;
 744
 745         DUP_ARRAY(newopt, options, nr + 1);
 746
 747         /* each alias has two string pointers and NULL */
 748         CALLOC_ARRAY(ctx->alias_groups, 3 * (nr_aliases + 1));
 749
 750         for (alias = 0, i = 0; i < nr; i++) {
 751                 int short_name;
 752                 const char *long_name;
 753                 const char *source;
 754                 struct strbuf help = STRBUF_INIT;
 755                 int j;
 756
 757                 if (newopt[i].type != OPTION_ALIAS)
 758                         continue;
 759
 760                 short_name = newopt[i].short_name;
 761                 long_name = newopt[i].long_name;
 762                 source = newopt[i].value;
 763
 764                 if (!long_name)
 765                         BUG("An alias must have long option name");
 766                 strbuf_addf(&help, _("alias of --%s"), source);
 767
 768                 for (j = 0; j < nr; j++) {
 769                         const char *name = options[j].long_name;
 770
 771                         if (!name || strcmp(name, source))
 772                                 continue;
 773
 774                         if (options[j].type == OPTION_ALIAS)
 775                                 BUG("No please. Nested aliases are not supported.");
 776
 777                         memcpy(newopt + i, options + j, sizeof(*newopt));
 778                         newopt[i].short_name = short_name;
 779                         newopt[i].long_name = long_name;
 780                         newopt[i].help = strbuf_detach(&help, NULL);
 781                         newopt[i].flags |= PARSE_OPT_FROM_ALIAS;
 782                         break;
 783                 }
 784
 785                 if (j == nr)
 786                         BUG("could not find source option '%s' of alias '%s'",
 787                             source, newopt[i].long_name);
 788                 ctx->alias_groups[alias * 3 + 0] = newopt[i].long_name;
 789                 ctx->alias_groups[alias * 3 + 1] = options[j].long_name;
 790                 ctx->alias_groups[alias * 3 + 2] = NULL;
 791                 alias++;
 792         }
 793
 794         return newopt;
 795 }
 796
 797 static void free_preprocessed_options(struct option *options)
 798 {
 799         int i;
 800
 801         if (!options)
 802                 return;
 803
 804         for (i = 0; options[i].type != OPTION_END; i++) {
 805                 if (options[i].flags & PARSE_OPT_FROM_ALIAS)
 806                         free((void *)options[i].help);
 807         }
 808         free(options);
 809 }
 810
 811 static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *,
 812                                                          const char * const *,
 813                                                          const struct option *,
 814                                                          int, int);
 815
 816 enum parse_opt_result parse_options_step(struct parse_opt_ctx_t *ctx,
 817                                          const struct option *options,
 818                                          const char * const usagestr[])
 819 {
 820         int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
 821
 822         /* we must reset ->opt, unknown short option leave it dangling */
 823         ctx->opt = NULL;
 824
 825         for (; ctx->argc; ctx->argc--, ctx->argv++) {
 826                 const char *arg = ctx->argv[0];
 827
 828                 if (ctx->flags & PARSE_OPT_ONE_SHOT &&
 829                     ctx->argc != ctx->total)
 830                         break;
 831
 832                 if (*arg != '-' || !arg[1]) {
 833                         if (parse_nodash_opt(ctx, arg, options) == 0)
 834                                 continue;
 835                         if (!ctx->has_subcommands) {
 836                                 if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
 837                                         return PARSE_OPT_NON_OPTION;
 838                                 ctx->out[ctx->cpidx++] = ctx->argv[0];
 839                                 continue;
 840                         }
 841                         switch (parse_subcommand(arg, options)) {
 842                         case PARSE_OPT_SUBCOMMAND:
 843                                 return PARSE_OPT_SUBCOMMAND;
 844                         case PARSE_OPT_UNKNOWN:
 845                                 if (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
 846                                         /*
 847                                          * arg is neither a short or long
 848                                          * option nor a subcommand.  Since
 849                                          * this command has a default
 850                                          * operation mode, we have to treat
 851                                          * this arg and all remaining args
 852                                          * as args meant to that default
 853                                          * operation mode.
 854                                          * So we are done parsing.
 855                                          */
 856                                         return PARSE_OPT_DONE;
 857                                 error(_("unknown subcommand: `%s'"), arg);
 858                                 usage_with_options(usagestr, options);
 859                         case PARSE_OPT_COMPLETE:
 860                         case PARSE_OPT_HELP:
 861                         case PARSE_OPT_ERROR:
 862                         case PARSE_OPT_DONE:
 863                         case PARSE_OPT_NON_OPTION:
 864                                 /* Impossible. */
 865                                 BUG("parse_subcommand() cannot return these");
 866                         }
 867                 }
 868
 869                 /* lone -h asks for help */
 870                 if (internal_help && ctx->total == 1 && !strcmp(arg + 1, "h"))
 871                         goto show_usage;
 872
 873                 /*
 874                  * lone --git-completion-helper and --git-completion-helper-all
 875                  * are asked by git-completion.bash
 876                  */
 877                 if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper"))
 878                         return show_gitcomp(options, 0);
 879                 if (ctx->total == 1 && !strcmp(arg, "--git-completion-helper-all"))
 880                         return show_gitcomp(options, 1);
 881
 882                 if (arg[1] != '-') {
 883                         ctx->opt = arg + 1;
 884                         switch (parse_short_opt(ctx, options)) {
 885                         case PARSE_OPT_ERROR:
 886                                 return PARSE_OPT_ERROR;
 887                         case PARSE_OPT_UNKNOWN:
 888                                 if (ctx->opt)
 889                                         check_typos(arg + 1, options);
 890                                 if (internal_help && *ctx->opt == 'h')
 891                                         goto show_usage;
 892                                 goto unknown;
 893                         case PARSE_OPT_NON_OPTION:
 894                         case PARSE_OPT_SUBCOMMAND:
 895                         case PARSE_OPT_HELP:
 896                         case PARSE_OPT_COMPLETE:
 897                                 BUG("parse_short_opt() cannot return these");
 898                         case PARSE_OPT_DONE:
 899                                 break;
 900                         }
 901                         if (ctx->opt)
 902                                 check_typos(arg + 1, options);
 903                         while (ctx->opt) {
 904                                 switch (parse_short_opt(ctx, options)) {
 905                                 case PARSE_OPT_ERROR:
 906                                         return PARSE_OPT_ERROR;
 907                                 case PARSE_OPT_UNKNOWN:
 908                                         if (internal_help && *ctx->opt == 'h')
 909                                                 goto show_usage;
 910
 911                                         /* fake a short option thing to hide the fact that we may have
 912                                          * started to parse aggregated stuff
 913                                          *
 914                                          * This is leaky, too bad.
 915                                          */
 916                                         ctx->argv[0] = xstrdup(ctx->opt - 1);
 917                                         *(char *)ctx->argv[0] = '-';
 918                                         goto unknown;
 919                                 case PARSE_OPT_NON_OPTION:
 920                                 case PARSE_OPT_SUBCOMMAND:
 921                                 case PARSE_OPT_COMPLETE:
 922                                 case PARSE_OPT_HELP:
 923                                         BUG("parse_short_opt() cannot return these");
 924                                 case PARSE_OPT_DONE:
 925                                         break;
 926                                 }
 927                         }
 928                         continue;
 929                 }
 930
 931                 if (!arg[2] /* "--" */) {
 932                         if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
 933                                 ctx->argc--;
 934                                 ctx->argv++;
 935                         }
 936                         break;
 937                 } else if (!strcmp(arg + 2, "end-of-options")) {
 938                         if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)) {
 939                                 ctx->argc--;
 940                                 ctx->argv++;
 941                         }
 942                         break;
 943                 }
 944
 945                 if (internal_help && !strcmp(arg + 2, "help-all"))
 946                         return usage_with_options_internal(ctx, usagestr, options, 1, 0);
 947                 if (internal_help && !strcmp(arg + 2, "help"))
 948                         goto show_usage;
 949                 switch (parse_long_opt(ctx, arg + 2, options)) {
 950                 case PARSE_OPT_ERROR:
 951                         return PARSE_OPT_ERROR;
 952                 case PARSE_OPT_UNKNOWN:
 953                         goto unknown;
 954                 case PARSE_OPT_HELP:
 955                         goto show_usage;
 956                 case PARSE_OPT_NON_OPTION:
 957                 case PARSE_OPT_SUBCOMMAND:
 958                 case PARSE_OPT_COMPLETE:
 959                         BUG("parse_long_opt() cannot return these");
 960                 case PARSE_OPT_DONE:
 961                         break;
 962                 }
 963                 continue;
 964 unknown:
 965                 if (ctx->flags & PARSE_OPT_ONE_SHOT)
 966                         break;
 967                 if (ctx->has_subcommands &&
 968                     (ctx->flags & PARSE_OPT_SUBCOMMAND_OPTIONAL) &&
 969                     (ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT)) {
 970                         /*
 971                          * Found an unknown option given to a command with
 972                          * subcommands that has a default operation mode:
 973                          * we treat this option and all remaining args as
 974                          * arguments meant to that default operation mode.
 975                          * So we are done parsing.
 976                          */
 977                         return PARSE_OPT_DONE;
 978                 }
 979                 if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN_OPT))
 980                         return PARSE_OPT_UNKNOWN;
 981                 ctx->out[ctx->cpidx++] = ctx->argv[0];
 982                 ctx->opt = NULL;
 983         }
 984         return PARSE_OPT_DONE;
 985
 986  show_usage:
 987         return usage_with_options_internal(ctx, usagestr, options, 0, 0);
 988 }
 989
 990 int parse_options_end(struct parse_opt_ctx_t *ctx)
 991 {
 992         if (ctx->flags & PARSE_OPT_ONE_SHOT)
 993                 return ctx->total - ctx->argc;
 994
 995         MOVE_ARRAY(ctx->out + ctx->cpidx, ctx->argv, ctx->argc);
 996         ctx->out[ctx->cpidx + ctx->argc] = NULL;
 997         return ctx->cpidx + ctx->argc;
 998 }
 999
1000 int parse_options(int argc, const char **argv,
1001                   const char *prefix,
1002                   const struct option *options,
1003                   const char * const usagestr[],
1004                   enum parse_opt_flags flags)
1005 {
1006         struct parse_opt_ctx_t ctx;
1007         struct option *real_options;
1008
1009         disallow_abbreviated_options =
1010                 git_env_bool("GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS", 0);
1011
1012         memset(&ctx, 0, sizeof(ctx));
1013         real_options = preprocess_options(&ctx, options);
1014         if (real_options)
1015                 options = real_options;
1016         parse_options_start_1(&ctx, argc, argv, prefix, options, flags);
1017         switch (parse_options_step(&ctx, options, usagestr)) {
1018         case PARSE_OPT_HELP:
1019         case PARSE_OPT_ERROR:
1020                 exit(129);
1021         case PARSE_OPT_COMPLETE:
1022                 exit(0);
1023         case PARSE_OPT_NON_OPTION:
1024         case PARSE_OPT_SUBCOMMAND:
1025                 break;
1026         case PARSE_OPT_DONE:
1027                 if (ctx.has_subcommands &&
1028                     !(flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)) {
1029                         error(_("need a subcommand"));
1030                         usage_with_options(usagestr, options);
1031                 }
1032                 break;
1033         case PARSE_OPT_UNKNOWN:
1034                 if (ctx.argv[0][1] == '-') {
1035                         error(_("unknown option `%s'"), ctx.argv[0] + 2);
1036                 } else if (isascii(*ctx.opt)) {
1037                         error(_("unknown switch `%c'"), *ctx.opt);
1038                 } else {
1039                         error(_("unknown non-ascii option in string: `%s'"),
1040                               ctx.argv[0]);
1041                 }
1042                 usage_with_options(usagestr, options);
1043         }
1044
1045         precompose_argv_prefix(argc, argv, NULL);
1046         free_preprocessed_options(real_options);
1047         free(ctx.alias_groups);
1048         for (struct parse_opt_cmdmode_list *elem = ctx.cmdmode_list; elem;) {
1049                 struct parse_opt_cmdmode_list *next = elem->next;
1050                 free(elem);
1051                 elem = next;
1052         }
1053         return parse_options_end(&ctx);
1054 }
1055
1056 static int usage_argh(const struct option *opts, FILE *outfile)
1057 {
1058         const char *s;
1059         int literal = (opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1060                 !opts->argh || !!strpbrk(opts->argh, "()<>[]|");
1061         if (opts->flags & PARSE_OPT_OPTARG)
1062                 if (opts->long_name)
1063                         s = literal ? "[=%s]" : "[=<%s>]";
1064                 else
1065                         s = literal ? "[%s]" : "[<%s>]";
1066         else
1067                 s = literal ? " %s" : " <%s>";
1068         return utf8_fprintf(outfile, s, opts->argh ? _(opts->argh) : _("..."));
1069 }
1070
1071 static int usage_indent(FILE *outfile)
1072 {
1073         return fprintf(outfile, "    ");
1074 }
1075
1076 #define USAGE_OPTS_WIDTH 26
1077
1078 static void usage_padding(FILE *outfile, size_t pos)
1079 {
1080         if (pos < USAGE_OPTS_WIDTH)
1081                 fprintf(outfile, "%*s", USAGE_OPTS_WIDTH - (int)pos, "");
1082         else
1083                 fprintf(outfile, "\n%*s", USAGE_OPTS_WIDTH, "");
1084 }
1085
1086 static const struct option *find_option_by_long_name(const struct option *opts,
1087                                                      const char *long_name)
1088 {
1089         for (; opts->type != OPTION_END; opts++) {
1090                 if (opts->long_name && !strcmp(opts->long_name, long_name))
1091                         return opts;
1092         }
1093         return NULL;
1094 }
1095
1096 static enum parse_opt_result usage_with_options_internal(struct parse_opt_ctx_t *ctx,
1097                                                          const char * const *usagestr,
1098                                                          const struct option *opts,
1099                                                          int full, int err)
1100 {
1101         const struct option *all_opts = opts;
1102         FILE *outfile = err ? stderr : stdout;
1103         int need_newline;
1104
1105         const char *usage_prefix = _("usage: %s");
1106         /*
1107          * The translation could be anything, but we can count on
1108          * msgfmt(1)'s --check option to have asserted that "%s" is in
1109          * the translation. So compute the length of the "usage: "
1110          * part. We are assuming that the translator wasn't overly
1111          * clever and used e.g. "%1$s" instead of "%s", there's only
1112          * one "%s" in "usage_prefix" above, so there's no reason to
1113          * do so even with a RTL language.
1114          */
1115         size_t usage_len = strlen(usage_prefix) - strlen("%s");
1116         /*
1117          * TRANSLATORS: the colon here should align with the
1118          * one in "usage: %s" translation.
1119          */
1120         const char *or_prefix = _("   or: %s");
1121         /*
1122          * TRANSLATORS: You should only need to translate this format
1123          * string if your language is a RTL language (e.g. Arabic,
1124          * Hebrew etc.), not if it's a LTR language (e.g. German,
1125          * Russian, Chinese etc.).
1126          *
1127          * When a translated usage string has an embedded "\n" it's
1128          * because options have wrapped to the next line. The line
1129          * after the "\n" will then be padded to align with the
1130          * command name, such as N_("git cmd [opt]\n<8
1131          * spaces>[opt2]"), where the 8 spaces are the same length as
1132          * "git cmd ".
1133          *
1134          * This format string prints out that already-translated
1135          * line. The "%*s" is whitespace padding to account for the
1136          * padding at the start of the line that we add in this
1137          * function. The "%s" is a line in the (hopefully already
1138          * translated) N_() usage string, which contained embedded
1139          * newlines before we split it up.
1140          */
1141         const char *usage_continued = _("%*s%s");
1142         const char *prefix = usage_prefix;
1143         int saw_empty_line = 0;
1144
1145         if (!usagestr)
1146                 return PARSE_OPT_HELP;
1147
1148         if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1149                 fprintf(outfile, "cat <<\\EOF\n");
1150
1151         while (*usagestr) {
1152                 const char *str = _(*usagestr++);
1153                 struct string_list list = STRING_LIST_INIT_DUP;
1154                 unsigned int j;
1155
1156                 if (!saw_empty_line && !*str)
1157                         saw_empty_line = 1;
1158
1159                 string_list_split(&list, str, '\n', -1);
1160                 for (j = 0; j < list.nr; j++) {
1161                         const char *line = list.items[j].string;
1162
1163                         if (saw_empty_line && *line)
1164                                 fprintf_ln(outfile, _("    %s"), line);
1165                         else if (saw_empty_line)
1166                                 fputc('\n', outfile);
1167                         else if (!j)
1168                                 fprintf_ln(outfile, prefix, line);
1169                         else
1170                                 fprintf_ln(outfile, usage_continued,
1171                                            (int)usage_len, "", line);
1172                 }
1173                 string_list_clear(&list, 0);
1174
1175                 prefix = or_prefix;
1176         }
1177
1178         need_newline = 1;
1179
1180         for (; opts->type != OPTION_END; opts++) {
1181                 size_t pos;
1182                 const char *cp, *np;
1183                 const char *positive_name = NULL;
1184
1185                 if (opts->type == OPTION_SUBCOMMAND)
1186                         continue;
1187                 if (opts->type == OPTION_GROUP) {
1188                         fputc('\n', outfile);
1189                         need_newline = 0;
1190                         if (*opts->help)
1191                                 fprintf(outfile, "%s\n", _(opts->help));
1192                         continue;
1193                 }
1194                 if (!full && (opts->flags & PARSE_OPT_HIDDEN))
1195                         continue;
1196
1197                 if (need_newline) {
1198                         fputc('\n', outfile);
1199                         need_newline = 0;
1200                 }
1201
1202                 pos = usage_indent(outfile);
1203                 if (opts->short_name) {
1204                         if (opts->flags & PARSE_OPT_NODASH)
1205                                 pos += fprintf(outfile, "%c", opts->short_name);
1206                         else
1207                                 pos += fprintf(outfile, "-%c", opts->short_name);
1208                 }
1209                 if (opts->long_name && opts->short_name)
1210                         pos += fprintf(outfile, ", ");
1211                 if (opts->long_name) {
1212                         const char *long_name = opts->long_name;
1213                         if ((opts->flags & PARSE_OPT_NONEG) ||
1214                             skip_prefix(long_name, "no-", &positive_name))
1215                                 pos += fprintf(outfile, "--%s", long_name);
1216                         else
1217                                 pos += fprintf(outfile, "--[no-]%s", long_name);
1218                 }
1219
1220                 if (opts->type == OPTION_NUMBER)
1221                         pos += utf8_fprintf(outfile, _("-NUM"));
1222
1223                 if ((opts->flags & PARSE_OPT_LITERAL_ARGHELP) ||
1224                     !(opts->flags & PARSE_OPT_NOARG))
1225                         pos += usage_argh(opts, outfile);
1226
1227                 if (opts->type == OPTION_ALIAS) {
1228                         usage_padding(outfile, pos);
1229                         fprintf_ln(outfile, _("alias of --%s"),
1230                                    (const char *)opts->value);
1231                         continue;
1232                 }
1233
1234                 for (cp = opts->help ? _(opts->help) : ""; *cp; cp = np) {
1235                         np = strchrnul(cp, '\n');
1236                         if (*np)
1237                                 np++;
1238                         usage_padding(outfile, pos);
1239                         fwrite(cp, 1, np - cp, outfile);
1240                         pos = 0;
1241                 }
1242                 fputc('\n', outfile);
1243
1244                 if (positive_name) {
1245                         if (find_option_by_long_name(all_opts, positive_name))
1246                                 continue;
1247                         pos = usage_indent(outfile);
1248                         pos += fprintf(outfile, "--%s", positive_name);
1249                         usage_padding(outfile, pos);
1250                         fprintf_ln(outfile, _("opposite of --no-%s"),
1251                                    positive_name);
1252                 }
1253         }
1254         fputc('\n', outfile);
1255
1256         if (!err && ctx && ctx->flags & PARSE_OPT_SHELL_EVAL)
1257                 fputs("EOF\n", outfile);
1258
1259         return PARSE_OPT_HELP;
1260 }
1261
1262 void NORETURN usage_with_options(const char * const *usagestr,
1263                         const struct option *opts)
1264 {
1265         usage_with_options_internal(NULL, usagestr, opts, 0, 1);
1266         exit(129);
1267 }
1268
1269 void NORETURN usage_msg_opt(const char *msg,
1270                    const char * const *usagestr,
1271                    const struct option *options)
1272 {
1273         die_message("%s\n", msg); /* The extra \n is intentional */
1274         usage_with_options(usagestr, options);
1275 }
1276
1277 void NORETURN usage_msg_optf(const char * const fmt,
1278                              const char * const *usagestr,
1279                              const struct option *options, ...)
1280 {
1281         struct strbuf msg = STRBUF_INIT;
1282         va_list ap;
1283         va_start(ap, options);
1284         strbuf_vaddf(&msg, fmt, ap);
1285         va_end(ap);
1286
1287         usage_msg_opt(msg.buf, usagestr, options);
1288 }
1289
1290 void die_for_incompatible_opt4(int opt1, const char *opt1_name,
1291                                int opt2, const char *opt2_name,
1292                                int opt3, const char *opt3_name,
1293                                int opt4, const char *opt4_name)
1294 {
1295         int count = 0;
1296         const char *options[4];
1297
1298         if (opt1)
1299                 options[count++] = opt1_name;
1300         if (opt2)
1301                 options[count++] = opt2_name;
1302         if (opt3)
1303                 options[count++] = opt3_name;
1304         if (opt4)
1305                 options[count++] = opt4_name;
1306         switch (count) {
1307         case 4:
1308                 die(_("options '%s', '%s', '%s', and '%s' cannot be used together"),
1309                     opt1_name, opt2_name, opt3_name, opt4_name);
1310                 break;
1311         case 3:
1312                 die(_("options '%s', '%s', and '%s' cannot be used together"),
1313                     options[0], options[1], options[2]);
1314                 break;
1315         case 2:
1316                 die(_("options '%s' and '%s' cannot be used together"),
1317                     options[0], options[1]);
1318                 break;
1319         default:
1320                 break;
1321         }
1322 }