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