Annotation of gforth/engine/getopt.c, revision 1.4

1.1       anton       1: /* Getopt for GNU.
                      2:    NOTE: getopt is now part of the C library, so if you don't know what
1.3       anton       3:    "Keep this file name-space clean" means, talk to roland@gnu.org
1.1       anton       4:    before changing it!
                      5: 
                      6:    Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
                      7:        Free Software Foundation, Inc.
                      8: 
                      9:    This program is free software; you can redistribute it and/or modify it
                     10:    under the terms of the GNU General Public License as published by the
1.4     ! anton      11:    Free Software Foundation; either version 3, or (at your option) any
1.1       anton      12:    later version.
                     13: 
                     14:    This program 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
                     17:    GNU General Public License for more details.
                     18: 
                     19:    You should have received a copy of the GNU General Public License
                     20:    along with this program; if not, write to the Free Software
1.2       anton      21:    Foundation, 59 Temple Place, Suite 330, Boston, MA 02111, USA.  */
1.1       anton      22: 
                     23: /* NOTE!!!  AIX requires this to be the first thing in the file.
                     24:    Do not put ANYTHING before it!  */
                     25: #if !defined (__GNUC__) && defined (_AIX)
                     26:  #pragma alloca
                     27: #endif
                     28: 
                     29: #ifdef HAVE_CONFIG_H
                     30: #include "config.h"
                     31: #endif
                     32: 
                     33: #ifdef __GNUC__
                     34: #define alloca __builtin_alloca
                     35: #else /* not __GNUC__ */
                     36: #if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__))))
                     37: #include <alloca.h>
                     38: #else
                     39: #ifndef _AIX
                     40: char *alloca ();
                     41: #endif
                     42: #endif /* alloca.h */
                     43: #endif /* not __GNUC__ */
                     44: 
                     45: #if !__STDC__ && !defined(const) && IN_GCC
                     46: #define const
                     47: #endif
                     48: 
                     49: /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.  */
                     50: #ifndef _NO_PROTO
                     51: #define _NO_PROTO
                     52: #endif
                     53: 
                     54: #include <stdio.h>
                     55: 
                     56: /* Comment out all this code if we are using the GNU C Library, and are not
                     57:    actually compiling the library itself.  This code is part of the GNU C
                     58:    Library, but also included in many other GNU distributions.  Compiling
                     59:    and linking in this code is a waste when using the GNU C library
                     60:    (especially if it is a shared library).  Rather than having every GNU
                     61:    program understand `configure --with-gnu-libc' and omit the object files,
                     62:    it is simpler to just do this in the source for each such file.  */
                     63: 
                     64: #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
                     65: 
                     66: 
                     67: /* This needs to come after some library #include
                     68:    to get __GNU_LIBRARY__ defined.  */
                     69: #ifdef __GNU_LIBRARY__
                     70: #undef alloca
                     71: /* Don't include stdlib.h for non-GNU C libraries because some of them
                     72:    contain conflicting prototypes for getopt.  */
                     73: #include <stdlib.h>
                     74: #else  /* Not GNU C library.  */
                     75: #define        __alloca        alloca
                     76: #endif /* GNU C library.  */
                     77: 
                     78: #if !defined (__STDC__) && !defined (const)
                     79: #  define const
                     80: #endif
                     81: 
                     82: /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
                     83:    long-named option.  Because this is not POSIX.2 compliant, it is
                     84:    being phased out.  */
                     85: /* #define GETOPT_COMPAT */
                     86: 
                     87: /* This version of `getopt' appears to the caller like standard Unix `getopt'
                     88:    but it behaves differently for the user, since it allows the user
                     89:    to intersperse the options with the other arguments.
                     90: 
                     91:    As `getopt' works, it permutes the elements of ARGV so that,
                     92:    when it is done, all the options precede everything else.  Thus
                     93:    all application programs are extended to handle flexible argument order.
                     94: 
                     95:    Setting the environment variable POSIXLY_CORRECT disables permutation.
                     96:    Then the behavior is completely standard.
                     97: 
                     98:    GNU application programs can use a third alternative mode in which
                     99:    they can distinguish the relative order of options and other arguments.  */
                    100: 
                    101: #include "getopt.h"
                    102: 
                    103: /* For communication from `getopt' to the caller.
                    104:    When `getopt' finds an option that takes an argument,
                    105:    the argument value is returned here.
                    106:    Also, when `ordering' is RETURN_IN_ORDER,
                    107:    each non-option ARGV-element is returned here.  */
                    108: 
                    109: char *optarg = 0;
                    110: 
                    111: /* Index in ARGV of the next element to be scanned.
                    112:    This is used for communication to and from the caller
                    113:    and for communication between successive calls to `getopt'.
                    114: 
                    115:    On entry to `getopt', zero means this is the first call; initialize.
                    116: 
                    117:    When `getopt' returns EOF, this is the index of the first of the
                    118:    non-option elements that the caller should itself scan.
                    119: 
                    120:    Otherwise, `optind' communicates from one call to the next
                    121:    how much of ARGV has been scanned so far.  */
                    122: 
                    123: /* XXX 1003.2 says this must be 1 before any call.  */
                    124: int optind = 0;
                    125: 
                    126: /* The next char to be scanned in the option-element
                    127:    in which the last option character we returned was found.
                    128:    This allows us to pick up the scan where we left off.
                    129: 
                    130:    If this is zero, or a null string, it means resume the scan
                    131:    by advancing to the next ARGV-element.  */
                    132: 
                    133: static char *nextchar;
                    134: 
                    135: /* Callers store zero here to inhibit the error message
                    136:    for unrecognized options.  */
                    137: 
                    138: int opterr = 1;
                    139: 
                    140: /* Set to an option character which was unrecognized.
                    141:    This must be initialized on some systems to avoid linking in the
                    142:    system's own getopt implementation.  */
                    143: 
                    144: int optopt = '?';
                    145: 
                    146: /* Describe how to deal with options that follow non-option ARGV-elements.
                    147: 
                    148:    If the caller did not specify anything,
                    149:    the default is REQUIRE_ORDER if the environment variable
                    150:    POSIXLY_CORRECT is defined, PERMUTE otherwise.
                    151: 
                    152:    REQUIRE_ORDER means don't recognize them as options;
                    153:    stop option processing when the first non-option is seen.
                    154:    This is what Unix does.
                    155:    This mode of operation is selected by either setting the environment
                    156:    variable POSIXLY_CORRECT, or using `+' as the first character
                    157:    of the list of option characters.
                    158: 
                    159:    PERMUTE is the default.  We permute the contents of ARGV as we scan,
                    160:    so that eventually all the non-options are at the end.  This allows options
                    161:    to be given in any order, even with programs that were not written to
                    162:    expect this.
                    163: 
                    164:    RETURN_IN_ORDER is an option available to programs that were written
                    165:    to expect options and other ARGV-elements in any order and that care about
                    166:    the ordering of the two.  We describe each non-option ARGV-element
                    167:    as if it were the argument of an option with character code 1.
                    168:    Using `-' as the first character of the list of option characters
                    169:    selects this mode of operation.
                    170: 
                    171:    The special argument `--' forces an end of option-scanning regardless
                    172:    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
                    173:    `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
                    174: 
                    175: static enum
                    176: {
                    177:   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
                    178: } ordering, default_ordering = PERMUTE;
                    179: 
                    180: #ifdef __GNU_LIBRARY__
                    181: /* We want to avoid inclusion of string.h with non-GNU libraries
                    182:    because there are many ways it can cause trouble.
                    183:    On some systems, it contains special magic macros that don't work
                    184:    in GCC.  */
                    185: #include <string.h>
                    186: #define        my_index        strchr
                    187: #define        my_bcopy(src, dst, n)   memcpy ((dst), (src), (n))
                    188: #else
                    189: 
                    190: /* Avoid depending on library functions or files
                    191:    whose names are inconsistent.  */
                    192: 
                    193: char *getenv ();
                    194: 
                    195: static char *
                    196: my_index (str, chr)
                    197:      const char *str;
                    198:      int chr;
                    199: {
                    200:   while (*str)
                    201:     {
                    202:       if (*str == chr)
                    203:        return (char *) str;
                    204:       str++;
                    205:     }
                    206:   return 0;
                    207: }
                    208: 
                    209: static void
                    210: my_bcopy (from, to, size)
                    211:      const char *from;
                    212:      char *to;
                    213:      int size;
                    214: {
                    215:   int i;
                    216:   for (i = 0; i < size; i++)
                    217:     to[i] = from[i];
                    218: }
                    219: #endif                         /* GNU C library.  */
                    220: 
                    221: /* Handle permutation of arguments.  */
                    222: 
                    223: /* Describe the part of ARGV that contains non-options that have
                    224:    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
                    225:    `last_nonopt' is the index after the last of them.  */
                    226: 
                    227: static int first_nonopt;
                    228: static int last_nonopt;
                    229: 
                    230: /* Exchange two adjacent subsequences of ARGV.
                    231:    One subsequence is elements [first_nonopt,last_nonopt)
                    232:    which contains all the non-options that have been skipped so far.
                    233:    The other is elements [last_nonopt,optind), which contains all
                    234:    the options processed since those non-options were skipped.
                    235: 
                    236:    `first_nonopt' and `last_nonopt' are relocated so that they describe
                    237:    the new indices of the non-options in ARGV after they are moved.  */
                    238: 
                    239: static void
                    240: exchange (argv)
                    241:      char **argv;
                    242: {
                    243:   int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
                    244:   char **temp = (char **) __alloca (nonopts_size);
                    245: 
                    246:   /* Interchange the two blocks of data in ARGV.  */
                    247: 
                    248:   my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size);
                    249:   my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt],
                    250:            (optind - last_nonopt) * sizeof (char *));
                    251:   my_bcopy ((char *) temp,
                    252:            (char *) &argv[first_nonopt + optind - last_nonopt],
                    253:            nonopts_size);
                    254: 
                    255:   /* Update records for the slots the non-options now occupy.  */
                    256: 
                    257:   first_nonopt += (optind - last_nonopt);
                    258:   last_nonopt = optind;
                    259: }
                    260: 
                    261: /* Scan elements of ARGV (whose length is ARGC) for option characters
                    262:    given in OPTSTRING.
                    263: 
                    264:    If an element of ARGV starts with '-', and is not exactly "-" or "--",
                    265:    then it is an option element.  The characters of this element
                    266:    (aside from the initial '-') are option characters.  If `getopt'
                    267:    is called repeatedly, it returns successively each of the option characters
                    268:    from each of the option elements.
                    269: 
                    270:    If `getopt' finds another option character, it returns that character,
                    271:    updating `optind' and `nextchar' so that the next call to `getopt' can
                    272:    resume the scan with the following option character or ARGV-element.
                    273: 
                    274:    If there are no more option characters, `getopt' returns `EOF'.
                    275:    Then `optind' is the index in ARGV of the first ARGV-element
                    276:    that is not an option.  (The ARGV-elements have been permuted
                    277:    so that those that are not options now come last.)
                    278: 
                    279:    OPTSTRING is a string containing the legitimate option characters.
                    280:    If an option character is seen that is not listed in OPTSTRING,
                    281:    return '?' after printing an error message.  If you set `opterr' to
                    282:    zero, the error message is suppressed but we still return '?'.
                    283: 
                    284:    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
                    285:    so the following text in the same ARGV-element, or the text of the following
                    286:    ARGV-element, is returned in `optarg'.  Two colons mean an option that
                    287:    wants an optional arg; if there is text in the current ARGV-element,
                    288:    it is returned in `optarg', otherwise `optarg' is set to zero.
                    289: 
                    290:    If OPTSTRING starts with `-' or `+', it requests different methods of
                    291:    handling the non-option ARGV-elements.
                    292:    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
                    293: 
                    294:    Long-named options begin with `--' instead of `-'.
                    295:    Their names may be abbreviated as long as the abbreviation is unique
                    296:    or is an exact match for some defined option.  If they have an
                    297:    argument, it follows the option name in the same ARGV-element, separated
                    298:    from the option name by a `=', or else the in next ARGV-element.
                    299:    When `getopt' finds a long-named option, it returns 0 if that option's
                    300:    `flag' field is nonzero, the value of the option's `val' field
                    301:    if the `flag' field is zero.
                    302: 
                    303:    The elements of ARGV aren't really const, because we permute them.
                    304:    But we pretend they're const in the prototype to be compatible
                    305:    with other systems.
                    306: 
                    307:    LONGOPTS is a vector of `struct option' terminated by an
                    308:    element containing a name which is zero.
                    309: 
                    310:    LONGIND returns the index in LONGOPT of the long-named option found.
                    311:    It is only valid when a long-named option has been found by the most
                    312:    recent call.
                    313: 
                    314:    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
                    315:    long-named options.  */
                    316: 
                    317: /* Call this function with an argument of 1 to set the default option
                    318:    ordering to that required by Posix.  The normal default is PERMUTE. */
                    319: void
                    320: getopt_set_posix_option_order (on_or_off)
                    321:      int on_or_off;
                    322: {
                    323:   if (on_or_off == 1)
                    324:     default_ordering = REQUIRE_ORDER;
                    325:   else
                    326:     default_ordering = PERMUTE;
                    327: }
                    328:        
                    329: int
                    330: _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
                    331:      int argc;
                    332:      char *const *argv;
                    333:      const char *optstring;
                    334:      const struct option *longopts;
                    335:      int *longind;
                    336:      int long_only;
                    337: {
                    338:   int option_index;
                    339: 
                    340:   optarg = 0;
                    341: 
                    342:   if (optind > argc || optind < 0)
                    343:     {
                    344:       optind = argc;
                    345:       return (EOF);
                    346:     }
                    347: 
                    348:   /* Initialize the internal data when the first call is made.
                    349:      Start processing options with ARGV-element 1 (since ARGV-element 0
                    350:      is the program name); the sequence of previously skipped
                    351:      non-option ARGV-elements is empty.  */
                    352: 
                    353:   if (optind == 0)
                    354:     {
                    355:       first_nonopt = last_nonopt = optind = 1;
                    356: 
                    357:       nextchar = NULL;
                    358: 
                    359:       /* Determine how to handle the ordering of options and nonoptions.  */
                    360: 
                    361:       if (optstring[0] == '-')
                    362:        {
                    363:          ordering = RETURN_IN_ORDER;
                    364:          ++optstring;
                    365:        }
                    366:       else if (optstring[0] == '+')
                    367:        {
                    368:          ordering = REQUIRE_ORDER;
                    369:          ++optstring;
                    370:        }
                    371:       else if (getenv ("POSIXLY_CORRECT") != NULL)
                    372:        ordering = REQUIRE_ORDER;
                    373:       else
                    374:        ordering = default_ordering;
                    375:     }
                    376: 
                    377:   if (nextchar == NULL || *nextchar == '\0')
                    378:     {
                    379:       if (ordering == PERMUTE)
                    380:        {
                    381:          /* If we have just processed some options following some non-options,
                    382:             exchange them so that the options come first.  */
                    383: 
                    384:          if (first_nonopt != last_nonopt && last_nonopt != optind)
                    385:            exchange ((char **) argv);
                    386:          else if (last_nonopt != optind)
                    387:            first_nonopt = optind;
                    388: 
                    389:          /* Now skip any additional non-options
                    390:             and extend the range of non-options previously skipped.  */
                    391: 
                    392:          while (optind < argc
                    393:                 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
                    394: #ifdef GETOPT_COMPAT
                    395:                 && (longopts == NULL
                    396:                     || argv[optind][0] != '+' || argv[optind][1] == '\0')
                    397: #endif                         /* GETOPT_COMPAT */
                    398:                 )
                    399:            optind++;
                    400:          last_nonopt = optind;
                    401:        }
                    402: 
                    403:       /* Special ARGV-element `--' means premature end of options.
                    404:         Skip it like a null option,
                    405:         then exchange with previous non-options as if it were an option,
                    406:         then skip everything else like a non-option.  */
                    407: 
                    408:       if (optind != argc && !strcmp (argv[optind], "--"))
                    409:        {
                    410:          optind++;
                    411: 
                    412:          if (first_nonopt != last_nonopt && last_nonopt != optind)
                    413:            exchange ((char **) argv);
                    414:          else if (first_nonopt == last_nonopt)
                    415:            first_nonopt = optind;
                    416:          last_nonopt = argc;
                    417: 
                    418:          optind = argc;
                    419:        }
                    420: 
                    421:       /* If we have done all the ARGV-elements, stop the scan
                    422:         and back over any non-options that we skipped and permuted.  */
                    423: 
                    424:       if (optind == argc)
                    425:        {
                    426:          /* Set the next-arg-index to point at the non-options
                    427:             that we previously skipped, so the caller will digest them.  */
                    428:          if (first_nonopt != last_nonopt)
                    429:            optind = first_nonopt;
                    430:          return EOF;
                    431:        }
                    432: 
                    433:       /* If we have come to a non-option and did not permute it,
                    434:         either stop the scan or describe it to the caller and pass it by.  */
                    435: 
                    436:       if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
                    437: #ifdef GETOPT_COMPAT
                    438:          && (longopts == NULL
                    439:              || argv[optind][0] != '+' || argv[optind][1] == '\0')
                    440: #endif                         /* GETOPT_COMPAT */
                    441:          )
                    442:        {
                    443:          if (ordering == REQUIRE_ORDER)
                    444:            return EOF;
                    445:          optarg = argv[optind++];
                    446:          return 1;
                    447:        }
                    448: 
                    449:       /* We have found another option-ARGV-element.
                    450:         Start decoding its characters.  */
                    451: 
                    452:       nextchar = (argv[optind] + 1
                    453:                  + (longopts != NULL && argv[optind][1] == '-'));
                    454:     }
                    455: 
                    456:   if (longopts != NULL
                    457:       && ((argv[optind][0] == '-'
                    458:           && (argv[optind][1] == '-' || long_only))
                    459: #ifdef GETOPT_COMPAT
                    460:          || argv[optind][0] == '+'
                    461: #endif                         /* GETOPT_COMPAT */
                    462:          ))
                    463:     {
                    464:       const struct option *p;
                    465:       char *s = nextchar;
                    466:       int exact = 0;
                    467:       int ambig = 0;
                    468:       const struct option *pfound = NULL;
                    469:       int indfound;
                    470: 
                    471:       while (*s && *s != '=')
                    472:        s++;
                    473: 
                    474:       /* Test all options for either exact match or abbreviated matches.  */
                    475:       for (p = longopts, option_index = 0; p->name;
                    476:           p++, option_index++)
                    477:        if (!strncmp (p->name, nextchar, s - nextchar))
                    478:          {
                    479:            if (s - nextchar == strlen (p->name))
                    480:              {
                    481:                /* Exact match found.  */
                    482:                pfound = p;
                    483:                indfound = option_index;
                    484:                exact = 1;
                    485:                break;
                    486:              }
                    487:            else if (pfound == NULL)
                    488:              {
                    489:                /* First nonexact match found.  */
                    490:                pfound = p;
                    491:                indfound = option_index;
                    492:              }
                    493:            else
                    494:              /* Second nonexact match found.  */
                    495:              ambig = 1;
                    496:          }
                    497: 
                    498:       if (ambig && !exact)
                    499:        {
                    500:          if (opterr)
                    501:            fprintf (stderr, "%s: option `%s' is ambiguous\n",
                    502:                     argv[0], argv[optind]);
                    503:          nextchar += strlen (nextchar);
                    504:          optind++;
                    505:          return '?';
                    506:        }
                    507: 
                    508:       if (pfound != NULL)
                    509:        {
                    510:          option_index = indfound;
                    511:          optind++;
                    512:          if (*s)
                    513:            {
                    514:              /* Don't test has_arg with >, because some C compilers don't
                    515:                 allow it to be used on enums.  */
                    516:              if (pfound->has_arg)
                    517:                optarg = s + 1;
                    518:              else
                    519:                {
                    520:                  if (opterr)
                    521:                    {
                    522:                      if (argv[optind - 1][1] == '-')
                    523:                        /* --option */
                    524:                        fprintf (stderr,
                    525:                                 "%s: option `--%s' doesn't allow an argument\n",
                    526:                                 argv[0], pfound->name);
                    527:                      else
                    528:                        /* +option or -option */
                    529:                        fprintf (stderr,
                    530:                             "%s: option `%c%s' doesn't allow an argument\n",
                    531:                             argv[0], argv[optind - 1][0], pfound->name);
                    532:                    }
                    533:                  nextchar += strlen (nextchar);
                    534:                  return '?';
                    535:                }
                    536:            }
                    537:          else if (pfound->has_arg == 1)
                    538:            {
                    539:              if (optind < argc)
                    540:                optarg = argv[optind++];
                    541:              else
                    542:                {
                    543:                  if (opterr)
                    544:                    fprintf (stderr, "%s: option `%s' requires an argument\n",
                    545:                             argv[0], argv[optind - 1]);
                    546:                  nextchar += strlen (nextchar);
                    547:                  return optstring[0] == ':' ? ':' : '?';
                    548:                }
                    549:            }
                    550:          nextchar += strlen (nextchar);
                    551:          if (longind != NULL)
                    552:            *longind = option_index;
                    553:          if (pfound->flag)
                    554:            {
                    555:              *(pfound->flag) = pfound->val;
                    556:              return 0;
                    557:            }
                    558:          return pfound->val;
                    559:        }
                    560:       /* Can't find it as a long option.  If this is not getopt_long_only,
                    561:         or the option starts with '--' or is not a valid short
                    562:         option, then it's an error.
                    563:         Otherwise interpret it as a short option.  */
                    564:       if (!long_only || argv[optind][1] == '-'
                    565: #ifdef GETOPT_COMPAT
                    566:          || argv[optind][0] == '+'
                    567: #endif                         /* GETOPT_COMPAT */
                    568:          || my_index (optstring, *nextchar) == NULL)
                    569:        {
                    570:          if (opterr)
                    571:            {
                    572:              if (argv[optind][1] == '-')
                    573:                /* --option */
                    574:                fprintf (stderr, "%s: unrecognized option `--%s'\n",
                    575:                         argv[0], nextchar);
                    576:              else
                    577:                /* +option or -option */
                    578:                fprintf (stderr, "%s: unrecognized option `%c%s'\n",
                    579:                         argv[0], argv[optind][0], nextchar);
                    580:            }
                    581:          nextchar = (char *) "";
                    582:          optind++;
                    583:          return '?';
                    584:        }
                    585:     }
                    586: 
                    587:   /* Look at and handle the next option-character.  */
                    588: 
                    589:   {
                    590:     char c = *nextchar++;
                    591:     char *temp = my_index (optstring, c);
                    592: 
                    593:     /* Increment `optind' when we start to process its last character.  */
                    594:     if (*nextchar == '\0')
                    595:       ++optind;
                    596: 
                    597:     optopt = c;
                    598: 
                    599:     if (temp == NULL || c == ':')
                    600:       {
                    601:        if (opterr)
                    602:          {
                    603: #if 0
                    604:            if (c < 040 || c >= 0177)
                    605:              fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
                    606:                       argv[0], c);
                    607:            else
                    608:              fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
                    609: #else
                    610:            /* 1003.2 specifies the format of this message.  */
                    611:            fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
                    612: #endif
                    613:          }
                    614:        optopt = c;
                    615:        return '?';
                    616:       }
                    617:     if (temp[1] == ':')
                    618:       {
                    619:        if (temp[2] == ':')
                    620:          {
                    621:            /* This is an option that accepts an argument optionally.  */
                    622:            if (*nextchar != '\0')
                    623:              {
                    624:                optarg = nextchar;
                    625:                optind++;
                    626:              }
                    627:            else
                    628:              optarg = 0;
                    629:            nextchar = NULL;
                    630:          }
                    631:        else
                    632:          {
                    633:            /* This is an option that requires an argument.  */
                    634:            if (*nextchar != '\0')
                    635:              {
                    636:                optarg = nextchar;
                    637:                /* If we end this ARGV-element by taking the rest as an arg,
                    638:                   we must advance to the next element now.  */
                    639:                optind++;
                    640:              }
                    641:            else if (optind == argc)
                    642:              {
                    643:                if (opterr)
                    644:                  {
                    645: #if 0
                    646:                    fprintf (stderr, "%s: option `-%c' requires an argument\n",
                    647:                             argv[0], c);
                    648: #else
                    649:                    /* 1003.2 specifies the format of this message.  */
                    650:                    fprintf (stderr, "%s: option requires an argument -- %c\n",
                    651:                             argv[0], c);
                    652: #endif
                    653:                  }
                    654:                optopt = c;
                    655:                if (optstring[0] == ':')
                    656:                  c = ':';
                    657:                else
                    658:                  c = '?';
                    659:              }
                    660:            else
                    661:              /* We already incremented `optind' once;
                    662:                 increment it again when taking next ARGV-elt as argument.  */
                    663:              optarg = argv[optind++];
                    664:            nextchar = NULL;
                    665:          }
                    666:       }
                    667:     return c;
                    668:   }
                    669: }
                    670: 
                    671: int
                    672: getopt (argc, argv, optstring)
                    673:      int argc;
                    674:      char *const *argv;
                    675:      const char *optstring;
                    676: {
                    677:   return _getopt_internal (argc, argv, optstring,
                    678:                           (const struct option *) 0,
                    679:                           (int *) 0,
                    680:                           0);
                    681: }
                    682: 
                    683: #endif /* _LIBC or not __GNU_LIBRARY__.  */
                    684: 
                    685: #ifdef TEST
                    686: 
                    687: /* Compile with -DTEST to make an executable for use in testing
                    688:    the above definition of `getopt'.  */
                    689: 
                    690: int
                    691: main (argc, argv)
                    692:      int argc;
                    693:      char **argv;
                    694: {
                    695:   int c;
                    696:   int digit_optind = 0;
                    697: 
                    698:   while (1)
                    699:     {
                    700:       int this_option_optind = optind ? optind : 1;
                    701: 
                    702:       c = getopt (argc, argv, "abc:d:0123456789");
                    703:       if (c == EOF)
                    704:        break;
                    705: 
                    706:       switch (c)
                    707:        {
                    708:        case '0':
                    709:        case '1':
                    710:        case '2':
                    711:        case '3':
                    712:        case '4':
                    713:        case '5':
                    714:        case '6':
                    715:        case '7':
                    716:        case '8':
                    717:        case '9':
                    718:          if (digit_optind != 0 && digit_optind != this_option_optind)
                    719:            printf ("digits occur in two different argv-elements.\n");
                    720:          digit_optind = this_option_optind;
                    721:          printf ("option %c\n", c);
                    722:          break;
                    723: 
                    724:        case 'a':
                    725:          printf ("option a\n");
                    726:          break;
                    727: 
                    728:        case 'b':
                    729:          printf ("option b\n");
                    730:          break;
                    731: 
                    732:        case 'c':
                    733:          printf ("option c with value `%s'\n", optarg);
                    734:          break;
                    735: 
                    736:        case '?':
                    737:          break;
                    738: 
                    739:        default:
                    740:          printf ("?? getopt returned character code 0%o ??\n", c);
                    741:        }
                    742:     }
                    743: 
                    744:   if (optind < argc)
                    745:     {
                    746:       printf ("non-option ARGV-elements: ");
                    747:       while (optind < argc)
                    748:        printf ("%s ", argv[optind++]);
                    749:       printf ("\n");
                    750:     }
                    751: 
                    752:   exit (0);
                    753: }
                    754: 
                    755: #endif /* TEST */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>