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