Annotation of gforth/getopt.c, revision 1.1

1.1     ! anton       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 roland@gnu.ai.mit.edu
        !             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
        !            11:    Free Software Foundation; either version 2, or (at your option) any
        !            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
        !            21:    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            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>