ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/utils/wingetopt.cpp
Revision: 1798
Committed: Thu Sep 13 14:10:11 2012 UTC (12 years, 7 months ago) by gezelter
File size: 25359 byte(s)
Log Message: 
Merged trunk changes into the development branch

File Contents

# Content
1 /* Getopt for Microsoft C
2 This code is a modification of the Free Software Foundation, Inc.
3 Getopt library for parsing command line argument the purpose was
4 to provide a Microsoft Visual C friendly derivative. This code
5 provides functionality for both Unicode and Multibyte builds.
6
7 Date: 02/03/2011 - Ludvik Jerabek - Initial Release
8 Version: 1.0
9 Comment: Supports getopt, getopt_long, and getopt_long_only
10 and POSIXLY_CORRECT environment flag
11 License: LGPL
12
13 Revisions:
14
15 02/03/2011 - Ludvik Jerabek - Initial Release
16 02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4
17 07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs
18 08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception
19 08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB
20 02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file
21 08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi
22
23 **DISCLAIMER**
24 THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
25 EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE
26 IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
27 PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE
28 EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT
29 APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY
30 DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY
31 USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST
32 PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON
33 YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE
34 EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
35 */
36
37 #define _CRT_SECURE_NO_WARNINGS
38 #include <stdlib.h>
39 #include <stdio.h>
40 #include "utils/wingetopt.h"
41
42 #ifdef __cplusplus
43 #define _GETOPT_THROW throw()
44 #else
45 #define _GETOPT_THROW
46 #endif
47
48 enum ENUM_ORDERING { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER };
49
50 struct _getopt_data_a
51 {
52 int optind;
53 int opterr;
54 int optopt;
55 char *optarg;
56 int __initialized;
57 char *__nextchar;
58 int __ordering;
59 int __posixly_correct;
60 int __first_nonopt;
61 int __last_nonopt;
62 };
63 struct _getopt_data_w
64 {
65 int optind;
66 int opterr;
67 int optopt;
68 wchar_t *optarg;
69 int __initialized;
70 wchar_t *__nextchar;
71 int __ordering;
72 int __posixly_correct;
73 int __first_nonopt;
74 int __last_nonopt;
75 };
76
77 static struct _getopt_data_a getopt_data_a;
78 static struct _getopt_data_w getopt_data_w;
79 char *optarg_a;
80 wchar_t *optarg_w;
81
82 int optind = 1;
83 int opterr = 1;
84 int optopt = '?';
85
86 static void exchange_a(char **argv, struct _getopt_data_a *d)
87 {
88 int bottom = d->__first_nonopt;
89 int middle = d->__last_nonopt;
90 int top = d->optind;
91 char *tem;
92 while (top > middle && middle > bottom)
93 {
94 if (top - middle > middle - bottom)
95 {
96 int len = middle - bottom;
97 register int i;
98 for (i = 0; i < len; i++)
99 {
100 tem = argv[bottom + i];
101 argv[bottom + i] = argv[top - (middle - bottom) + i];
102 argv[top - (middle - bottom) + i] = tem;
103 }
104 top -= len;
105 }
106 else
107 {
108 int len = top - middle;
109 register int i;
110 for (i = 0; i < len; i++)
111 {
112 tem = argv[bottom + i];
113 argv[bottom + i] = argv[middle + i];
114 argv[middle + i] = tem;
115 }
116 bottom += len;
117 }
118 }
119 d->__first_nonopt += (d->optind - d->__last_nonopt);
120 d->__last_nonopt = d->optind;
121 }
122
123 static void exchange_w(wchar_t **argv, struct _getopt_data_w *d)
124 {
125 int bottom = d->__first_nonopt;
126 int middle = d->__last_nonopt;
127 int top = d->optind;
128 wchar_t *tem;
129 while (top > middle && middle > bottom)
130 {
131 if (top - middle > middle - bottom)
132 {
133 int len = middle - bottom;
134 register int i;
135 for (i = 0; i < len; i++)
136 {
137 tem = argv[bottom + i];
138 argv[bottom + i] = argv[top - (middle - bottom) + i];
139 argv[top - (middle - bottom) + i] = tem;
140 }
141 top -= len;
142 }
143 else
144 {
145 int len = top - middle;
146 register int i;
147 for (i = 0; i < len; i++)
148 {
149 tem = argv[bottom + i];
150 argv[bottom + i] = argv[middle + i];
151 argv[middle + i] = tem;
152 }
153 bottom += len;
154 }
155 }
156 d->__first_nonopt += (d->optind - d->__last_nonopt);
157 d->__last_nonopt = d->optind;
158 }
159
160 static const char *_getopt_initialize_a (const char *optstring, struct _getopt_data_a *d, int posixly_correct)
161 {
162 d->__first_nonopt = d->__last_nonopt = d->optind;
163 d->__nextchar = NULL;
164 d->__posixly_correct = posixly_correct | !!getenv("POSIXLY_CORRECT");
165
166
167 if (optstring[0] == '-')
168 {
169 d->__ordering = RETURN_IN_ORDER;
170 ++optstring;
171 }
172 else if (optstring[0] == '+')
173 {
174 d->__ordering = REQUIRE_ORDER;
175 ++optstring;
176 }
177 else if (d->__posixly_correct)
178 d->__ordering = REQUIRE_ORDER;
179 else
180 d->__ordering = PERMUTE;
181 return optstring;
182 }
183
184 static const wchar_t *_getopt_initialize_w (const wchar_t *optstring, struct _getopt_data_w *d, int posixly_correct)
185 {
186 d->__first_nonopt = d->__last_nonopt = d->optind;
187 d->__nextchar = NULL;
188 d->__posixly_correct = posixly_correct | !!_wgetenv(L"POSIXLY_CORRECT");
189
190
191 if (optstring[0] == L'-')
192 {
193 d->__ordering = RETURN_IN_ORDER;
194 ++optstring;
195 }
196 else if (optstring[0] == L'+')
197 {
198 d->__ordering = REQUIRE_ORDER;
199 ++optstring;
200 }
201 else if (d->__posixly_correct)
202 d->__ordering = REQUIRE_ORDER;
203 else
204 d->__ordering = PERMUTE;
205 return optstring;
206 }
207
208 int _getopt_internal_r_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, struct _getopt_data_a *d, int posixly_correct)
209 {
210 int print_errors = d->opterr;
211
212 if (argc < 1)
213 return -1;
214
215 d->optarg = NULL;
216
217 if (d->optind == 0 || !d->__initialized)
218 {
219 if (d->optind == 0)
220 d->optind = 1;
221 optstring = _getopt_initialize_a (optstring, d, posixly_correct);
222 d->__initialized = 1;
223 }
224 else if (optstring[0] == '-' || optstring[0] == '+')
225 optstring++;
226 if (optstring[0] == ':')
227 print_errors = 0;
228
229 if (d->__nextchar == NULL || *d->__nextchar == '\0')
230 {
231 if (d->__last_nonopt > d->optind)
232 d->__last_nonopt = d->optind;
233 if (d->__first_nonopt > d->optind)
234 d->__first_nonopt = d->optind;
235
236 if (d->__ordering == PERMUTE)
237 {
238 if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
239 exchange_a ((char **) argv, d);
240 else if (d->__last_nonopt != d->optind)
241 d->__first_nonopt = d->optind;
242
243 while (d->optind < argc && (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0'))
244 d->optind++;
245 d->__last_nonopt = d->optind;
246 }
247
248 if (d->optind != argc && !strcmp(argv[d->optind], "--"))
249 {
250 d->optind++;
251
252 if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
253 exchange_a((char **) argv, d);
254 else if (d->__first_nonopt == d->__last_nonopt)
255 d->__first_nonopt = d->optind;
256 d->__last_nonopt = argc;
257
258 d->optind = argc;
259 }
260
261 if (d->optind == argc)
262 {
263 if (d->__first_nonopt != d->__last_nonopt)
264 d->optind = d->__first_nonopt;
265 return -1;
266 }
267
268 if ((argv[d->optind][0] != '-' || argv[d->optind][1] == '\0'))
269 {
270 if (d->__ordering == REQUIRE_ORDER)
271 return -1;
272 d->optarg = argv[d->optind++];
273 return 1;
274 }
275
276 d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == '-'));
277 }
278
279 if (longopts != NULL && (argv[d->optind][1] == '-' || (long_only && (argv[d->optind][2] || !strchr(optstring, argv[d->optind][1])))))
280 {
281 char *nameend;
282 const struct option_a *p;
283 const struct option_a *pfound = NULL;
284 int exact = 0;
285 int ambig = 0;
286 int indfound = -1;
287 int option_index;
288
289 for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++);
290
291 for (p = longopts, option_index = 0; p->name; p++, option_index++)
292 if (!strncmp(p->name, d->__nextchar, nameend - d->__nextchar))
293 {
294 if ((unsigned int)(nameend - d->__nextchar) == (unsigned int)strlen(p->name))
295 {
296 pfound = p;
297 indfound = option_index;
298 exact = 1;
299 break;
300 }
301 else if (pfound == NULL)
302 {
303 pfound = p;
304 indfound = option_index;
305 }
306 else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
307 ambig = 1;
308 }
309
310 if (ambig && !exact)
311 {
312 if (print_errors)
313 {
314 fprintf(stderr, "%s: option '%s' is ambiguous\n",
315 argv[0], argv[d->optind]);
316 }
317 d->__nextchar += strlen(d->__nextchar);
318 d->optind++;
319 d->optopt = 0;
320 return '?';
321 }
322
323 if (pfound != NULL)
324 {
325 option_index = indfound;
326 d->optind++;
327 if (*nameend)
328 {
329 if (pfound->has_arg)
330 d->optarg = nameend + 1;
331 else
332 {
333 if (print_errors)
334 {
335 if (argv[d->optind - 1][1] == '-')
336 {
337 fprintf(stderr, "%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name);
338 }
339 else
340 {
341 fprintf(stderr, "%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name);
342 }
343
344 }
345
346 d->__nextchar += strlen(d->__nextchar);
347
348 d->optopt = pfound->val;
349 return '?';
350 }
351 }
352 else if (pfound->has_arg == 1)
353 {
354 if (d->optind < argc)
355 d->optarg = argv[d->optind++];
356 else
357 {
358 if (print_errors)
359 {
360 fprintf(stderr,"%s: option '--%s' requires an argument\n",argv[0], pfound->name);
361 }
362 d->__nextchar += strlen(d->__nextchar);
363 d->optopt = pfound->val;
364 return optstring[0] == ':' ? ':' : '?';
365 }
366 }
367 d->__nextchar += strlen(d->__nextchar);
368 if (longind != NULL)
369 *longind = option_index;
370 if (pfound->flag)
371 {
372 *(pfound->flag) = pfound->val;
373 return 0;
374 }
375 return pfound->val;
376 }
377
378 if (!long_only || argv[d->optind][1] == '-' || strchr(optstring, *d->__nextchar) == NULL)
379 {
380 if (print_errors)
381 {
382 if (argv[d->optind][1] == '-')
383 {
384 /* --option */
385 fprintf(stderr, "%s: unrecognized option '--%s'\n",argv[0], d->__nextchar);
386 }
387 else
388 {
389 /* +option or -option */
390 fprintf(stderr, "%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar);
391 }
392 }
393 d->__nextchar = (char *)"";
394 d->optind++;
395 d->optopt = 0;
396 return '?';
397 }
398 }
399
400 {
401 char c = *d->__nextchar++;
402 char *temp = (char*)strchr(optstring, c);
403
404 if (*d->__nextchar == '\0')
405 ++d->optind;
406
407 if (temp == NULL || c == ':' || c == ';')
408 {
409 if (print_errors)
410 {
411 fprintf(stderr, "%s: invalid option -- '%c'\n", argv[0], c);
412 }
413 d->optopt = c;
414 return '?';
415 }
416 if (temp[0] == 'W' && temp[1] == ';')
417 {
418 char *nameend;
419 const struct option_a *p;
420 const struct option_a *pfound = NULL;
421 int exact = 0;
422 int ambig = 0;
423 int indfound = 0;
424 int option_index;
425
426 if (*d->__nextchar != '\0')
427 {
428 d->optarg = d->__nextchar;
429 d->optind++;
430 }
431 else if (d->optind == argc)
432 {
433 if (print_errors)
434 {
435 fprintf(stderr,
436 "%s: option requires an argument -- '%c'\n",
437 argv[0], c);
438 }
439 d->optopt = c;
440 if (optstring[0] == ':')
441 c = ':';
442 else
443 c = '?';
444 return c;
445 }
446 else
447 d->optarg = argv[d->optind++];
448
449 for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; nameend++);
450
451 for (p = longopts, option_index = 0; p->name; p++, option_index++)
452 if (!strncmp(p->name, d->__nextchar, nameend - d->__nextchar))
453 {
454 if ((unsigned int) (nameend - d->__nextchar) == strlen(p->name))
455 {
456 pfound = p;
457 indfound = option_index;
458 exact = 1;
459 break;
460 }
461 else if (pfound == NULL)
462 {
463 pfound = p;
464 indfound = option_index;
465 }
466 else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
467 ambig = 1;
468 }
469 if (ambig && !exact)
470 {
471 if (print_errors)
472 {
473 fprintf(stderr, "%s: option '-W %s' is ambiguous\n",
474 argv[0], d->optarg);
475 }
476 d->__nextchar += strlen(d->__nextchar);
477 d->optind++;
478 return '?';
479 }
480 if (pfound != NULL)
481 {
482 option_index = indfound;
483 if (*nameend)
484 {
485 if (pfound->has_arg)
486 d->optarg = nameend + 1;
487 else
488 {
489 if (print_errors)
490 {
491 fprintf(stderr, "\
492 %s: option '-W %s' doesn't allow an argument\n",
493 argv[0], pfound->name);
494 }
495
496 d->__nextchar += strlen(d->__nextchar);
497 return '?';
498 }
499 }
500 else if (pfound->has_arg == 1)
501 {
502 if (d->optind < argc)
503 d->optarg = argv[d->optind++];
504 else
505 {
506 if (print_errors)
507 {
508 fprintf(stderr, "\
509 %s: option '-W %s' requires an argument\n",
510 argv[0], pfound->name);
511 }
512 d->__nextchar += strlen(d->__nextchar);
513 return optstring[0] == ':' ? ':' : '?';
514 }
515 }
516 else
517 d->optarg = NULL;
518 d->__nextchar += strlen(d->__nextchar);
519 if (longind != NULL)
520 *longind = option_index;
521 if (pfound->flag)
522 {
523 *(pfound->flag) = pfound->val;
524 return 0;
525 }
526 return pfound->val;
527 }
528 d->__nextchar = NULL;
529 return 'W';
530 }
531 if (temp[1] == ':')
532 {
533 if (temp[2] == ':')
534 {
535 if (*d->__nextchar != '\0')
536 {
537 d->optarg = d->__nextchar;
538 d->optind++;
539 }
540 else
541 d->optarg = NULL;
542 d->__nextchar = NULL;
543 }
544 else
545 {
546 if (*d->__nextchar != '\0')
547 {
548 d->optarg = d->__nextchar;
549 d->optind++;
550 }
551 else if (d->optind == argc)
552 {
553 if (print_errors)
554 {
555 fprintf(stderr,
556 "%s: option requires an argument -- '%c'\n",
557 argv[0], c);
558 }
559 d->optopt = c;
560 if (optstring[0] == ':')
561 c = ':';
562 else
563 c = '?';
564 }
565 else
566 d->optarg = argv[d->optind++];
567 d->__nextchar = NULL;
568 }
569 }
570 return c;
571 }
572 }
573
574 int _getopt_internal_r_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, struct _getopt_data_w *d, int posixly_correct)
575 {
576 int print_errors = d->opterr;
577
578 if (argc < 1)
579 return -1;
580
581 d->optarg = NULL;
582
583 if (d->optind == 0 || !d->__initialized)
584 {
585 if (d->optind == 0)
586 d->optind = 1;
587 optstring = _getopt_initialize_w (optstring, d, posixly_correct);
588 d->__initialized = 1;
589 }
590 else if (optstring[0] == L'-' || optstring[0] == L'+')
591 optstring++;
592 if (optstring[0] == L':')
593 print_errors = 0;
594
595 if (d->__nextchar == NULL || *d->__nextchar == L'\0')
596 {
597 if (d->__last_nonopt > d->optind)
598 d->__last_nonopt = d->optind;
599 if (d->__first_nonopt > d->optind)
600 d->__first_nonopt = d->optind;
601
602 if (d->__ordering == PERMUTE)
603 {
604 if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
605 exchange_w((wchar_t **) argv, d);
606 else if (d->__last_nonopt != d->optind)
607 d->__first_nonopt = d->optind;
608
609 while (d->optind < argc && (argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0'))
610 d->optind++;
611 d->__last_nonopt = d->optind;
612 }
613
614 if (d->optind != argc && !wcscmp(argv[d->optind], L"--"))
615 {
616 d->optind++;
617
618 if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
619 exchange_w((wchar_t **) argv, d);
620 else if (d->__first_nonopt == d->__last_nonopt)
621 d->__first_nonopt = d->optind;
622 d->__last_nonopt = argc;
623
624 d->optind = argc;
625 }
626
627 if (d->optind == argc)
628 {
629 if (d->__first_nonopt != d->__last_nonopt)
630 d->optind = d->__first_nonopt;
631 return -1;
632 }
633
634 if ((argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0'))
635 {
636 if (d->__ordering == REQUIRE_ORDER)
637 return -1;
638 d->optarg = argv[d->optind++];
639 return 1;
640 }
641
642 d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == L'-'));
643 }
644
645 if (longopts != NULL && (argv[d->optind][1] == L'-' || (long_only && (argv[d->optind][2] || !wcschr(optstring, argv[d->optind][1])))))
646 {
647 wchar_t *nameend;
648 const struct option_w *p;
649 const struct option_w *pfound = NULL;
650 int exact = 0;
651 int ambig = 0;
652 int indfound = -1;
653 int option_index;
654
655 for (nameend = d->__nextchar; *nameend && *nameend != L'='; nameend++);
656
657 for (p = longopts, option_index = 0; p->name; p++, option_index++)
658 if (!wcsncmp(p->name, d->__nextchar, nameend - d->__nextchar))
659 {
660 if ((unsigned int)(nameend - d->__nextchar) == (unsigned int)wcslen(p->name))
661 {
662 pfound = p;
663 indfound = option_index;
664 exact = 1;
665 break;
666 }
667 else if (pfound == NULL)
668 {
669 pfound = p;
670 indfound = option_index;
671 }
672 else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
673 ambig = 1;
674 }
675
676 if (ambig && !exact)
677 {
678 if (print_errors)
679 {
680 fwprintf(stderr, L"%s: option '%s' is ambiguous\n",
681 argv[0], argv[d->optind]);
682 }
683 d->__nextchar += wcslen(d->__nextchar);
684 d->optind++;
685 d->optopt = 0;
686 return L'?';
687 }
688
689 if (pfound != NULL)
690 {
691 option_index = indfound;
692 d->optind++;
693 if (*nameend)
694 {
695 if (pfound->has_arg)
696 d->optarg = nameend + 1;
697 else
698 {
699 if (print_errors)
700 {
701 if (argv[d->optind - 1][1] == L'-')
702 {
703 fwprintf(stderr, L"%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name);
704 }
705 else
706 {
707 fwprintf(stderr, L"%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name);
708 }
709
710 }
711
712 d->__nextchar += wcslen(d->__nextchar);
713
714 d->optopt = pfound->val;
715 return L'?';
716 }
717 }
718 else if (pfound->has_arg == 1)
719 {
720 if (d->optind < argc)
721 d->optarg = argv[d->optind++];
722 else
723 {
724 if (print_errors)
725 {
726 fwprintf(stderr,L"%s: option '--%s' requires an argument\n",argv[0], pfound->name);
727 }
728 d->__nextchar += wcslen(d->__nextchar);
729 d->optopt = pfound->val;
730 return optstring[0] == L':' ? L':' : L'?';
731 }
732 }
733 d->__nextchar += wcslen(d->__nextchar);
734 if (longind != NULL)
735 *longind = option_index;
736 if (pfound->flag)
737 {
738 *(pfound->flag) = pfound->val;
739 return 0;
740 }
741 return pfound->val;
742 }
743
744 if (!long_only || argv[d->optind][1] == L'-' || wcschr(optstring, *d->__nextchar) == NULL)
745 {
746 if (print_errors)
747 {
748 if (argv[d->optind][1] == L'-')
749 {
750 /* --option */
751 fwprintf(stderr, L"%s: unrecognized option '--%s'\n",argv[0], d->__nextchar);
752 }
753 else
754 {
755 /* +option or -option */
756 fwprintf(stderr, L"%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar);
757 }
758 }
759 d->__nextchar = (wchar_t *)L"";
760 d->optind++;
761 d->optopt = 0;
762 return L'?';
763 }
764 }
765
766 {
767 wchar_t c = *d->__nextchar++;
768 wchar_t *temp = (wchar_t*)wcschr(optstring, c);
769
770 if (*d->__nextchar == L'\0')
771 ++d->optind;
772
773 if (temp == NULL || c == L':' || c == L';')
774 {
775 if (print_errors)
776 {
777 fwprintf(stderr, L"%s: invalid option -- '%c'\n", argv[0], c);
778 }
779 d->optopt = c;
780 return L'?';
781 }
782 if (temp[0] == L'W' && temp[1] == L';')
783 {
784 wchar_t *nameend;
785 const struct option_w *p;
786 const struct option_w *pfound = NULL;
787 int exact = 0;
788 int ambig = 0;
789 int indfound = 0;
790 int option_index;
791
792 if (*d->__nextchar != L'\0')
793 {
794 d->optarg = d->__nextchar;
795 d->optind++;
796 }
797 else if (d->optind == argc)
798 {
799 if (print_errors)
800 {
801 fwprintf(stderr,
802 L"%s: option requires an argument -- '%c'\n",
803 argv[0], c);
804 }
805 d->optopt = c;
806 if (optstring[0] == L':')
807 c = L':';
808 else
809 c = L'?';
810 return c;
811 }
812 else
813 d->optarg = argv[d->optind++];
814
815 for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != L'='; nameend++);
816
817 for (p = longopts, option_index = 0; p->name; p++, option_index++)
818 if (!wcsncmp(p->name, d->__nextchar, nameend - d->__nextchar))
819 {
820 if ((unsigned int) (nameend - d->__nextchar) == wcslen(p->name))
821 {
822 pfound = p;
823 indfound = option_index;
824 exact = 1;
825 break;
826 }
827 else if (pfound == NULL)
828 {
829 pfound = p;
830 indfound = option_index;
831 }
832 else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
833 ambig = 1;
834 }
835 if (ambig && !exact)
836 {
837 if (print_errors)
838 {
839 fwprintf(stderr, L"%s: option '-W %s' is ambiguous\n",
840 argv[0], d->optarg);
841 }
842 d->__nextchar += wcslen(d->__nextchar);
843 d->optind++;
844 return L'?';
845 }
846 if (pfound != NULL)
847 {
848 option_index = indfound;
849 if (*nameend)
850 {
851 if (pfound->has_arg)
852 d->optarg = nameend + 1;
853 else
854 {
855 if (print_errors)
856 {
857 fwprintf(stderr, L"\
858 %s: option '-W %s' doesn't allow an argument\n",
859 argv[0], pfound->name);
860 }
861
862 d->__nextchar += wcslen(d->__nextchar);
863 return L'?';
864 }
865 }
866 else if (pfound->has_arg == 1)
867 {
868 if (d->optind < argc)
869 d->optarg = argv[d->optind++];
870 else
871 {
872 if (print_errors)
873 {
874 fwprintf(stderr, L"\
875 %s: option '-W %s' requires an argument\n",
876 argv[0], pfound->name);
877 }
878 d->__nextchar += wcslen(d->__nextchar);
879 return optstring[0] == L':' ? L':' : L'?';
880 }
881 }
882 else
883 d->optarg = NULL;
884 d->__nextchar += wcslen(d->__nextchar);
885 if (longind != NULL)
886 *longind = option_index;
887 if (pfound->flag)
888 {
889 *(pfound->flag) = pfound->val;
890 return 0;
891 }
892 return pfound->val;
893 }
894 d->__nextchar = NULL;
895 return L'W';
896 }
897 if (temp[1] == L':')
898 {
899 if (temp[2] == L':')
900 {
901 if (*d->__nextchar != L'\0')
902 {
903 d->optarg = d->__nextchar;
904 d->optind++;
905 }
906 else
907 d->optarg = NULL;
908 d->__nextchar = NULL;
909 }
910 else
911 {
912 if (*d->__nextchar != L'\0')
913 {
914 d->optarg = d->__nextchar;
915 d->optind++;
916 }
917 else if (d->optind == argc)
918 {
919 if (print_errors)
920 {
921 fwprintf(stderr,
922 L"%s: option requires an argument -- '%c'\n",
923 argv[0], c);
924 }
925 d->optopt = c;
926 if (optstring[0] == L':')
927 c = L':';
928 else
929 c = L'?';
930 }
931 else
932 d->optarg = argv[d->optind++];
933 d->__nextchar = NULL;
934 }
935 }
936 return c;
937 }
938 }
939
940 int _getopt_internal_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, int posixly_correct)
941 {
942 int result;
943 getopt_data_a.optind = optind;
944 getopt_data_a.opterr = opterr;
945 result = _getopt_internal_r_a (argc, argv, optstring, longopts,longind, long_only, &getopt_data_a,posixly_correct);
946 optind = getopt_data_a.optind;
947 optarg_a = getopt_data_a.optarg;
948 optopt = getopt_data_a.optopt;
949 return result;
950 }
951
952 int _getopt_internal_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, int posixly_correct)
953 {
954 int result;
955 getopt_data_w.optind = optind;
956 getopt_data_w.opterr = opterr;
957 result = _getopt_internal_r_w (argc, argv, optstring, longopts,longind, long_only, &getopt_data_w,posixly_correct);
958 optind = getopt_data_w.optind;
959 optarg_w = getopt_data_w.optarg;
960 optopt = getopt_data_w.optopt;
961 return result;
962 }
963
964 int getopt_a (int argc, char *const *argv, const char *optstring) _GETOPT_THROW
965 {
966 return _getopt_internal_a (argc, argv, optstring, (const struct option_a *) 0, (int *) 0, 0, 0);
967 }
968
969 int getopt_w (int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW
970 {
971 return _getopt_internal_w (argc, argv, optstring, (const struct option_w *) 0, (int *) 0, 0, 0);
972 }
973
974 int getopt_long_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW
975 {
976 return _getopt_internal_a (argc, argv, options, long_options, opt_index, 0, 0);
977 }
978
979 int getopt_long_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW
980 {
981 return _getopt_internal_w (argc, argv, options, long_options, opt_index, 0, 0);
982 }
983
984 int _getopt_long_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d)
985 {
986 return _getopt_internal_r_a (argc, argv, options, long_options, opt_index,0, d, 0);
987 }
988
989 int _getopt_long_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d)
990 {
991 return _getopt_internal_r_w (argc, argv, options, long_options, opt_index,0, d, 0);
992 }
993
994 int getopt_long_only_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW
995 {
996 return _getopt_internal_a (argc, argv, options, long_options, opt_index, 1, 0);
997 }
998
999 int getopt_long_only_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW
1000 {
1001 return _getopt_internal_w (argc, argv, options, long_options, opt_index, 1, 0);
1002 }
1003
1004 int _getopt_long_only_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d)
1005 {
1006 return _getopt_internal_r_a (argc, argv, options, long_options, opt_index, 1, d, 0);
1007 }
1008
1009 int _getopt_long_only_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d)
1010 {
1011 return _getopt_internal_r_w (argc, argv, options, long_options, opt_index, 1, d, 0);
1012 }

Properties

Name Value
svn:eol-style native