OSDN Git Service

eb32f1e2d330f75efe192a3e751515ab446408c9
[lha/lha.git] / src / getopt_long.c
1 /*
2   This getopt_long() is compatible with GNU's, however, added original
3   extention (short 1 byte option).
4
5
6   Copyright (c) 2004 Koji Arai
7
8   Permission is hereby granted, free of charge, to any person
9   obtaining a copy of this software and associated documentation files
10   (the "Software"), to deal in the Software without restriction,
11   including without limitation the rights to use, copy, modify, merge,
12   publish, distribute, sublicense, and/or sell copies of the Software,
13   and to permit persons to whom the Software is furnished to do so,
14   subject to the following conditions:
15
16   The above copyright notice and this permission notice shall be
17   included in all copies or substantial portions of the Software.
18
19   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
23   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
24   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26   SOFTWARE.
27
28
29   Compilation for Test:
30
31       GNU:
32       cc -DUSE_GNU -DDEBUG getopt_long.c -o test_getopt_long_gnu
33
34       not GNU:
35       cc -I. -DDEBUG getopt_long.c -o test_getopt_long
36
37       ./test_getopt_long
38       ./test_getopt_long_gnu
39
40   BUGS:
41     * not implemented any features for getopt() and getopt_long().
42 */
43
44 #include <assert.h>
45 #include <stdio.h>
46 #include <string.h>
47
48 #if DEBUG
49 static int
50 puts_argv(char **argv)
51 {
52     int i;
53
54     for (i = 0; argv[i]; i++) {
55         if (i) printf(" ");
56
57         printf("%s", argv[i]);
58     }
59     printf("\n");
60
61     return 0;
62 }
63 #endif
64
65 #ifndef USE_GNU
66 #include <stdio.h>
67 #include <getopt_long.h>
68
69 char *optarg;
70 int optind;
71
72 int opterr;
73 int optopt;
74
75 /*
76   return value 0: no option (include '-')
77                1: short option like '-x'
78                2: long option like '--xxx' and just '--'
79 */
80 static int
81 is_option(char *arg)
82 {
83     if (arg[0] == '-') {
84         switch (arg[1]) {
85         case 0:                 /* just "-" */
86             return 0;
87         case '-':               /* long option (include just "--")*/
88             return 2;
89         default:                /* short option */
90             return 1;
91         }
92     }
93     return 0;
94 }
95
96 static int
97 insert_argv(char **argv, int src, int dest)
98 {
99     int i;
100     char *tmp = argv[src];
101
102     if (src > dest) {
103         for (i = src; i > dest; i--)
104             argv[i] = argv[i-1];
105     }
106     if (src < dest) {
107         for (i = src; i < dest; i++)
108             argv[i] = argv[i+1];
109     }
110
111     argv[dest] = tmp;
112
113     return 0;
114 }
115
116 static int
117 search_longopt(char *arg, struct option *longopts)
118 {
119     int i, found = -1;
120     int len;
121     for (len = 0; arg[len] && arg[len] != '='; len++)
122         ;
123
124     for (i = 0; longopts[i].name; i++) {
125         if (strncmp(arg, longopts[i].name, len) == 0) {
126             if (found != -1)
127                 return -1;      /* found some candidate */
128             found = i;
129         }
130     }
131     return found;
132 }
133
134 /*
135  * implemented my extention feature.
136  * optional 1 byte argument with [...]
137  *   e.g.) shortopts = "a[0123]b"
138  *          accepts "-a0 -a1b" (same as "-a0 -a1 -b")
139  */
140 static int
141 has_argument_short(char *arg, const char *shortopts)
142 {
143     int i;
144     int open_bracket = 0;
145     for (i = 0; shortopts[i]; i++) {
146         switch (shortopts[i]) {
147         case '[':
148             open_bracket++;
149             continue;
150         case ']':
151             if (open_bracket <= 0) {
152                 fprintf(stderr, "getopt_long() -- unbalanced bracket in short options");
153                 return -1;
154             }
155             open_bracket--;
156             continue;
157         }
158         if (open_bracket) continue;
159         if (*arg != shortopts[i]) continue;
160
161         switch (shortopts[i+1]) {
162         case ':':
163             if (shortopts[i+2] != ':') {
164                 if (arg[1])
165                     return 1; /* following string is argument */
166                 else
167                     return 2; /* next argv is argument */
168             }
169             else {
170                 /* '::' means optional argument (GNU extention) */
171                 if (arg[1])
172                     return 1;
173                 else
174                     return 0; /* no argument */
175             }
176         case '[':
177             if (arg[1] == '\0')
178                 return 0;   /* no argument */
179             /* my extention */
180             for (i++; shortopts[i] && shortopts[i] != ']'; i++) {
181                 if (arg[1] == shortopts[i])
182                     return 3; /* has 1 byte argument */
183             }
184             if (!shortopts[i]) {
185                 fprintf(stderr, "getopt_long() -- unbalanced bracket in short options");
186                 return -1;
187             }
188
189             /* shortopts = "a[0123]b", arg = "ab"
190                -> "-a -b" */
191             return 0;   /* no argument */
192         default:
193             return 0;   /* no argument */
194         }
195     }
196     /* Invalid option */
197     return -1;
198 }
199
200 static int
201 has_argument_long(char *arg, struct option *longopts)
202 {
203     int i;
204
205     i = search_longopt(arg, longopts);
206     if (i == -1) {
207         /* Invalid option */
208         return -1;
209     }
210     else {
211         int len = strlen(arg);
212         char *p = strchr(arg, '=');
213         if (p) {
214             len = p - arg;
215         }
216
217         switch (longopts[i].has_arg) {
218         case no_argument:
219             return 0;
220         case required_argument:
221             if (arg[len] == '=')
222                 return 1;
223             else
224                 return 2;
225         case optional_argument:
226             if (arg[len] == '=')
227                 return 1;
228             else
229                 return 0;
230         default:
231             assert(0);
232         }
233     }
234 }
235
236 /*
237   -1: no option
238    0: no argument
239    1: has argument in this argv
240    2: has argument in next argv
241    3: has 1 byte argument in this argv
242 */
243 static int
244 has_argument(char *arg,
245              const char *shortopts,
246              struct option *longopts)
247 {
248     int i, n;
249
250     switch (is_option(arg)) {
251     case 0:                     /* no option */
252         return -1;
253     case 1:
254         /* short option */
255         n = -1;
256         for (i = 1; arg[i]; i++) {
257             n = has_argument_short(arg+i, shortopts);
258             if (n == 0 && arg[i+1]) continue;
259             if (n == 3 && arg[i+2]) { i++; continue; }
260             break;
261         }
262         return n;
263     case 2:
264         /* long option */
265         return has_argument_long(arg+2, longopts);
266         break;
267     default:
268         assert(0);
269     }
270 }
271
272 int
273 getopt_long(int argc, char **argv,
274             const char *shortopts,
275             struct option *longopts,
276             int *indexptr)
277 {
278     char *opt;
279     int i;
280     static int shortoptind;
281     static int no_optind = 0;
282
283     if (optind == 0) {            /* skip first argument (command name) */
284         optind++;
285         no_optind = 0;
286         shortoptind = 0;
287     }
288
289     optarg = 0;
290
291     if (no_optind && !shortoptind) {
292         while (!is_option(argv[no_optind]))
293             insert_argv(argv, no_optind, optind-1);
294
295         if (has_argument(argv[no_optind], shortopts, longopts) == 2)
296             no_optind += 2;
297         else
298             no_optind++;
299
300         if (argv[optind] && strcmp(argv[optind], "--") == 0) {
301             while (!is_option(argv[no_optind]))
302                 insert_argv(argv, no_optind, optind);
303             optind = no_optind;
304             no_optind = 0;
305         }
306     }
307
308     if (optind >= argc)
309         goto end_of_option;
310
311  retry:
312     /*
313     puts_argv(&argv[optind]);
314     */
315     opt = argv[optind];
316
317     if (shortoptind == 0 && is_option(opt) == 1) {
318         shortoptind++;
319     }
320
321     if (shortoptind) {
322         /* short option */
323         char *p = &opt[shortoptind];
324
325         if (*p == '\0')
326             assert(0);
327
328         switch (has_argument_short(p, shortopts)) {
329         case 0:
330             /* no argument */
331             optarg = 0;
332
333             shortoptind++;
334             if (opt[shortoptind] == '\0')
335                 optind++, shortoptind = 0;
336             return *p;
337         case 1:
338             /* following character is argument */
339             optind++, shortoptind = 0;
340             optarg = &p[1];
341             return *p;
342         case 2:
343             /* next argv is argument */
344             optind++, shortoptind = 0;
345             optarg = argv[optind++];
346             return *p;
347         case 3:
348             /* has 1 byte argument */
349             optarg = &p[1];
350             if (p[2] == 0)
351                 optind++, shortoptind = 0;
352             else
353                 shortoptind += 2;
354             return *p;
355         default:
356             /* Invalid option */
357             if (opterr)
358                 fprintf(stderr,
359                         "%s: invalid option -- %c\n",
360                         argv[0],
361                         *p);
362
363             optind++, shortoptind = 0;
364             optopt = *p;
365             return '?';
366         }
367     }
368     else if (opt[0] == '-' && opt[1] == '-') {
369         /* long option */
370
371         if (opt[2] == '\0') {
372             /* end of command line switch */
373             optind++;
374             return -1;
375         }
376
377         opt += 2;
378
379         i = search_longopt(opt, longopts);
380         if (i == -1) {
381             optind++;
382             optopt = 0;
383             return '?';
384         }
385         else {
386             int len = strlen(opt);
387             char *p = strchr(opt, '=');
388             if (p) {
389                 len = p - opt;
390             }
391
392             switch (longopts[i].has_arg) {
393             case no_argument:
394                 break;
395             case required_argument:
396                 if (opt[len] == '=')
397                     optarg = opt + len + 1;
398                 else {
399                     optind++;
400                     optarg = argv[optind];
401                     if (optarg == 0) {
402                         if (opterr)
403                             fprintf(stderr,
404                                     "%s: option `--%s' requires an argument\n",
405                                     argv[0],
406                                     opt);
407
408                         optopt = 0;
409                         return '?'; /* no argument */
410                     }
411                 }
412                 break;
413             case optional_argument:
414                 if (opt[len] == '=')
415                     optarg = opt + len + 1;
416                 else {
417                     optarg = 0;
418                 }
419                 break;
420             default:
421                 break;
422             }
423
424             *indexptr = i;
425             optind++;
426             if (longopts[i].flag) {
427                 *longopts[i].flag = longopts[i].val;
428                 return 0;
429             }
430             else {
431                 return longopts[i].val;
432             }
433         }
434
435         optind++;
436         optopt = 0;
437         return '?';
438     }
439
440     /* not option */
441     if (no_optind == 0)
442         no_optind = optind;
443
444     for (i = optind; argv[i]; i++) {
445         if (is_option(argv[i])) {
446             optind = i;
447             goto retry;
448         }
449     }
450
451  end_of_option:
452     if (no_optind) {
453         optind = no_optind;
454         no_optind = 0;
455     }
456
457     return -1;
458 }
459 #endif /* USE_GNU */
460
461 #if DEBUG
462
463 #include <stdio.h>
464 #include <assert.h>
465 #include <stdlib.h>
466
467 #if USE_GNU
468 #include <getopt.h>  /* use GNU getopt_long() */
469 #endif
470
471 static int verbose_flag;
472 static int option_index;
473 int argc;
474 char *argv[50];
475 char **p;
476 int c;
477 static struct option long_options[] = {
478     {"verbose", no_argument, &verbose_flag, 1},
479     {"brief", no_argument, &verbose_flag, 0},
480     {"add", required_argument, 0, 'a'},
481     {"append", no_argument, 0, 0},
482     {"delete", required_argument, 0, 0},
483     {"create", optional_argument, 0, 0},
484     {"change", optional_argument, 0, 0},
485     {0, 0, 0, 0}
486 };
487
488 int
489 call_getopt_long(int argc, char **argv,
490                  const char *shortopts,
491                  struct option *longopts,
492                  int *indexptr)
493 {
494     int c;
495     c = getopt_long(argc, argv, shortopts, longopts, indexptr);
496     puts_argv(argv);
497     printf("ret=%d(%c) option_index=%d ", c, c, option_index);
498     printf("optind=%d optarg=[%s] opterr=%d optopt=%d(%c)\n",
499            optind, optarg, opterr, optopt, optopt);
500     if (c == 0) {
501         struct option *opt;
502         opt = &longopts[*indexptr];
503         printf("long option: --%s has_arg=%d\n", opt->name, opt->has_arg);
504         if (opt->flag)
505             printf("           flag=[%8p] val=%d\n", opt->flag, *opt->flag);
506     }
507
508     return c;
509 }
510
511 void
512 test1()
513 {
514     optind = 0;
515     argc = 0;
516     p = argv;
517
518     argc++; *p++ = "command_name";
519     argc++; *p++ = "-a";
520     argc++; *p++ = "-bcd";
521     argc++; *p++ = "-d";
522     argc++; *p++ = "-e";
523     argc++; *p++ = "-f";
524     argc++; *p++ = "-g";
525     *p = 0;
526
527     /*************************/
528     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
529
530     assert(c == 'a');
531     assert(option_index == 0);
532     assert(optind == 2);
533     assert(optarg == 0);
534     assert(optopt == 0);
535
536     /*************************/
537     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
538
539     assert(c == 'b');
540     assert(option_index == 0);
541     assert(optind == 2);
542     assert(optarg == 0);
543     assert(optopt == 0);
544
545     /*************************/
546     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
547
548     assert(c == 'c');
549     assert(option_index == 0);
550     assert(optind == 3);
551     assert(optarg == &argv[2][3]);
552     assert(optopt == 0);
553
554     /*************************/
555     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
556
557     assert(c == 'd');
558     assert(option_index == 0);
559     assert(optind == 5);
560     assert(optarg == argv[4]);
561     assert(optopt == 0);
562
563     /*************************/
564     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
565
566     assert(c == '?');
567     assert(option_index == 0);
568     assert(optind == 6);
569     assert(optarg == 0);
570     assert(optopt == 'f');
571
572     /*************************/
573     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
574
575     assert(c == '?');
576     assert(option_index == 0);
577     assert(optind == 7);
578     assert(optarg == 0);
579     assert(optopt == 'g');
580
581     /*************************/
582     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
583
584     assert(c == -1);
585     assert(option_index == 0);
586     assert(optind == 7);
587     assert(optarg == 0);
588     assert(optopt == 'g');      /* no changed */
589 }
590
591 void
592 test2()
593 {
594     optind = 0;
595     argc = 0;
596     p = argv;
597
598     argc++; *p++ = "command_name";
599     argc++; *p++ = "--verbose";
600     argc++; *p++ = "--brief";
601     argc++; *p++ = "--add";
602     argc++; *p++ = "add_argument";
603     argc++; *p++ = "--add=add_argument";
604     argc++; *p++ = "--append";
605     argc++; *p++ = "--delete=del_argument";
606     argc++; *p++ = "--create=cre_argument";
607     argc++; *p++ = "--create";
608     argc++; *p++ = "files...";
609     *p = 0;
610
611     /*************************/
612     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
613
614     assert(c == 0);
615     assert(option_index == 0);
616     assert(optind == 2);
617     assert(optarg == 0);
618     assert(optopt == 'g');      /* no changed */
619     assert(strcmp(long_options[option_index].name, "verbose") == 0);
620     assert(*long_options[option_index].flag == 1);
621
622     /*************************/
623     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
624
625     assert(c == 0);
626     assert(option_index == 1);
627     assert(optind == 3);
628     assert(optarg == 0);
629     assert(optopt == 'g');      /* no changed */
630     assert(strcmp(long_options[option_index].name, "brief") == 0);
631     assert(*long_options[option_index].flag == 0);
632
633     /*************************/
634     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
635
636     assert(c == 'a');
637     assert(option_index == 2);
638     assert(optind == 5);
639     assert(optarg == argv[4]);
640     assert(optopt == 'g');      /* no changed */
641     assert(strcmp(long_options[option_index].name, "add") == 0);
642     assert(long_options[option_index].flag == 0);
643
644     /*************************/
645     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
646
647     assert(c == 'a');
648     assert(option_index == 2);
649     assert(optind == 6);
650     assert(optarg == argv[5]+6);
651     assert(optopt == 'g');      /* no changed */
652     assert(strcmp(long_options[option_index].name, "add") == 0);
653     assert(long_options[option_index].flag == 0);
654
655     /*************************/
656     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
657
658     assert(c == 0);
659     assert(option_index == 3);
660     assert(optind == 7);
661     assert(optarg == 0);
662     assert(optopt == 'g');      /* no changed */
663     assert(strcmp(long_options[option_index].name, "append") == 0);
664     assert(long_options[option_index].flag == 0);
665
666     /*************************/
667     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
668
669     assert(c == 0);
670     assert(option_index == 4);
671     assert(optind == 8);
672     assert(optarg == argv[7]+9);
673     assert(optopt == 'g');      /* no changed */
674     assert(strcmp(long_options[option_index].name, "delete") == 0);
675     assert(long_options[option_index].flag == 0);
676
677     /*************************/
678     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
679
680     assert(c == 0);
681     assert(option_index == 5);
682     assert(optind == 9);
683     assert(optarg == argv[8]+9);
684     assert(optopt == 'g');      /* no changed */
685     assert(strcmp(long_options[option_index].name, "create") == 0);
686     assert(long_options[option_index].flag == 0);
687
688     /*************************/
689     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
690
691     assert(c == 0);
692     assert(option_index == 5);
693     assert(optind == 10);
694     assert(optarg == 0);
695     assert(optopt == 'g');      /* no changed */
696     assert(strcmp(long_options[option_index].name, "create") == 0);
697     assert(long_options[option_index].flag == 0);
698
699     /*************************/
700     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
701
702     assert(c == -1);
703     assert(option_index == 5);  /* no changed */
704     assert(optind == 10);
705     assert(optarg == 0);
706     assert(optopt == 'g');      /* no changed */
707     assert(strcmp(argv[optind], "files...") == 0);
708
709 }
710
711 void
712 test3()
713 {
714     optind = 0;
715     argc = 0;
716     p = argv;
717
718     argc++; *p++ = "command_name";
719     argc++; *p++ = "--delete";  /* required argument has no argument */
720     *p = 0;
721
722     /*************************/
723     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
724
725     assert(c == '?');
726     assert(option_index == 5);  /* no changed */
727     assert(optind == 2);        /* changed */
728     assert(optarg == 0);
729     assert(optopt == 0);       /* changed */
730     assert(argv[optind] == 0);
731
732     /* */
733     optind = 0;
734     argc = 0;
735     p = argv;
736
737     argc++; *p++ = "command_name";
738     argc++; *p++ = "--file";  /* not option */
739     *p = 0;
740
741     /*************************/
742     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
743
744     assert(c == '?');
745     assert(option_index == 5);  /* no changed */
746     assert(optind == 2);
747     assert(optarg == 0);
748     assert(optopt == 0);
749     assert(argv[optind] == 0);
750 }
751
752 void
753 test4()
754 {
755     optind = 0;
756     argc = 0;
757     p = argv;
758
759     argc++; *p++ = "command_name";
760     argc++; *p++ = "-a";
761     argc++; *p++ = "a1";
762     argc++; *p++ = "a2";
763     argc++; *p++ = "-b";
764     argc++; *p++ = "b";
765     argc++; *p++ = "-efg";      /* some options in a argument */
766     argc++; *p++ = "g";
767     argc++; *p++ = "-c";
768     argc++; *p++ = "c";
769     argc++; *p++ = "d";
770     *p = 0;
771
772     /*************************/
773     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
774
775     p = argv;
776     assert(strcmp(*p++, "command_name") == 0);
777     assert(strcmp(*p++, "-a") == 0);
778     assert(strcmp(*p++, "a1") == 0);
779     assert(strcmp(*p++, "a2") == 0);
780     assert(strcmp(*p++, "-b") == 0);
781     assert(strcmp(*p++, "b") == 0);
782     assert(strcmp(*p++, "-efg") == 0);
783     assert(strcmp(*p++, "g") == 0);
784     assert(strcmp(*p++, "-c") == 0);
785     assert(strcmp(*p++, "c") == 0);
786     assert(strcmp(*p++, "d") == 0);
787     assert(*p == 0);
788
789     assert(c == 'a');
790     assert(option_index == 5);  /* no changed */
791     assert(optind == 2);
792     assert(optarg == 0);
793     assert(optopt == 0);
794
795     /*************************/
796     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
797
798     p = argv;
799     assert(strcmp(*p++, "command_name") == 0);
800     assert(strcmp(*p++, "-a") == 0);
801     assert(strcmp(*p++, "a1") == 0);
802     assert(strcmp(*p++, "a2") == 0);
803     assert(strcmp(*p++, "-b") == 0);
804     assert(strcmp(*p++, "b") == 0);
805     assert(strcmp(*p++, "-efg") == 0);
806     assert(strcmp(*p++, "g") == 0);
807     assert(strcmp(*p++, "-c") == 0);
808     assert(strcmp(*p++, "c") == 0);
809     assert(strcmp(*p++, "d") == 0);
810     assert(*p == 0);
811
812     assert(c == 'b');
813     assert(option_index == 5);  /* no changed */
814     assert(optind == 5);
815     assert(optarg == 0);
816     assert(optopt == 0);
817
818     /*************************/
819     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
820
821     p = argv;
822     assert(strcmp(*p++, "command_name") == 0);
823     assert(strcmp(*p++, "-a") == 0);
824     assert(strcmp(*p++, "-b") == 0);
825     assert(strcmp(*p++, "a1") == 0);
826     assert(strcmp(*p++, "a2") == 0);
827     assert(strcmp(*p++, "b") == 0);
828     assert(strcmp(*p++, "-efg") == 0);
829     assert(strcmp(*p++, "g") == 0);
830     assert(strcmp(*p++, "-c") == 0);
831     assert(strcmp(*p++, "c") == 0);
832     assert(strcmp(*p++, "d") == 0);
833     assert(*p == 0);
834
835     assert(c == 'e');
836     assert(option_index == 5);  /* no changed */
837     assert(optind == 6);
838     assert(optarg == 0);
839     assert(optopt == 0);
840
841     /*************************/
842     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
843
844     p = argv;
845     assert(strcmp(*p++, "command_name") == 0);
846     assert(strcmp(*p++, "-a") == 0);
847     assert(strcmp(*p++, "-b") == 0);
848     assert(strcmp(*p++, "a1") == 0);
849     assert(strcmp(*p++, "a2") == 0);
850     assert(strcmp(*p++, "b") == 0);
851     assert(strcmp(*p++, "-efg") == 0);
852     assert(strcmp(*p++, "g") == 0);
853     assert(strcmp(*p++, "-c") == 0);
854     assert(strcmp(*p++, "c") == 0);
855     assert(strcmp(*p++, "d") == 0);
856     assert(*p == 0);
857
858     assert(c == 'f');
859     assert(option_index == 5);  /* no changed */
860     assert(optind == 6);
861     assert(optarg == 0);
862     assert(optopt == 0);
863
864     /*************************/
865     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
866
867     p = argv;
868     assert(strcmp(*p++, "command_name") == 0);
869     assert(strcmp(*p++, "-a") == 0);
870     assert(strcmp(*p++, "-b") == 0);
871     assert(strcmp(*p++, "a1") == 0);
872     assert(strcmp(*p++, "a2") == 0);
873     assert(strcmp(*p++, "b") == 0);
874     assert(strcmp(*p++, "-efg") == 0);
875     assert(strcmp(*p++, "g") == 0);
876     assert(strcmp(*p++, "-c") == 0);
877     assert(strcmp(*p++, "c") == 0);
878     assert(strcmp(*p++, "d") == 0);
879     assert(*p == 0);
880
881     assert(c == 'g');
882     assert(option_index == 5);  /* no changed */
883     assert(optind == 8);
884     assert(optarg == argv[7]);
885     assert(optopt == 0);
886
887     /*************************/
888     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
889
890     p = argv;
891     assert(strcmp(*p++, "command_name") == 0);
892     assert(strcmp(*p++, "-a") == 0);
893     assert(strcmp(*p++, "-b") == 0);
894     assert(strcmp(*p++, "-efg") == 0);
895     assert(strcmp(*p++, "g") == 0);
896     assert(strcmp(*p++, "a1") == 0);
897     assert(strcmp(*p++, "a2") == 0);
898     assert(strcmp(*p++, "b") == 0);
899     assert(strcmp(*p++, "-c") == 0);
900     assert(strcmp(*p++, "c") == 0);
901     assert(strcmp(*p++, "d") == 0);
902     assert(*p == 0);
903
904     assert(c == 'c');
905     assert(option_index == 5);  /* no changed */
906     assert(optind == 10);
907     assert(optarg == argv[9]);
908     assert(optopt == 0);
909
910     /*************************/
911     c = call_getopt_long(argc, argv, "abc:d:efg:", long_options, &option_index);
912
913     p = argv;
914     assert(strcmp(*p++, "command_name") == 0);
915     assert(strcmp(*p++, "-a") == 0);
916     assert(strcmp(*p++, "-b") == 0);
917     assert(strcmp(*p++, "-efg") == 0);
918     assert(strcmp(*p++, "g") == 0);
919     assert(strcmp(*p++, "-c") == 0);
920     assert(strcmp(*p++, "c") == 0);
921     assert(strcmp(*p++, "a1") == 0);
922     assert(strcmp(*p++, "a2") == 0);
923     assert(strcmp(*p++, "b") == 0);
924     assert(strcmp(*p++, "d") == 0);
925     assert(*p == 0);
926
927     assert(c == -1);
928     assert(option_index == 5);  /* no changed */
929     assert(optind == 7);
930     assert(optarg == 0);
931     assert(optopt == 0);
932
933 }
934
935 void
936 test5()
937 {
938     optind = 0;
939     argc = 0;
940     p = argv;
941
942     argc++; *p++ = "command_name";
943     argc++; *p++ = "-a";
944     argc++; *p++ = "-";
945     argc++; *p++ = "-b";
946     *p = 0;
947
948     /*************************/
949     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
950
951     p = argv;
952     assert(strcmp(*p++, "command_name") == 0);
953     assert(strcmp(*p++, "-a") == 0);
954     assert(strcmp(*p++, "-") == 0);
955     assert(strcmp(*p++, "-b") == 0);
956     assert(*p == 0);
957
958     assert(c == 'a');
959     assert(option_index == 5);  /* no changed */
960     assert(optind == 2);
961     assert(optarg == 0);
962     assert(optopt == 0);
963
964     /*************************/
965     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
966
967     p = argv;
968     assert(strcmp(*p++, "command_name") == 0);
969     assert(strcmp(*p++, "-a") == 0);
970     assert(strcmp(*p++, "-") == 0);
971     assert(strcmp(*p++, "-b") == 0);
972     assert(*p == 0);
973
974     assert(c == 'b');
975     assert(option_index == 5);  /* no changed */
976     assert(optind == 4);
977     assert(optarg == 0);
978     assert(optopt == 0);
979
980     /*************************/
981     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
982
983     p = argv;
984     assert(strcmp(*p++, "command_name") == 0);
985     assert(strcmp(*p++, "-a") == 0);
986     assert(strcmp(*p++, "-b") == 0);
987     assert(strcmp(*p++, "-") == 0);
988     assert(*p == 0);
989
990     assert(c == -1);
991     assert(option_index == 5);  /* no changed */
992     assert(optind == 3);
993     assert(optarg == 0);
994     assert(optopt == 0);
995 }
996
997 void
998 test6()
999 {
1000     optind = 0;
1001     argc = 0;
1002     p = argv;
1003
1004     argc++; *p++ = "command_name";
1005     argc++; *p++ = "-a";
1006     argc++; *p++ = "-";
1007     argc++; *p++ = "-";
1008     argc++; *p++ = "-b";
1009     *p = 0;
1010
1011     /*************************/
1012     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1013
1014     p = argv;
1015     assert(strcmp(*p++, "command_name") == 0);
1016     assert(strcmp(*p++, "-a") == 0);
1017     assert(strcmp(*p++, "-") == 0);
1018     assert(strcmp(*p++, "-") == 0);
1019     assert(strcmp(*p++, "-b") == 0);
1020     assert(*p == 0);
1021
1022     assert(c == 'a');
1023     assert(option_index == 5);  /* no changed */
1024     assert(optind == 2);
1025     assert(optarg == 0);
1026     assert(optopt == 0);
1027
1028     /*************************/
1029     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1030
1031     p = argv;
1032     assert(strcmp(*p++, "command_name") == 0);
1033     assert(strcmp(*p++, "-a") == 0);
1034     assert(strcmp(*p++, "-") == 0);
1035     assert(strcmp(*p++, "-") == 0);
1036     assert(strcmp(*p++, "-b") == 0);
1037     assert(*p == 0);
1038
1039     assert(c == 'b');
1040     assert(option_index == 5);  /* no changed */
1041     assert(optind == 5);
1042     assert(optarg == 0);
1043     assert(optopt == 0);
1044
1045     /*************************/
1046     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1047
1048     p = argv;
1049     assert(strcmp(*p++, "command_name") == 0);
1050     assert(strcmp(*p++, "-a") == 0);
1051     assert(strcmp(*p++, "-b") == 0);
1052     assert(strcmp(*p++, "-") == 0);
1053     assert(strcmp(*p++, "-") == 0);
1054     assert(*p == 0);
1055
1056     assert(c == -1);
1057     assert(option_index == 5);  /* no changed */
1058     assert(optind == 3);
1059     assert(optarg == 0);
1060     assert(optopt == 0);
1061 }
1062
1063 void
1064 test7()
1065 {
1066     optind = 0;
1067     argc = 0;
1068     p = argv;
1069
1070     argc++; *p++ = "command_name";
1071     argc++; *p++ = "-a";
1072     argc++; *p++ = "-";
1073     argc++; *p++ = "-";
1074     argc++; *p++ = "-c";
1075     argc++; *p++ = "c";
1076     *p = 0;
1077
1078     /*************************/
1079     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1080
1081     p = argv;
1082     assert(strcmp(*p++, "command_name") == 0);
1083     assert(strcmp(*p++, "-a") == 0);
1084     assert(strcmp(*p++, "-") == 0);
1085     assert(strcmp(*p++, "-") == 0);
1086     assert(strcmp(*p++, "-c") == 0);
1087     assert(strcmp(*p++, "c") == 0);
1088     assert(*p == 0);
1089
1090     assert(c == 'a');
1091     assert(option_index == 5);  /* no changed */
1092     assert(optind == 2);
1093     assert(optarg == 0);
1094     assert(optopt == 0);
1095
1096     /*************************/
1097     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1098
1099     p = argv;
1100     assert(strcmp(*p++, "command_name") == 0);
1101     assert(strcmp(*p++, "-a") == 0);
1102     assert(strcmp(*p++, "-") == 0);
1103     assert(strcmp(*p++, "-") == 0);
1104     assert(strcmp(*p++, "-c") == 0);
1105     assert(strcmp(*p++, "c") == 0);
1106     assert(*p == 0);
1107
1108     assert(c == 'c');
1109     assert(option_index == 5);  /* no changed */
1110     assert(optind == 6);
1111     assert(optarg == argv[5]);
1112     assert(optopt == 0);
1113
1114     /*************************/
1115     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1116
1117     p = argv;
1118     assert(strcmp(*p++, "command_name") == 0);
1119     assert(strcmp(*p++, "-a") == 0);
1120     assert(strcmp(*p++, "-c") == 0);
1121     assert(strcmp(*p++, "c") == 0);
1122     assert(strcmp(*p++, "-") == 0);
1123     assert(strcmp(*p++, "-") == 0);
1124     assert(*p == 0);
1125
1126     assert(c == -1);
1127     assert(option_index == 5);  /* no changed */
1128     assert(optind == 4);
1129     assert(optarg == 0);
1130     assert(optopt == 0);
1131 }
1132
1133 void
1134 test8()
1135 {
1136     optind = 0;
1137     argc = 0;
1138     p = argv;
1139
1140     argc++; *p++ = "command_name";
1141     argc++; *p++ = "-a";
1142     argc++; *p++ = "-c";
1143     argc++; *p++ = "c";
1144     argc++; *p++ = "--";
1145     argc++; *p++ = "-d";
1146     argc++; *p++ = "d";
1147     *p = 0;
1148
1149     /*************************/
1150     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1151
1152     p = argv;
1153     assert(strcmp(*p++, "command_name") == 0);
1154     assert(strcmp(*p++, "-a") == 0);
1155     assert(strcmp(*p++, "-c") == 0);
1156     assert(strcmp(*p++, "c") == 0);
1157     assert(strcmp(*p++, "--") == 0);
1158     assert(strcmp(*p++, "-d") == 0);
1159     assert(strcmp(*p++, "d") == 0);
1160     assert(*p == 0);
1161
1162     assert(c == 'a');
1163     assert(option_index == 5);  /* no changed */
1164     assert(optind == 2);
1165     assert(optarg == 0);
1166     assert(optopt == 0);
1167
1168     /*************************/
1169     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1170
1171     p = argv;
1172     assert(strcmp(*p++, "command_name") == 0);
1173     assert(strcmp(*p++, "-a") == 0);
1174     assert(strcmp(*p++, "-c") == 0);
1175     assert(strcmp(*p++, "c") == 0);
1176     assert(strcmp(*p++, "--") == 0);
1177     assert(strcmp(*p++, "-d") == 0);
1178     assert(strcmp(*p++, "d") == 0);
1179     assert(*p == 0);
1180
1181     assert(c == 'c');
1182     assert(option_index == 5);  /* no changed */
1183     assert(optind == 4);
1184     assert(optarg == argv[3]);
1185     assert(optopt == 0);
1186
1187     /*************************/
1188     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1189
1190     p = argv;
1191     assert(strcmp(*p++, "command_name") == 0);
1192     assert(strcmp(*p++, "-a") == 0);
1193     assert(strcmp(*p++, "-c") == 0);
1194     assert(strcmp(*p++, "c") == 0);
1195     assert(strcmp(*p++, "--") == 0);
1196     assert(strcmp(*p++, "-d") == 0);
1197     assert(strcmp(*p++, "d") == 0);
1198     assert(*p == 0);
1199
1200     assert(c == -1);
1201     assert(option_index == 5);  /* no changed */
1202     assert(optind == 5);
1203     assert(optarg == 0);
1204     assert(optopt == 0);
1205
1206     /*************************/
1207     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1208
1209     p = argv;
1210     assert(strcmp(*p++, "command_name") == 0);
1211     assert(strcmp(*p++, "-a") == 0);
1212     assert(strcmp(*p++, "-c") == 0);
1213     assert(strcmp(*p++, "c") == 0);
1214     assert(strcmp(*p++, "--") == 0);
1215     assert(strcmp(*p++, "-d") == 0);
1216     assert(strcmp(*p++, "d") == 0);
1217     assert(*p == 0);
1218
1219     assert(c == 'd');
1220     assert(option_index == 5);  /* no changed */
1221     assert(optind == 7);
1222     assert(optarg == argv[6]);
1223     assert(optopt == 0);
1224 }
1225
1226 void
1227 test9()
1228 {
1229     optind = 0;
1230     argc = 0;
1231     p = argv;
1232
1233     argc++; *p++ = "command_name";
1234     argc++; *p++ = "-a";
1235     argc++; *p++ = "-";
1236     argc++; *p++ = "-";
1237     argc++; *p++ = "-c";
1238     argc++; *p++ = "c";
1239     argc++; *p++ = "--";
1240     argc++; *p++ = "-d";
1241     argc++; *p++ = "d";
1242     *p = 0;
1243
1244     /*************************/
1245     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1246
1247     p = argv;
1248     assert(strcmp(*p++, "command_name") == 0);
1249     assert(strcmp(*p++, "-a") == 0);
1250     assert(strcmp(*p++, "-") == 0);
1251     assert(strcmp(*p++, "-") == 0);
1252     assert(strcmp(*p++, "-c") == 0);
1253     assert(strcmp(*p++, "c") == 0);
1254     assert(strcmp(*p++, "--") == 0);
1255     assert(strcmp(*p++, "-d") == 0);
1256     assert(strcmp(*p++, "d") == 0);
1257     assert(*p == 0);
1258
1259     assert(c == 'a');
1260     assert(option_index == 5);  /* no changed */
1261     assert(optind == 2);
1262     assert(optarg == 0);
1263     assert(optopt == 0);
1264
1265     /*************************/
1266     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1267
1268     p = argv;
1269     assert(strcmp(*p++, "command_name") == 0);
1270     assert(strcmp(*p++, "-a") == 0);
1271     assert(strcmp(*p++, "-") == 0);
1272     assert(strcmp(*p++, "-") == 0);
1273     assert(strcmp(*p++, "-c") == 0);
1274     assert(strcmp(*p++, "c") == 0);
1275     assert(strcmp(*p++, "--") == 0);
1276     assert(strcmp(*p++, "-d") == 0);
1277     assert(strcmp(*p++, "d") == 0);
1278     assert(*p == 0);
1279
1280     assert(c == 'c');
1281     assert(option_index == 5);  /* no changed */
1282     assert(optind == 6);
1283     assert(optarg == argv[5]);
1284     assert(optopt == 0);
1285
1286     /*************************/
1287     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1288
1289     p = argv;
1290     assert(strcmp(*p++, "command_name") == 0);
1291     assert(strcmp(*p++, "-a") == 0);
1292     assert(strcmp(*p++, "-c") == 0);
1293     assert(strcmp(*p++, "c") == 0);
1294     assert(strcmp(*p++, "--") == 0);
1295     assert(strcmp(*p++, "-") == 0);
1296     assert(strcmp(*p++, "-") == 0);
1297     assert(strcmp(*p++, "-d") == 0);
1298     assert(strcmp(*p++, "d") == 0);
1299     assert(*p == 0);
1300
1301     assert(c == -1);
1302     assert(option_index == 5);  /* no changed */
1303     assert(optind == 5);
1304     assert(optarg == 0);
1305     assert(optopt == 0);
1306
1307     /*************************/
1308     c = call_getopt_long(argc, argv, "abc:d:", long_options, &option_index);
1309
1310     p = argv;
1311     assert(strcmp(*p++, "command_name") == 0);
1312     assert(strcmp(*p++, "-a") == 0);
1313     assert(strcmp(*p++, "-c") == 0);
1314     assert(strcmp(*p++, "c") == 0);
1315     assert(strcmp(*p++, "--") == 0);
1316     assert(strcmp(*p++, "-") == 0);
1317     assert(strcmp(*p++, "-") == 0);
1318     assert(strcmp(*p++, "-d") == 0);
1319     assert(strcmp(*p++, "d") == 0);
1320     assert(*p == 0);
1321
1322     assert(c == 'd');
1323     assert(option_index == 5);  /* no changed */
1324     assert(optind == 9);
1325     assert(optarg == argv[8]);
1326     assert(optopt == 0);
1327 }
1328
1329 void
1330 test10()
1331 {
1332     optind = 0;
1333     argc = 0;
1334     p = argv;
1335
1336     argc++; *p++ = "command_name";
1337     argc++; *p++ = "-a";
1338     argc++; *p++ = "-cc";
1339     argc++; *p++ = "-d";
1340     argc++; *p++ = "d";
1341     argc++; *p++ = "-c";        /* no argument */
1342     argc++; *p++ = "-d";        /* at last */
1343     *p = 0;
1344
1345     /*************************/
1346     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1347
1348     p = argv;
1349     assert(strcmp(*p++, "command_name") == 0);
1350     assert(strcmp(*p++, "-a") == 0);
1351     assert(strcmp(*p++, "-cc") == 0);
1352     assert(strcmp(*p++, "-d") == 0);
1353     assert(strcmp(*p++, "d") == 0);
1354     assert(strcmp(*p++, "-c") == 0);
1355     assert(strcmp(*p++, "-d") == 0);
1356     assert(*p == 0);
1357
1358     assert(c == 'a');
1359     assert(option_index == 5);  /* no changed */
1360     assert(optind == 2);
1361     assert(optarg == 0);
1362     assert(optopt == 0);
1363
1364     /*************************/
1365     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1366
1367     p = argv;
1368     assert(strcmp(*p++, "command_name") == 0);
1369     assert(strcmp(*p++, "-a") == 0);
1370     assert(strcmp(*p++, "-cc") == 0);
1371     assert(strcmp(*p++, "-d") == 0);
1372     assert(strcmp(*p++, "d") == 0);
1373     assert(strcmp(*p++, "-c") == 0);
1374     assert(strcmp(*p++, "-d") == 0);
1375     assert(*p == 0);
1376
1377     assert(c == 'c');
1378     assert(option_index == 5);  /* no changed */
1379     assert(optind == 3);
1380     assert(optarg == argv[2]+2);
1381     assert(optopt == 0);
1382
1383     /*************************/
1384     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1385
1386     p = argv;
1387     assert(strcmp(*p++, "command_name") == 0);
1388     assert(strcmp(*p++, "-a") == 0);
1389     assert(strcmp(*p++, "-cc") == 0);
1390     assert(strcmp(*p++, "-d") == 0);
1391     assert(strcmp(*p++, "d") == 0);
1392     assert(strcmp(*p++, "-c") == 0);
1393     assert(strcmp(*p++, "-d") == 0);
1394     assert(*p == 0);
1395
1396     assert(c == 'd');
1397     assert(option_index == 5);  /* no changed */
1398     assert(optind == 4);
1399     assert(optarg == 0);
1400     assert(optopt == 0);
1401
1402     /*************************/
1403     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1404
1405     p = argv;
1406     assert(strcmp(*p++, "command_name") == 0);
1407     assert(strcmp(*p++, "-a") == 0);
1408     assert(strcmp(*p++, "-cc") == 0);
1409     assert(strcmp(*p++, "-d") == 0);
1410     assert(strcmp(*p++, "d") == 0);
1411     assert(strcmp(*p++, "-c") == 0);
1412     assert(strcmp(*p++, "-d") == 0);
1413     assert(*p == 0);
1414
1415     assert(c == 'c');
1416     assert(option_index == 5);  /* no changed */
1417     assert(optind == 6);
1418     assert(optarg == 0);
1419     assert(optopt == 0);
1420
1421     /*************************/
1422     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1423
1424     p = argv;
1425     assert(strcmp(*p++, "command_name") == 0);
1426     assert(strcmp(*p++, "-a") == 0);
1427     assert(strcmp(*p++, "-cc") == 0);
1428     assert(strcmp(*p++, "-d") == 0);
1429     assert(strcmp(*p++, "-c") == 0);
1430     assert(strcmp(*p++, "d") == 0);
1431     assert(strcmp(*p++, "-d") == 0);
1432     assert(*p == 0);
1433
1434     assert(c == 'd');
1435     assert(option_index == 5);  /* no changed */
1436     assert(optind == 7);
1437     assert(optarg == 0);
1438     assert(optopt == 0);
1439
1440     /*************************/
1441     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1442
1443     p = argv;
1444     assert(strcmp(*p++, "command_name") == 0);
1445     assert(strcmp(*p++, "-a") == 0);
1446     assert(strcmp(*p++, "-cc") == 0);
1447     assert(strcmp(*p++, "-d") == 0);
1448     assert(strcmp(*p++, "-c") == 0);
1449     assert(strcmp(*p++, "-d") == 0);
1450     assert(strcmp(*p++, "d") == 0);
1451     assert(*p == 0);
1452
1453     assert(c == -1);
1454     assert(option_index == 5);  /* no changed */
1455     assert(optind == 6);
1456     assert(optarg == 0);
1457     assert(optopt == 0);
1458 }
1459
1460 void
1461 test11()
1462 {
1463     optind = 0;
1464     argc = 0;
1465     p = argv;
1466
1467     argc++; *p++ = "command_name";
1468     argc++; *p++ = "--verbose";
1469     argc++; *p++ = "--create=c";
1470     argc++; *p++ = "--change";
1471     argc++; *p++ = "d";
1472     argc++; *p++ = "--create";  /* no argument */
1473     argc++; *p++ = "--change";  /* at last */
1474     *p = 0;
1475
1476     /*************************/
1477     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1478
1479     p = argv;
1480     assert(strcmp(*p++, "command_name") == 0);
1481     assert(strcmp(*p++, "--verbose") == 0);
1482     assert(strcmp(*p++, "--create=c") == 0);
1483     assert(strcmp(*p++, "--change") == 0);
1484     assert(strcmp(*p++, "d") == 0);
1485     assert(strcmp(*p++, "--create") == 0);
1486     assert(strcmp(*p++, "--change") == 0);
1487     assert(*p == 0);
1488
1489     assert(c == 0);
1490     assert(option_index == 0);
1491     assert(optind == 2);
1492     assert(optarg == 0);
1493     assert(optopt == 0);
1494
1495     /*************************/
1496     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1497
1498     p = argv;
1499     assert(strcmp(*p++, "command_name") == 0);
1500     assert(strcmp(*p++, "--verbose") == 0);
1501     assert(strcmp(*p++, "--create=c") == 0);
1502     assert(strcmp(*p++, "--change") == 0);
1503     assert(strcmp(*p++, "d") == 0);
1504     assert(strcmp(*p++, "--create") == 0);
1505     assert(strcmp(*p++, "--change") == 0);
1506     assert(*p == 0);
1507
1508     assert(c == 0);
1509     assert(option_index == 5);
1510     assert(optind == 3);
1511     assert(optarg == argv[2]+9);
1512     assert(optopt == 0);
1513
1514     /*************************/
1515     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1516
1517     p = argv;
1518     assert(strcmp(*p++, "command_name") == 0);
1519     assert(strcmp(*p++, "--verbose") == 0);
1520     assert(strcmp(*p++, "--create=c") == 0);
1521     assert(strcmp(*p++, "--change") == 0);
1522     assert(strcmp(*p++, "d") == 0);
1523     assert(strcmp(*p++, "--create") == 0);
1524     assert(strcmp(*p++, "--change") == 0);
1525     assert(*p == 0);
1526
1527     assert(c == 0);
1528     assert(option_index == 6);
1529     assert(optind == 4);
1530     assert(optarg == 0);
1531     assert(optopt == 0);
1532
1533     /*************************/
1534     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1535
1536     p = argv;
1537     assert(strcmp(*p++, "command_name") == 0);
1538     assert(strcmp(*p++, "--verbose") == 0);
1539     assert(strcmp(*p++, "--create=c") == 0);
1540     assert(strcmp(*p++, "--change") == 0);
1541     assert(strcmp(*p++, "d") == 0);
1542     assert(strcmp(*p++, "--create") == 0);
1543     assert(strcmp(*p++, "--change") == 0);
1544     assert(*p == 0);
1545
1546     assert(c == 0);
1547     assert(option_index == 5);
1548     assert(optind == 6);
1549     assert(optarg == 0);
1550     assert(optopt == 0);
1551
1552     /*************************/
1553     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1554
1555     p = argv;
1556     assert(strcmp(*p++, "command_name") == 0);
1557     assert(strcmp(*p++, "--verbose") == 0);
1558     assert(strcmp(*p++, "--create=c") == 0);
1559     assert(strcmp(*p++, "--change") == 0);
1560     assert(strcmp(*p++, "--create") == 0);
1561     assert(strcmp(*p++, "d") == 0);
1562     assert(strcmp(*p++, "--change") == 0);
1563     assert(*p == 0);
1564
1565     assert(c == 0);
1566     assert(option_index == 6);
1567     assert(optind == 7);
1568     assert(optarg == 0);
1569     assert(optopt == 0);
1570
1571     /*************************/
1572     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1573
1574     p = argv;
1575     assert(strcmp(*p++, "command_name") == 0);
1576     assert(strcmp(*p++, "--verbose") == 0);
1577     assert(strcmp(*p++, "--create=c") == 0);
1578     assert(strcmp(*p++, "--change") == 0);
1579     assert(strcmp(*p++, "--create") == 0);
1580     assert(strcmp(*p++, "--change") == 0);
1581     assert(strcmp(*p++, "d") == 0);
1582     assert(*p == 0);
1583
1584     assert(c == -1);
1585     assert(option_index == 6);
1586     assert(optind == 6);
1587     assert(optarg == 0);
1588     assert(optopt == 0);
1589 }
1590
1591 void
1592 test12()
1593 {
1594     optind = 0;
1595     argc = 0;
1596     p = argv;
1597
1598     argc++; *p++ = "command_name";
1599     argc++; *p++ = "--verbose";
1600     argc++; *p++ = "--create=c";
1601     argc++; *p++ = "files...";
1602     argc++; *p++ = "--delete";  /* required argument */
1603     argc++; *p++ = "d";
1604     argc++; *p++ = "--create";  /* no argument */
1605     argc++; *p++ = "--change";  /* at last */
1606     *p = 0;
1607
1608     /*************************/
1609     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1610
1611     p = argv;
1612     assert(strcmp(*p++, "command_name") == 0);
1613     assert(strcmp(*p++, "--verbose") == 0);
1614     assert(strcmp(*p++, "--create=c") == 0);
1615     assert(strcmp(*p++, "files...") == 0);
1616     assert(strcmp(*p++, "--delete") == 0);
1617     assert(strcmp(*p++, "d") == 0);
1618     assert(strcmp(*p++, "--create") == 0);
1619     assert(strcmp(*p++, "--change") == 0);
1620     assert(*p == 0);
1621
1622     assert(c == 0);
1623     assert(option_index == 0);
1624     assert(optind == 2);
1625     assert(optarg == 0);
1626     assert(optopt == 0);
1627
1628     /*************************/
1629     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1630
1631     p = argv;
1632     assert(strcmp(*p++, "command_name") == 0);
1633     assert(strcmp(*p++, "--verbose") == 0);
1634     assert(strcmp(*p++, "--create=c") == 0);
1635     assert(strcmp(*p++, "files...") == 0);
1636     assert(strcmp(*p++, "--delete") == 0);
1637     assert(strcmp(*p++, "d") == 0);
1638     assert(strcmp(*p++, "--create") == 0);
1639     assert(strcmp(*p++, "--change") == 0);
1640     assert(*p == 0);
1641
1642     assert(c == 0);
1643     assert(option_index == 5);
1644     assert(optind == 3);
1645     assert(optarg == argv[2]+9);
1646     assert(optopt == 0);
1647
1648     /*************************/
1649     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1650
1651     p = argv;
1652     assert(strcmp(*p++, "command_name") == 0);
1653     assert(strcmp(*p++, "--verbose") == 0);
1654     assert(strcmp(*p++, "--create=c") == 0);
1655     assert(strcmp(*p++, "files...") == 0);
1656     assert(strcmp(*p++, "--delete") == 0);
1657     assert(strcmp(*p++, "d") == 0);
1658     assert(strcmp(*p++, "--create") == 0);
1659     assert(strcmp(*p++, "--change") == 0);
1660     assert(*p == 0);
1661
1662     assert(c == 0);
1663     assert(option_index == 4);
1664     assert(optind == 6);
1665     assert(optarg == argv[5]);
1666     assert(optopt == 0);
1667
1668     /*************************/
1669     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1670
1671     p = argv;
1672     assert(strcmp(*p++, "command_name") == 0);
1673     assert(strcmp(*p++, "--verbose") == 0);
1674     assert(strcmp(*p++, "--create=c") == 0);
1675     assert(strcmp(*p++, "--delete") == 0);
1676     assert(strcmp(*p++, "d") == 0);
1677     assert(strcmp(*p++, "files...") == 0);
1678     assert(strcmp(*p++, "--create") == 0);
1679     assert(strcmp(*p++, "--change") == 0);
1680     assert(*p == 0);
1681
1682     assert(c == 0);
1683     assert(option_index == 5);
1684     assert(optind == 7);
1685     assert(optarg == 0);
1686     assert(optopt == 0);
1687
1688     /*************************/
1689     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1690
1691     p = argv;
1692     assert(strcmp(*p++, "command_name") == 0);
1693     assert(strcmp(*p++, "--verbose") == 0);
1694     assert(strcmp(*p++, "--create=c") == 0);
1695     assert(strcmp(*p++, "--delete") == 0);
1696     assert(strcmp(*p++, "d") == 0);
1697     assert(strcmp(*p++, "--create") == 0);
1698     assert(strcmp(*p++, "files...") == 0);
1699     assert(strcmp(*p++, "--change") == 0);
1700     assert(*p == 0);
1701
1702     assert(c == 0);
1703     assert(option_index == 6);
1704     assert(optind == 8);
1705     assert(optarg == 0);
1706     assert(optopt == 0);
1707
1708     /*************************/
1709     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1710
1711     p = argv;
1712     assert(strcmp(*p++, "command_name") == 0);
1713     assert(strcmp(*p++, "--verbose") == 0);
1714     assert(strcmp(*p++, "--create=c") == 0);
1715     assert(strcmp(*p++, "--delete") == 0);
1716     assert(strcmp(*p++, "d") == 0);
1717     assert(strcmp(*p++, "--create") == 0);
1718     assert(strcmp(*p++, "--change") == 0);
1719     assert(strcmp(*p++, "files...") == 0);
1720     assert(*p == 0);
1721
1722     assert(c == -1);
1723     assert(option_index == 6);
1724     assert(optind == 7);
1725     assert(optarg == 0);
1726     assert(optopt == 0);
1727 }
1728
1729 void
1730 test13()
1731 {
1732     optind = 0;
1733     argc = 0;
1734     p = argv;
1735
1736     argc++; *p++ = "command_name";
1737     argc++; *p++ = "--verbose";
1738     argc++; *p++ = "--create=c";
1739     argc++; *p++ = "files...";
1740     argc++; *p++ = "--delete";
1741     argc++; *p++ = "d";
1742     argc++; *p++ = "--";        /* option terminator */
1743     argc++; *p++ = "--change";
1744     *p = 0;
1745
1746     /*************************/
1747     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1748
1749     p = argv;
1750     assert(strcmp(*p++, "command_name") == 0);
1751     assert(strcmp(*p++, "--verbose") == 0);
1752     assert(strcmp(*p++, "--create=c") == 0);
1753     assert(strcmp(*p++, "files...") == 0);
1754     assert(strcmp(*p++, "--delete") == 0);
1755     assert(strcmp(*p++, "d") == 0);
1756     assert(strcmp(*p++, "--") == 0);
1757     assert(strcmp(*p++, "--change") == 0);
1758     assert(*p == 0);
1759
1760     assert(c == 0);
1761     assert(option_index == 0);
1762     assert(optind == 2);
1763     assert(optarg == 0);
1764     assert(optopt == 0);
1765
1766     /*************************/
1767     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1768
1769     p = argv;
1770     assert(strcmp(*p++, "command_name") == 0);
1771     assert(strcmp(*p++, "--verbose") == 0);
1772     assert(strcmp(*p++, "--create=c") == 0);
1773     assert(strcmp(*p++, "files...") == 0);
1774     assert(strcmp(*p++, "--delete") == 0);
1775     assert(strcmp(*p++, "d") == 0);
1776     assert(strcmp(*p++, "--") == 0);
1777     assert(strcmp(*p++, "--change") == 0);
1778     assert(*p == 0);
1779
1780     assert(c == 0);
1781     assert(option_index == 5);
1782     assert(optind == 3);
1783     assert(optarg == argv[2]+9);
1784     assert(optopt == 0);
1785
1786     /*************************/
1787     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1788
1789     p = argv;
1790     assert(strcmp(*p++, "command_name") == 0);
1791     assert(strcmp(*p++, "--verbose") == 0);
1792     assert(strcmp(*p++, "--create=c") == 0);
1793     assert(strcmp(*p++, "files...") == 0);
1794     assert(strcmp(*p++, "--delete") == 0);
1795     assert(strcmp(*p++, "d") == 0);
1796     assert(strcmp(*p++, "--") == 0);
1797     assert(strcmp(*p++, "--change") == 0);
1798     assert(*p == 0);
1799
1800     assert(c == 0);
1801     assert(option_index == 4);
1802     assert(optind == 6);
1803     assert(optarg == argv[5]);
1804     assert(optopt == 0);
1805
1806     /*************************/
1807     c = call_getopt_long(argc, argv, "abc::d::", long_options, &option_index);
1808
1809     p = argv;
1810     assert(strcmp(*p++, "command_name") == 0);
1811     assert(strcmp(*p++, "--verbose") == 0);
1812     assert(strcmp(*p++, "--create=c") == 0);
1813     assert(strcmp(*p++, "--delete") == 0);
1814     assert(strcmp(*p++, "d") == 0);
1815     assert(strcmp(*p++, "--") == 0);
1816     assert(strcmp(*p++, "files...") == 0);
1817     assert(strcmp(*p++, "--change") == 0);
1818     assert(*p == 0);
1819
1820     assert(c == -1);
1821     assert(option_index == 4);
1822     assert(optind == 6);
1823     assert(optarg == 0);
1824     assert(optopt == 0);
1825
1826 }
1827
1828 void
1829 test14()
1830 {
1831     optind = 0;
1832     argc = 0;
1833     p = argv;
1834
1835     argc++; *p++ = "command_name";
1836     argc++; *p++ = "-o5";
1837     argc++; *p++ = "files...";
1838     *p = 0;
1839
1840     /*************************/
1841     c = call_getopt_long(argc, argv, "o[567]", long_options, &option_index);
1842
1843     p = argv;
1844     assert(strcmp(*p++, "command_name") == 0);
1845     assert(strcmp(*p++, "-o5") == 0);
1846     assert(strcmp(*p++, "files...") == 0);
1847     assert(*p == 0);
1848
1849     assert(c == 'o');
1850     assert(option_index == 4);  /* no changed */
1851     assert(optind == 2);
1852     assert(optarg == argv[1]+2);
1853     assert(optopt == 0);
1854
1855     /*************************/
1856     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1857
1858     p = argv;
1859     assert(strcmp(*p++, "command_name") == 0);
1860     assert(strcmp(*p++, "-o5") == 0);
1861     assert(strcmp(*p++, "files...") == 0);
1862     assert(*p == 0);
1863
1864     assert(c == -1);
1865     assert(option_index == 4);  /* no changed */
1866     assert(optind == 2);
1867     assert(optarg == 0);
1868     assert(optopt == 0);
1869
1870 }
1871
1872 void
1873 test15()
1874 {
1875     optind = 0;
1876     argc = 0;
1877     p = argv;
1878
1879     argc++; *p++ = "command_name";
1880     argc++; *p++ = "-a";
1881     argc++; *p++ = "-ccd";
1882     argc++; *p++ = "-ce";
1883     argc++; *p++ = "-d";
1884     argc++; *p++ = "d";
1885     argc++; *p++ = "-cdd";
1886     argc++; *p++ = "-d";
1887     *p = 0;
1888
1889     /*************************/
1890     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1891
1892     p = argv;
1893     assert(strcmp(*p++, "command_name") == 0);
1894     assert(strcmp(*p++, "-a") == 0);
1895     assert(strcmp(*p++, "-ccd") == 0);
1896     assert(strcmp(*p++, "-ce") == 0);
1897     assert(strcmp(*p++, "-d") == 0);
1898     assert(strcmp(*p++, "d") == 0);
1899     assert(strcmp(*p++, "-cdd") == 0);
1900     assert(strcmp(*p++, "-d") == 0);
1901     assert(*p == 0);
1902
1903     assert(c == 'a');
1904     assert(option_index == 4);  /* no changed */
1905     assert(optind == 2);
1906     assert(optarg == 0);
1907     assert(optopt == 0);
1908
1909     /*************************/
1910     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1911
1912     p = argv;
1913     assert(strcmp(*p++, "command_name") == 0);
1914     assert(strcmp(*p++, "-a") == 0);
1915     assert(strcmp(*p++, "-ccd") == 0);
1916     assert(strcmp(*p++, "-ce") == 0);
1917     assert(strcmp(*p++, "-d") == 0);
1918     assert(strcmp(*p++, "d") == 0);
1919     assert(strcmp(*p++, "-cdd") == 0);
1920     assert(strcmp(*p++, "-d") == 0);
1921     assert(*p == 0);
1922
1923     assert(c == 'c');
1924     assert(option_index == 4);  /* no changed */
1925     assert(optind == 2);
1926     assert(optarg == argv[2]+2);
1927     assert(optopt == 0);
1928
1929     /*************************/
1930     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1931
1932     p = argv;
1933     assert(strcmp(*p++, "command_name") == 0);
1934     assert(strcmp(*p++, "-a") == 0);
1935     assert(strcmp(*p++, "-ccd") == 0);
1936     assert(strcmp(*p++, "-ce") == 0);
1937     assert(strcmp(*p++, "-d") == 0);
1938     assert(strcmp(*p++, "d") == 0);
1939     assert(strcmp(*p++, "-cdd") == 0);
1940     assert(strcmp(*p++, "-d") == 0);
1941     assert(*p == 0);
1942
1943     assert(c == 'd');
1944     assert(option_index == 4);  /* no changed */
1945     assert(optind == 3);
1946     assert(optarg == 0);
1947     assert(optopt == 0);
1948
1949     /*************************/
1950     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1951
1952     p = argv;
1953     assert(strcmp(*p++, "command_name") == 0);
1954     assert(strcmp(*p++, "-a") == 0);
1955     assert(strcmp(*p++, "-ccd") == 0);
1956     assert(strcmp(*p++, "-ce") == 0);
1957     assert(strcmp(*p++, "-d") == 0);
1958     assert(strcmp(*p++, "d") == 0);
1959     assert(strcmp(*p++, "-cdd") == 0);
1960     assert(strcmp(*p++, "-d") == 0);
1961     assert(*p == 0);
1962
1963     assert(c == 'c');
1964     assert(option_index == 4);  /* no changed */
1965     assert(optind == 4);
1966     assert(optarg == argv[3]+2);
1967     assert(optopt == 0);
1968
1969     /*************************/
1970     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1971
1972     p = argv;
1973     assert(strcmp(*p++, "command_name") == 0);
1974     assert(strcmp(*p++, "-a") == 0);
1975     assert(strcmp(*p++, "-ccd") == 0);
1976     assert(strcmp(*p++, "-ce") == 0);
1977     assert(strcmp(*p++, "-d") == 0);
1978     assert(strcmp(*p++, "d") == 0);
1979     assert(strcmp(*p++, "-cdd") == 0);
1980     assert(strcmp(*p++, "-d") == 0);
1981     assert(*p == 0);
1982
1983     assert(c == 'd');
1984     assert(option_index == 4);  /* no changed */
1985     assert(optind == 5);
1986     assert(optarg == 0);
1987     assert(optopt == 0);
1988
1989     /*************************/
1990     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
1991
1992     p = argv;
1993     assert(strcmp(*p++, "command_name") == 0);
1994     assert(strcmp(*p++, "-a") == 0);
1995     assert(strcmp(*p++, "-ccd") == 0);
1996     assert(strcmp(*p++, "-ce") == 0);
1997     assert(strcmp(*p++, "-d") == 0);
1998     assert(strcmp(*p++, "d") == 0);
1999     assert(strcmp(*p++, "-cdd") == 0);
2000     assert(strcmp(*p++, "-d") == 0);
2001     assert(*p == 0);
2002
2003     assert(c == 'c');
2004     assert(option_index == 4);  /* no changed */
2005     assert(optind == 6);
2006     assert(optarg == argv[6]+2);
2007     assert(optopt == 0);
2008
2009     /*************************/
2010     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
2011
2012     p = argv;
2013     assert(strcmp(*p++, "command_name") == 0);
2014     assert(strcmp(*p++, "-a") == 0);
2015     assert(strcmp(*p++, "-ccd") == 0);
2016     assert(strcmp(*p++, "-ce") == 0);
2017     assert(strcmp(*p++, "-d") == 0);
2018     assert(strcmp(*p++, "d") == 0);
2019     assert(strcmp(*p++, "-cdd") == 0);
2020     assert(strcmp(*p++, "-d") == 0);
2021     assert(*p == 0);
2022
2023     assert(c == 'd');
2024     assert(option_index == 4);  /* no changed */
2025     assert(optind == 7);
2026     assert(optarg == 0);
2027     assert(optopt == 0);
2028
2029     /*************************/
2030     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
2031
2032     p = argv;
2033     assert(strcmp(*p++, "command_name") == 0);
2034     assert(strcmp(*p++, "-a") == 0);
2035     assert(strcmp(*p++, "-ccd") == 0);
2036     assert(strcmp(*p++, "-ce") == 0);
2037     assert(strcmp(*p++, "-d") == 0);
2038     assert(strcmp(*p++, "-cdd") == 0);
2039     assert(strcmp(*p++, "d") == 0);
2040     assert(strcmp(*p++, "-d") == 0);
2041     assert(*p == 0);
2042
2043     assert(c == 'd');
2044     assert(option_index == 4);  /* no changed */
2045     assert(optind == 8);
2046     assert(optarg == 0);
2047     assert(optopt == 0);
2048
2049
2050     /*************************/
2051     c = call_getopt_long(argc, argv, "abc[cde]d[fgh]", long_options, &option_index);
2052
2053     p = argv;
2054     assert(strcmp(*p++, "command_name") == 0);
2055     assert(strcmp(*p++, "-a") == 0);
2056     assert(strcmp(*p++, "-ccd") == 0);
2057     assert(strcmp(*p++, "-ce") == 0);
2058     assert(strcmp(*p++, "-d") == 0);
2059     assert(strcmp(*p++, "-cdd") == 0);
2060     assert(strcmp(*p++, "-d") == 0);
2061     assert(strcmp(*p++, "d") == 0);
2062     assert(*p == 0);
2063
2064     assert(c == -1);
2065     assert(option_index == 4);  /* no changed */
2066     assert(optind == 7);
2067     assert(optarg == 0);
2068     assert(optopt == 0);
2069
2070
2071 }
2072
2073 int
2074 main()
2075 {
2076     opterr = 0;
2077     optopt = 0;
2078
2079     test1();
2080     test2();
2081     test3();
2082     test4();
2083     test5();
2084     test6();
2085     test7();
2086     test8();
2087     test9();
2088     test10();
2089     test11();
2090     test12();
2091     test13();
2092 #ifndef USE_GNU
2093     test14();
2094     test15();
2095 #endif
2096
2097     return 0;
2098 }
2099 #endif