isl_arg_parse: allow options without long name
[platform/upstream/isl.git] / isl_arg.c
1 /*
2  * Copyright 2008-2009 Katholieke Universiteit Leuven
3  *
4  * Use of this software is governed by the GNU LGPLv2.1 license
5  *
6  * Written by Sven Verdoolaege, K.U.Leuven, Departement
7  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #include <isl/arg.h>
15 #include <isl/ctx.h>
16
17 static void set_default_choice(struct isl_arg *arg, void *opt)
18 {
19         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.choice.default_value;
20 }
21
22 static void set_default_flags(struct isl_arg *arg, void *opt)
23 {
24         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.flags.default_value;
25 }
26
27 static void set_default_bool(struct isl_arg *arg, void *opt)
28 {
29         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.b.default_value;
30 }
31
32 static void set_default_child(struct isl_arg *arg, void *opt)
33 {
34         void *child = calloc(1, arg->u.child.size);
35
36         if (child)
37                 isl_arg_set_defaults(arg->u.child.child, child);
38
39         *(void **)(((char *)opt) + arg->offset) = child;
40 }
41
42 static void set_default_user(struct isl_arg *arg, void *opt)
43 {
44         arg->u.user.init(((char *)opt) + arg->offset);
45 }
46
47 static void set_default_long(struct isl_arg *arg, void *opt)
48 {
49         *(long *)(((char *)opt) + arg->offset) = arg->u.l.default_value;
50 }
51
52 static void set_default_ulong(struct isl_arg *arg, void *opt)
53 {
54         *(unsigned long *)(((char *)opt) + arg->offset) = arg->u.ul.default_value;
55 }
56
57 static void set_default_str(struct isl_arg *arg, void *opt)
58 {
59         const char *str = NULL;
60         if (arg->u.str.default_value)
61                 str = strdup(arg->u.str.default_value);
62         *(const char **)(((char *)opt) + arg->offset) = str;
63 }
64
65 void isl_arg_set_defaults(struct isl_arg *arg, void *opt)
66 {
67         int i;
68
69         for (i = 0; arg[i].type != isl_arg_end; ++i) {
70                 switch (arg[i].type) {
71                 case isl_arg_choice:
72                         set_default_choice(&arg[i], opt);
73                         break;
74                 case isl_arg_flags:
75                         set_default_flags(&arg[i], opt);
76                         break;
77                 case isl_arg_bool:
78                         set_default_bool(&arg[i], opt);
79                         break;
80                 case isl_arg_child:
81                         set_default_child(&arg[i], opt);
82                         break;
83                 case isl_arg_user:
84                         set_default_user(&arg[i], opt);
85                         break;
86                 case isl_arg_long:
87                         set_default_long(&arg[i], opt);
88                         break;
89                 case isl_arg_ulong:
90                         set_default_ulong(&arg[i], opt);
91                         break;
92                 case isl_arg_arg:
93                 case isl_arg_str:
94                         set_default_str(&arg[i], opt);
95                         break;
96                 case isl_arg_version:
97                 case isl_arg_end:
98                         break;
99                 }
100         }
101 }
102
103 void isl_arg_free(struct isl_arg *arg, void *opt)
104 {
105         int i;
106
107         if (!opt)
108                 return;
109
110         for (i = 0; arg[i].type != isl_arg_end; ++i) {
111                 switch (arg[i].type) {
112                 case isl_arg_child:
113                         isl_arg_free(arg[i].u.child.child,
114                                 *(void **)(((char *)opt) + arg[i].offset));
115                         break;
116                 case isl_arg_arg:
117                 case isl_arg_str:
118                         free(*(char **)(((char *)opt) + arg[i].offset));
119                         break;
120                 case isl_arg_user:
121                         if (arg[i].u.user.clear)
122                                 arg[i].u.user.clear(((char *)opt) + arg[i].offset);
123                         break;
124                 case isl_arg_bool:
125                 case isl_arg_choice:
126                 case isl_arg_flags:
127                 case isl_arg_long:
128                 case isl_arg_ulong:
129                 case isl_arg_version:
130                 case isl_arg_end:
131                         break;
132                 }
133         }
134
135         free(opt);
136 }
137
138 static int print_arg_help(struct isl_arg *decl, const char *prefix, int no)
139 {
140         int len = 0;
141
142         if (!decl->long_name) {
143                 printf("  -%c", decl->short_name);
144                 return 4;
145         }
146
147         if (decl->short_name)
148                 printf("  -%c, --", decl->short_name);
149         else
150                 printf("      --");
151         len += 8;
152
153         if (prefix) {
154                 printf("%s-", prefix);
155                 len += strlen(prefix) + 1;
156         }
157         if (no) {
158                 printf("no-");
159                 len += 3;
160         }
161         printf("%s", decl->long_name);
162         len += strlen(decl->long_name);
163
164         return len;
165 }
166
167 const void *isl_memrchr(const void *s, int c, size_t n)
168 {
169         const char *p = s;
170         while (n-- > 0)
171                 if (p[n] == c)
172                         return p + n;
173         return NULL;
174 }
175
176 static int print_help_msg(struct isl_arg *decl, int pos)
177 {
178         int len;
179         const char *s;
180
181         if (!decl->help_msg)
182                 return pos;
183
184         if (pos >= 29)
185                 printf("\n%30s", "");
186         else
187                 printf("%*s", 30 - pos, "");
188
189         s = decl->help_msg;
190         len = strlen(s);
191         while (len > 45) {
192                 const char *space = isl_memrchr(s, ' ', 45);
193                 int l;
194
195                 if (!space)
196                         space = strchr(s + 45, ' ');
197                 if (!space)
198                         break;
199                 l = space - s;
200                 printf("%.*s", l, s);
201                 s = space + 1;
202                 len -= l + 1;
203                 printf("\n%30s", "");
204         }
205
206         printf("%s", s);
207         return len;
208 }
209
210 static void print_default(struct isl_arg *decl, const char *def, int pos)
211 {
212         int i;
213         const char *default_prefix = "[default: ";
214         const char *default_suffix = "]";
215         int len;
216
217         len = strlen(default_prefix) + strlen(def) + strlen(default_suffix);
218
219         if (!decl->help_msg) {
220                 if (pos >= 29)
221                         printf("\n%30s", "");
222                 else
223                         printf("%*s", 30 - pos, "");
224                 pos = 0;
225         } else {
226                 if (pos + len >= 48)
227                         printf("\n%30s", "");
228                 else
229                         printf(" ");
230         }
231         printf("%s%s%s", default_prefix, def, default_suffix);
232 }
233
234 static void print_default_choice(struct isl_arg *decl, int pos)
235 {
236         int i;
237         const char *s = "none";
238
239         for (i = 0; decl->u.choice.choice[i].name; ++i)
240                 if (decl->u.choice.choice[i].value == decl->u.choice.default_value) {
241                         s = decl->u.choice.choice[i].name;
242                         break;
243                 }
244
245         print_default(decl, s, pos);
246 }
247
248 static void print_choice_help(struct isl_arg *decl, const char *prefix)
249 {
250         int i;
251         int pos;
252
253         pos = print_arg_help(decl, prefix, 0);
254         printf("=");
255         pos++;
256
257         for (i = 0; decl->u.choice.choice[i].name; ++i) {
258                 if (i) {
259                         printf("|");
260                         pos++;
261                 }
262                 printf("%s", decl->u.choice.choice[i].name);
263                 pos += strlen(decl->u.choice.choice[i].name);
264         }
265
266         pos = print_help_msg(decl, pos);
267         print_default_choice(decl, pos);
268
269         printf("\n");
270 }
271
272 static void print_default_flags(struct isl_arg *decl, int pos)
273 {
274         int i, first;
275         const char *default_prefix = "[default: ";
276         const char *default_suffix = "]";
277         int len = strlen(default_prefix) + strlen(default_suffix);
278
279         for (i = 0; decl->u.flags.flags[i].name; ++i)
280                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
281                      decl->u.flags.flags[i].value)
282                         len += strlen(decl->u.flags.flags[i].name);
283
284         if (!decl->help_msg) {
285                 if (pos >= 29)
286                         printf("\n%30s", "");
287                 else
288                         printf("%*s", 30 - pos, "");
289                 pos = 0;
290         } else {
291                 if (pos + len >= 48)
292                         printf("\n%30s", "");
293                 else
294                         printf(" ");
295         }
296         printf("%s", default_prefix);
297
298         for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
299                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
300                      decl->u.flags.flags[i].value) {
301                         if (!first)
302                                 printf(",");
303                         printf("%s", decl->u.flags.flags[i].name);
304                         first = 0;
305                 }
306
307         printf("%s", default_suffix);
308 }
309
310 static void print_flags_help(struct isl_arg *decl, const char *prefix)
311 {
312         int i, j;
313         int pos;
314
315         pos = print_arg_help(decl, prefix, 0);
316         printf("=");
317         pos++;
318
319         for (i = 0; decl->u.flags.flags[i].name; ++i) {
320                 if (i) {
321                         printf(",");
322                         pos++;
323                 }
324                 for (j = i;
325                      decl->u.flags.flags[j].mask == decl->u.flags.flags[i].mask;
326                      ++j) {
327                         if (j != i) {
328                                 printf("|");
329                                 pos++;
330                         }
331                         printf("%s", decl->u.flags.flags[j].name);
332                         pos += strlen(decl->u.flags.flags[j].name);
333                 }
334                 i = j - 1;
335         }
336
337         pos = print_help_msg(decl, pos);
338         print_default_flags(decl, pos);
339
340         printf("\n");
341 }
342
343 static void print_bool_help(struct isl_arg *decl, const char *prefix)
344 {
345         int pos;
346         int no = decl->u.b.default_value == 1;
347         pos = print_arg_help(decl, prefix, no);
348         pos = print_help_msg(decl, pos);
349         print_default(decl, no ? "yes" : "no", pos);
350         printf("\n");
351 }
352
353 static void print_long_help(struct isl_arg *decl, const char *prefix)
354 {
355         int pos;
356         pos = print_arg_help(decl, prefix, 0);
357         if (decl->u.l.default_value != decl->u.l.default_selected) {
358                 printf("[");
359                 pos++;
360         }
361         printf("=long");
362         pos += 5;
363         if (decl->u.l.default_value != decl->u.l.default_selected) {
364                 printf("]");
365                 pos++;
366         }
367         print_help_msg(decl, pos);
368         printf("\n");
369 }
370
371 static void print_ulong_help(struct isl_arg *decl, const char *prefix)
372 {
373         int pos;
374         pos = print_arg_help(decl, prefix, 0);
375         printf("=ulong");
376         pos += 6;
377         print_help_msg(decl, pos);
378         printf("\n");
379 }
380
381 static void print_str_help(struct isl_arg *decl, const char *prefix)
382 {
383         int pos;
384         const char *a = decl->argument_name ? decl->argument_name : "string";
385         pos = print_arg_help(decl, prefix, 0);
386         printf("=%s", a);
387         pos += 1 + strlen(a);
388         print_help_msg(decl, pos);
389         printf("\n");
390 }
391
392 static void print_help(struct isl_arg *arg, const char *prefix)
393 {
394         int i;
395
396         for (i = 0; arg[i].type != isl_arg_end; ++i) {
397                 switch (arg[i].type) {
398                 case isl_arg_flags:
399                         print_flags_help(&arg[i], prefix);
400                         break;
401                 case isl_arg_choice:
402                         print_choice_help(&arg[i], prefix);
403                         break;
404                 case isl_arg_bool:
405                         print_bool_help(&arg[i], prefix);
406                         break;
407                 case isl_arg_long:
408                         print_long_help(&arg[i], prefix);
409                         break;
410                 case isl_arg_ulong:
411                         print_ulong_help(&arg[i], prefix);
412                         break;
413                 case isl_arg_str:
414                         print_str_help(&arg[i], prefix);
415                         break;
416                 case isl_arg_version:
417                         printf("  -V, --version\n");
418                         break;
419                 case isl_arg_arg:
420                 case isl_arg_child:
421                 case isl_arg_user:
422                 case isl_arg_end:
423                         break;
424                 }
425         }
426
427         for (i = 0; arg[i].type != isl_arg_end; ++i) {
428                 if (arg[i].type != isl_arg_child)
429                         continue;
430
431                 printf("\n");
432                 if (arg[i].help_msg)
433                         printf(" %s\n", arg[i].help_msg);
434                 print_help(arg[i].u.child.child, arg[i].long_name);
435         }
436 }
437
438 static const char *prog_name(const char *prog)
439 {
440         const char *slash;
441
442         slash = strrchr(prog, '/');
443         if (slash)
444                 prog = slash + 1;
445         if (strncmp(prog, "lt-", 3) == 0)
446                 prog += 3;
447
448         return prog;
449 }
450
451 static void print_help_and_exit(struct isl_arg *arg, const char *prog)
452 {
453         int i;
454
455         printf("Usage: %s [OPTION...]", prog_name(prog));
456
457         for (i = 0; arg[i].type != isl_arg_end; ++i)
458                 if (arg[i].type == isl_arg_arg)
459                         printf(" %s", arg[i].argument_name);
460
461         printf("\n\n");
462
463         print_help(arg, NULL);
464
465         exit(0);
466 }
467
468 static const char *skip_name(struct isl_arg *decl, const char *arg,
469         const char *prefix, int need_argument, int *has_argument)
470 {
471         const char *equal;
472         const char *name;
473         const char *end;
474
475         if (arg[0] == '-' && arg[1] && arg[1] == decl->short_name) {
476                 if (need_argument && !arg[2])
477                         return NULL;
478                 if (has_argument)
479                         *has_argument = arg[2] != '\0';
480                 return arg + 2;
481         }
482         if (!decl->long_name)
483                 return NULL;
484
485         if (strncmp(arg, "--", 2))
486                 return NULL;
487
488         name = arg + 2;
489         equal = strchr(name, '=');
490         if (need_argument && !equal)
491                 return NULL;
492
493         if (has_argument)
494                 *has_argument = !!equal;
495         end = equal ? equal : name + strlen(name);
496
497         if (prefix) {
498                 size_t prefix_len = strlen(prefix);
499                 if (strncmp(name, prefix, prefix_len) == 0 &&
500                     name[prefix_len] == '-')
501                         name += prefix_len + 1;
502         }
503
504         if (end - name != strlen(decl->long_name) ||
505             strncmp(name, decl->long_name, end - name))
506                 return NULL;
507
508         return equal ? equal + 1 : end;
509 }
510
511 static int parse_choice_option(struct isl_arg *decl, char **arg,
512         const char *prefix, void *opt)
513 {
514         int i;
515         int has_argument;
516         const char *choice;
517
518         choice = skip_name(decl, arg[0], prefix, 0, &has_argument);
519         if (!choice)
520                 return 0;
521
522         if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
523                 unsigned u = decl->u.choice.default_selected;
524                 if (decl->u.choice.set)
525                         decl->u.choice.set(opt, u);
526                 else
527                         *(unsigned *)(((char *)opt) + decl->offset) = u;
528
529                 return 1;
530         }
531
532         if (!has_argument)
533                 choice = arg[1];
534
535         for (i = 0; decl->u.choice.choice[i].name; ++i) {
536                 unsigned u;
537
538                 if (strcmp(choice, decl->u.choice.choice[i].name))
539                         continue;
540
541                 u = decl->u.choice.choice[i].value;
542                 if (decl->u.choice.set)
543                         decl->u.choice.set(opt, u);
544                 else
545                         *(unsigned *)(((char *)opt) + decl->offset) = u;
546
547                 return has_argument ? 1 : 2;
548         }
549
550         return 0;
551 }
552
553 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
554         size_t len)
555 {
556         int i;
557
558         for (i = 0; decl->u.flags.flags[i].name; ++i) {
559                 if (strncmp(flag, decl->u.flags.flags[i].name, len))
560                         continue;
561
562                 *val &= ~decl->u.flags.flags[i].mask;
563                 *val |= decl->u.flags.flags[i].value;
564
565                 return 1;
566         }
567
568         return 0;
569 }
570
571 static int parse_flags_option(struct isl_arg *decl, char **arg,
572         const char *prefix, void *opt)
573 {
574         int has_argument;
575         const char *flags;
576         const char *comma;
577         unsigned val;
578
579         flags = skip_name(decl, arg[0], prefix, 0, &has_argument);
580         if (!flags)
581                 return 0;
582
583         if (!has_argument && !arg[1])
584                 return 0;
585
586         if (!has_argument)
587                 flags = arg[1];
588
589         val = *(unsigned *)(((char *)opt) + decl->offset);
590
591         while ((comma = strchr(flags, ',')) != NULL) {
592                 if (!set_flag(decl, &val, flags, comma - flags))
593                         return 0;
594                 flags = comma + 1;
595         }
596         if (!set_flag(decl, &val, flags, strlen(flags)))
597                 return 0;
598
599         *(unsigned *)(((char *)opt) + decl->offset) = val;
600
601         return has_argument ? 1 : 2;
602 }
603
604 static int parse_bool_option(struct isl_arg *decl, const char *arg,
605         const char *prefix, void *opt)
606 {
607         if (skip_name(decl, arg, prefix, 0, NULL)) {
608                 *(unsigned *)(((char *)opt) + decl->offset) = 1;
609
610                 return 1;
611         }
612
613         if (!decl->long_name)
614                 return 0;
615
616         if (strncmp(arg, "--", 2))
617                 return 0;
618         arg += 2;
619
620         if (prefix) {
621                 size_t prefix_len = strlen(prefix);
622                 if (strncmp(arg, prefix, prefix_len) == 0 &&
623                     arg[prefix_len] == '-') {
624                         arg += prefix_len + 1;
625                         prefix = NULL;
626                 }
627         }
628
629         if (strncmp(arg, "no-", 3))
630                 return 0;
631         arg += 3;
632
633         if (prefix) {
634                 size_t prefix_len = strlen(prefix);
635                 if (strncmp(arg, prefix, prefix_len) == 0 &&
636                     arg[prefix_len] == '-')
637                         arg += prefix_len + 1;
638         }
639
640         if (!strcmp(arg, decl->long_name)) {
641                 *(unsigned *)(((char *)opt) + decl->offset) = 0;
642
643                 return 1;
644         }
645
646         return 0;
647 }
648
649 static int parse_str_option(struct isl_arg *decl, char **arg,
650         const char *prefix, void *opt)
651 {
652         int has_argument;
653         const char *s;
654         char **p = (char **)(((char *)opt) + decl->offset);
655
656         s = skip_name(decl, arg[0], prefix, 0, &has_argument);
657         if (!s)
658                 return 0;
659
660         if (has_argument) {
661                 *p = strdup(s);
662                 return 1;
663         }
664
665         if (arg[1]) {
666                 *p = strdup(arg[1]);
667                 return 2;
668         }
669
670         return 0;
671 }
672
673 static int parse_long_option(struct isl_arg *decl, char **arg,
674         const char *prefix, void *opt)
675 {
676         int has_argument;
677         const char *val;
678         char *endptr;
679         long *p = (long *)(((char *)opt) + decl->offset);
680
681         val = skip_name(decl, arg[0], prefix, 0, &has_argument);
682         if (!val)
683                 return 0;
684
685         if (has_argument) {
686                 long l = strtol(val, NULL, 0);
687                 if (decl->u.l.set)
688                         decl->u.l.set(opt, l);
689                 else
690                         *p = l;
691                 return 1;
692         }
693
694         if (arg[1]) {
695                 long l = strtol(arg[1], &endptr, 0);
696                 if (*endptr == '\0') {
697                         if (decl->u.l.set)
698                                 decl->u.l.set(opt, l);
699                         else
700                                 *p = l;
701                         return 2;
702                 }
703         }
704
705         if (decl->u.l.default_value != decl->u.l.default_selected) {
706                 if (decl->u.l.set)
707                         decl->u.l.set(opt, decl->u.l.default_selected);
708                 else
709                         *p = decl->u.l.default_selected;
710                 return 1;
711         }
712
713         return 0;
714 }
715
716 static int parse_ulong_option(struct isl_arg *decl, char **arg,
717         const char *prefix, void *opt)
718 {
719         int has_argument;
720         const char *val;
721         char *endptr;
722         unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
723
724         val = skip_name(decl, arg[0], prefix, 0, &has_argument);
725         if (!val)
726                 return 0;
727
728         if (has_argument) {
729                 *p = strtoul(val, NULL, 0);
730                 return 1;
731         }
732
733         if (arg[1]) {
734                 unsigned long ul = strtoul(arg[1], &endptr, 0);
735                 if (*endptr == '\0') {
736                         *p = ul;
737                         return 2;
738                 }
739         }
740
741         return 0;
742 }
743
744 static int parse_option(struct isl_arg *decl, char **arg,
745         const char *prefix, void *opt);
746
747 static int parse_child_option(struct isl_arg *decl, char **arg, void *opt)
748 {
749         return parse_option(decl->u.child.child, arg, decl->long_name,
750                                 *(void **)(((char *)opt) + decl->offset));
751 }
752
753 static int parse_option(struct isl_arg *decl, char **arg,
754         const char *prefix, void *opt)
755 {
756         int i;
757
758         for (i = 0; decl[i].type != isl_arg_end; ++i) {
759                 int parsed = 0;
760                 switch (decl[i].type) {
761                 case isl_arg_choice:
762                         parsed = parse_choice_option(&decl[i], arg, prefix, opt);
763                         break;
764                 case isl_arg_flags:
765                         parsed = parse_flags_option(&decl[i], arg, prefix, opt);
766                         break;
767                 case isl_arg_long:
768                         parsed = parse_long_option(&decl[i], arg, prefix, opt);
769                         break;
770                 case isl_arg_ulong:
771                         parsed = parse_ulong_option(&decl[i], arg, prefix, opt);
772                         break;
773                 case isl_arg_bool:
774                         parsed = parse_bool_option(&decl[i], *arg, prefix, opt);
775                         break;
776                 case isl_arg_str:
777                         parsed = parse_str_option(&decl[i], arg, prefix, opt);
778                         break;
779                 case isl_arg_child:
780                         parsed = parse_child_option(&decl[i], arg, opt);
781                         break;
782                 case isl_arg_arg:
783                 case isl_arg_user:
784                 case isl_arg_version:
785                 case isl_arg_end:
786                         break;
787                 }
788                 if (parsed)
789                         return parsed;
790         }
791
792         return 0;
793 }
794
795 static int any_version(struct isl_arg *decl)
796 {
797         int i;
798
799         for (i = 0; decl[i].type != isl_arg_end; ++i) {
800                 switch (decl[i].type) {
801                 case isl_arg_version:
802                         return 1;
803                 case isl_arg_child:
804                         if (any_version(decl[i].u.child.child))
805                                 return 1;
806                         break;
807                 default:
808                         break;
809                 }
810         }
811
812         return 0;
813 }
814
815 static void print_version(struct isl_arg *decl)
816 {
817         int i;
818
819         for (i = 0; decl[i].type != isl_arg_end; ++i) {
820                 switch (decl[i].type) {
821                 case isl_arg_version:
822                         decl[i].u.version.print_version();
823                         break;
824                 case isl_arg_child:
825                         print_version(decl[i].u.child.child);
826                         break;
827                 default:
828                         break;
829                 }
830         }
831 }
832
833 static void print_version_and_exit(struct isl_arg *decl)
834 {
835         print_version(decl);
836
837         exit(0);
838 }
839
840 static int drop_argument(int argc, char **argv, int drop, int n)
841 {
842         for (; drop < argc; ++drop)
843                 argv[drop] = argv[drop + n];
844
845         return argc - n;
846 }
847
848 static int n_arg(struct isl_arg *arg)
849 {
850         int i;
851         int n_arg = 0;
852
853         for (i = 0; arg[i].type != isl_arg_end; ++i)
854                 if (arg[i].type == isl_arg_arg)
855                         n_arg++;
856
857         return n_arg;
858 }
859
860 int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
861         unsigned flags)
862 {
863         int skip = 0;
864         int i;
865         int n;
866
867         n = n_arg(arg);
868
869         for (i = 1; i < argc; ++i) {
870                 if (strcmp(argv[i], "--help") == 0)
871                         print_help_and_exit(arg, argv[0]);
872         }
873
874         for (i = 1; i < argc; ++i) {
875                 if ((strcmp(argv[i], "--version") == 0 ||
876                      strcmp(argv[i], "-V") == 0) && any_version(arg))
877                         print_version_and_exit(arg);
878         }
879
880         while (argc > 1 + skip) {
881                 int parsed;
882                 if (argv[1 + skip][0] != '-')
883                         break;
884                 parsed = parse_option(arg, &argv[1 + skip], NULL, opt);
885                 if (parsed)
886                         argc = drop_argument(argc, argv, 1 + skip, parsed);
887                 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
888                         fprintf(stderr, "%s: unrecognized option: %s\n",
889                                         prog_name(argv[0]), argv[1 + skip]);
890                         exit(-1);
891                 } else
892                         ++skip;
893         }
894
895         if (ISL_FL_ISSET(flags, ISL_ARG_ALL) ? argc != 1 + n
896                                              : argc < 1 + skip + n) {
897                 fprintf(stderr, "%s: expecting %d arguments\n",
898                                 prog_name(argv[0]), n);
899                 exit(-1);
900         }
901
902         for (i = 0; arg[i].type != isl_arg_end; ++i) {
903                 const char *str;
904                 if (arg[i].type != isl_arg_arg)
905                         continue;
906                 str = strdup(argv[1 + skip]);
907                 *(const char **)(((char *)opt) + arg[i].offset) = str;
908                 argc = drop_argument(argc, argv, 1 + skip, 1);
909         }
910
911         return argc;
912 }