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