contrib/llvm/tools/lldb/source/Host/common/GetOptInc.cpp

   1 //===-- GetOptInc.cpp -------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Host/common/GetOptInc.h"
  11
  12 #if defined(REPLACE_GETOPT) || defined(REPLACE_GETOPT_LONG) ||                 \
  13     defined(REPLACE_GETOPT_LONG_ONLY)
  14
  15 // getopt.cpp
  16 #include <errno.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #if defined(REPLACE_GETOPT)
  21 int opterr = 1;   /* if error message should be printed */
  22 int optind = 1;   /* index into parent argv vector */
  23 int optopt = '?'; /* character checked for validity */
  24 int optreset;     /* reset getopt */
  25 char *optarg;     /* argument associated with option */
  26 #endif
  27
  28 #define PRINT_ERROR ((opterr) && (*options != ':'))
  29
  30 #define FLAG_PERMUTE 0x01  /* permute non-options to the end of argv */
  31 #define FLAG_ALLARGS 0x02  /* treat non-options as args to option "-1" */
  32 #define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */
  33
  34 /* return values */
  35 #define BADCH (int)'?'
  36 #define BADARG ((*options == ':') ? (int)':' : (int)'?')
  37 #define INORDER (int)1
  38
  39 #define EMSG ""
  40
  41 static int getopt_internal(int, char *const *, const char *,
  42                            const struct option *, int *, int);
  43 static int parse_long_options(char *const *, const char *,
  44                               const struct option *, int *, int);
  45 static int gcd(int, int);
  46 static void permute_args(int, int, int, char *const *);
  47
  48 static const char *place = EMSG; /* option letter processing */
  49
  50 /* XXX: set optreset to 1 rather than these two */
  51 static int nonopt_start = -1; /* first non option argument (for permute) */
  52 static int nonopt_end = -1;   /* first option after non options (for permute) */
  53
  54 /*
  55 * Compute the greatest common divisor of a and b.
  56 */
  57 static int gcd(int a, int b) {
  58   int c;
  59
  60   c = a % b;
  61   while (c != 0) {
  62     a = b;
  63     b = c;
  64     c = a % b;
  65   }
  66
  67   return (b);
  68 }
  69
  70 static void pass() {}
  71 #define warnx(a, ...) pass();
  72
  73 /*
  74 * Exchange the block from nonopt_start to nonopt_end with the block
  75 * from nonopt_end to opt_end (keeping the same order of arguments
  76 * in each block).
  77 */
  78 static void permute_args(int panonopt_start, int panonopt_end, int opt_end,
  79                          char *const *nargv) {
  80   int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
  81   char *swap;
  82
  83   /*
  84   * compute lengths of blocks and number and size of cycles
  85   */
  86   nnonopts = panonopt_end - panonopt_start;
  87   nopts = opt_end - panonopt_end;
  88   ncycle = gcd(nnonopts, nopts);
  89   cyclelen = (opt_end - panonopt_start) / ncycle;
  90
  91   for (i = 0; i < ncycle; i++) {
  92     cstart = panonopt_end + i;
  93     pos = cstart;
  94     for (j = 0; j < cyclelen; j++) {
  95       if (pos >= panonopt_end)
  96         pos -= nnonopts;
  97       else
  98         pos += nopts;
  99       swap = nargv[pos];
 100       /* LINTED const cast */
 101       ((char **)nargv)[pos] = nargv[cstart];
 102       /* LINTED const cast */
 103       ((char **)nargv)[cstart] = swap;
 104     }
 105   }
 106 }
 107
 108 /*
 109 * parse_long_options --
 110 *  Parse long options in argc/argv argument vector.
 111 * Returns -1 if short_too is set and the option does not match long_options.
 112 */
 113 static int parse_long_options(char *const *nargv, const char *options,
 114                               const struct option *long_options, int *idx,
 115                               int short_too) {
 116   char *current_argv, *has_equal;
 117   size_t current_argv_len;
 118   int i, match;
 119
 120   current_argv = const_cast<char *>(place);
 121   match = -1;
 122
 123   optind++;
 124
 125   if ((has_equal = strchr(current_argv, '=')) != NULL) {
 126     /* argument found (--option=arg) */
 127     current_argv_len = has_equal - current_argv;
 128     has_equal++;
 129   } else
 130     current_argv_len = strlen(current_argv);
 131
 132   for (i = 0; long_options[i].name; i++) {
 133     /* find matching long option */
 134     if (strncmp(current_argv, long_options[i].name, current_argv_len))
 135       continue;
 136
 137     if (strlen(long_options[i].name) == current_argv_len) {
 138       /* exact match */
 139       match = i;
 140       break;
 141     }
 142     /*
 143     * If this is a known short option, don't allow
 144     * a partial match of a single character.
 145     */
 146     if (short_too && current_argv_len == 1)
 147       continue;
 148
 149     if (match == -1) /* partial match */
 150       match = i;
 151     else {
 152       /* ambiguous abbreviation */
 153       if (PRINT_ERROR)
 154         warnx(ambig, (int)current_argv_len, current_argv);
 155       optopt = 0;
 156       return (BADCH);
 157     }
 158   }
 159   if (match != -1) { /* option found */
 160     if (long_options[match].has_arg == no_argument && has_equal) {
 161       if (PRINT_ERROR)
 162         warnx(noarg, (int)current_argv_len, current_argv);
 163       /*
 164       * XXX: GNU sets optopt to val regardless of flag
 165       */
 166       if (long_options[match].flag == NULL)
 167         optopt = long_options[match].val;
 168       else
 169         optopt = 0;
 170       return (BADARG);
 171     }
 172     if (long_options[match].has_arg == required_argument ||
 173         long_options[match].has_arg == optional_argument) {
 174       if (has_equal)
 175         optarg = has_equal;
 176       else if (long_options[match].has_arg == required_argument) {
 177         /*
 178         * optional argument doesn't use next nargv
 179         */
 180         optarg = nargv[optind++];
 181       }
 182     }
 183     if ((long_options[match].has_arg == required_argument) &&
 184         (optarg == NULL)) {
 185       /*
 186       * Missing argument; leading ':' indicates no error
 187       * should be generated.
 188       */
 189       if (PRINT_ERROR)
 190         warnx(recargstring, current_argv);
 191       /*
 192       * XXX: GNU sets optopt to val regardless of flag
 193       */
 194       if (long_options[match].flag == NULL)
 195         optopt = long_options[match].val;
 196       else
 197         optopt = 0;
 198       --optind;
 199       return (BADARG);
 200     }
 201   } else { /* unknown option */
 202     if (short_too) {
 203       --optind;
 204       return (-1);
 205     }
 206     if (PRINT_ERROR)
 207       warnx(illoptstring, current_argv);
 208     optopt = 0;
 209     return (BADCH);
 210   }
 211   if (idx)
 212     *idx = match;
 213   if (long_options[match].flag) {
 214     *long_options[match].flag = long_options[match].val;
 215     return (0);
 216   } else
 217     return (long_options[match].val);
 218 }
 219
 220 /*
 221 * getopt_internal --
 222 *  Parse argc/argv argument vector.  Called by user level routines.
 223 */
 224 static int getopt_internal(int nargc, char *const *nargv, const char *options,
 225                            const struct option *long_options, int *idx,
 226                            int flags) {
 227   const char *oli; /* option letter list index */
 228   int optchar, short_too;
 229   static int posixly_correct = -1;
 230
 231   if (options == NULL)
 232     return (-1);
 233
 234   /*
 235   * XXX Some GNU programs (like cvs) set optind to 0 instead of
 236   * XXX using optreset.  Work around this braindamage.
 237   */
 238   if (optind == 0)
 239     optind = optreset = 1;
 240
 241   /*
 242   * Disable GNU extensions if POSIXLY_CORRECT is set or options
 243   * string begins with a '+'.
 244   */
 245   if (posixly_correct == -1 || optreset)
 246     posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
 247   if (*options == '-')
 248     flags |= FLAG_ALLARGS;
 249   else if (posixly_correct || *options == '+')
 250     flags &= ~FLAG_PERMUTE;
 251   if (*options == '+' || *options == '-')
 252     options++;
 253
 254   optarg = NULL;
 255   if (optreset)
 256     nonopt_start = nonopt_end = -1;
 257 start:
 258   if (optreset || !*place) { /* update scanning pointer */
 259     optreset = 0;
 260     if (optind >= nargc) { /* end of argument vector */
 261       place = EMSG;
 262       if (nonopt_end != -1) {
 263         /* do permutation, if we have to */
 264         permute_args(nonopt_start, nonopt_end, optind, nargv);
 265         optind -= nonopt_end - nonopt_start;
 266       } else if (nonopt_start != -1) {
 267         /*
 268         * If we skipped non-options, set optind
 269         * to the first of them.
 270         */
 271         optind = nonopt_start;
 272       }
 273       nonopt_start = nonopt_end = -1;
 274       return (-1);
 275     }
 276     if (*(place = nargv[optind]) != '-' ||
 277         (place[1] == '\0' && strchr(options, '-') == NULL)) {
 278       place = EMSG; /* found non-option */
 279       if (flags & FLAG_ALLARGS) {
 280         /*
 281         * GNU extension:
 282         * return non-option as argument to option 1
 283         */
 284         optarg = nargv[optind++];
 285         return (INORDER);
 286       }
 287       if (!(flags & FLAG_PERMUTE)) {
 288         /*
 289         * If no permutation wanted, stop parsing
 290         * at first non-option.
 291         */
 292         return (-1);
 293       }
 294       /* do permutation */
 295       if (nonopt_start == -1)
 296         nonopt_start = optind;
 297       else if (nonopt_end != -1) {
 298         permute_args(nonopt_start, nonopt_end, optind, nargv);
 299         nonopt_start = optind - (nonopt_end - nonopt_start);
 300         nonopt_end = -1;
 301       }
 302       optind++;
 303       /* process next argument */
 304       goto start;
 305     }
 306     if (nonopt_start != -1 && nonopt_end == -1)
 307       nonopt_end = optind;
 308
 309     /*
 310     * If we have "-" do nothing, if "--" we are done.
 311     */
 312     if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
 313       optind++;
 314       place = EMSG;
 315       /*
 316       * We found an option (--), so if we skipped
 317       * non-options, we have to permute.
 318       */
 319       if (nonopt_end != -1) {
 320         permute_args(nonopt_start, nonopt_end, optind, nargv);
 321         optind -= nonopt_end - nonopt_start;
 322       }
 323       nonopt_start = nonopt_end = -1;
 324       return (-1);
 325     }
 326   }
 327
 328   /*
 329   * Check long options if:
 330   *  1) we were passed some
 331   *  2) the arg is not just "-"
 332   *  3) either the arg starts with -- we are getopt_long_only()
 333   */
 334   if (long_options != NULL && place != nargv[optind] &&
 335       (*place == '-' || (flags & FLAG_LONGONLY))) {
 336     short_too = 0;
 337     if (*place == '-')
 338       place++; /* --foo long option */
 339     else if (*place != ':' && strchr(options, *place) != NULL)
 340       short_too = 1; /* could be short option too */
 341
 342     optchar = parse_long_options(nargv, options, long_options, idx, short_too);
 343     if (optchar != -1) {
 344       place = EMSG;
 345       return (optchar);
 346     }
 347   }
 348
 349   if ((optchar = (int)*place++) == (int)':' ||
 350       (optchar == (int)'-' && *place != '\0') ||
 351       (oli = strchr(options, optchar)) == NULL) {
 352     /*
 353     * If the user specified "-" and  '-' isn't listed in
 354     * options, return -1 (non-option) as per POSIX.
 355     * Otherwise, it is an unknown option character (or ':').
 356     */
 357     if (optchar == (int)'-' && *place == '\0')
 358       return (-1);
 359     if (!*place)
 360       ++optind;
 361     if (PRINT_ERROR)
 362       warnx(illoptchar, optchar);
 363     optopt = optchar;
 364     return (BADCH);
 365   }
 366   if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
 367     /* -W long-option */
 368     if (*place) /* no space */
 369       /* NOTHING */;
 370     else if (++optind >= nargc) { /* no arg */
 371       place = EMSG;
 372       if (PRINT_ERROR)
 373         warnx(recargchar, optchar);
 374       optopt = optchar;
 375       return (BADARG);
 376     } else /* white space */
 377       place = nargv[optind];
 378     optchar = parse_long_options(nargv, options, long_options, idx, 0);
 379     place = EMSG;
 380     return (optchar);
 381   }
 382   if (*++oli != ':') { /* doesn't take argument */
 383     if (!*place)
 384       ++optind;
 385   } else { /* takes (optional) argument */
 386     optarg = NULL;
 387     if (*place) /* no white space */
 388       optarg = const_cast<char *>(place);
 389     else if (oli[1] != ':') {  /* arg not optional */
 390       if (++optind >= nargc) { /* no arg */
 391         place = EMSG;
 392         if (PRINT_ERROR)
 393           warnx(recargchar, optchar);
 394         optopt = optchar;
 395         return (BADARG);
 396       } else
 397         optarg = nargv[optind];
 398     }
 399     place = EMSG;
 400     ++optind;
 401   }
 402   /* dump back option letter */
 403   return (optchar);
 404 }
 405
 406 /*
 407 * getopt --
 408 *  Parse argc/argv argument vector.
 409 *
 410 * [eventually this will replace the BSD getopt]
 411 */
 412 #if defined(REPLACE_GETOPT)
 413 int getopt(int nargc, char *const *nargv, const char *options) {
 414
 415   /*
 416   * We don't pass FLAG_PERMUTE to getopt_internal() since
 417   * the BSD getopt(3) (unlike GNU) has never done this.
 418   *
 419   * Furthermore, since many privileged programs call getopt()
 420   * before dropping privileges it makes sense to keep things
 421   * as simple (and bug-free) as possible.
 422   */
 423   return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
 424 }
 425 #endif
 426
 427 /*
 428 * getopt_long --
 429 *  Parse argc/argv argument vector.
 430 */
 431 #if defined(REPLACE_GETOPT_LONG)
 432 int getopt_long(int nargc, char *const *nargv, const char *options,
 433                 const struct option *long_options, int *idx) {
 434   return (
 435       getopt_internal(nargc, nargv, options, long_options, idx, FLAG_PERMUTE));
 436 }
 437 #endif
 438
 439 /*
 440 * getopt_long_only --
 441 *  Parse argc/argv argument vector.
 442 */
 443 #if defined(REPLACE_GETOPT_LONG_ONLY)
 444 int getopt_long_only(int nargc, char *const *nargv, const char *options,
 445                      const struct option *long_options, int *idx) {
 446
 447   return (getopt_internal(nargc, nargv, options, long_options, idx,
 448                           FLAG_PERMUTE | FLAG_LONGONLY));
 449 }
 450 #endif
 451
 452 #endif