1: /* Getopt for GNU.
    2:    NOTE: getopt is now part of the C library, so if you don't know what
    3:    "Keep this file name-space clean" means, talk to drepper@gnu.org
    4:    before changing it!
    5:    Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004
    6:         Free Software Foundation, Inc.
    7:    This file is part of the GNU C Library.
    8: 
    9:    The GNU C Library is free software; you can redistribute it and/or
   10:    modify it under the terms of the GNU Lesser General Public
   11:    License as published by the Free Software Foundation; either
   12:    version 2.1 of the License, or (at your option) any later version.
   13: 
   14:    The GNU C Library is distributed in the hope that it will be useful,
   15:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   16:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   17:    Lesser General Public License for more details.
   18: 
   19:    You should have received a copy of the GNU Lesser General Public
   20:    License along with the GNU C Library; if not, write to the Free
   21:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   22:    02111-1307 USA.  */
   23: ^L
   24: /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
   25:    Ditto for AIX 3.2 and <stdlib.h>.  */
   26: #ifndef _NO_PROTO
   27: # define _NO_PROTO
   28: #endif
   29: 
   30: #ifdef HAVE_CONFIG_H
   31: # include <config.h>
   32: #endif
   33: 
   34: #include <stdio.h>
   35: 
   36: /* Comment out all this code if we are using the GNU C Library, and are not
   37:    actually compiling the library itself.  This code is part of the GNU C
   38:    Library, but also included in many other GNU distributions.  Compiling
   39:    and linking in this code is a waste when using the GNU C library
   40:    (especially if it is a shared library).  Rather than having every GNU
   41:    program understand `configure --with-gnu-libc' and omit the object files,
   42:    it is simpler to just do this in the source for each such file.  */
   43: 
   44: #define GETOPT_INTERFACE_VERSION 2
   45: #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
   46: # include <gnu-versions.h>
   47: # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
   48: #  define ELIDE_CODE
   49: # endif
   50: #endif
   51: 
   52: #ifndef ELIDE_CODE
   53: 
   54: 
   55: /* This needs to come after some library #include
   56:    to get __GNU_LIBRARY__ defined.  */
   57: #ifdef  __GNU_LIBRARY__
   58: /* Don't include stdlib.h for non-GNU C libraries because some of them
   59:    contain conflicting prototypes for getopt.  */
   60: # include <stdlib.h>
   61: # include <unistd.h>
   62: #endif  /* GNU C library.  */
   63: 
   64: #include <string.h>
   65: 
   66: #ifdef VMS
   67: # include <unixlib.h>
   68: #endif
   69: 
   70: #ifdef _LIBC
   71: # include <libintl.h>
   72: #else
   73: # include "gettext.h"
   74: # define _(msgid) gettext (msgid)
   75: #endif
   76: 
   77: #if defined _LIBC && defined USE_IN_LIBIO
   78: # include <wchar.h>
   79: #endif
   80: 
   81: #ifndef attribute_hidden
   82: # define attribute_hidden
   83: #endif
   84: 
   85: /* This version of `getopt' appears to the caller like standard Unix `getopt'
   86:    but it behaves differently for the user, since it allows the user
   87:    to intersperse the options with the other arguments.
   88: 
   89:    As `getopt' works, it permutes the elements of ARGV so that,
   90:    when it is done, all the options precede everything else.  Thus
   91:    all application programs are extended to handle flexible argument order.
   92: 
   93:    Setting the environment variable POSIXLY_CORRECT disables permutation.
   94:    Then the behavior is completely standard.
   95: 
   96:    GNU application programs can use a third alternative mode in which
   97:    they can distinguish the relative order of options and other arguments.  */
   98: 
   99: #include "getopt.h"
  100: #include "getopt_int.h"
  101: 
  102: /* For communication from `getopt' to the caller.
  103:    When `getopt' finds an option that takes an argument,
  104:    the argument value is returned here.
  105:    Also, when `ordering' is RETURN_IN_ORDER,
  106:    each non-option ARGV-element is returned here.  */
  107: 
  108: char *optarg;
  109: 
  110: /* Index in ARGV of the next element to be scanned.
  111:    This is used for communication to and from the caller
  112:    and for communication between successive calls to `getopt'.
  113: 
  114:    On entry to `getopt', zero means this is the first call; initialize.
  115: 
  116:    When `getopt' returns -1, this is the index of the first of the
  117:    non-option elements that the caller should itself scan.
  118: 
  119:    Otherwise, `optind' communicates from one call to the next
  120:    how much of ARGV has been scanned so far.  */
  121: 
  122: /* 1003.2 says this must be 1 before any call.  */
  123: int optind = 1;
  124: 
  125: /* Callers store zero here to inhibit the error message
  126:    for unrecognized options.  */
  127: 
  128: int opterr = 1;
  129: 
  130: /* Set to an option character which was unrecognized.
  131:    This must be initialized on some systems to avoid linking in the
  132:    system's own getopt implementation.  */
  133: 
  134: int optopt = '?';
  135: 
  136: /* Keep a global copy of all internal members of getopt_data.  */
  137: 
  138: static struct _getopt_data getopt_data;
  139: 
  140: ^L
  141: #ifndef __GNU_LIBRARY__
  142: 
  143: /* Avoid depending on library functions or files
  144:    whose names are inconsistent.  */
  145: 
  146: #ifndef getenv
  147: extern char *getenv ();
  148: #endif
  149: 
  150: #endif /* not __GNU_LIBRARY__ */
  151: ^L
  152: #ifdef _LIBC
  153: /* Stored original parameters.
  154:    XXX This is no good solution.  We should rather copy the args so
  155:    that we can compare them later.  But we must not use malloc(3).  */
  156: extern int __libc_argc;
  157: extern char **__libc_argv;
  158: 
  159: /* Bash 2.0 gives us an environment variable containing flags
  160:    indicating ARGV elements that should not be considered arguments.  */
  161: 
  162: # ifdef USE_NONOPTION_FLAGS
  163: /* Defined in getopt_init.c  */
  164: extern char *__getopt_nonoption_flags;
  165: # endif
  166: 
  167: # ifdef USE_NONOPTION_FLAGS
  168: #  define SWAP_FLAGS(ch1, ch2) \
  169:   if (d->__nonoption_flags_len > 0)                                           \
  170:     {                                                                         \
  171:       char __tmp = __getopt_nonoption_flags[ch1];                             \
  172:       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
  173:       __getopt_nonoption_flags[ch2] = __tmp;                                  \
  174:     }
  175: # else
  176: #  define SWAP_FLAGS(ch1, ch2)
  177: # endif
  178: #else   /* !_LIBC */
  179: # define SWAP_FLAGS(ch1, ch2)
  180: #endif  /* _LIBC */
  181: 
  182: /* Exchange two adjacent subsequences of ARGV.
  183:    One subsequence is elements [first_nonopt,last_nonopt)
  184:    which contains all the non-options that have been skipped so far.
  185:    The other is elements [last_nonopt,optind), which contains all
  186:    the options processed since those non-options were skipped.
  187: 
  188:    `first_nonopt' and `last_nonopt' are relocated so that they describe
  189:    the new indices of the non-options in ARGV after they are moved.  */
  190: 
  191: static void
  192: exchange (char **argv, struct _getopt_data *d)
  193: {
  194:   int bottom = d->__first_nonopt;
  195:   int middle = d->__last_nonopt;
  196:   int top = d->optind;
  197:   char *tem;
  198: 
  199:   /* Exchange the shorter segment with the far end of the longer segment.
  200:      That puts the shorter segment into the right place.
  201:      It leaves the longer segment in the right place overall,
  202:      but it consists of two parts that need to be swapped next.  */
  203: 
  204: #if defined _LIBC && defined USE_NONOPTION_FLAGS
  205:   /* First make sure the handling of the `__getopt_nonoption_flags'
  206:      string can work normally.  Our top argument must be in the range
  207:      of the string.  */
  208:   if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
  209:     {
  210:       /* We must extend the array.  The user plays games with us and
  211:          presents new arguments.  */
  212:       char *new_str = malloc (top + 1);
  213:       if (new_str == NULL)
  214:         d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
  215:       else
  216:         {
  217:           memset (__mempcpy (new_str, __getopt_nonoption_flags,
  218:                              d->__nonoption_flags_max_len),
  219:                   '\0', top + 1 - d->__nonoption_flags_max_len);
  220:           d->__nonoption_flags_max_len = top + 1;
  221:           __getopt_nonoption_flags = new_str;
  222:         }
  223:     }
  224: #endif
  225: 
  226:   while (top > middle && middle > bottom)
  227:     {
  228:       if (top - middle > middle - bottom)
  229:         {
  230:           /* Bottom segment is the short one.  */
  231:           int len = middle - bottom;
  232:           register int i;
  233: 
  234:           /* Swap it with the top part of the top segment.  */
  235:           for (i = 0; i < len; i++)
  236:             {
  237:               tem = argv[bottom + i];
  238:               argv[bottom + i] = argv[top - (middle - bottom) + i];
  239:               argv[top - (middle - bottom) + i] = tem;
  240:               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
  241:             }
  242:           /* Exclude the moved bottom segment from further swapping.  */
  243:           top -= len;
  244:         }
  245:       else
  246:         {
  247:           /* Top segment is the short one.  */
  248:           int len = top - middle;
  249:           register int i;
  250: 
  251:           /* Swap it with the bottom part of the bottom segment.  */
  252:           for (i = 0; i < len; i++)
  253:             {
  254:               tem = argv[bottom + i];
  255:               argv[bottom + i] = argv[middle + i];
  256:               argv[middle + i] = tem;
  257:               SWAP_FLAGS (bottom + i, middle + i);
  258:             }
  259:           /* Exclude the moved top segment from further swapping.  */
  260:           bottom += len;
  261:         }
  262:     }
  263: 
  264:   /* Update records for the slots the non-options now occupy.  */
  265: 
  266:   d->__first_nonopt += (d->optind - d->__last_nonopt);
  267:   d->__last_nonopt = d->optind;
  268: }
  269: 
  270: /* Initialize the internal data when the first call is made.  */
  271: 
  272: static const char *
  273: _getopt_initialize (int argc, char *const *argv, const char *optstring,
  274:                     struct _getopt_data *d)
  275: {
  276:   /* Start processing options with ARGV-element 1 (since ARGV-element 0
  277:      is the program name); the sequence of previously skipped
  278:      non-option ARGV-elements is empty.  */
  279: 
  280:   d->__first_nonopt = d->__last_nonopt = d->optind;
  281: 
  282:   d->__nextchar = NULL;
  283: 
  284:   d->__posixly_correct = !!getenv ("POSIXLY_CORRECT");
  285: 
  286:   /* Determine how to handle the ordering of options and nonoptions.  */
  287: 
  288:   if (optstring[0] == '-')
  289:     {
  290:       d->__ordering = RETURN_IN_ORDER;
  291:       ++optstring;
  292:     }
  293:   else if (optstring[0] == '+')
  294:     {
  295:       d->__ordering = REQUIRE_ORDER;
  296:       ++optstring;
  297:     }
  298:   else if (d->__posixly_correct)
  299:     d->__ordering = REQUIRE_ORDER;
  300:   else
  301:     d->__ordering = PERMUTE;
  302: 
  303: #if defined _LIBC && defined USE_NONOPTION_FLAGS
  304:   if (!d->__posixly_correct
  305:       && argc == __libc_argc && argv == __libc_argv)
  306:     {
  307:       if (d->__nonoption_flags_max_len == 0)
  308:         {
  309:           if (__getopt_nonoption_flags == NULL
  310:               || __getopt_nonoption_flags[0] == '\0')
  311:             d->__nonoption_flags_max_len = -1;
  312:           else
  313:             {
  314:               const char *orig_str = __getopt_nonoption_flags;
  315:               int len = d->__nonoption_flags_max_len = strlen (orig_str);
  316:               if (d->__nonoption_flags_max_len < argc)
  317:                 d->__nonoption_flags_max_len = argc;
  318:               __getopt_nonoption_flags =
  319:                 (char *) malloc (d->__nonoption_flags_max_len);
  320:               if (__getopt_nonoption_flags == NULL)
  321:                 d->__nonoption_flags_max_len = -1;
  322:               else
  323:                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
  324:                         '\0', d->__nonoption_flags_max_len - len);
  325:             }
  326:         }
  327:       d->__nonoption_flags_len = d->__nonoption_flags_max_len;
  328:     }
  329:   else
  330:     d->__nonoption_flags_len = 0;
  331: #endif
  332: 
  333:   return optstring;
  334: }
  335: ^L
  336: /* Scan elements of ARGV (whose length is ARGC) for option characters
  337:    given in OPTSTRING.
  338: 
  339:    If an element of ARGV starts with '-', and is not exactly "-" or "--",
  340:    then it is an option element.  The characters of this element
  341:    (aside from the initial '-') are option characters.  If `getopt'
  342:    is called repeatedly, it returns successively each of the option characters
  343:    from each of the option elements.
  344: 
  345:    If `getopt' finds another option character, it returns that character,
  346:    updating `optind' and `nextchar' so that the next call to `getopt' can
  347:    resume the scan with the following option character or ARGV-element.
  348: 
  349:    If there are no more option characters, `getopt' returns -1.
  350:    Then `optind' is the index in ARGV of the first ARGV-element
  351:    that is not an option.  (The ARGV-elements have been permuted
  352:    so that those that are not options now come last.)
  353: 
  354:    OPTSTRING is a string containing the legitimate option characters.
  355:    If an option character is seen that is not listed in OPTSTRING,
  356:    return '?' after printing an error message.  If you set `opterr' to
  357:    zero, the error message is suppressed but we still return '?'.
  358: 
  359:    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
  360:    so the following text in the same ARGV-element, or the text of the following
  361:    ARGV-element, is returned in `optarg'.  Two colons mean an option that
  362:    wants an optional arg; if there is text in the current ARGV-element,
  363:    it is returned in `optarg', otherwise `optarg' is set to zero.
  364: 
  365:    If OPTSTRING starts with `-' or `+', it requests different methods of
  366:    handling the non-option ARGV-elements.
  367:    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
  368: 
  369:    Long-named options begin with `--' instead of `-'.
  370:    Their names may be abbreviated as long as the abbreviation is unique
  371:    or is an exact match for some defined option.  If they have an
  372:    argument, it follows the option name in the same ARGV-element, separated
  373:    from the option name by a `=', or else the in next ARGV-element.
  374:    When `getopt' finds a long-named option, it returns 0 if that option's
  375:    `flag' field is nonzero, the value of the option's `val' field
  376:    if the `flag' field is zero.
  377: 
  378:    The elements of ARGV aren't really const, because we permute them.
  379:    But we pretend they're const in the prototype to be compatible
  380:    with other systems.
  381: 
  382:    LONGOPTS is a vector of `struct option' terminated by an
  383:    element containing a name which is zero.
  384: 
  385:    LONGIND returns the index in LONGOPT of the long-named option found.
  386:    It is only valid when a long-named option has been found by the most
  387:    recent call.
  388: 
  389:    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
  390:    long-named options.  */
  391: 
  392: int
  393: _getopt_internal_r (int argc, char *const *argv, const char *optstring,
  394:                     const struct option *longopts, int *longind,
  395:                     int long_only, struct _getopt_data *d)
  396: {
  397:   int print_errors = d->opterr;
  398:   if (optstring[0] == ':')
  399:     print_errors = 0;
  400: 
  401:   if (argc < 1)
  402:     return -1;
  403: 
  404:   d->optarg = NULL;
  405: 
  406:   if (d->optind == 0 || !d->__initialized)
  407:     {
  408:       if (d->optind == 0)
  409:         d->optind = 1; /* Don't scan ARGV[0], the program name.  */
  410:       optstring = _getopt_initialize (argc, argv, optstring, d);
  411:       d->__initialized = 1;
  412:     }
  413: 
  414:   /* Test whether ARGV[optind] points to a non-option argument.
  415:      Either it does not have option syntax, or there is an environment flag
  416:      from the shell indicating it is not an option.  The later information
  417:      is only used when the used in the GNU libc.  */
  418: #if defined _LIBC && defined USE_NONOPTION_FLAGS
  419: # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
  420:                       || (d->optind < d->__nonoption_flags_len                      \
  421:                           && __getopt_nonoption_flags[d->optind] == '1'))
  422: #else
  423: # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
  424: #endif
  425: 
  426:   if (d->__nextchar == NULL || *d->__nextchar == '\0')
  427:     {
  428:       /* Advance to the next ARGV-element.  */
  429: 
  430:       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
  431:          moved back by the user (who may also have changed the arguments).  */
  432:       if (d->__last_nonopt > d->optind)
  433:         d->__last_nonopt = d->optind;
  434:       if (d->__first_nonopt > d->optind)
  435:         d->__first_nonopt = d->optind;
  436: 
  437:       if (d->__ordering == PERMUTE)
  438:         {
  439:           /* If we have just processed some options following some non-options,
  440:              exchange them so that the options come first.  */
  441: 
  442:           if (d->__first_nonopt != d->__last_nonopt
  443:               && d->__last_nonopt != d->optind)
  444:             exchange ((char **) argv, d);
  445:           else if (d->__last_nonopt != d->optind)
  446:             d->__first_nonopt = d->optind;
  447: 
  448:           /* Skip any additional non-options
  449:              and extend the range of non-options previously skipped.  */
  450: 
  451:           while (d->optind < argc && NONOPTION_P)
  452:             d->optind++;
  453:           d->__last_nonopt = d->optind;
  454:         }
  455: 
  456:       /* The special ARGV-element `--' means premature end of options.
  457:          Skip it like a null option,
  458:          then exchange with previous non-options as if it were an option,
  459:          then skip everything else like a non-option.  */
  460: 
  461:       if (d->optind != argc && !strcmp (argv[d->optind], "--"))
  462:         {
  463:           d->optind++;
  464: 
  465:           if (d->__first_nonopt != d->__last_nonopt
  466:               && d->__last_nonopt != d->optind)
  467:             exchange ((char **) argv, d);
  468:           else if (d->__first_nonopt == d->__last_nonopt)
  469:             d->__first_nonopt = d->optind;
  470:           d->__last_nonopt = argc;
  471: 
  472:           d->optind = argc;
  473:         }
  474: 
  475:       /* If we have done all the ARGV-elements, stop the scan
  476:          and back over any non-options that we skipped and permuted.  */
  477: 
  478:       if (d->optind == argc)
  479:         {
  480:           /* Set the next-arg-index to point at the non-options
  481:              that we previously skipped, so the caller will digest them.  */
  482:           if (d->__first_nonopt != d->__last_nonopt)
  483:             d->optind = d->__first_nonopt;
  484:           return -1;
  485:         }
  486: 
  487:       /* If we have come to a non-option and did not permute it,
  488:          either stop the scan or describe it to the caller and pass it by.  */
  489: 
  490:       if (NONOPTION_P)
  491:         {
  492:           if (d->__ordering == REQUIRE_ORDER)
  493:             return -1;
  494:           d->optarg = argv[d->optind++];
  495:           return 1;
  496:         }
  497: 
  498:       /* We have found another option-ARGV-element.
  499:          Skip the initial punctuation.  */
  500: 
  501:       d->__nextchar = (argv[d->optind] + 1
  502:                   + (longopts != NULL && argv[d->optind][1] == '-'));
  503:     }
  504: 
  505:   /* Decode the current option-ARGV-element.  */
  506: 
  507:   /* Check whether the ARGV-element is a long option.
  508: 
  509:      If long_only and the ARGV-element has the form "-f", where f is
  510:      a valid short option, don't consider it an abbreviated form of
  511:      a long option that starts with f.  Otherwise there would be no
  512:      way to give the -f short option.
  513: 
  514:      On the other hand, if there's a long option "fubar" and
  515:      the ARGV-element is "-fu", do consider that an abbreviation of
  516:      the long option, just like "--fu", and not "-f" with arg "u".
  517: 
  518:      This distinction seems to be the most useful approach.  */
  519: 
  520:   if (longopts != NULL
  521:       && (argv[d->optind][1] == '-'
  522:           || (long_only && (argv[d->optind][2]
  523:                             || !strchr (optstring, argv[d->optind][1])))))
  524:     {
  525:       char *nameend;
  526:       const struct option *p;
  527:       const struct option *pfound = NULL;
  528:       int exact = 0;
  529:       int ambig = 0;
  530:       int indfound = -1;
  531:       int option_index;
  532: 
  533:       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
  534:         /* Do nothing.  */ ;
  535: 
  536:       /* Test all long options for either exact match
  537:          or abbreviated matches.  */
  538:       for (p = longopts, option_index = 0; p->name; p++, option_index++)
  539:         if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
  540:           {
  541:             if ((unsigned int) (nameend - d->__nextchar)
  542:                 == (unsigned int) strlen (p->name))
  543:               {
  544:                 /* Exact match found.  */
  545:                 pfound = p;
  546:                 indfound = option_index;
  547:                 exact = 1;
  548:                 break;
  549:               }
  550:             else if (pfound == NULL)
  551:               {
  552:                 /* First nonexact match found.  */
  553:                 pfound = p;
  554:                 indfound = option_index;
  555:               }
  556:             else if (long_only
  557:                      || pfound->has_arg != p->has_arg
  558:                      || pfound->flag != p->flag
  559:                      || pfound->val != p->val)
  560:               /* Second or later nonexact match found.  */
  561:               ambig = 1;
  562:           }
  563: 
  564:       if (ambig && !exact)
  565:         {
  566:           if (print_errors)
  567:             {
  568: #if defined _LIBC && defined USE_IN_LIBIO
  569:               char *buf;
  570: 
  571:               if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"),
  572:                               argv[0], argv[d->optind]) >= 0)
  573:                 {
  574:                   _IO_flockfile (stderr);
  575: 
  576:                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  577:                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  578: 
  579:                   __fxprintf (NULL, "%s", buf);
  580: