Branch data Line data Source code
1 : : /* Getopt for GNU.
2 : : NOTE: getopt is part of the C library, so if you don't know what
3 : : "Keep this file name-space clean" means, talk to drepper@gnu.org
4 : : before changing it!
5 : : Copyright (C) 1987-1996, 1998-2004, 2006, 2008-2013 Free Software
6 : : Foundation, Inc.
7 : : This file is part of the GNU C Library.
8 : :
9 : : This program is free software: you can redistribute it and/or modify
10 : : it under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3 of the License, or
12 : : (at your option) any 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, see <http://www.gnu.org/licenses/>. */
21 : :
22 : : #ifndef _LIBC
23 : : # include <config.h>
24 : : #endif
25 : :
26 : : #include "getopt.h"
27 : :
28 : : #include <stdio.h>
29 : : #include <stdlib.h>
30 : : #include <string.h>
31 : : #include <unistd.h>
32 : :
33 : : #ifdef _LIBC
34 : : # include <libintl.h>
35 : : #else
36 : : # include "gettext.h"
37 : : # define _(msgid) gettext (msgid)
38 : : #endif
39 : :
40 : : #if defined _LIBC && defined USE_IN_LIBIO
41 : : # include <wchar.h>
42 : : #endif
43 : :
44 : : /* This version of 'getopt' appears to the caller like standard Unix 'getopt'
45 : : but it behaves differently for the user, since it allows the user
46 : : to intersperse the options with the other arguments.
47 : :
48 : : As 'getopt_long' works, it permutes the elements of ARGV so that,
49 : : when it is done, all the options precede everything else. Thus
50 : : all application programs are extended to handle flexible argument order.
51 : :
52 : : Using 'getopt' or setting the environment variable POSIXLY_CORRECT
53 : : disables permutation.
54 : : Then the behavior is completely standard.
55 : :
56 : : GNU application programs can use a third alternative mode in which
57 : : they can distinguish the relative order of options and other arguments. */
58 : :
59 : : #include "getopt_int.h"
60 : :
61 : : /* For communication from 'getopt' to the caller.
62 : : When 'getopt' finds an option that takes an argument,
63 : : the argument value is returned here.
64 : : Also, when 'ordering' is RETURN_IN_ORDER,
65 : : each non-option ARGV-element is returned here. */
66 : :
67 : : char *optarg;
68 : :
69 : : /* Index in ARGV of the next element to be scanned.
70 : : This is used for communication to and from the caller
71 : : and for communication between successive calls to 'getopt'.
72 : :
73 : : On entry to 'getopt', zero means this is the first call; initialize.
74 : :
75 : : When 'getopt' returns -1, this is the index of the first of the
76 : : non-option elements that the caller should itself scan.
77 : :
78 : : Otherwise, 'optind' communicates from one call to the next
79 : : how much of ARGV has been scanned so far. */
80 : :
81 : : /* 1003.2 says this must be 1 before any call. */
82 : : int optind = 1;
83 : :
84 : : /* Callers store zero here to inhibit the error message
85 : : for unrecognized options. */
86 : :
87 : : int opterr = 1;
88 : :
89 : : /* Set to an option character which was unrecognized.
90 : : This must be initialized on some systems to avoid linking in the
91 : : system's own getopt implementation. */
92 : :
93 : : int optopt = '?';
94 : :
95 : : /* Keep a global copy of all internal members of getopt_data. */
96 : :
97 : : static struct _getopt_data getopt_data;
98 : :
99 : :
100 : : #if defined HAVE_DECL_GETENV && !HAVE_DECL_GETENV
101 : : extern char *getenv ();
102 : : #endif
103 : :
104 : : #ifdef _LIBC
105 : : /* Stored original parameters.
106 : : XXX This is no good solution. We should rather copy the args so
107 : : that we can compare them later. But we must not use malloc(3). */
108 : : extern int __libc_argc;
109 : : extern char **__libc_argv;
110 : :
111 : : /* Bash 2.0 gives us an environment variable containing flags
112 : : indicating ARGV elements that should not be considered arguments. */
113 : :
114 : : # ifdef USE_NONOPTION_FLAGS
115 : : /* Defined in getopt_init.c */
116 : : extern char *__getopt_nonoption_flags;
117 : : # endif
118 : :
119 : : # ifdef USE_NONOPTION_FLAGS
120 : : # define SWAP_FLAGS(ch1, ch2) \
121 : : if (d->__nonoption_flags_len > 0) \
122 : : { \
123 : : char __tmp = __getopt_nonoption_flags[ch1]; \
124 : : __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
125 : : __getopt_nonoption_flags[ch2] = __tmp; \
126 : : }
127 : : # else
128 : : # define SWAP_FLAGS(ch1, ch2)
129 : : # endif
130 : : #else /* !_LIBC */
131 : : # define SWAP_FLAGS(ch1, ch2)
132 : : #endif /* _LIBC */
133 : :
134 : : /* Exchange two adjacent subsequences of ARGV.
135 : : One subsequence is elements [first_nonopt,last_nonopt)
136 : : which contains all the non-options that have been skipped so far.
137 : : The other is elements [last_nonopt,optind), which contains all
138 : : the options processed since those non-options were skipped.
139 : :
140 : : 'first_nonopt' and 'last_nonopt' are relocated so that they describe
141 : : the new indices of the non-options in ARGV after they are moved. */
142 : :
143 : : static void
144 : 18 : exchange (char **argv, struct _getopt_data *d)
145 : : {
146 : 18 : int bottom = d->__first_nonopt;
147 : 18 : int middle = d->__last_nonopt;
148 : 18 : int top = d->optind;
149 : : char *tem;
150 : :
151 : : /* Exchange the shorter segment with the far end of the longer segment.
152 : : That puts the shorter segment into the right place.
153 : : It leaves the longer segment in the right place overall,
154 : : but it consists of two parts that need to be swapped next. */
155 : :
156 : : #if defined _LIBC && defined USE_NONOPTION_FLAGS
157 : : /* First make sure the handling of the '__getopt_nonoption_flags'
158 : : string can work normally. Our top argument must be in the range
159 : : of the string. */
160 : : if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
161 : : {
162 : : /* We must extend the array. The user plays games with us and
163 : : presents new arguments. */
164 : : char *new_str = malloc (top + 1);
165 : : if (new_str == NULL)
166 : : d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
167 : : else
168 : : {
169 : : memset (__mempcpy (new_str, __getopt_nonoption_flags,
170 : : d->__nonoption_flags_max_len),
171 : : '\0', top + 1 - d->__nonoption_flags_max_len);
172 : : d->__nonoption_flags_max_len = top + 1;
173 : : __getopt_nonoption_flags = new_str;
174 : : }
175 : : }
176 : : #endif
177 : :
178 [ + - ][ + + ]: 54 : while (top > middle && middle > bottom)
179 : : {
180 [ + + ]: 36 : if (top - middle > middle - bottom)
181 : : {
182 : : /* Bottom segment is the short one. */
183 : 8 : int len = middle - bottom;
184 : : register int i;
185 : :
186 : : /* Swap it with the top part of the top segment. */
187 [ + + ]: 16 : for (i = 0; i < len; i++)
188 : : {
189 : 8 : tem = argv[bottom + i];
190 : 8 : argv[bottom + i] = argv[top - (middle - bottom) + i];
191 : 8 : argv[top - (middle - bottom) + i] = tem;
192 : : SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
193 : : }
194 : : /* Exclude the moved bottom segment from further swapping. */
195 : 8 : top -= len;
196 : : }
197 : : else
198 : : {
199 : : /* Top segment is the short one. */
200 : 28 : int len = top - middle;
201 : : register int i;
202 : :
203 : : /* Swap it with the bottom part of the bottom segment. */
204 [ + + ]: 56 : for (i = 0; i < len; i++)
205 : : {
206 : 28 : tem = argv[bottom + i];
207 : 28 : argv[bottom + i] = argv[middle + i];
208 : 28 : argv[middle + i] = tem;
209 : : SWAP_FLAGS (bottom + i, middle + i);
210 : : }
211 : : /* Exclude the moved top segment from further swapping. */
212 : 28 : bottom += len;
213 : : }
214 : : }
215 : :
216 : : /* Update records for the slots the non-options now occupy. */
217 : :
218 : 18 : d->__first_nonopt += (d->optind - d->__last_nonopt);
219 : 18 : d->__last_nonopt = d->optind;
220 : 18 : }
221 : :
222 : : /* Initialize the internal data when the first call is made. */
223 : :
224 : : static const char *
225 : 111 : _getopt_initialize (int argc _GL_UNUSED,
226 : : char **argv _GL_UNUSED, const char *optstring,
227 : : struct _getopt_data *d, int posixly_correct)
228 : : {
229 : : /* Start processing options with ARGV-element 1 (since ARGV-element 0
230 : : is the program name); the sequence of previously skipped
231 : : non-option ARGV-elements is empty. */
232 : :
233 : 111 : d->__first_nonopt = d->__last_nonopt = d->optind;
234 : :
235 : 111 : d->__nextchar = NULL;
236 : :
237 [ + + ][ + + ]: 111 : d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
238 : :
239 : : /* Determine how to handle the ordering of options and nonoptions. */
240 : :
241 [ + + ]: 111 : if (optstring[0] == '-')
242 : : {
243 : 7 : d->__ordering = RETURN_IN_ORDER;
244 : 7 : ++optstring;
245 : : }
246 [ + + ]: 104 : else if (optstring[0] == '+')
247 : : {
248 : 15 : d->__ordering = REQUIRE_ORDER;
249 : 15 : ++optstring;
250 : : }
251 [ + + ]: 89 : else if (d->__posixly_correct)
252 : 50 : d->__ordering = REQUIRE_ORDER;
253 : : else
254 : 39 : d->__ordering = PERMUTE;
255 : :
256 : : #if defined _LIBC && defined USE_NONOPTION_FLAGS
257 : : if (!d->__posixly_correct
258 : : && argc == __libc_argc && argv == __libc_argv)
259 : : {
260 : : if (d->__nonoption_flags_max_len == 0)
261 : : {
262 : : if (__getopt_nonoption_flags == NULL
263 : : || __getopt_nonoption_flags[0] == '\0')
264 : : d->__nonoption_flags_max_len = -1;
265 : : else
266 : : {
267 : : const char *orig_str = __getopt_nonoption_flags;
268 : : int len = d->__nonoption_flags_max_len = strlen (orig_str);
269 : : if (d->__nonoption_flags_max_len < argc)
270 : : d->__nonoption_flags_max_len = argc;
271 : : __getopt_nonoption_flags =
272 : : (char *) malloc (d->__nonoption_flags_max_len);
273 : : if (__getopt_nonoption_flags == NULL)
274 : : d->__nonoption_flags_max_len = -1;
275 : : else
276 : : memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
277 : : '\0', d->__nonoption_flags_max_len - len);
278 : : }
279 : : }
280 : : d->__nonoption_flags_len = d->__nonoption_flags_max_len;
281 : : }
282 : : else
283 : : d->__nonoption_flags_len = 0;
284 : : #endif
285 : :
286 : 111 : return optstring;
287 : : }
288 : :
289 : : /* Scan elements of ARGV (whose length is ARGC) for option characters
290 : : given in OPTSTRING.
291 : :
292 : : If an element of ARGV starts with '-', and is not exactly "-" or "--",
293 : : then it is an option element. The characters of this element
294 : : (aside from the initial '-') are option characters. If 'getopt'
295 : : is called repeatedly, it returns successively each of the option characters
296 : : from each of the option elements.
297 : :
298 : : If 'getopt' finds another option character, it returns that character,
299 : : updating 'optind' and 'nextchar' so that the next call to 'getopt' can
300 : : resume the scan with the following option character or ARGV-element.
301 : :
302 : : If there are no more option characters, 'getopt' returns -1.
303 : : Then 'optind' is the index in ARGV of the first ARGV-element
304 : : that is not an option. (The ARGV-elements have been permuted
305 : : so that those that are not options now come last.)
306 : :
307 : : OPTSTRING is a string containing the legitimate option characters.
308 : : If an option character is seen that is not listed in OPTSTRING,
309 : : return '?' after printing an error message. If you set 'opterr' to
310 : : zero, the error message is suppressed but we still return '?'.
311 : :
312 : : If a char in OPTSTRING is followed by a colon, that means it wants an arg,
313 : : so the following text in the same ARGV-element, or the text of the following
314 : : ARGV-element, is returned in 'optarg'. Two colons mean an option that
315 : : wants an optional arg; if there is text in the current ARGV-element,
316 : : it is returned in 'optarg', otherwise 'optarg' is set to zero.
317 : :
318 : : If OPTSTRING starts with '-' or '+', it requests different methods of
319 : : handling the non-option ARGV-elements.
320 : : See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
321 : :
322 : : Long-named options begin with '--' instead of '-'.
323 : : Their names may be abbreviated as long as the abbreviation is unique
324 : : or is an exact match for some defined option. If they have an
325 : : argument, it follows the option name in the same ARGV-element, separated
326 : : from the option name by a '=', or else the in next ARGV-element.
327 : : When 'getopt' finds a long-named option, it returns 0 if that option's
328 : : 'flag' field is nonzero, the value of the option's 'val' field
329 : : if the 'flag' field is zero.
330 : :
331 : : The elements of ARGV aren't really const, because we permute them.
332 : : But we pretend they're const in the prototype to be compatible
333 : : with other systems.
334 : :
335 : : LONGOPTS is a vector of 'struct option' terminated by an
336 : : element containing a name which is zero.
337 : :
338 : : LONGIND returns the index in LONGOPT of the long-named option found.
339 : : It is only valid when a long-named option has been found by the most
340 : : recent call.
341 : :
342 : : If LONG_ONLY is nonzero, '-' as well as '--' can introduce
343 : : long-named options. */
344 : :
345 : : int
346 : 641 : _getopt_internal_r (int argc, char **argv, const char *optstring,
347 : : const struct option *longopts, int *longind,
348 : : int long_only, struct _getopt_data *d, int posixly_correct)
349 : : {
350 : 641 : int print_errors = d->opterr;
351 : :
352 [ - + ]: 641 : if (argc < 1)
353 : 0 : return -1;
354 : :
355 : 641 : d->optarg = NULL;
356 : :
357 [ + + ][ - + ]: 641 : if (d->optind == 0 || !d->__initialized)
358 : : {
359 [ + - ]: 111 : if (d->optind == 0)
360 : 111 : d->optind = 1; /* Don't scan ARGV[0], the program name. */
361 : 111 : optstring = _getopt_initialize (argc, argv, optstring, d,
362 : : posixly_correct);
363 : 111 : d->__initialized = 1;
364 : : }
365 [ + + ][ + + ]: 530 : else if (optstring[0] == '-' || optstring[0] == '+')
366 : 100 : optstring++;
367 [ + + ]: 641 : if (optstring[0] == ':')
368 : 68 : print_errors = 0;
369 : :
370 : : /* Test whether ARGV[optind] points to a non-option argument.
371 : : Either it does not have option syntax, or there is an environment flag
372 : : from the shell indicating it is not an option. The later information
373 : : is only used when the used in the GNU libc. */
374 : : #if defined _LIBC && defined USE_NONOPTION_FLAGS
375 : : # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
376 : : || (d->optind < d->__nonoption_flags_len \
377 : : && __getopt_nonoption_flags[d->optind] == '1'))
378 : : #else
379 : : # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
380 : : #endif
381 : :
382 [ + + ][ + + ]: 641 : if (d->__nextchar == NULL || *d->__nextchar == '\0')
383 : : {
384 : : /* Advance to the next ARGV-element. */
385 : :
386 : : /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
387 : : moved back by the user (who may also have changed the arguments). */
388 [ + + ]: 607 : if (d->__last_nonopt > d->optind)
389 : 43 : d->__last_nonopt = d->optind;
390 [ + + ]: 607 : if (d->__first_nonopt > d->optind)
391 : 43 : d->__first_nonopt = d->optind;
392 : :
393 [ + + ]: 607 : if (d->__ordering == PERMUTE)
394 : : {
395 : : /* If we have just processed some options following some non-options,
396 : : exchange them so that the options come first. */
397 : :
398 [ + + ]: 226 : if (d->__first_nonopt != d->__last_nonopt
399 [ + - ]: 16 : && d->__last_nonopt != d->optind)
400 : 16 : exchange ((char **) argv, d);
401 [ + + ]: 210 : else if (d->__last_nonopt != d->optind)
402 : 120 : d->__first_nonopt = d->optind;
403 : :
404 : : /* Skip any additional non-options
405 : : and extend the range of non-options previously skipped. */
406 : :
407 [ + + ][ + + ]: 350 : while (d->optind < argc && NONOPTION_P)
[ - + ]
408 : 124 : d->optind++;
409 : 226 : d->__last_nonopt = d->optind;
410 : : }
411 : :
412 : : /* The special ARGV-element '--' means premature end of options.
413 : : Skip it like a null option,
414 : : then exchange with previous non-options as if it were an option,
415 : : then skip everything else like a non-option. */
416 : :
417 [ + + ][ + + ]: 607 : if (d->optind != argc && !strcmp (argv[d->optind], "--"))
418 : : {
419 : 8 : d->optind++;
420 : :
421 [ + + ]: 8 : if (d->__first_nonopt != d->__last_nonopt
422 [ + - ]: 2 : && d->__last_nonopt != d->optind)
423 : 2 : exchange ((char **) argv, d);
424 [ + - ]: 6 : else if (d->__first_nonopt == d->__last_nonopt)
425 : 6 : d->__first_nonopt = d->optind;
426 : 8 : d->__last_nonopt = argc;
427 : :
428 : 8 : d->optind = argc;
429 : : }
430 : :
431 : : /* If we have done all the ARGV-elements, stop the scan
432 : : and back over any non-options that we skipped and permuted. */
433 : :
434 [ + + ]: 607 : if (d->optind == argc)
435 : : {
436 : : /* Set the next-arg-index to point at the non-options
437 : : that we previously skipped, so the caller will digest them. */
438 [ + + ]: 118 : if (d->__first_nonopt != d->__last_nonopt)
439 : 84 : d->optind = d->__first_nonopt;
440 : 118 : return -1;
441 : : }
442 : :
443 : : /* If we have come to a non-option and did not permute it,
444 : : either stop the scan or describe it to the caller and pass it by. */
445 : :
446 [ + + ][ - + ]: 489 : if (NONOPTION_P)
447 : : {
448 [ + + ]: 132 : if (d->__ordering == REQUIRE_ORDER)
449 : 100 : return -1;
450 : 32 : d->optarg = argv[d->optind++];
451 : 32 : return 1;
452 : : }
453 : :
454 : : /* We have found another option-ARGV-element.
455 : : Skip the initial punctuation. */
456 : :
457 : 357 : d->__nextchar = (argv[d->optind] + 1
458 [ + + ][ + + ]: 357 : + (longopts != NULL && argv[d->optind][1] == '-'));
459 : : }
460 : :
461 : : /* Decode the current option-ARGV-element. */
462 : :
463 : : /* Check whether the ARGV-element is a long option.
464 : :
465 : : If long_only and the ARGV-element has the form "-f", where f is
466 : : a valid short option, don't consider it an abbreviated form of
467 : : a long option that starts with f. Otherwise there would be no
468 : : way to give the -f short option.
469 : :
470 : : On the other hand, if there's a long option "fubar" and
471 : : the ARGV-element is "-fu", do consider that an abbreviation of
472 : : the long option, just like "--fu", and not "-f" with arg "u".
473 : :
474 : : This distinction seems to be the most useful approach. */
475 : :
476 [ + + ]: 391 : if (longopts != NULL
477 [ + + ]: 186 : && (argv[d->optind][1] == '-'
478 [ + + ][ + + ]: 141 : || (long_only && (argv[d->optind][2]
479 [ + + ]: 3 : || !strchr (optstring, argv[d->optind][1])))))
480 : : {
481 : : char *nameend;
482 : : unsigned int namelen;
483 : : const struct option *p;
484 : 53 : const struct option *pfound = NULL;
485 : : struct option_list
486 : : {
487 : : const struct option *p;
488 : : struct option_list *next;
489 : 53 : } *ambig_list = NULL;
490 : 53 : int exact = 0;
491 : 53 : int indfound = -1;
492 : : int option_index;
493 : :
494 [ + + ][ + + ]: 213 : for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
495 : : /* Do nothing. */ ;
496 : 53 : namelen = nameend - d->__nextchar;
497 : :
498 : : /* Test all long options for either exact match
499 : : or abbreviated matches. */
500 [ + + ]: 328 : for (p = longopts, option_index = 0; p->name; p++, option_index++)
501 [ + + ]: 294 : if (!strncmp (p->name, d->__nextchar, namelen))
502 : : {
503 [ + + ]: 83 : if (namelen == (unsigned int) strlen (p->name))
504 : : {
505 : : /* Exact match found. */
506 : 19 : pfound = p;
507 : 19 : indfound = option_index;
508 : 19 : exact = 1;
509 : 19 : break;
510 : : }
511 [ + + ]: 64 : else if (pfound == NULL)
512 : : {
513 : : /* First nonexact match found. */
514 : 36 : pfound = p;
515 : 36 : indfound = option_index;
516 : : }
517 [ + + ]: 28 : else if (long_only
518 [ + - ]: 14 : || pfound->has_arg != p->has_arg
519 [ + - ]: 14 : || pfound->flag != p->flag
520 [ + + ]: 14 : || pfound->val != p->val)
521 : : {
522 : : /* Second or later nonexact match found. */
523 : 22 : struct option_list *newp = malloc (sizeof (*newp));
524 : 22 : newp->p = p;
525 : 22 : newp->next = ambig_list;
526 : 22 : ambig_list = newp;
527 : : }
528 : : }
529 : :
530 [ + + ][ + - ]: 53 : if (ambig_list != NULL && !exact)
531 : : {
532 [ - + ]: 11 : if (print_errors)
533 : : {
534 : : struct option_list first;
535 : 0 : first.p = pfound;
536 : 0 : first.next = ambig_list;
537 : 0 : ambig_list = &first;
538 : :
539 : : #if defined _LIBC && defined USE_IN_LIBIO
540 : : char *buf = NULL;
541 : : size_t buflen = 0;
542 : :
543 : : FILE *fp = open_memstream (&buf, &buflen);
544 : : if (fp != NULL)
545 : : {
546 : : fprintf (fp,
547 : : _("%s: option '%s' is ambiguous; possibilities:"),
548 : : argv[0], argv[d->optind]);
549 : :
550 : : do
551 : : {
552 : : fprintf (fp, " '--%s'", ambig_list->p->name);
553 : : ambig_list = ambig_list->next;
554 : : }
555 : : while (ambig_list != NULL);
556 : :
557 : : fputc_unlocked ('\n', fp);
558 : :
559 : : if (__builtin_expect (fclose (fp) != EOF, 1))
560 : : {
561 : : _IO_flockfile (stderr);
562 : :
563 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
564 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
565 : :
566 : : __fxprintf (NULL, "%s", buf);
567 : :
568 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
569 : : _IO_funlockfile (stderr);
570 : :
571 : : free (buf);
572 : : }
573 : : }
574 : : #else
575 : 0 : fprintf (stderr,
576 : 0 : _("%s: option '%s' is ambiguous; possibilities:"),
577 : 0 : argv[0], argv[d->optind]);
578 : : do
579 : : {
580 : 0 : fprintf (stderr, " '--%s'", ambig_list->p->name);
581 : 0 : ambig_list = ambig_list->next;
582 : : }
583 [ # # ]: 0 : while (ambig_list != NULL);
584 : :
585 : 0 : fputc ('\n', stderr);
586 : : #endif
587 : : }
588 : 11 : d->__nextchar += strlen (d->__nextchar);
589 : 11 : d->optind++;
590 : 11 : d->optopt = 0;
591 : 11 : return '?';
592 : : }
593 : :
594 [ - + ]: 42 : while (ambig_list != NULL)
595 : : {
596 : 0 : struct option_list *pn = ambig_list->next;
597 : 0 : free (ambig_list);
598 : 0 : ambig_list = pn;
599 : : }
600 : :
601 [ + + ]: 42 : if (pfound != NULL)
602 : : {
603 : 41 : option_index = indfound;
604 : 41 : d->optind++;
605 [ + + ]: 41 : if (*nameend)
606 : : {
607 : : /* Don't test has_arg with >, because some C compilers don't
608 : : allow it to be used on enums. */
609 [ + + ]: 12 : if (pfound->has_arg)
610 : 8 : d->optarg = nameend + 1;
611 : : else
612 : : {
613 [ - + ]: 4 : if (print_errors)
614 : : {
615 : : #if defined _LIBC && defined USE_IN_LIBIO
616 : : char *buf;
617 : : int n;
618 : : #endif
619 : :
620 [ # # ]: 0 : if (argv[d->optind - 1][1] == '-')
621 : : {
622 : : /* --option */
623 : : #if defined _LIBC && defined USE_IN_LIBIO
624 : : n = __asprintf (&buf, _("\
625 : : %s: option '--%s' doesn't allow an argument\n"),
626 : : argv[0], pfound->name);
627 : : #else
628 : 0 : fprintf (stderr, _("\
629 : : %s: option '--%s' doesn't allow an argument\n"),
630 : : argv[0], pfound->name);
631 : : #endif
632 : : }
633 : : else
634 : : {
635 : : /* +option or -option */
636 : : #if defined _LIBC && defined USE_IN_LIBIO
637 : : n = __asprintf (&buf, _("\
638 : : %s: option '%c%s' doesn't allow an argument\n"),
639 : : argv[0], argv[d->optind - 1][0],
640 : : pfound->name);
641 : : #else
642 : 0 : fprintf (stderr, _("\
643 : : %s: option '%c%s' doesn't allow an argument\n"),
644 : 0 : argv[0], argv[d->optind - 1][0],
645 : : pfound->name);
646 : : #endif
647 : : }
648 : :
649 : : #if defined _LIBC && defined USE_IN_LIBIO
650 : : if (n >= 0)
651 : : {
652 : : _IO_flockfile (stderr);
653 : :
654 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
655 : : ((_IO_FILE *) stderr)->_flags2
656 : : |= _IO_FLAGS2_NOTCANCEL;
657 : :
658 : : __fxprintf (NULL, "%s", buf);
659 : :
660 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
661 : : _IO_funlockfile (stderr);
662 : :
663 : : free (buf);
664 : : }
665 : : #endif
666 : : }
667 : :
668 : 4 : d->__nextchar += strlen (d->__nextchar);
669 : :
670 : 4 : d->optopt = pfound->val;
671 : 4 : return '?';
672 : : }
673 : : }
674 [ + + ]: 29 : else if (pfound->has_arg == 1)
675 : : {
676 [ + - ]: 4 : if (d->optind < argc)
677 : 4 : d->optarg = argv[d->optind++];
678 : : else
679 : : {
680 [ # # ]: 0 : if (print_errors)
681 : : {
682 : : #if defined _LIBC && defined USE_IN_LIBIO
683 : : char *buf;
684 : :
685 : : if (__asprintf (&buf, _("\
686 : : %s: option '--%s' requires an argument\n"),
687 : : argv[0], pfound->name) >= 0)
688 : : {
689 : : _IO_flockfile (stderr);
690 : :
691 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
692 : : ((_IO_FILE *) stderr)->_flags2
693 : : |= _IO_FLAGS2_NOTCANCEL;
694 : :
695 : : __fxprintf (NULL, "%s", buf);
696 : :
697 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
698 : : _IO_funlockfile (stderr);
699 : :
700 : : free (buf);
701 : : }
702 : : #else
703 : 0 : fprintf (stderr,
704 : 0 : _("%s: option '--%s' requires an argument\n"),
705 : : argv[0], pfound->name);
706 : : #endif
707 : : }
708 : 0 : d->__nextchar += strlen (d->__nextchar);
709 : 0 : d->optopt = pfound->val;
710 [ # # ]: 0 : return optstring[0] == ':' ? ':' : '?';
711 : : }
712 : : }
713 : 37 : d->__nextchar += strlen (d->__nextchar);
714 [ + - ]: 37 : if (longind != NULL)
715 : 37 : *longind = option_index;
716 [ + + ]: 37 : if (pfound->flag)
717 : : {
718 : 9 : *(pfound->flag) = pfound->val;
719 : 9 : return 0;
720 : : }
721 : 28 : return pfound->val;
722 : : }
723 : :
724 : : /* Can't find it as a long option. If this is not getopt_long_only,
725 : : or the option starts with '--' or is not a valid short
726 : : option, then it's an error.
727 : : Otherwise interpret it as a short option. */
728 [ + - ][ + - ]: 1 : if (!long_only || argv[d->optind][1] == '-'
729 [ - + ]: 1 : || strchr (optstring, *d->__nextchar) == NULL)
730 : : {
731 [ # # ]: 0 : if (print_errors)
732 : : {
733 : : #if defined _LIBC && defined USE_IN_LIBIO
734 : : char *buf;
735 : : int n;
736 : : #endif
737 : :
738 [ # # ]: 0 : if (argv[d->optind][1] == '-')
739 : : {
740 : : /* --option */
741 : : #if defined _LIBC && defined USE_IN_LIBIO
742 : : n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
743 : : argv[0], d->__nextchar);
744 : : #else
745 : 0 : fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
746 : : argv[0], d->__nextchar);
747 : : #endif
748 : : }
749 : : else
750 : : {
751 : : /* +option or -option */
752 : : #if defined _LIBC && defined USE_IN_LIBIO
753 : : n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
754 : : argv[0], argv[d->optind][0], d->__nextchar);
755 : : #else
756 : 0 : fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
757 : 0 : argv[0], argv[d->optind][0], d->__nextchar);
758 : : #endif
759 : : }
760 : :
761 : : #if defined _LIBC && defined USE_IN_LIBIO
762 : : if (n >= 0)
763 : : {
764 : : _IO_flockfile (stderr);
765 : :
766 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
767 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
768 : :
769 : : __fxprintf (NULL, "%s", buf);
770 : :
771 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
772 : : _IO_funlockfile (stderr);
773 : :
774 : : free (buf);
775 : : }
776 : : #endif
777 : : }
778 : 0 : d->__nextchar = (char *) "";
779 : 0 : d->optind++;
780 : 0 : d->optopt = 0;
781 : 0 : return '?';
782 : : }
783 : : }
784 : :
785 : : /* Look at and handle the next short option-character. */
786 : :
787 : : {
788 : 339 : char c = *d->__nextchar++;
789 : 339 : const char *temp = strchr (optstring, c);
790 : :
791 : : /* Increment 'optind' when we start to process its last character. */
792 [ + + ]: 339 : if (*d->__nextchar == '\0')
793 : 265 : ++d->optind;
794 : :
795 [ + + ][ + + ]: 339 : if (temp == NULL || c == ':' || c == ';')
[ - + ]
796 : : {
797 [ + + ]: 34 : if (print_errors)
798 : : {
799 : : #if defined _LIBC && defined USE_IN_LIBIO
800 : : char *buf;
801 : : int n;
802 : : #endif
803 : :
804 : : #if defined _LIBC && defined USE_IN_LIBIO
805 : : n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
806 : : argv[0], c);
807 : : #else
808 : 12 : fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
809 : : #endif
810 : :
811 : : #if defined _LIBC && defined USE_IN_LIBIO
812 : : if (n >= 0)
813 : : {
814 : : _IO_flockfile (stderr);
815 : :
816 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
817 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
818 : :
819 : : __fxprintf (NULL, "%s", buf);
820 : :
821 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
822 : : _IO_funlockfile (stderr);
823 : :
824 : : free (buf);
825 : : }
826 : : #endif
827 : : }
828 : 34 : d->optopt = c;
829 : 34 : return '?';
830 : : }
831 : : /* Convenience. Treat POSIX -W foo same as long option --foo */
832 [ + + ][ + - ]: 305 : if (temp[0] == 'W' && temp[1] == ';')
833 : : {
834 : : char *nameend;
835 : : const struct option *p;
836 : 40 : const struct option *pfound = NULL;
837 : 40 : int exact = 0;
838 : 40 : int ambig = 0;
839 : 40 : int indfound = 0;
840 : : int option_index;
841 : :
842 [ + + ]: 40 : if (longopts == NULL)
843 : 5 : goto no_longs;
844 : :
845 : : /* This is an option that requires an argument. */
846 [ + + ]: 35 : if (*d->__nextchar != '\0')
847 : : {
848 : 21 : d->optarg = d->__nextchar;
849 : : /* If we end this ARGV-element by taking the rest as an arg,
850 : : we must advance to the next element now. */
851 : 21 : d->optind++;
852 : : }
853 [ + + ]: 14 : else if (d->optind == argc)
854 : : {
855 [ - + ]: 1 : if (print_errors)
856 : : {
857 : : #if defined _LIBC && defined USE_IN_LIBIO
858 : : char *buf;
859 : :
860 : : if (__asprintf (&buf,
861 : : _("%s: option requires an argument -- '%c'\n"),
862 : : argv[0], c) >= 0)
863 : : {
864 : : _IO_flockfile (stderr);
865 : :
866 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
867 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
868 : :
869 : : __fxprintf (NULL, "%s", buf);
870 : :
871 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
872 : : _IO_funlockfile (stderr);
873 : :
874 : : free (buf);
875 : : }
876 : : #else
877 : 0 : fprintf (stderr,
878 : 0 : _("%s: option requires an argument -- '%c'\n"),
879 : : argv[0], c);
880 : : #endif
881 : : }
882 : 1 : d->optopt = c;
883 [ - + ]: 1 : if (optstring[0] == ':')
884 : 0 : c = ':';
885 : : else
886 : 1 : c = '?';
887 : 1 : return c;
888 : : }
889 : : else
890 : : /* We already incremented 'd->optind' once;
891 : : increment it again when taking next ARGV-elt as argument. */
892 : 13 : d->optarg = argv[d->optind++];
893 : :
894 : : /* optarg is now the argument, see if it's in the
895 : : table of longopts. */
896 : :
897 [ + + ][ + + ]: 130 : for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
898 : 96 : nameend++)
899 : : /* Do nothing. */ ;
900 : :
901 : : /* Test all long options for either exact match
902 : : or abbreviated matches. */
903 [ + + ]: 160 : for (p = longopts, option_index = 0; p->name; p++, option_index++)
904 [ + + ]: 140 : if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
905 : : {
906 [ + + ]: 32 : if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
907 : : {
908 : : /* Exact match found. */
909 : 14 : pfound = p;
910 : 14 : indfound = option_index;
911 : 14 : exact = 1;
912 : 14 : break;
913 : : }
914 [ + - ]: 18 : else if (pfound == NULL)
915 : : {
916 : : /* First nonexact match found. */
917 : 18 : pfound = p;
918 : 18 : indfound = option_index;
919 : : }
920 [ # # ]: 0 : else if (long_only
921 [ # # ]: 0 : || pfound->has_arg != p->has_arg
922 [ # # ]: 0 : || pfound->flag != p->flag
923 [ # # ]: 0 : || pfound->val != p->val)
924 : : /* Second or later nonexact match found. */
925 : 0 : ambig = 1;
926 : : }
927 [ - + ][ # # ]: 34 : if (ambig && !exact)
928 : : {
929 [ # # ]: 0 : if (print_errors)
930 : : {
931 : : #if defined _LIBC && defined USE_IN_LIBIO
932 : : char *buf;
933 : :
934 : : if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
935 : : argv[0], d->optarg) >= 0)
936 : : {
937 : : _IO_flockfile (stderr);
938 : :
939 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
940 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
941 : :
942 : : __fxprintf (NULL, "%s", buf);
943 : :
944 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
945 : : _IO_funlockfile (stderr);
946 : :
947 : : free (buf);
948 : : }
949 : : #else
950 : 0 : fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
951 : : argv[0], d->optarg);
952 : : #endif
953 : : }
954 : 0 : d->__nextchar += strlen (d->__nextchar);
955 : 0 : d->optind++;
956 : 0 : return '?';
957 : : }
958 [ + + ]: 34 : if (pfound != NULL)
959 : : {
960 : 32 : option_index = indfound;
961 [ + + ]: 32 : if (*nameend)
962 : : {
963 : : /* Don't test has_arg with >, because some C compilers don't
964 : : allow it to be used on enums. */
965 [ + - ]: 10 : if (pfound->has_arg)
966 : 10 : d->optarg = nameend + 1;
967 : : else
968 : : {
969 [ # # ]: 0 : if (print_errors)
970 : : {
971 : : #if defined _LIBC && defined USE_IN_LIBIO
972 : : char *buf;
973 : :
974 : : if (__asprintf (&buf, _("\
975 : : %s: option '-W %s' doesn't allow an argument\n"),
976 : : argv[0], pfound->name) >= 0)
977 : : {
978 : : _IO_flockfile (stderr);
979 : :
980 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
981 : : ((_IO_FILE *) stderr)->_flags2
982 : : |= _IO_FLAGS2_NOTCANCEL;
983 : :
984 : : __fxprintf (NULL, "%s", buf);
985 : :
986 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
987 : : _IO_funlockfile (stderr);
988 : :
989 : : free (buf);
990 : : }
991 : : #else
992 : 0 : fprintf (stderr, _("\
993 : : %s: option '-W %s' doesn't allow an argument\n"),
994 : : argv[0], pfound->name);
995 : : #endif
996 : : }
997 : :
998 : 0 : d->__nextchar += strlen (d->__nextchar);
999 : 0 : return '?';
1000 : : }
1001 : : }
1002 [ + + ]: 22 : else if (pfound->has_arg == 1)
1003 : : {
1004 [ + - ]: 4 : if (d->optind < argc)
1005 : 4 : d->optarg = argv[d->optind++];
1006 : : else
1007 : : {
1008 [ # # ]: 0 : if (print_errors)
1009 : : {
1010 : : #if defined _LIBC && defined USE_IN_LIBIO
1011 : : char *buf;
1012 : :
1013 : : if (__asprintf (&buf, _("\
1014 : : %s: option '-W %s' requires an argument\n"),
1015 : : argv[0], pfound->name) >= 0)
1016 : : {
1017 : : _IO_flockfile (stderr);
1018 : :
1019 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1020 : : ((_IO_FILE *) stderr)->_flags2
1021 : : |= _IO_FLAGS2_NOTCANCEL;
1022 : :
1023 : : __fxprintf (NULL, "%s", buf);
1024 : :
1025 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1026 : : _IO_funlockfile (stderr);
1027 : :
1028 : : free (buf);
1029 : : }
1030 : : #else
1031 : 0 : fprintf (stderr, _("\
1032 : : %s: option '-W %s' requires an argument\n"),
1033 : : argv[0], pfound->name);
1034 : : #endif
1035 : : }
1036 : 0 : d->__nextchar += strlen (d->__nextchar);
1037 [ # # ]: 0 : return optstring[0] == ':' ? ':' : '?';
1038 : : }
1039 : : }
1040 : : else
1041 : 18 : d->optarg = NULL;
1042 : 32 : d->__nextchar += strlen (d->__nextchar);
1043 [ + - ]: 32 : if (longind != NULL)
1044 : 32 : *longind = option_index;
1045 [ + + ]: 32 : if (pfound->flag)
1046 : : {
1047 : 8 : *(pfound->flag) = pfound->val;
1048 : 8 : return 0;
1049 : : }
1050 : 24 : return pfound->val;
1051 : : }
1052 : :
1053 : : no_longs:
1054 : 7 : d->__nextchar = NULL;
1055 : 7 : return 'W'; /* Let the application handle it. */
1056 : : }
1057 [ + + ]: 265 : if (temp[1] == ':')
1058 : : {
1059 [ + + ]: 117 : if (temp[2] == ':')
1060 : : {
1061 : : /* This is an option that accepts an argument optionally. */
1062 [ + + ]: 21 : if (*d->__nextchar != '\0')
1063 : : {
1064 : 7 : d->optarg = d->__nextchar;
1065 : 7 : d->optind++;
1066 : : }
1067 : : else
1068 : 14 : d->optarg = NULL;
1069 : 21 : d->__nextchar = NULL;
1070 : : }
1071 : : else
1072 : : {
1073 : : /* This is an option that requires an argument. */
1074 [ + + ]: 96 : if (*d->__nextchar != '\0')
1075 : : {
1076 : 12 : d->optarg = d->__nextchar;
1077 : : /* If we end this ARGV-element by taking the rest as an arg,
1078 : : we must advance to the next element now. */
1079 : 12 : d->optind++;
1080 : : }
1081 [ + + ]: 84 : else if (d->optind == argc)
1082 : : {
1083 [ + + ]: 20 : if (print_errors)
1084 : : {
1085 : : #if defined _LIBC && defined USE_IN_LIBIO
1086 : : char *buf;
1087 : :
1088 : : if (__asprintf (&buf, _("\
1089 : : %s: option requires an argument -- '%c'\n"),
1090 : : argv[0], c) >= 0)
1091 : : {
1092 : : _IO_flockfile (stderr);
1093 : :
1094 : : int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1095 : : ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1096 : :
1097 : : __fxprintf (NULL, "%s", buf);
1098 : :
1099 : : ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1100 : : _IO_funlockfile (stderr);
1101 : :
1102 : : free (buf);
1103 : : }
1104 : : #else
1105 : 4 : fprintf (stderr,
1106 : 4 : _("%s: option requires an argument -- '%c'\n"),
1107 : : argv[0], c);
1108 : : #endif
1109 : : }
1110 : 20 : d->optopt = c;
1111 [ + + ]: 20 : if (optstring[0] == ':')
1112 : 12 : c = ':';
1113 : : else
1114 : 8 : c = '?';
1115 : : }
1116 : : else
1117 : : /* We already incremented 'optind' once;
1118 : : increment it again when taking next ARGV-elt as argument. */
1119 : 64 : d->optarg = argv[d->optind++];
1120 : 96 : d->__nextchar = NULL;
1121 : : }
1122 : : }
1123 : 641 : return c;
1124 : : }
1125 : : }
1126 : :
1127 : : int
1128 : 641 : _getopt_internal (int argc, char **argv, const char *optstring,
1129 : : const struct option *longopts, int *longind, int long_only,
1130 : : int posixly_correct)
1131 : : {
1132 : : int result;
1133 : :
1134 : 641 : getopt_data.optind = optind;
1135 : 641 : getopt_data.opterr = opterr;
1136 : :
1137 : 641 : result = _getopt_internal_r (argc, argv, optstring, longopts,
1138 : : longind, long_only, &getopt_data,
1139 : : posixly_correct);
1140 : :
1141 : 641 : optind = getopt_data.optind;
1142 : 641 : optarg = getopt_data.optarg;
1143 : 641 : optopt = getopt_data.optopt;
1144 : :
1145 : 641 : return result;
1146 : : }
1147 : :
1148 : : /* glibc gets a LSB-compliant getopt.
1149 : : Standalone applications get a POSIX-compliant getopt. */
1150 : : #if _LIBC
1151 : : enum { POSIXLY_CORRECT = 0 };
1152 : : #else
1153 : : enum { POSIXLY_CORRECT = 1 };
1154 : : #endif
1155 : :
1156 : : int
1157 : : getopt (int argc, char *const *argv, const char *optstring)
1158 : : {
1159 : 348 : return _getopt_internal (argc, (char **) argv, optstring,
1160 : : (const struct option *) 0,
1161 : : (int *) 0,
1162 : : 0, POSIXLY_CORRECT);
1163 : : }
1164 : :
1165 : : #ifdef _LIBC
1166 : : int
1167 : : __posix_getopt (int argc, char *const *argv, const char *optstring)
1168 : : {
1169 : : return _getopt_internal (argc, argv, optstring,
1170 : : (const struct option *) 0,
1171 : : (int *) 0,
1172 : : 0, 1);
1173 : : }
1174 : : #endif
1175 : :
1176 : :
1177 : : #ifdef TEST
1178 : :
1179 : : /* Compile with -DTEST to make an executable for use in testing
1180 : : the above definition of 'getopt'. */
1181 : :
1182 : : int
1183 : : main (int argc, char **argv)
1184 : : {
1185 : : int c;
1186 : : int digit_optind = 0;
1187 : :
1188 : : while (1)
1189 : : {
1190 : : int this_option_optind = optind ? optind : 1;
1191 : :
1192 : : c = getopt (argc, argv, "abc:d:0123456789");
1193 : : if (c == -1)
1194 : : break;
1195 : :
1196 : : switch (c)
1197 : : {
1198 : : case '0':
1199 : : case '1':
1200 : : case '2':
1201 : : case '3':
1202 : : case '4':
1203 : : case '5':
1204 : : case '6':
1205 : : case '7':
1206 : : case '8':
1207 : : case '9':
1208 : : if (digit_optind != 0 && digit_optind != this_option_optind)
1209 : : printf ("digits occur in two different argv-elements.\n");
1210 : : digit_optind = this_option_optind;
1211 : : printf ("option %c\n", c);
1212 : : break;
1213 : :
1214 : : case 'a':
1215 : : printf ("option a\n");
1216 : : break;
1217 : :
1218 : : case 'b':
1219 : : printf ("option b\n");
1220 : : break;
1221 : :
1222 : : case 'c':
1223 : : printf ("option c with value '%s'\n", optarg);
1224 : : break;
1225 : :
1226 : : case '?':
1227 : : break;
1228 : :
1229 : : default:
1230 : : printf ("?? getopt returned character code 0%o ??\n", c);
1231 : : }
1232 : : }
1233 : :
1234 : : if (optind < argc)
1235 : : {
1236 : : printf ("non-option ARGV-elements: ");
1237 : : while (optind < argc)
1238 : : printf ("%s ", argv[optind++]);
1239 : : printf ("\n");
1240 : : }
1241 : :
1242 : : exit (0);
1243 : : }
1244 : :
1245 : : #endif /* TEST */
|
