Refactor headers
[wimlib] / programs / wgetopt.c
1 /* 
2  * wgetopt.c:  Wide-character versions of getopt, getopt_long, and
3  * getopt_long_only.
4  *
5  * This has been modified from the original, which is
6  * Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
7  * 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
8  * 2010 Free Software Foundation, Inc.
9  *
10  * This file is part of wimlib, a library for working with WIM files.
11  *
12  * wimlib is free software; you can redistribute it and/or modify it under the
13  * terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 3 of the License, or (at your option)
15  * any later version.
16  *
17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
24  */
25
26 #include "wgetopt.h"
27 #include <stdlib.h>
28 #include <stdio.h>
29
30 /* For communication from `getopt' to the caller.
31    When `getopt' finds an option that takes an argument,
32    the argument value is returned here.
33    Also, when `ordering' is RETURN_IN_ORDER,
34    each non-option ARGV-element is returned here.  */
35
36 wchar_t *woptarg = NULL;
37
38 /* Index in ARGV of the next element to be scanned.
39    This is used for communication to and from the caller
40    and for communication between successive calls to `getopt'.
41
42    On entry to `getopt', zero means this is the first call; initialize.
43
44    When `getopt' returns -1, this is the index of the first of the
45    non-option elements that the caller should itself scan.
46
47    Otherwise, `woptind' communicates from one call to the next
48    how much of ARGV has been scanned so far.  */
49
50 /* 1003.2 says this must be 1 before any call.  */
51 int woptind = 1;
52
53 /* Formerly, initialization of getopt depended on woptind==0, which
54    causes problems with re-calling getopt as programs generally don't
55    know that. */
56
57 int __getopt_initialized = 0;
58
59 /* The next char to be scanned in the option-element
60    in which the last option character we returned was found.
61    This allows us to pick up the scan where we left off.
62
63    If this is zero, or a null string, it means resume the scan
64    by advancing to the next ARGV-element.  */
65
66 static wchar_t *nextchar;
67
68 /* Callers store zero here to inhibit the error message
69    for unrecognized options.  */
70
71 int wopterr = 1;
72
73 /* Set to an option character which was unrecognized.
74    This must be initialized on some systems to avoid linking in the
75    system's own getopt implementation.  */
76
77 int woptopt = '?';
78
79 /* Describe how to deal with options that follow non-option ARGV-elements.
80
81    If the caller did not specify anything,
82    the default is REQUIRE_ORDER if the environment variable
83    POSIXLY_CORRECT is defined, PERMUTE otherwise.
84
85    REQUIRE_ORDER means don't recognize them as options;
86    stop option processing when the first non-option is seen.
87    This is what Unix does.
88    This mode of operation is selected by either setting the environment
89    variable POSIXLY_CORRECT, or using `+' as the first character
90    of the list of option characters.
91
92    PERMUTE is the default.  We permute the contents of ARGV as we scan,
93    so that eventually all the non-options are at the end.  This allows options
94    to be given in any order, even with programs that were not written to
95    expect this.
96
97    RETURN_IN_ORDER is an option available to programs that were written
98    to expect options and other ARGV-elements in any order and that care about
99    the ordering of the two.  We describe each non-option ARGV-element
100    as if it were the argument of an option with character code 1.
101    Using `-' as the first character of the list of option characters
102    selects this mode of operation.
103
104    The special argument `--' forces an end of option-scanning regardless
105    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
106    `--' can cause `getopt' to return -1 with `woptind' != ARGC.  */
107
108 static enum
109 {
110   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
111 } ordering;
112
113 /* Value of POSIXLY_CORRECT environment variable.  */
114 static char *posixly_correct;
115
116
117 /* Handle permutation of arguments.  */
118
119 /* Describe the part of ARGV that contains non-options that have
120    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
121    `last_nonopt' is the index after the last of them.  */
122
123 static int first_nonopt;
124 static int last_nonopt;
125
126 /* Exchange two adjacent subsequences of ARGV.
127    One subsequence is elements [first_nonopt,last_nonopt)
128    which contains all the non-options that have been skipped so far.
129    The other is elements [last_nonopt,woptind), which contains all
130    the options processed since those non-options were skipped.
131
132    `first_nonopt' and `last_nonopt' are relocated so that they describe
133    the new indices of the non-options in ARGV after they are moved.  */
134
135 static void
136 exchange (wchar_t **argv)
137 {
138   int bottom = first_nonopt;
139   int middle = last_nonopt;
140   int top = woptind;
141   wchar_t *tem;
142
143   /* Exchange the shorter segment with the far end of the longer segment.
144      That puts the shorter segment into the right place.
145      It leaves the longer segment in the right place overall,
146      but it consists of two parts that need to be swapped next.  */
147
148   while (top > middle && middle > bottom)
149     {
150       if (top - middle > middle - bottom)
151         {
152           /* Bottom segment is the short one.  */
153           int len = middle - bottom;
154           register int i;
155
156           /* Swap it with the top part of the top segment.  */
157           for (i = 0; i < len; i++)
158             {
159               tem = argv[bottom + i];
160               argv[bottom + i] = argv[top - (middle - bottom) + i];
161               argv[top - (middle - bottom) + i] = tem;
162             }
163           /* Exclude the moved bottom segment from further swapping.  */
164           top -= len;
165         }
166       else
167         {
168           /* Top segment is the short one.  */
169           int len = top - middle;
170           register int i;
171
172           /* Swap it with the bottom part of the bottom segment.  */
173           for (i = 0; i < len; i++)
174             {
175               tem = argv[bottom + i];
176               argv[bottom + i] = argv[middle + i];
177               argv[middle + i] = tem;
178             }
179           /* Exclude the moved top segment from further swapping.  */
180           bottom += len;
181         }
182     }
183
184   /* Update records for the slots the non-options now occupy.  */
185
186   first_nonopt += (woptind - last_nonopt);
187   last_nonopt = woptind;
188 }
189
190 /* Initialize the internal data when the first call is made.  */
191
192 static const wchar_t *
193 _getopt_initialize (int argc, wchar_t *const *argv, const wchar_t *optstring)
194 {
195   /* Start processing options with ARGV-element 1 (since ARGV-element 0
196      is the program name); the sequence of previously skipped
197      non-option ARGV-elements is empty.  */
198
199   first_nonopt = last_nonopt = woptind;
200
201   nextchar = NULL;
202
203   posixly_correct = getenv ("POSIXLY_CORRECT");
204
205   /* Determine how to handle the ordering of options and nonoptions.  */
206
207   if (optstring[0] == L'-')
208     {
209       ordering = RETURN_IN_ORDER;
210       ++optstring;
211     }
212   else if (optstring[0] == L'+')
213     {
214       ordering = REQUIRE_ORDER;
215       ++optstring;
216     }
217   else if (posixly_correct != NULL)
218     ordering = REQUIRE_ORDER;
219   else
220     ordering = PERMUTE;
221
222   return optstring;
223 }
224 \f
225 /* Scan elements of ARGV (whose length is ARGC) for option characters
226    given in OPTSTRING.
227
228    If an element of ARGV starts with '-', and is not exactly "-" or "--",
229    then it is an option element.  The characters of this element
230    (aside from the initial '-') are option characters.  If `getopt'
231    is called repeatedly, it returns successively each of the option characters
232    from each of the option elements.
233
234    If `getopt' finds another option character, it returns that character,
235    updating `woptind' and `nextchar' so that the next call to `getopt' can
236    resume the scan with the following option character or ARGV-element.
237
238    If there are no more option characters, `getopt' returns -1.
239    Then `woptind' is the index in ARGV of the first ARGV-element
240    that is not an option.  (The ARGV-elements have been permuted
241    so that those that are not options now come last.)
242
243    OPTSTRING is a string containing the legitimate option characters.
244    If an option character is seen that is not listed in OPTSTRING,
245    return '?' after printing an error message.  If you set `wopterr' to
246    zero, the error message is suppressed but we still return '?'.
247
248    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
249    so the following text in the same ARGV-element, or the text of the following
250    ARGV-element, is returned in `woptarg'.  Two colons mean an option that
251    wants an optional arg; if there is text in the current ARGV-element,
252    it is returned in `woptarg', otherwise `woptarg' is set to zero.
253
254    If OPTSTRING starts with `-' or `+', it requests different methods of
255    handling the non-option ARGV-elements.
256    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
257
258    Long-named options begin with `--' instead of `-'.
259    Their names may be abbreviated as long as the abbreviation is unique
260    or is an exact match for some defined option.  If they have an
261    argument, it follows the option name in the same ARGV-element, separated
262    from the option name by a `=', or else the in next ARGV-element.
263    When `getopt' finds a long-named option, it returns 0 if that option's
264    `flag' field is nonzero, the value of the option's `val' field
265    if the `flag' field is zero.
266
267    The elements of ARGV aren't really const, because we permute them.
268    But we pretend they're const in the prototype to be compatible
269    with other systems.
270
271    LONGOPTS is a vector of `struct woption' terminated by an
272    element containing a name which is zero.
273
274    LONGIND returns the index in LONGOPT of the long-named option found.
275    It is only valid when a long-named option has been found by the most
276    recent call.
277
278    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
279    long-named options.  */
280
281 static int
282 _wgetopt_internal (int argc, wchar_t *const *argv, const wchar_t *optstring,
283                   const struct woption *longopts, int *longind, int long_only)
284 {
285   woptarg = NULL;
286
287   if (woptind == 0 || !__getopt_initialized)
288     {
289       if (woptind == 0)
290         woptind = 1;    /* Don't scan ARGV[0], the program name.  */
291       optstring = _getopt_initialize (argc, argv, optstring);
292       __getopt_initialized = 1;
293     }
294
295   /* Test whether ARGV[woptind] points to a non-option argument.
296      Either it does not have option syntax, or there is an environment flag
297      from the shell indicating it is not an option.  The later information
298      is only used when the used in the GNU libc.  */
299 # define NONOPTION_P (argv[woptind][0] != L'-' || argv[woptind][1] == L'\0')
300
301   if (nextchar == NULL || *nextchar == '\0')
302     {
303       /* Advance to the next ARGV-element.  */
304
305       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
306          moved back by the user (who may also have changed the arguments).  */
307       if (last_nonopt > woptind)
308         last_nonopt = woptind;
309       if (first_nonopt > woptind)
310         first_nonopt = woptind;
311
312       if (ordering == PERMUTE)
313         {
314           /* If we have just processed some options following some non-options,
315              exchange them so that the options come first.  */
316
317           if (first_nonopt != last_nonopt && last_nonopt != woptind)
318             exchange ((wchar_t **) argv);
319           else if (last_nonopt != woptind)
320             first_nonopt = woptind;
321
322           /* Skip any additional non-options
323              and extend the range of non-options previously skipped.  */
324
325           while (woptind < argc && NONOPTION_P)
326             woptind++;
327           last_nonopt = woptind;
328         }
329
330       /* The special ARGV-element `--' means premature end of options.
331          Skip it like a null option,
332          then exchange with previous non-options as if it were an option,
333          then skip everything else like a non-option.  */
334
335       if (woptind != argc && !wcscmp (argv[woptind], L"--"))
336         {
337           woptind++;
338
339           if (first_nonopt != last_nonopt && last_nonopt != woptind)
340             exchange ((wchar_t **) argv);
341           else if (first_nonopt == last_nonopt)
342             first_nonopt = woptind;
343           last_nonopt = argc;
344
345           woptind = argc;
346         }
347
348       /* If we have done all the ARGV-elements, stop the scan
349          and back over any non-options that we skipped and permuted.  */
350
351       if (woptind == argc)
352         {
353           /* Set the next-arg-index to point at the non-options
354              that we previously skipped, so the caller will digest them.  */
355           if (first_nonopt != last_nonopt)
356             woptind = first_nonopt;
357           return -1;
358         }
359
360       /* If we have come to a non-option and did not permute it,
361          either stop the scan or describe it to the caller and pass it by.  */
362
363       if (NONOPTION_P)
364         {
365           if (ordering == REQUIRE_ORDER)
366             return -1;
367           woptarg = argv[woptind++];
368           return 1;
369         }
370
371       /* We have found another option-ARGV-element.
372          Skip the initial punctuation.  */
373
374       nextchar = (argv[woptind] + 1
375                   + (longopts != NULL && argv[woptind][1] == L'-'));
376     }
377
378   /* Decode the current option-ARGV-element.  */
379
380   /* Check whether the ARGV-element is a long option.
381
382      If long_only and the ARGV-element has the form "-f", where f is
383      a valid short option, don't consider it an abbreviated form of
384      a long option that starts with f.  Otherwise there would be no
385      way to give the -f short option.
386
387      On the other hand, if there's a long option "fubar" and
388      the ARGV-element is "-fu", do consider that an abbreviation of
389      the long option, just like "--fu", and not "-f" with arg "u".
390
391      This distinction seems to be the most useful approach.  */
392
393   if (longopts != NULL
394       && (argv[woptind][1] == L'-'
395           || (long_only && (argv[woptind][2] || !wcschr (optstring, argv[woptind][1])))))
396     {
397       wchar_t *nameend;
398       const struct woption *p;
399       const struct woption *pfound = NULL;
400       int exact = 0;
401       int ambig = 0;
402       int indfound = -1;
403       int option_index;
404
405       for (nameend = nextchar; *nameend && *nameend != L'='; nameend++)
406         /* Do nothing.  */ ;
407
408       /* Test all long options for either exact match
409          or abbreviated matches.  */
410       for (p = longopts, option_index = 0; p->name; p++, option_index++)
411         if (!wcsncmp (p->name, nextchar, nameend - nextchar))
412           {
413             if ((unsigned int) (nameend - nextchar)
414                 == (unsigned int) wcslen (p->name))
415               {
416                 /* Exact match found.  */
417                 pfound = p;
418                 indfound = option_index;
419                 exact = 1;
420                 break;
421               }
422             else if (pfound == NULL)
423               {
424                 /* First nonexact match found.  */
425                 pfound = p;
426                 indfound = option_index;
427               }
428             else
429               /* Second or later nonexact match found.  */
430               ambig = 1;
431           }
432
433       if (ambig && !exact)
434         {
435           if (wopterr)
436             fwprintf (stderr, L"%ls: option `%ls' is ambiguous\n",
437                       argv[0], argv[woptind]);
438           nextchar += wcslen (nextchar);
439           woptind++;
440           woptopt = 0;
441           return L'?';
442         }
443
444       if (pfound != NULL)
445         {
446           option_index = indfound;
447           woptind++;
448           if (*nameend)
449             {
450               /* Don't test has_arg with >, because some C compilers don't
451                  allow it to be used on enums.  */
452               if (pfound->has_arg)
453                 woptarg = nameend + 1;
454               else
455                 {
456                   if (wopterr) {
457                    if (argv[woptind - 1][1] == L'-')
458                     /* --option */
459                     fwprintf (stderr,
460                      L"%ls: option `--%ls' doesn't allow an argument\n",
461                      argv[0], pfound->name);
462                    else
463                     /* +option or -option */
464                     fwprintf (stderr,
465                      L"%ls: option `%lc%ls' doesn't allow an argument\n",
466                      argv[0], argv[woptind - 1][0], pfound->name);
467                   }
468
469                   nextchar += wcslen (nextchar);
470
471                   woptopt = pfound->val;
472                   return L'?';
473                 }
474             }
475           else if (pfound->has_arg == 1)
476             {
477               if (woptind < argc)
478                 woptarg = argv[woptind++];
479               else
480                 {
481                   if (wopterr)
482                     fwprintf (stderr,
483                            L"%ls: option `%ls' requires an argument\n",
484                            argv[0], argv[woptind - 1]);
485                   nextchar += wcslen (nextchar);
486                   woptopt = pfound->val;
487                   return optstring[0] == L':' ? L':' : L'?';
488                 }
489             }
490           nextchar += wcslen (nextchar);
491           if (longind != NULL)
492             *longind = option_index;
493           if (pfound->flag)
494             {
495               *(pfound->flag) = pfound->val;
496               return 0;
497             }
498           return pfound->val;
499         }
500
501       /* Can't find it as a long option.  If this is not getopt_long_only,
502          or the option starts with '--' or is not a valid short
503          option, then it's an error.
504          Otherwise interpret it as a short option.  */
505       if (!long_only || argv[woptind][1] == L'-'
506           || wcschr (optstring, *nextchar) == NULL)
507         {
508           if (wopterr)
509             {
510               if (argv[woptind][1] == '-')
511                 /* --option */
512                 fwprintf (stderr, L"%ls: unrecognized option `--%ls'\n",
513                          argv[0], nextchar);
514               else
515                 /* +option or -option */
516                 fwprintf (stderr, L"%ls: unrecognized option `%lc%ls'\n",
517                          argv[0], argv[woptind][0], nextchar);
518             }
519           nextchar = (wchar_t *) L"";
520           woptind++;
521           woptopt = 0;
522           return L'?';
523         }
524     }
525
526   /* Look at and handle the next short option-character.  */
527
528   {
529     wchar_t c = *nextchar++;
530     wchar_t *temp = wcschr (optstring, c);
531
532     /* Increment `woptind' when we start to process its last character.  */
533     if (*nextchar == L'\0')
534       ++woptind;
535
536     if (temp == NULL || c == L':')
537       {
538         if (wopterr)
539           {
540             if (posixly_correct)
541               /* 1003.2 specifies the format of this message.  */
542               fwprintf (stderr, L"%ls: illegal option -- %lc\n",
543                        argv[0], c);
544             else
545               fwprintf (stderr, L"%ls: invalid option -- %lc\n",
546                        argv[0], c);
547           }
548         woptopt = c;
549         return L'?';
550       }
551     /* Convenience. Treat POSIX -W foo same as long option --foo */
552     if (temp[0] == L'W' && temp[1] == L';')
553       {
554         wchar_t *nameend;
555         const struct woption *p;
556         const struct woption *pfound = NULL;
557         int exact = 0;
558         int ambig = 0;
559         int indfound = 0;
560         int option_index;
561
562         /* This is an option that requires an argument.  */
563         if (*nextchar != L'\0')
564           {
565             woptarg = nextchar;
566             /* If we end this ARGV-element by taking the rest as an arg,
567                we must advance to the next element now.  */
568             woptind++;
569           }
570         else if (woptind == argc)
571           {
572             if (wopterr)
573               {
574                 /* 1003.2 specifies the format of this message.  */
575                 fwprintf (stderr, L"%ls: option requires an argument -- %lc\n",
576                          argv[0], c);
577               }
578             woptopt = c;
579             if (optstring[0] == L':')
580               c = L':';
581             else
582               c = L'?';
583             return c;
584           }
585         else
586           /* We already incremented `woptind' once;
587              increment it again when taking next ARGV-elt as argument.  */
588           woptarg = argv[woptind++];
589
590         /* woptarg is now the argument, see if it's in the
591            table of longopts.  */
592
593         for (nextchar = nameend = woptarg; *nameend && *nameend != L'='; nameend++)
594           /* Do nothing.  */ ;
595
596         /* Test all long options for either exact match
597            or abbreviated matches.  */
598         for (p = longopts, option_index = 0; p->name; p++, option_index++)
599           if (!wcsncmp (p->name, nextchar, nameend - nextchar))
600             {
601               if ((unsigned int) (nameend - nextchar) == wcslen (p->name))
602                 {
603                   /* Exact match found.  */
604                   pfound = p;
605                   indfound = option_index;
606                   exact = 1;
607                   break;
608                 }
609               else if (pfound == NULL)
610                 {
611                   /* First nonexact match found.  */
612                   pfound = p;
613                   indfound = option_index;
614                 }
615               else
616                 /* Second or later nonexact match found.  */
617                 ambig = 1;
618             }
619         if (ambig && !exact)
620           {
621             if (wopterr)
622               fwprintf (stderr, L"%ls: option `-W %ls' is ambiguous\n",
623                        argv[0], argv[woptind]);
624             nextchar += wcslen (nextchar);
625             woptind++;
626             return L'?';
627           }
628         if (pfound != NULL)
629           {
630             option_index = indfound;
631             if (*nameend)
632               {
633                 /* Don't test has_arg with >, because some C compilers don't
634                    allow it to be used on enums.  */
635                 if (pfound->has_arg)
636                   woptarg = nameend + 1;
637                 else
638                   {
639                     if (wopterr)
640                       fwprintf (stderr, L"\
641 %ls: option `-W %ls' doesn't allow an argument\n",
642                                argv[0], pfound->name);
643
644                     nextchar += wcslen (nextchar);
645                     return L'?';
646                   }
647               }
648             else if (pfound->has_arg == 1)
649               {
650                 if (woptind < argc)
651                   woptarg = argv[woptind++];
652                 else
653                   {
654                     if (wopterr)
655                       fwprintf (stderr,
656                                L"%ls: option `%ls' requires an argument\n",
657                                argv[0], argv[woptind - 1]);
658                     nextchar += wcslen (nextchar);
659                     return optstring[0] == L':' ? L':' : L'?';
660                   }
661               }
662             nextchar += wcslen (nextchar);
663             if (longind != NULL)
664               *longind = option_index;
665             if (pfound->flag)
666               {
667                 *(pfound->flag) = pfound->val;
668                 return 0;
669               }
670             return pfound->val;
671           }
672           nextchar = NULL;
673           return L'W';  /* Let the application handle it.   */
674       }
675     if (temp[1] == L':')
676       {
677         if (temp[2] == L':')
678           {
679             /* This is an option that accepts an argument optionally.  */
680             if (*nextchar != L'\0')
681               {
682                 woptarg = nextchar;
683                 woptind++;
684               }
685             else
686               woptarg = NULL;
687             nextchar = NULL;
688           }
689         else
690           {
691             /* This is an option that requires an argument.  */
692             if (*nextchar != L'\0')
693               {
694                 woptarg = nextchar;
695                 /* If we end this ARGV-element by taking the rest as an arg,
696                    we must advance to the next element now.  */
697                 woptind++;
698               }
699             else if (woptind == argc)
700               {
701                 if (wopterr)
702                   {
703                     /* 1003.2 specifies the format of this message.  */
704                     fwprintf (stderr,
705                              L"%ls: option requires an argument -- %lc\n",
706                              argv[0], c);
707                   }
708                 woptopt = c;
709                 if (optstring[0] == L':')
710                   c = L':';
711                 else
712                   c = L'?';
713               }
714             else
715               /* We already incremented `woptind' once;
716                  increment it again when taking next ARGV-elt as argument.  */
717               woptarg = argv[woptind++];
718             nextchar = NULL;
719           }
720       }
721     return c;
722   }
723 }
724
725 int
726 wgetopt (int argc, wchar_t *const *argv, const wchar_t *optstring)
727 {
728   return _wgetopt_internal (argc, argv, optstring,
729                             (const struct woption *) 0,
730                             (int *) 0,
731                             0);
732 }
733
734 int
735 wgetopt_long (int argc, wchar_t * const *argv, const wchar_t *options,
736               const struct woption *long_options, int *opt_index)
737 {
738   return _wgetopt_internal (argc, argv, options, long_options, opt_index, 0);
739 }
740
741 /* Like getopt_long, but '-' as well as '--' can indicate a long option.
742    If an option that starts with '-' (not '--') doesn't match a long option,
743    but does match a short option, it is parsed as a short option
744    instead.  */
745 int
746 wgetopt_long_only (int argc, wchar_t * const *argv, const wchar_t *options,
747                   const struct woption *long_options, int *opt_index)
748 {
749   return _wgetopt_internal (argc, argv, options, long_options, opt_index, 1);
750 }