summaryrefslogtreecommitdiffstats
path: root/gl/getopt.c
diff options
context:
space:
mode:
Diffstat (limited to 'gl/getopt.c')
-rw-r--r--gl/getopt.c1275
1 files changed, 637 insertions, 638 deletions
diff --git a/gl/getopt.c b/gl/getopt.c
index f1e6d1f..aaabc8d 100644
--- a/gl/getopt.c
+++ b/gl/getopt.c
@@ -1,9 +1,9 @@
1/* Getopt for GNU. 1/* Getopt for GNU.
2 NOTE: getopt is now part of the C library, so if you don't know what 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 3 "Keep this file name-space clean" means, talk to drepper@gnu.org
4 before changing it! 4 before changing it!
5 Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004,2006,2008 5 Copyright (C) 1987-1996, 1998-2004, 2006, 2008-2010 Free Software
6 Free Software Foundation, Inc. 6 Foundation, Inc.
7 This file is part of the GNU C Library. 7 This file is part of the GNU C Library.
8 8
9 This program is free software: you can redistribute it and/or modify 9 This program is free software: you can redistribute it and/or modify
@@ -41,12 +41,9 @@
41# include <wchar.h> 41# include <wchar.h>
42#endif 42#endif
43 43
44#ifndef attribute_hidden 44/* This version of `getopt' appears to the caller like standard Unix `getopt'
45# define attribute_hidden 45 but it behaves differently for the user, since it allows the user
46#endif 46 to intersperse the options with the other arguments.
47
48/* Unlike standard Unix `getopt', functions like `getopt_long'
49 let the user intersperse the options with the other arguments.
50 47
51 As `getopt_long' works, it permutes the elements of ARGV so that, 48 As `getopt_long' works, it permutes the elements of ARGV so that,
52 when it is done, all the options precede everything else. Thus 49 when it is done, all the options precede everything else. Thus
@@ -54,7 +51,7 @@
54 51
55 Using `getopt' or setting the environment variable POSIXLY_CORRECT 52 Using `getopt' or setting the environment variable POSIXLY_CORRECT
56 disables permutation. 53 disables permutation.
57 Then the application's behavior is completely standard. 54 Then the behavior is completely standard.
58 55
59 GNU application programs can use a third alternative mode in which 56 GNU application programs can use a third alternative mode in which
60 they can distinguish the relative order of options and other arguments. */ 57 they can distinguish the relative order of options and other arguments. */
@@ -121,18 +118,18 @@ extern char *__getopt_nonoption_flags;
121 118
122# ifdef USE_NONOPTION_FLAGS 119# ifdef USE_NONOPTION_FLAGS
123# define SWAP_FLAGS(ch1, ch2) \ 120# define SWAP_FLAGS(ch1, ch2) \
124 if (d->__nonoption_flags_len > 0) \ 121 if (d->__nonoption_flags_len > 0) \
125 { \ 122 { \
126 char __tmp = __getopt_nonoption_flags[ch1]; \ 123 char __tmp = __getopt_nonoption_flags[ch1]; \
127 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ 124 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
128 __getopt_nonoption_flags[ch2] = __tmp; \ 125 __getopt_nonoption_flags[ch2] = __tmp; \
129 } 126 }
130# else 127# else
131# define SWAP_FLAGS(ch1, ch2) 128# define SWAP_FLAGS(ch1, ch2)
132# endif 129# endif
133#else /* !_LIBC */ 130#else /* !_LIBC */
134# define SWAP_FLAGS(ch1, ch2) 131# define SWAP_FLAGS(ch1, ch2)
135#endif /* _LIBC */ 132#endif /* _LIBC */
136 133
137/* Exchange two adjacent subsequences of ARGV. 134/* Exchange two adjacent subsequences of ARGV.
138 One subsequence is elements [first_nonopt,last_nonopt) 135 One subsequence is elements [first_nonopt,last_nonopt)
@@ -163,57 +160,57 @@ exchange (char **argv, struct _getopt_data *d)
163 if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len) 160 if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
164 { 161 {
165 /* We must extend the array. The user plays games with us and 162 /* We must extend the array. The user plays games with us and
166 presents new arguments. */ 163 presents new arguments. */
167 char *new_str = malloc (top + 1); 164 char *new_str = malloc (top + 1);
168 if (new_str == NULL) 165 if (new_str == NULL)
169 d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0; 166 d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
170 else 167 else
171 { 168 {
172 memset (__mempcpy (new_str, __getopt_nonoption_flags, 169 memset (__mempcpy (new_str, __getopt_nonoption_flags,
173 d->__nonoption_flags_max_len), 170 d->__nonoption_flags_max_len),
174 '\0', top + 1 - d->__nonoption_flags_max_len); 171 '\0', top + 1 - d->__nonoption_flags_max_len);
175 d->__nonoption_flags_max_len = top + 1; 172 d->__nonoption_flags_max_len = top + 1;
176 __getopt_nonoption_flags = new_str; 173 __getopt_nonoption_flags = new_str;
177 } 174 }
178 } 175 }
179#endif 176#endif
180 177
181 while (top > middle && middle > bottom) 178 while (top > middle && middle > bottom)
182 { 179 {
183 if (top - middle > middle - bottom) 180 if (top - middle > middle - bottom)
184 { 181 {
185 /* Bottom segment is the short one. */ 182 /* Bottom segment is the short one. */
186 int len = middle - bottom; 183 int len = middle - bottom;
187 register int i; 184 register int i;
188 185
189 /* Swap it with the top part of the top segment. */ 186 /* Swap it with the top part of the top segment. */
190 for (i = 0; i < len; i++) 187 for (i = 0; i < len; i++)
191 { 188 {
192 tem = argv[bottom + i]; 189 tem = argv[bottom + i];
193 argv[bottom + i] = argv[top - (middle - bottom) + i]; 190 argv[bottom + i] = argv[top - (middle - bottom) + i];
194 argv[top - (middle - bottom) + i] = tem; 191 argv[top - (middle - bottom) + i] = tem;
195 SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); 192 SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
196 } 193 }
197 /* Exclude the moved bottom segment from further swapping. */ 194 /* Exclude the moved bottom segment from further swapping. */
198 top -= len; 195 top -= len;
199 } 196 }
200 else 197 else
201 { 198 {
202 /* Top segment is the short one. */ 199 /* Top segment is the short one. */
203 int len = top - middle; 200 int len = top - middle;
204 register int i; 201 register int i;
205 202
206 /* Swap it with the bottom part of the bottom segment. */ 203 /* Swap it with the bottom part of the bottom segment. */
207 for (i = 0; i < len; i++) 204 for (i = 0; i < len; i++)
208 { 205 {
209 tem = argv[bottom + i]; 206 tem = argv[bottom + i];
210 argv[bottom + i] = argv[middle + i]; 207 argv[bottom + i] = argv[middle + i];
211 argv[middle + i] = tem; 208 argv[middle + i] = tem;
212 SWAP_FLAGS (bottom + i, middle + i); 209 SWAP_FLAGS (bottom + i, middle + i);
213 } 210 }
214 /* Exclude the moved top segment from further swapping. */ 211 /* Exclude the moved top segment from further swapping. */
215 bottom += len; 212 bottom += len;
216 } 213 }
217 } 214 }
218 215
219 /* Update records for the slots the non-options now occupy. */ 216 /* Update records for the slots the non-options now occupy. */
@@ -225,8 +222,9 @@ exchange (char **argv, struct _getopt_data *d)
225/* Initialize the internal data when the first call is made. */ 222/* Initialize the internal data when the first call is made. */
226 223
227static const char * 224static const char *
228_getopt_initialize (int argc, char **argv, const char *optstring, 225_getopt_initialize (int argc _GL_UNUSED,
229 int posixly_correct, struct _getopt_data *d) 226 char **argv _GL_UNUSED, const char *optstring,
227 struct _getopt_data *d, int posixly_correct)
230{ 228{
231 /* Start processing options with ARGV-element 1 (since ARGV-element 0 229 /* Start processing options with ARGV-element 1 (since ARGV-element 0
232 is the program name); the sequence of previously skipped 230 is the program name); the sequence of previously skipped
@@ -260,25 +258,25 @@ _getopt_initialize (int argc, char **argv, const char *optstring,
260 && argc == __libc_argc && argv == __libc_argv) 258 && argc == __libc_argc && argv == __libc_argv)
261 { 259 {
262 if (d->__nonoption_flags_max_len == 0) 260 if (d->__nonoption_flags_max_len == 0)
263 { 261 {
264 if (__getopt_nonoption_flags == NULL 262 if (__getopt_nonoption_flags == NULL
265 || __getopt_nonoption_flags[0] == '\0') 263 || __getopt_nonoption_flags[0] == '\0')
266 d->__nonoption_flags_max_len = -1; 264 d->__nonoption_flags_max_len = -1;
267 else 265 else
268 { 266 {
269 const char *orig_str = __getopt_nonoption_flags; 267 const char *orig_str = __getopt_nonoption_flags;
270 int len = d->__nonoption_flags_max_len = strlen (orig_str); 268 int len = d->__nonoption_flags_max_len = strlen (orig_str);
271 if (d->__nonoption_flags_max_len < argc) 269 if (d->__nonoption_flags_max_len < argc)
272 d->__nonoption_flags_max_len = argc; 270 d->__nonoption_flags_max_len = argc;
273 __getopt_nonoption_flags = 271 __getopt_nonoption_flags =
274 (char *) malloc (d->__nonoption_flags_max_len); 272 (char *) malloc (d->__nonoption_flags_max_len);
275 if (__getopt_nonoption_flags == NULL) 273 if (__getopt_nonoption_flags == NULL)
276 d->__nonoption_flags_max_len = -1; 274 d->__nonoption_flags_max_len = -1;
277 else 275 else
278 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), 276 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
279 '\0', d->__nonoption_flags_max_len - len); 277 '\0', d->__nonoption_flags_max_len - len);
280 } 278 }
281 } 279 }
282 d->__nonoption_flags_len = d->__nonoption_flags_max_len; 280 d->__nonoption_flags_len = d->__nonoption_flags_max_len;
283 } 281 }
284 else 282 else
@@ -330,6 +328,10 @@ _getopt_initialize (int argc, char **argv, const char *optstring,
330 `flag' field is nonzero, the value of the option's `val' field 328 `flag' field is nonzero, the value of the option's `val' field
331 if the `flag' field is zero. 329 if the `flag' field is zero.
332 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
333 LONGOPTS is a vector of `struct option' terminated by an 335 LONGOPTS is a vector of `struct option' terminated by an
334 element containing a name which is zero. 336 element containing a name which is zero.
335 337
@@ -338,15 +340,12 @@ _getopt_initialize (int argc, char **argv, const char *optstring,
338 recent call. 340 recent call.
339 341
340 If LONG_ONLY is nonzero, '-' as well as '--' can introduce 342 If LONG_ONLY is nonzero, '-' as well as '--' can introduce
341 long-named options. 343 long-named options. */
342
343 If POSIXLY_CORRECT is nonzero, behave as if the POSIXLY_CORRECT
344 environment variable were set. */
345 344
346int 345int
347_getopt_internal_r (int argc, char **argv, const char *optstring, 346_getopt_internal_r (int argc, char **argv, const char *optstring,
348 const struct option *longopts, int *longind, 347 const struct option *longopts, int *longind,
349 int long_only, int posixly_correct, struct _getopt_data *d) 348 int long_only, struct _getopt_data *d, int posixly_correct)
350{ 349{
351 int print_errors = d->opterr; 350 int print_errors = d->opterr;
352 if (optstring[0] == ':') 351 if (optstring[0] == ':')
@@ -360,9 +359,9 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
360 if (d->optind == 0 || !d->__initialized) 359 if (d->optind == 0 || !d->__initialized)
361 { 360 {
362 if (d->optind == 0) 361 if (d->optind == 0)
363 d->optind = 1; /* Don't scan ARGV[0], the program name. */ 362 d->optind = 1; /* Don't scan ARGV[0], the program name. */
364 optstring = _getopt_initialize (argc, argv, optstring, 363 optstring = _getopt_initialize (argc, argv, optstring, d,
365 posixly_correct, d); 364 posixly_correct);
366 d->__initialized = 1; 365 d->__initialized = 1;
367 } 366 }
368 367
@@ -372,8 +371,8 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
372 is only used when the used in the GNU libc. */ 371 is only used when the used in the GNU libc. */
373#if defined _LIBC && defined USE_NONOPTION_FLAGS 372#if defined _LIBC && defined USE_NONOPTION_FLAGS
374# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \ 373# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
375 || (d->optind < d->__nonoption_flags_len \ 374 || (d->optind < d->__nonoption_flags_len \
376 && __getopt_nonoption_flags[d->optind] == '1')) 375 && __getopt_nonoption_flags[d->optind] == '1'))
377#else 376#else
378# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0') 377# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
379#endif 378#endif
@@ -383,78 +382,78 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
383 /* Advance to the next ARGV-element. */ 382 /* Advance to the next ARGV-element. */
384 383
385 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been 384 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
386 moved back by the user (who may also have changed the arguments). */ 385 moved back by the user (who may also have changed the arguments). */
387 if (d->__last_nonopt > d->optind) 386 if (d->__last_nonopt > d->optind)
388 d->__last_nonopt = d->optind; 387 d->__last_nonopt = d->optind;
389 if (d->__first_nonopt > d->optind) 388 if (d->__first_nonopt > d->optind)
390 d->__first_nonopt = d->optind; 389 d->__first_nonopt = d->optind;
391 390
392 if (d->__ordering == PERMUTE) 391 if (d->__ordering == PERMUTE)
393 { 392 {
394 /* If we have just processed some options following some non-options, 393 /* If we have just processed some options following some non-options,
395 exchange them so that the options come first. */ 394 exchange them so that the options come first. */
396 395
397 if (d->__first_nonopt != d->__last_nonopt 396 if (d->__first_nonopt != d->__last_nonopt
398 && d->__last_nonopt != d->optind) 397 && d->__last_nonopt != d->optind)
399 exchange ((char **) argv, d); 398 exchange ((char **) argv, d);
400 else if (d->__last_nonopt != d->optind) 399 else if (d->__last_nonopt != d->optind)
401 d->__first_nonopt = d->optind; 400 d->__first_nonopt = d->optind;
402 401
403 /* Skip any additional non-options 402 /* Skip any additional non-options
404 and extend the range of non-options previously skipped. */ 403 and extend the range of non-options previously skipped. */
405 404
406 while (d->optind < argc && NONOPTION_P) 405 while (d->optind < argc && NONOPTION_P)
407 d->optind++; 406 d->optind++;
408 d->__last_nonopt = d->optind; 407 d->__last_nonopt = d->optind;
409 } 408 }
410 409
411 /* The special ARGV-element `--' means premature end of options. 410 /* The special ARGV-element `--' means premature end of options.
412 Skip it like a null option, 411 Skip it like a null option,
413 then exchange with previous non-options as if it were an option, 412 then exchange with previous non-options as if it were an option,
414 then skip everything else like a non-option. */ 413 then skip everything else like a non-option. */
415 414
416 if (d->optind != argc && !strcmp (argv[d->optind], "--")) 415 if (d->optind != argc && !strcmp (argv[d->optind], "--"))
417 { 416 {
418 d->optind++; 417 d->optind++;
419 418
420 if (d->__first_nonopt != d->__last_nonopt 419 if (d->__first_nonopt != d->__last_nonopt
421 && d->__last_nonopt != d->optind) 420 && d->__last_nonopt != d->optind)
422 exchange ((char **) argv, d); 421 exchange ((char **) argv, d);
423 else if (d->__first_nonopt == d->__last_nonopt) 422 else if (d->__first_nonopt == d->__last_nonopt)
424 d->__first_nonopt = d->optind; 423 d->__first_nonopt = d->optind;
425 d->__last_nonopt = argc; 424 d->__last_nonopt = argc;
426 425
427 d->optind = argc; 426 d->optind = argc;
428 } 427 }
429 428
430 /* If we have done all the ARGV-elements, stop the scan 429 /* If we have done all the ARGV-elements, stop the scan
431 and back over any non-options that we skipped and permuted. */ 430 and back over any non-options that we skipped and permuted. */
432 431
433 if (d->optind == argc) 432 if (d->optind == argc)
434 { 433 {
435 /* Set the next-arg-index to point at the non-options 434 /* Set the next-arg-index to point at the non-options
436 that we previously skipped, so the caller will digest them. */ 435 that we previously skipped, so the caller will digest them. */
437 if (d->__first_nonopt != d->__last_nonopt) 436 if (d->__first_nonopt != d->__last_nonopt)
438 d->optind = d->__first_nonopt; 437 d->optind = d->__first_nonopt;
439 return -1; 438 return -1;
440 } 439 }
441 440
442 /* If we have come to a non-option and did not permute it, 441 /* If we have come to a non-option and did not permute it,
443 either stop the scan or describe it to the caller and pass it by. */ 442 either stop the scan or describe it to the caller and pass it by. */
444 443
445 if (NONOPTION_P) 444 if (NONOPTION_P)
446 { 445 {
447 if (d->__ordering == REQUIRE_ORDER) 446 if (d->__ordering == REQUIRE_ORDER)
448 return -1; 447 return -1;
449 d->optarg = argv[d->optind++]; 448 d->optarg = argv[d->optind++];
450 return 1; 449 return 1;
451 } 450 }
452 451
453 /* We have found another option-ARGV-element. 452 /* We have found another option-ARGV-element.
454 Skip the initial punctuation. */ 453 Skip the initial punctuation. */
455 454
456 d->__nextchar = (argv[d->optind] + 1 455 d->__nextchar = (argv[d->optind] + 1
457 + (longopts != NULL && argv[d->optind][1] == '-')); 456 + (longopts != NULL && argv[d->optind][1] == '-'));
458 } 457 }
459 458
460 /* Decode the current option-ARGV-element. */ 459 /* Decode the current option-ARGV-element. */
@@ -474,8 +473,8 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
474 473
475 if (longopts != NULL 474 if (longopts != NULL
476 && (argv[d->optind][1] == '-' 475 && (argv[d->optind][1] == '-'
477 || (long_only && (argv[d->optind][2] 476 || (long_only && (argv[d->optind][2]
478 || !strchr (optstring, argv[d->optind][1]))))) 477 || !strchr (optstring, argv[d->optind][1])))))
479 { 478 {
480 char *nameend; 479 char *nameend;
481 const struct option *p; 480 const struct option *p;
@@ -486,251 +485,251 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
486 int option_index; 485 int option_index;
487 486
488 for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++) 487 for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
489 /* Do nothing. */ ; 488 /* Do nothing. */ ;
490 489
491 /* Test all long options for either exact match 490 /* Test all long options for either exact match
492 or abbreviated matches. */ 491 or abbreviated matches. */
493 for (p = longopts, option_index = 0; p->name; p++, option_index++) 492 for (p = longopts, option_index = 0; p->name; p++, option_index++)
494 if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar)) 493 if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
495 { 494 {
496 if ((unsigned int) (nameend - d->__nextchar) 495 if ((unsigned int) (nameend - d->__nextchar)
497 == (unsigned int) strlen (p->name)) 496 == (unsigned int) strlen (p->name))
498 { 497 {
499 /* Exact match found. */ 498 /* Exact match found. */
500 pfound = p; 499 pfound = p;
501 indfound = option_index; 500 indfound = option_index;
502 exact = 1; 501 exact = 1;
503 break; 502 break;
504 } 503 }
505 else if (pfound == NULL) 504 else if (pfound == NULL)
506 { 505 {
507 /* First nonexact match found. */ 506 /* First nonexact match found. */
508 pfound = p; 507 pfound = p;
509 indfound = option_index; 508 indfound = option_index;
510 } 509 }
511 else if (long_only 510 else if (long_only
512 || pfound->has_arg != p->has_arg 511 || pfound->has_arg != p->has_arg
513 || pfound->flag != p->flag 512 || pfound->flag != p->flag
514 || pfound->val != p->val) 513 || pfound->val != p->val)
515 /* Second or later nonexact match found. */ 514 /* Second or later nonexact match found. */
516 ambig = 1; 515 ambig = 1;
517 } 516 }
518 517
519 if (ambig && !exact) 518 if (ambig && !exact)
520 { 519 {
521 if (print_errors) 520 if (print_errors)
522 { 521 {
523#if defined _LIBC && defined USE_IN_LIBIO 522#if defined _LIBC && defined USE_IN_LIBIO
524 char *buf; 523 char *buf;
525 524
526 if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"), 525 if (__asprintf (&buf, _("%s: option '%s' is ambiguous\n"),
527 argv[0], argv[d->optind]) >= 0) 526 argv[0], argv[d->optind]) >= 0)
528 { 527 {
529 _IO_flockfile (stderr); 528 _IO_flockfile (stderr);
530 529
531 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 530 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
532 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 531 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
533 532
534 __fxprintf (NULL, "%s", buf); 533 __fxprintf (NULL, "%s", buf);
535 534
536 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 535 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
537 _IO_funlockfile (stderr); 536 _IO_funlockfile (stderr);
538 537
539 free (buf); 538 free (buf);
540 } 539 }
541#else 540#else
542 fprintf (stderr, _("%s: option `%s' is ambiguous\n"), 541 fprintf (stderr, _("%s: option '%s' is ambiguous\n"),
543 argv[0], argv[d->optind]); 542 argv[0], argv[d->optind]);
544#endif 543#endif
545 } 544 }
546 d->__nextchar += strlen (d->__nextchar); 545 d->__nextchar += strlen (d->__nextchar);
547 d->optind++; 546 d->optind++;
548 d->optopt = 0; 547 d->optopt = 0;
549 return '?'; 548 return '?';
550 } 549 }
551 550
552 if (pfound != NULL) 551 if (pfound != NULL)
553 { 552 {
554 option_index = indfound; 553 option_index = indfound;
555 d->optind++; 554 d->optind++;
556 if (*nameend) 555 if (*nameend)
557 { 556 {
558 /* Don't test has_arg with >, because some C compilers don't 557 /* Don't test has_arg with >, because some C compilers don't
559 allow it to be used on enums. */ 558 allow it to be used on enums. */
560 if (pfound->has_arg) 559 if (pfound->has_arg)
561 d->optarg = nameend + 1; 560 d->optarg = nameend + 1;
562 else 561 else
563 { 562 {
564 if (print_errors) 563 if (print_errors)
565 { 564 {
566#if defined _LIBC && defined USE_IN_LIBIO 565#if defined _LIBC && defined USE_IN_LIBIO
567 char *buf; 566 char *buf;
568 int n; 567 int n;
569#endif 568#endif
570 569
571 if (argv[d->optind - 1][1] == '-') 570 if (argv[d->optind - 1][1] == '-')
572 { 571 {
573 /* --option */ 572 /* --option */
574#if defined _LIBC && defined USE_IN_LIBIO 573#if defined _LIBC && defined USE_IN_LIBIO
575 n = __asprintf (&buf, _("\ 574 n = __asprintf (&buf, _("\
576%s: option `--%s' doesn't allow an argument\n"), 575%s: option '--%s' doesn't allow an argument\n"),
577 argv[0], pfound->name); 576 argv[0], pfound->name);
578#else 577#else
579 fprintf (stderr, _("\ 578 fprintf (stderr, _("\
580%s: option `--%s' doesn't allow an argument\n"), 579%s: option '--%s' doesn't allow an argument\n"),
581 argv[0], pfound->name); 580 argv[0], pfound->name);
582#endif 581#endif
583 } 582 }
584 else 583 else
585 { 584 {
586 /* +option or -option */ 585 /* +option or -option */
587#if defined _LIBC && defined USE_IN_LIBIO 586#if defined _LIBC && defined USE_IN_LIBIO
588 n = __asprintf (&buf, _("\ 587 n = __asprintf (&buf, _("\
589%s: option `%c%s' doesn't allow an argument\n"), 588%s: option '%c%s' doesn't allow an argument\n"),
590 argv[0], argv[d->optind - 1][0], 589 argv[0], argv[d->optind - 1][0],
591 pfound->name); 590 pfound->name);
592#else 591#else
593 fprintf (stderr, _("\ 592 fprintf (stderr, _("\
594%s: option `%c%s' doesn't allow an argument\n"), 593%s: option '%c%s' doesn't allow an argument\n"),
595 argv[0], argv[d->optind - 1][0], 594 argv[0], argv[d->optind - 1][0],
596 pfound->name); 595 pfound->name);
597#endif 596#endif
598 } 597 }
599 598
600#if defined _LIBC && defined USE_IN_LIBIO 599#if defined _LIBC && defined USE_IN_LIBIO
601 if (n >= 0) 600 if (n >= 0)
602 { 601 {
603 _IO_flockfile (stderr); 602 _IO_flockfile (stderr);
604 603
605 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 604 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
606 ((_IO_FILE *) stderr)->_flags2 605 ((_IO_FILE *) stderr)->_flags2
607 |= _IO_FLAGS2_NOTCANCEL; 606 |= _IO_FLAGS2_NOTCANCEL;
608 607
609 __fxprintf (NULL, "%s", buf); 608 __fxprintf (NULL, "%s", buf);
610 609
611 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 610 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
612 _IO_funlockfile (stderr); 611 _IO_funlockfile (stderr);
613 612
614 free (buf); 613 free (buf);
615 } 614 }
616#endif 615#endif
617 } 616 }
618 617
619 d->__nextchar += strlen (d->__nextchar); 618 d->__nextchar += strlen (d->__nextchar);
620 619
621 d->optopt = pfound->val; 620 d->optopt = pfound->val;
622 return '?'; 621 return '?';
623 } 622 }
624 } 623 }
625 else if (pfound->has_arg == 1) 624 else if (pfound->has_arg == 1)
626 { 625 {
627 if (d->optind < argc) 626 if (d->optind < argc)
628 d->optarg = argv[d->optind++]; 627 d->optarg = argv[d->optind++];
629 else 628 else
630 { 629 {
631 if (print_errors) 630 if (print_errors)
632 { 631 {
633#if defined _LIBC && defined USE_IN_LIBIO 632#if defined _LIBC && defined USE_IN_LIBIO
634 char *buf; 633 char *buf;
635 634
636 if (__asprintf (&buf, _("\ 635 if (__asprintf (&buf, _("\
637%s: option `%s' requires an argument\n"), 636%s: option '%s' requires an argument\n"),
638 argv[0], argv[d->optind - 1]) >= 0) 637 argv[0], argv[d->optind - 1]) >= 0)
639 { 638 {
640 _IO_flockfile (stderr); 639 _IO_flockfile (stderr);
641 640
642 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 641 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
643 ((_IO_FILE *) stderr)->_flags2 642 ((_IO_FILE *) stderr)->_flags2
644 |= _IO_FLAGS2_NOTCANCEL; 643 |= _IO_FLAGS2_NOTCANCEL;
645 644
646 __fxprintf (NULL, "%s", buf); 645 __fxprintf (NULL, "%s", buf);
647 646
648 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 647 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
649 _IO_funlockfile (stderr); 648 _IO_funlockfile (stderr);
650 649
651 free (buf); 650 free (buf);
652 } 651 }
653#else 652#else
654 fprintf (stderr, 653 fprintf (stderr,
655 _("%s: option `%s' requires an argument\n"), 654 _("%s: option '%s' requires an argument\n"),
656 argv[0], argv[d->optind - 1]); 655 argv[0], argv[d->optind - 1]);
657#endif 656#endif
658 } 657 }
659 d->__nextchar += strlen (d->__nextchar); 658 d->__nextchar += strlen (d->__nextchar);
660 d->optopt = pfound->val; 659 d->optopt = pfound->val;
661 return optstring[0] == ':' ? ':' : '?'; 660 return optstring[0] == ':' ? ':' : '?';
662 } 661 }
663 } 662 }
664 d->__nextchar += strlen (d->__nextchar); 663 d->__nextchar += strlen (d->__nextchar);
665 if (longind != NULL) 664 if (longind != NULL)
666 *longind = option_index; 665 *longind = option_index;
667 if (pfound->flag) 666 if (pfound->flag)
668 { 667 {
669 *(pfound->flag) = pfound->val; 668 *(pfound->flag) = pfound->val;
670 return 0; 669 return 0;
671 } 670 }
672 return pfound->val; 671 return pfound->val;
673 } 672 }
674 673
675 /* Can't find it as a long option. If this is not getopt_long_only, 674 /* Can't find it as a long option. If this is not getopt_long_only,
676 or the option starts with '--' or is not a valid short 675 or the option starts with '--' or is not a valid short
677 option, then it's an error. 676 option, then it's an error.
678 Otherwise interpret it as a short option. */ 677 Otherwise interpret it as a short option. */
679 if (!long_only || argv[d->optind][1] == '-' 678 if (!long_only || argv[d->optind][1] == '-'
680 || strchr (optstring, *d->__nextchar) == NULL) 679 || strchr (optstring, *d->__nextchar) == NULL)
681 { 680 {
682 if (print_errors) 681 if (print_errors)
683 { 682 {
684#if defined _LIBC && defined USE_IN_LIBIO 683#if defined _LIBC && defined USE_IN_LIBIO
685 char *buf; 684 char *buf;
686 int n; 685 int n;
687#endif 686#endif
688 687
689 if (argv[d->optind][1] == '-') 688 if (argv[d->optind][1] == '-')
690 { 689 {
691 /* --option */ 690 /* --option */
692#if defined _LIBC && defined USE_IN_LIBIO 691#if defined _LIBC && defined USE_IN_LIBIO
693 n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"), 692 n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
694 argv[0], d->__nextchar); 693 argv[0], d->__nextchar);
695#else 694#else
696 fprintf (stderr, _("%s: unrecognized option `--%s'\n"), 695 fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
697 argv[0], d->__nextchar); 696 argv[0], d->__nextchar);
698#endif 697#endif
699 } 698 }
700 else 699 else
701 { 700 {
702 /* +option or -option */ 701 /* +option or -option */
703#if defined _LIBC && defined USE_IN_LIBIO 702#if defined _LIBC && defined USE_IN_LIBIO
704 n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"), 703 n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
705 argv[0], argv[d->optind][0], d->__nextchar); 704 argv[0], argv[d->optind][0], d->__nextchar);
706#else 705#else
707 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), 706 fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
708 argv[0], argv[d->optind][0], d->__nextchar); 707 argv[0], argv[d->optind][0], d->__nextchar);
709#endif 708#endif
710 } 709 }
711 710
712#if defined _LIBC && defined USE_IN_LIBIO 711#if defined _LIBC && defined USE_IN_LIBIO
713 if (n >= 0) 712 if (n >= 0)
714 { 713 {
715 _IO_flockfile (stderr); 714 _IO_flockfile (stderr);
716 715
717 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 716 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
718 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 717 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
719 718
720 __fxprintf (NULL, "%s", buf); 719 __fxprintf (NULL, "%s", buf);
721 720
722 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 721 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
723 _IO_funlockfile (stderr); 722 _IO_funlockfile (stderr);
724 723
725 free (buf); 724 free (buf);
726 } 725 }
727#endif 726#endif
728 } 727 }
729 d->__nextchar = (char *) ""; 728 d->__nextchar = (char *) "";
730 d->optind++; 729 d->optind++;
731 d->optopt = 0; 730 d->optopt = 0;
732 return '?'; 731 return '?';
733 } 732 }
734 } 733 }
735 734
736 /* Look at and handle the next short option-character. */ 735 /* Look at and handle the next short option-character. */
@@ -745,335 +744,321 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
745 744
746 if (temp == NULL || c == ':') 745 if (temp == NULL || c == ':')
747 { 746 {
748 if (print_errors) 747 if (print_errors)
749 { 748 {
750#if defined _LIBC && defined USE_IN_LIBIO 749#if defined _LIBC && defined USE_IN_LIBIO
751 char *buf; 750 char *buf;
752 int n; 751 int n;
753#endif 752#endif
754 753
755 if (d->__posixly_correct)
756 {
757 /* 1003.2 specifies the format of this message. */
758#if defined _LIBC && defined USE_IN_LIBIO
759 n = __asprintf (&buf, _("%s: illegal option -- %c\n"),
760 argv[0], c);
761#else
762 fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
763#endif
764 }
765 else
766 {
767#if defined _LIBC && defined USE_IN_LIBIO 754#if defined _LIBC && defined USE_IN_LIBIO
768 n = __asprintf (&buf, _("%s: invalid option -- %c\n"), 755 n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
769 argv[0], c); 756 argv[0], c);
770#else 757#else
771 fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c); 758 fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
772#endif 759#endif
773 }
774 760
775#if defined _LIBC && defined USE_IN_LIBIO 761#if defined _LIBC && defined USE_IN_LIBIO
776 if (n >= 0) 762 if (n >= 0)
777 { 763 {
778 _IO_flockfile (stderr); 764 _IO_flockfile (stderr);
779 765
780 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 766 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
781 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 767 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
782 768
783 __fxprintf (NULL, "%s", buf); 769 __fxprintf (NULL, "%s", buf);
784 770
785 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 771 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
786 _IO_funlockfile (stderr); 772 _IO_funlockfile (stderr);
787 773
788 free (buf); 774 free (buf);
789 } 775 }
790#endif 776#endif
791 } 777 }
792 d->optopt = c; 778 d->optopt = c;
793 return '?'; 779 return '?';
794 } 780 }
795 /* Convenience. Treat POSIX -W foo same as long option --foo */ 781 /* Convenience. Treat POSIX -W foo same as long option --foo */
796 if (temp[0] == 'W' && temp[1] == ';') 782 if (temp[0] == 'W' && temp[1] == ';')
797 { 783 {
798 char *nameend; 784 char *nameend;
799 const struct option *p; 785 const struct option *p;
800 const struct option *pfound = NULL; 786 const struct option *pfound = NULL;
801 int exact = 0; 787 int exact = 0;
802 int ambig = 0; 788 int ambig = 0;
803 int indfound = 0; 789 int indfound = 0;
804 int option_index; 790 int option_index;
805 791
806 /* This is an option that requires an argument. */ 792 /* This is an option that requires an argument. */
807 if (*d->__nextchar != '\0') 793 if (*d->__nextchar != '\0')
808 { 794 {
809 d->optarg = d->__nextchar; 795 d->optarg = d->__nextchar;
810 /* If we end this ARGV-element by taking the rest as an arg, 796 /* If we end this ARGV-element by taking the rest as an arg,
811 we must advance to the next element now. */ 797 we must advance to the next element now. */
812 d->optind++; 798 d->optind++;
813 } 799 }
814 else if (d->optind == argc) 800 else if (d->optind == argc)
815 { 801 {
816 if (print_errors) 802 if (print_errors)
817 { 803 {
818 /* 1003.2 specifies the format of this message. */
819#if defined _LIBC && defined USE_IN_LIBIO 804#if defined _LIBC && defined USE_IN_LIBIO
820 char *buf; 805 char *buf;
821 806
822 if (__asprintf (&buf, 807 if (__asprintf (&buf,
823 _("%s: option requires an argument -- %c\n"), 808 _("%s: option requires an argument -- '%c'\n"),
824 argv[0], c) >= 0) 809 argv[0], c) >= 0)
825 { 810 {
826 _IO_flockfile (stderr); 811 _IO_flockfile (stderr);
827 812
828 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 813 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
829 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 814 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
830 815
831 __fxprintf (NULL, "%s", buf); 816 __fxprintf (NULL, "%s", buf);
832 817
833 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 818 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
834 _IO_funlockfile (stderr); 819 _IO_funlockfile (stderr);
835 820
836 free (buf); 821 free (buf);
837 } 822 }
838#else 823#else
839 fprintf (stderr, _("%s: option requires an argument -- %c\n"), 824 fprintf (stderr,
840 argv[0], c); 825 _("%s: option requires an argument -- '%c'\n"),
826 argv[0], c);
841#endif 827#endif
842 } 828 }
843 d->optopt = c; 829 d->optopt = c;
844 if (optstring[0] == ':') 830 if (optstring[0] == ':')
845 c = ':'; 831 c = ':';
846 else 832 else
847 c = '?'; 833 c = '?';
848 return c; 834 return c;
849 } 835 }
850 else 836 else
851 /* We already incremented `d->optind' once; 837 /* We already incremented `d->optind' once;
852 increment it again when taking next ARGV-elt as argument. */ 838 increment it again when taking next ARGV-elt as argument. */
853 d->optarg = argv[d->optind++]; 839 d->optarg = argv[d->optind++];
854 840
855 /* optarg is now the argument, see if it's in the 841 /* optarg is now the argument, see if it's in the
856 table of longopts. */ 842 table of longopts. */
857 843
858 for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; 844 for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
859 nameend++) 845 nameend++)
860 /* Do nothing. */ ; 846 /* Do nothing. */ ;
861 847
862 /* Test all long options for either exact match 848 /* Test all long options for either exact match
863 or abbreviated matches. */ 849 or abbreviated matches. */
864 for (p = longopts, option_index = 0; p->name; p++, option_index++) 850 for (p = longopts, option_index = 0; p->name; p++, option_index++)
865 if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar)) 851 if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
866 { 852 {
867 if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name)) 853 if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
868 { 854 {
869 /* Exact match found. */ 855 /* Exact match found. */
870 pfound = p; 856 pfound = p;
871 indfound = option_index; 857 indfound = option_index;
872 exact = 1; 858 exact = 1;
873 break; 859 break;
874 } 860 }
875 else if (pfound == NULL) 861 else if (pfound == NULL)
876 { 862 {
877 /* First nonexact match found. */ 863 /* First nonexact match found. */
878 pfound = p; 864 pfound = p;
879 indfound = option_index; 865 indfound = option_index;
880 } 866 }
881 else 867 else
882 /* Second or later nonexact match found. */ 868 /* Second or later nonexact match found. */
883 ambig = 1; 869 ambig = 1;
884 } 870 }
885 if (ambig && !exact) 871 if (ambig && !exact)
886 { 872 {
887 if (print_errors) 873 if (print_errors)
888 { 874 {
889#if defined _LIBC && defined USE_IN_LIBIO 875#if defined _LIBC && defined USE_IN_LIBIO
890 char *buf; 876 char *buf;
891 877
892 if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"), 878 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
893 argv[0], argv[d->optind]) >= 0) 879 argv[0], argv[d->optind]) >= 0)
894 { 880 {
895 _IO_flockfile (stderr); 881 _IO_flockfile (stderr);
896 882
897 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 883 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
898 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 884 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
899 885
900 __fxprintf (NULL, "%s", buf); 886 __fxprintf (NULL, "%s", buf);
901 887
902 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 888 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
903 _IO_funlockfile (stderr); 889 _IO_funlockfile (stderr);
904 890
905 free (buf); 891 free (buf);
906 } 892 }
907#else 893#else
908 fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), 894 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
909 argv[0], argv[d->optind]); 895 argv[0], argv[d->optind]);
910#endif 896#endif
911 } 897 }
912 d->__nextchar += strlen (d->__nextchar); 898 d->__nextchar += strlen (d->__nextchar);
913 d->optind++; 899 d->optind++;
914 return '?'; 900 return '?';
915 } 901 }
916 if (pfound != NULL) 902 if (pfound != NULL)
917 { 903 {
918 option_index = indfound; 904 option_index = indfound;
919 if (*nameend) 905 if (*nameend)
920 { 906 {
921 /* Don't test has_arg with >, because some C compilers don't 907 /* Don't test has_arg with >, because some C compilers don't
922 allow it to be used on enums. */ 908 allow it to be used on enums. */
923 if (pfound->has_arg) 909 if (pfound->has_arg)
924 d->optarg = nameend + 1; 910 d->optarg = nameend + 1;
925 else 911 else
926 { 912 {
927 if (print_errors) 913 if (print_errors)
928 { 914 {
929#if defined _LIBC && defined USE_IN_LIBIO 915#if defined _LIBC && defined USE_IN_LIBIO
930 char *buf; 916 char *buf;
931 917
932 if (__asprintf (&buf, _("\ 918 if (__asprintf (&buf, _("\
933%s: option `-W %s' doesn't allow an argument\n"), 919%s: option '-W %s' doesn't allow an argument\n"),
934 argv[0], pfound->name) >= 0) 920 argv[0], pfound->name) >= 0)
935 { 921 {
936 _IO_flockfile (stderr); 922 _IO_flockfile (stderr);
937 923
938 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 924 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
939 ((_IO_FILE *) stderr)->_flags2 925 ((_IO_FILE *) stderr)->_flags2
940 |= _IO_FLAGS2_NOTCANCEL; 926 |= _IO_FLAGS2_NOTCANCEL;
941 927
942 __fxprintf (NULL, "%s", buf); 928 __fxprintf (NULL, "%s", buf);
943 929
944 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 930 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
945 _IO_funlockfile (stderr); 931 _IO_funlockfile (stderr);
946 932
947 free (buf); 933 free (buf);
948 } 934 }
949#else 935#else
950 fprintf (stderr, _("\ 936 fprintf (stderr, _("\
951%s: option `-W %s' doesn't allow an argument\n"), 937%s: option '-W %s' doesn't allow an argument\n"),
952 argv[0], pfound->name); 938 argv[0], pfound->name);
953#endif 939#endif
954 } 940 }
955 941
956 d->__nextchar += strlen (d->__nextchar); 942 d->__nextchar += strlen (d->__nextchar);
957 return '?'; 943 return '?';
958 } 944 }
959 } 945 }
960 else if (pfound->has_arg == 1) 946 else if (pfound->has_arg == 1)
961 { 947 {
962 if (d->optind < argc) 948 if (d->optind < argc)
963 d->optarg = argv[d->optind++]; 949 d->optarg = argv[d->optind++];
964 else 950 else
965 { 951 {
966 if (print_errors) 952 if (print_errors)
967 { 953 {
968#if defined _LIBC && defined USE_IN_LIBIO 954#if defined _LIBC && defined USE_IN_LIBIO
969 char *buf; 955 char *buf;
970 956
971 if (__asprintf (&buf, _("\ 957 if (__asprintf (&buf, _("\
972%s: option `%s' requires an argument\n"), 958%s: option '%s' requires an argument\n"),
973 argv[0], argv[d->optind - 1]) >= 0) 959 argv[0], argv[d->optind - 1]) >= 0)
974 { 960 {
975 _IO_flockfile (stderr); 961 _IO_flockfile (stderr);
976 962
977 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 963 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
978 ((_IO_FILE *) stderr)->_flags2 964 ((_IO_FILE *) stderr)->_flags2
979 |= _IO_FLAGS2_NOTCANCEL; 965 |= _IO_FLAGS2_NOTCANCEL;
980 966
981 __fxprintf (NULL, "%s", buf); 967 __fxprintf (NULL, "%s", buf);
982 968
983 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 969 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
984 _IO_funlockfile (stderr); 970 _IO_funlockfile (stderr);
985 971
986 free (buf); 972 free (buf);
987 } 973 }
988#else 974#else
989 fprintf (stderr, 975 fprintf (stderr,
990 _("%s: option `%s' requires an argument\n"), 976 _("%s: option '%s' requires an argument\n"),
991 argv[0], argv[d->optind - 1]); 977 argv[0], argv[d->optind - 1]);
992#endif 978#endif
993 } 979 }
994 d->__nextchar += strlen (d->__nextchar); 980 d->__nextchar += strlen (d->__nextchar);
995 return optstring[0] == ':' ? ':' : '?'; 981 return optstring[0] == ':' ? ':' : '?';
996 } 982 }
997 } 983 }
998 d->__nextchar += strlen (d->__nextchar); 984 d->__nextchar += strlen (d->__nextchar);
999 if (longind != NULL) 985 if (longind != NULL)
1000 *longind = option_index; 986 *longind = option_index;
1001 if (pfound->flag) 987 if (pfound->flag)
1002 { 988 {
1003 *(pfound->flag) = pfound->val; 989 *(pfound->flag) = pfound->val;
1004 return 0; 990 return 0;
1005 } 991 }
1006 return pfound->val; 992 return pfound->val;
1007 } 993 }
1008 d->__nextchar = NULL; 994 d->__nextchar = NULL;
1009 return 'W'; /* Let the application handle it. */ 995 return 'W'; /* Let the application handle it. */
1010 } 996 }
1011 if (temp[1] == ':') 997 if (temp[1] == ':')
1012 { 998 {
1013 if (temp[2] == ':') 999 if (temp[2] == ':')
1014 { 1000 {
1015 /* This is an option that accepts an argument optionally. */ 1001 /* This is an option that accepts an argument optionally. */
1016 if (*d->__nextchar != '\0') 1002 if (*d->__nextchar != '\0')
1017 { 1003 {
1018 d->optarg = d->__nextchar; 1004 d->optarg = d->__nextchar;
1019 d->optind++; 1005 d->optind++;
1020 } 1006 }
1021 else 1007 else
1022 d->optarg = NULL; 1008 d->optarg = NULL;
1023 d->__nextchar = NULL; 1009 d->__nextchar = NULL;
1024 } 1010 }
1025 else 1011 else
1026 { 1012 {
1027 /* This is an option that requires an argument. */ 1013 /* This is an option that requires an argument. */
1028 if (*d->__nextchar != '\0') 1014 if (*d->__nextchar != '\0')
1029 { 1015 {
1030 d->optarg = d->__nextchar; 1016 d->optarg = d->__nextchar;
1031 /* If we end this ARGV-element by taking the rest as an arg, 1017 /* If we end this ARGV-element by taking the rest as an arg,
1032 we must advance to the next element now. */ 1018 we must advance to the next element now. */
1033 d->optind++; 1019 d->optind++;
1034 } 1020 }
1035 else if (d->optind == argc) 1021 else if (d->optind == argc)
1036 { 1022 {
1037 if (print_errors) 1023 if (print_errors)
1038 { 1024 {
1039 /* 1003.2 specifies the format of this message. */
1040#if defined _LIBC && defined USE_IN_LIBIO 1025#if defined _LIBC && defined USE_IN_LIBIO
1041 char *buf; 1026 char *buf;
1042 1027
1043 if (__asprintf (&buf, _("\ 1028 if (__asprintf (&buf, _("\
1044%s: option requires an argument -- %c\n"), 1029%s: option requires an argument -- '%c'\n"),
1045 argv[0], c) >= 0) 1030 argv[0], c) >= 0)
1046 { 1031 {
1047 _IO_flockfile (stderr); 1032 _IO_flockfile (stderr);
1048 1033
1049 int old_flags2 = ((_IO_FILE *) stderr)->_flags2; 1034 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1050 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; 1035 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1051 1036
1052 __fxprintf (NULL, "%s", buf); 1037 __fxprintf (NULL, "%s", buf);
1053 1038
1054 ((_IO_FILE *) stderr)->_flags2 = old_flags2; 1039 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1055 _IO_funlockfile (stderr); 1040 _IO_funlockfile (stderr);
1056 1041
1057 free (buf); 1042 free (buf);
1058 } 1043 }
1059#else 1044#else
1060 fprintf (stderr, 1045 fprintf (stderr,
1061 _("%s: option requires an argument -- %c\n"), 1046 _("%s: option requires an argument -- '%c'\n"),
1062 argv[0], c); 1047 argv[0], c);
1063#endif 1048#endif
1064 } 1049 }
1065 d->optopt = c; 1050 d->optopt = c;
1066 if (optstring[0] == ':') 1051 if (optstring[0] == ':')
1067 c = ':'; 1052 c = ':';
1068 else 1053 else
1069 c = '?'; 1054 c = '?';
1070 } 1055 }
1071 else 1056 else
1072 /* We already incremented `optind' once; 1057 /* We already incremented `optind' once;
1073 increment it again when taking next ARGV-elt as argument. */ 1058 increment it again when taking next ARGV-elt as argument. */
1074 d->optarg = argv[d->optind++]; 1059 d->optarg = argv[d->optind++];
1075 d->__nextchar = NULL; 1060 d->__nextchar = NULL;
1076 } 1061 }
1077 } 1062 }
1078 return c; 1063 return c;
1079 } 1064 }
@@ -1081,16 +1066,17 @@ _getopt_internal_r (int argc, char **argv, const char *optstring,
1081 1066
1082int 1067int
1083_getopt_internal (int argc, char **argv, const char *optstring, 1068_getopt_internal (int argc, char **argv, const char *optstring,
1084 const struct option *longopts, int *longind, 1069 const struct option *longopts, int *longind, int long_only,
1085 int long_only, int posixly_correct) 1070 int posixly_correct)
1086{ 1071{
1087 int result; 1072 int result;
1088 1073
1089 getopt_data.optind = optind; 1074 getopt_data.optind = optind;
1090 getopt_data.opterr = opterr; 1075 getopt_data.opterr = opterr;
1091 1076
1092 result = _getopt_internal_r (argc, argv, optstring, longopts, longind, 1077 result = _getopt_internal_r (argc, argv, optstring, longopts,
1093 long_only, posixly_correct, &getopt_data); 1078 longind, long_only, &getopt_data,
1079 posixly_correct);
1094 1080
1095 optind = getopt_data.optind; 1081 optind = getopt_data.optind;
1096 optarg = getopt_data.optarg; 1082 optarg = getopt_data.optarg;
@@ -1110,10 +1096,23 @@ enum { POSIXLY_CORRECT = 1 };
1110int 1096int
1111getopt (int argc, char *const *argv, const char *optstring) 1097getopt (int argc, char *const *argv, const char *optstring)
1112{ 1098{
1113 return _getopt_internal (argc, (char **) argv, optstring, NULL, NULL, 0, 1099 return _getopt_internal (argc, (char **) argv, optstring,
1114 POSIXLY_CORRECT); 1100 (const struct option *) 0,
1101 (int *) 0,
1102 0, POSIXLY_CORRECT);
1115} 1103}
1116 1104
1105#ifdef _LIBC
1106int
1107__posix_getopt (int argc, char *const *argv, const char *optstring)
1108{
1109 return _getopt_internal (argc, argv, optstring,
1110 (const struct option *) 0,
1111 (int *) 0,
1112 0, 1);
1113}
1114#endif
1115
1117 1116
1118#ifdef TEST 1117#ifdef TEST
1119 1118
@@ -1132,51 +1131,51 @@ main (int argc, char **argv)
1132 1131
1133 c = getopt (argc, argv, "abc:d:0123456789"); 1132 c = getopt (argc, argv, "abc:d:0123456789");
1134 if (c == -1) 1133 if (c == -1)
1135 break; 1134 break;
1136 1135
1137 switch (c) 1136 switch (c)
1138 { 1137 {
1139 case '0': 1138 case '0':
1140 case '1': 1139 case '1':
1141 case '2': 1140 case '2':
1142 case '3': 1141 case '3':
1143 case '4': 1142 case '4':
1144 case '5': 1143 case '5':
1145 case '6': 1144 case '6':
1146 case '7': 1145 case '7':
1147 case '8': 1146 case '8':
1148 case '9': 1147 case '9':
1149 if (digit_optind != 0 && digit_optind != this_option_optind) 1148 if (digit_optind != 0 && digit_optind != this_option_optind)
1150 printf ("digits occur in two different argv-elements.\n"); 1149 printf ("digits occur in two different argv-elements.\n");
1151 digit_optind = this_option_optind; 1150 digit_optind = this_option_optind;
1152 printf ("option %c\n", c); 1151 printf ("option %c\n", c);
1153 break; 1152 break;
1154 1153
1155 case 'a': 1154 case 'a':
1156 printf ("option a\n"); 1155 printf ("option a\n");
1157 break; 1156 break;
1158 1157
1159 case 'b': 1158 case 'b':
1160 printf ("option b\n"); 1159 printf ("option b\n");
1161 break; 1160 break;
1162 1161
1163 case 'c': 1162 case 'c':
1164 printf ("option c with value `%s'\n", optarg); 1163 printf ("option c with value '%s'\n", optarg);
1165 break; 1164 break;
1166 1165
1167 case '?': 1166 case '?':
1168 break; 1167 break;
1169 1168
1170 default: 1169 default:
1171 printf ("?? getopt returned character code 0%o ??\n", c); 1170 printf ("?? getopt returned character code 0%o ??\n", c);
1172 } 1171 }
1173 } 1172 }
1174 1173
1175 if (optind < argc) 1174 if (optind < argc)
1176 { 1175 {
1177 printf ("non-option ARGV-elements: "); 1176 printf ("non-option ARGV-elements: ");
1178 while (optind < argc) 1177 while (optind < argc)
1179 printf ("%s ", argv[optind++]); 1178 printf ("%s ", argv[optind++]);
1180 printf ("\n"); 1179 printf ("\n");
1181 } 1180 }
1182 1181