← Back to branch summary

~ubuntu-branches/ubuntu/vivid/diffutils/vivid

« back to all changes in this revision

Viewing changes to lib/getopt.c

  • Committer: Bazaar Package Importer
  • Author(s): Santiago Vila
  • Date: 2010-02-13 11:49:00 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100213114900-09lz8jx6wct52qp8
Tags: 1:2.9-1
http://bugs.debian.org/82923
http://bugs.debian.org/200614
http://bugs.debian.org/228441
http://bugs.debian.org/473233
http://bugs.debian.org/313686
http://bugs.debian.org/320222
http://bugs.debian.org/324627
http://bugs.debian.org/356083
http://bugs.debian.org/409274
http://bugs.debian.org/418005
http://bugs.debian.org/481708
http://bugs.debian.org/427370
* New upstream release, now under GPL version 3 or later.
* There is now a --tab-size option. Closes: #82923.
* Manpage for cmp describes exit status. Closes: #200614.
* Manpage for diff describes exit status. Closes: #228441, #473233.
* The file de.po is now more recent. Closes: #313686.
* Fixed bad sdiff behaviour. Closes: #320222.
* Added wdiff to Suggests. Closes: #324627.
* Fixed cmp behaviour regarding stdout and stderr. Closes: #356083.
* The file ru.po is now more recent. Closes: #409274.
* The file es.po is now more recent. Closes: #418005, #481708.
* The file nl.po is now more recent. Closes: #427370.
* Modified watch file to use http instead of ftp.
* Removed .comment section from executables.
* Added Homepage field to control file.

Show diffs side-by-side

added added

removed removed

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