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