← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to gnulib/getopt.c

  • Committer: Monty Taylor
  • Date: 2009-03-24 17:44:41 UTC
  • mto: (960.5.2 mordred)
  • mto: This revision was merged to the branch mainline in revision 964.
  • Revision ID: mordred@inaugust.com-20090324174441-nmsq0gwjlgf7f0mt
Changed handlerton to StorageEngine.

Show diffs side-by-side

added added

removed removed

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