compat/getopt.c

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