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