getopt.c

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