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