2 * Copyright 2008-2009 Katholieke Universiteit Leuven
4 * Use of this software is governed by the MIT license
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
17 static struct isl_arg help_arg
[] = {
18 ISL_ARG_PHANTOM_BOOL('h', "help", NULL
, "print this help, then exit")
21 static void set_default_choice(struct isl_arg
*arg
, void *opt
)
23 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.choice
.default_value
;
26 static void set_default_flags(struct isl_arg
*arg
, void *opt
)
28 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.flags
.default_value
;
31 static void set_default_bool(struct isl_arg
*arg
, void *opt
)
33 if (arg
->offset
== (size_t) -1)
35 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.b
.default_value
;
38 static void set_default_child(struct isl_arg
*arg
, void *opt
)
42 if (arg
->offset
== (size_t) -1)
45 child
= calloc(1, arg
->u
.child
.child
->options_size
);
46 *(void **)(((char *)opt
) + arg
->offset
) = child
;
50 isl_args_set_defaults(arg
->u
.child
.child
, child
);
53 static void set_default_user(struct isl_arg
*arg
, void *opt
)
55 arg
->u
.user
.init(((char *)opt
) + arg
->offset
);
58 static void set_default_int(struct isl_arg
*arg
, void *opt
)
60 *(int *)(((char *)opt
) + arg
->offset
) = arg
->u
.i
.default_value
;
63 static void set_default_long(struct isl_arg
*arg
, void *opt
)
65 *(long *)(((char *)opt
) + arg
->offset
) = arg
->u
.l
.default_value
;
68 static void set_default_ulong(struct isl_arg
*arg
, void *opt
)
70 *(unsigned long *)(((char *)opt
) + arg
->offset
) = arg
->u
.ul
.default_value
;
73 static void set_default_str(struct isl_arg
*arg
, void *opt
)
75 const char *str
= NULL
;
76 if (arg
->u
.str
.default_value
)
77 str
= strdup(arg
->u
.str
.default_value
);
78 *(const char **)(((char *)opt
) + arg
->offset
) = str
;
81 static void set_default_str_list(struct isl_arg
*arg
, void *opt
)
83 *(const char ***)(((char *) opt
) + arg
->offset
) = NULL
;
84 *(int *)(((char *) opt
) + arg
->u
.str_list
.offset_n
) = 0;
87 void isl_args_set_defaults(struct isl_args
*args
, void *opt
)
91 for (i
= 0; args
->args
[i
].type
!= isl_arg_end
; ++i
) {
92 switch (args
->args
[i
].type
) {
94 set_default_choice(&args
->args
[i
], opt
);
97 set_default_flags(&args
->args
[i
], opt
);
100 set_default_bool(&args
->args
[i
], opt
);
103 set_default_child(&args
->args
[i
], opt
);
106 set_default_user(&args
->args
[i
], opt
);
109 set_default_int(&args
->args
[i
], opt
);
112 set_default_long(&args
->args
[i
], opt
);
115 set_default_ulong(&args
->args
[i
], opt
);
119 set_default_str(&args
->args
[i
], opt
);
121 case isl_arg_str_list
:
122 set_default_str_list(&args
->args
[i
], opt
);
126 case isl_arg_version
:
133 static void free_str_list(struct isl_arg
*arg
, void *opt
)
136 int n
= *(int *)(((char *) opt
) + arg
->u
.str_list
.offset_n
);
137 char **list
= *(char ***)(((char *) opt
) + arg
->offset
);
139 for (i
= 0; i
< n
; ++i
)
144 static void free_user(struct isl_arg
*arg
, void *opt
)
146 if (arg
->u
.user
.clear
)
147 arg
->u
.user
.clear(((char *)opt
) + arg
->offset
);
150 static void free_args(struct isl_arg
*arg
, void *opt
)
154 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
155 switch (arg
[i
].type
) {
157 if (arg
[i
].offset
== (size_t) -1)
158 free_args(arg
[i
].u
.child
.child
->args
, opt
);
160 isl_args_free(arg
[i
].u
.child
.child
,
161 *(void **)(((char *)opt
) + arg
[i
].offset
));
165 free(*(char **)(((char *)opt
) + arg
[i
].offset
));
167 case isl_arg_str_list
:
168 free_str_list(&arg
[i
], opt
);
171 free_user(&arg
[i
], opt
);
180 case isl_arg_version
:
188 void isl_args_free(struct isl_args
*args
, void *opt
)
193 free_args(args
->args
, opt
);
198 static int print_arg_help(struct isl_arg
*decl
, const char *prefix
, int no
)
202 if (!decl
->long_name
) {
203 printf(" -%c", decl
->short_name
);
207 if (decl
->short_name
) {
208 printf(" -%c, --", decl
->short_name
);
210 } else if (decl
->flags
& ISL_ARG_SINGLE_DASH
) {
219 printf("%s-", prefix
);
220 len
+= strlen(prefix
) + 1;
226 printf("%s", decl
->long_name
);
227 len
+= strlen(decl
->long_name
);
229 while ((++decl
)->type
== isl_arg_alias
) {
236 printf("%s", decl
->long_name
);
237 len
+= strlen(decl
->long_name
);
243 const void *isl_memrchr(const void *s
, int c
, size_t n
)
252 static int wrap_msg(const char *s
, int indent
, int pos
)
255 int wrap_len
= 75 - indent
;
257 if (pos
+ 1 >= indent
)
258 printf("\n%*s", indent
, "");
260 printf("%*s", indent
- pos
, "");
263 while (len
> wrap_len
) {
264 const char *space
= isl_memrchr(s
, ' ', wrap_len
);
268 space
= strchr(s
+ wrap_len
, ' ');
272 printf("%.*s", l
, s
);
275 printf("\n%*s", indent
, "");
282 static int print_help_msg(struct isl_arg
*decl
, int pos
)
287 return wrap_msg(decl
->help_msg
, 30, pos
);
290 static void print_default(struct isl_arg
*decl
, const char *def
, int pos
)
292 const char *default_prefix
= "[default: ";
293 const char *default_suffix
= "]";
296 len
= strlen(default_prefix
) + strlen(def
) + strlen(default_suffix
);
298 if (!decl
->help_msg
) {
300 printf("\n%30s", "");
302 printf("%*s", 30 - pos
, "");
306 printf("\n%30s", "");
310 printf("%s%s%s", default_prefix
, def
, default_suffix
);
313 static void print_default_choice(struct isl_arg
*decl
, void *opt
, int pos
)
316 const char *s
= "none";
319 p
= (unsigned *)(((char *) opt
) + decl
->offset
);
320 for (i
= 0; decl
->u
.choice
.choice
[i
].name
; ++i
)
321 if (decl
->u
.choice
.choice
[i
].value
== *p
) {
322 s
= decl
->u
.choice
.choice
[i
].name
;
326 print_default(decl
, s
, pos
);
329 static void print_choice_help(struct isl_arg
*decl
, const char *prefix
,
335 pos
= print_arg_help(decl
, prefix
, 0);
339 for (i
= 0; decl
->u
.choice
.choice
[i
].name
; ++i
) {
344 printf("%s", decl
->u
.choice
.choice
[i
].name
);
345 pos
+= strlen(decl
->u
.choice
.choice
[i
].name
);
348 pos
= print_help_msg(decl
, pos
);
349 print_default_choice(decl
, opt
, pos
);
354 static void print_default_flags(struct isl_arg
*decl
, void *opt
, int pos
)
357 const char *default_prefix
= "[default: ";
358 const char *default_suffix
= "]";
359 int len
= strlen(default_prefix
) + strlen(default_suffix
);
362 p
= (unsigned *)(((char *) opt
) + decl
->offset
);
363 for (i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
)
364 if ((*p
& decl
->u
.flags
.flags
[i
].mask
) ==
365 decl
->u
.flags
.flags
[i
].value
)
366 len
+= strlen(decl
->u
.flags
.flags
[i
].name
);
368 if (!decl
->help_msg
) {
370 printf("\n%30s", "");
372 printf("%*s", 30 - pos
, "");
376 printf("\n%30s", "");
380 printf("%s", default_prefix
);
382 for (first
= 1, i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
)
383 if ((*p
& decl
->u
.flags
.flags
[i
].mask
) ==
384 decl
->u
.flags
.flags
[i
].value
) {
387 printf("%s", decl
->u
.flags
.flags
[i
].name
);
391 printf("%s", default_suffix
);
394 static void print_flags_help(struct isl_arg
*decl
, const char *prefix
,
400 pos
= print_arg_help(decl
, prefix
, 0);
404 for (i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
) {
410 decl
->u
.flags
.flags
[j
].mask
== decl
->u
.flags
.flags
[i
].mask
;
416 printf("%s", decl
->u
.flags
.flags
[j
].name
);
417 pos
+= strlen(decl
->u
.flags
.flags
[j
].name
);
422 pos
= print_help_msg(decl
, pos
);
423 print_default_flags(decl
, opt
, pos
);
428 static void print_bool_help(struct isl_arg
*decl
, const char *prefix
, void *opt
)
431 unsigned *p
= opt
? (unsigned *)(((char *) opt
) + decl
->offset
) : NULL
;
432 int no
= p
? *p
== 1 : 0;
433 pos
= print_arg_help(decl
, prefix
, no
);
434 pos
= print_help_msg(decl
, pos
);
435 if (decl
->offset
!= (size_t) -1)
436 print_default(decl
, no
? "yes" : "no", pos
);
440 static int print_argument_name(struct isl_arg
*decl
, const char *name
, int pos
)
442 printf("%c<%s>", decl
->long_name
? '=' : ' ', name
);
443 return pos
+ 3 + strlen(name
);
446 static void print_int_help(struct isl_arg
*decl
, const char *prefix
, void *opt
)
450 int *p
= (int *)(((char *) opt
) + decl
->offset
);
451 pos
= print_arg_help(decl
, prefix
, 0);
452 pos
= print_argument_name(decl
, decl
->argument_name
, pos
);
453 pos
= print_help_msg(decl
, pos
);
454 snprintf(val
, sizeof(val
), "%d", *p
);
455 print_default(decl
, val
, pos
);
459 static void print_long_help(struct isl_arg
*decl
, const char *prefix
, void *opt
)
462 long *p
= (long *)(((char *) opt
) + decl
->offset
);
463 pos
= print_arg_help(decl
, prefix
, 0);
464 if (*p
!= decl
->u
.l
.default_selected
) {
470 if (*p
!= decl
->u
.l
.default_selected
) {
474 print_help_msg(decl
, pos
);
478 static void print_ulong_help(struct isl_arg
*decl
, const char *prefix
)
481 pos
= print_arg_help(decl
, prefix
, 0);
484 print_help_msg(decl
, pos
);
488 static void print_str_help(struct isl_arg
*decl
, const char *prefix
, void *opt
)
491 const char *a
= decl
->argument_name
? decl
->argument_name
: "string";
492 const char **p
= (const char **)(((char *) opt
) + decl
->offset
);
493 pos
= print_arg_help(decl
, prefix
, 0);
494 pos
= print_argument_name(decl
, a
, pos
);
495 pos
= print_help_msg(decl
, pos
);
497 print_default(decl
, *p
, pos
);
501 static void print_str_list_help(struct isl_arg
*decl
, const char *prefix
)
504 const char *a
= decl
->argument_name
? decl
->argument_name
: "string";
505 pos
= print_arg_help(decl
, prefix
, 0);
506 pos
= print_argument_name(decl
, a
, pos
);
507 pos
= print_help_msg(decl
, pos
);
511 static void print_help(struct isl_arg
*arg
, const char *prefix
, void *opt
)
516 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
517 if (arg
[i
].flags
& ISL_ARG_HIDDEN
)
519 switch (arg
[i
].type
) {
521 print_flags_help(&arg
[i
], prefix
, opt
);
525 print_choice_help(&arg
[i
], prefix
, opt
);
529 print_bool_help(&arg
[i
], prefix
, opt
);
533 print_int_help(&arg
[i
], prefix
, opt
);
537 print_long_help(&arg
[i
], prefix
, opt
);
541 print_ulong_help(&arg
[i
], prefix
);
545 print_str_help(&arg
[i
], prefix
, opt
);
548 case isl_arg_str_list
:
549 print_str_list_help(&arg
[i
], prefix
);
553 case isl_arg_version
:
563 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
566 if (arg
[i
].type
!= isl_arg_child
)
568 if (arg
[i
].flags
& ISL_ARG_HIDDEN
)
574 printf(" %s\n", arg
[i
].help_msg
);
575 if (arg
[i
].offset
== (size_t) -1)
578 child
= *(void **)(((char *) opt
) + arg
[i
].offset
);
579 print_help(arg
[i
].u
.child
.child
->args
, arg
[i
].long_name
, child
);
584 static const char *prog_name(const char *prog
)
588 slash
= strrchr(prog
, '/');
591 if (strncmp(prog
, "lt-", 3) == 0)
597 static int any_version(struct isl_arg
*decl
)
601 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
602 switch (decl
[i
].type
) {
603 case isl_arg_version
:
606 if (any_version(decl
[i
].u
.child
.child
->args
))
617 static void print_help_and_exit(struct isl_arg
*arg
, const char *prog
,
622 printf("Usage: %s [OPTION...]", prog_name(prog
));
624 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
)
625 if (arg
[i
].type
== isl_arg_arg
)
626 printf(" %s", arg
[i
].argument_name
);
630 print_help(arg
, NULL
, opt
);
632 if (any_version(arg
))
633 printf(" -V, --version\n");
634 print_bool_help(help_arg
, NULL
, NULL
);
636 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
637 if (arg
[i
].type
!= isl_arg_footer
)
639 wrap_msg(arg
[i
].help_msg
, 0, 0);
646 static int match_long_name(struct isl_arg
*decl
,
647 const char *start
, const char *end
)
650 if (end
- start
== strlen(decl
->long_name
) &&
651 !strncmp(start
, decl
->long_name
, end
- start
))
653 } while ((++decl
)->type
== isl_arg_alias
);
658 static const char *skip_dash_dash(struct isl_arg
*decl
, const char *arg
)
660 if (!strncmp(arg
, "--", 2))
662 if ((decl
->flags
& ISL_ARG_SINGLE_DASH
) && arg
[0] == '-')
667 static const char *skip_name(struct isl_arg
*decl
, const char *arg
,
668 const char *prefix
, int need_argument
, int *has_argument
)
674 if (arg
[0] == '-' && arg
[1] && arg
[1] == decl
->short_name
) {
675 if (need_argument
&& !arg
[2])
678 *has_argument
= arg
[2] != '\0';
681 if (!decl
->long_name
)
684 name
= skip_dash_dash(decl
, arg
);
688 equal
= strchr(name
, '=');
689 if (need_argument
&& !equal
)
693 *has_argument
= !!equal
;
694 end
= equal
? equal
: name
+ strlen(name
);
697 size_t prefix_len
= strlen(prefix
);
698 if (strncmp(name
, prefix
, prefix_len
) == 0 &&
699 name
[prefix_len
] == '-')
700 name
+= prefix_len
+ 1;
703 if (!match_long_name(decl
, name
, end
))
706 return equal
? equal
+ 1 : end
;
709 static int parse_choice_option(struct isl_arg
*decl
, char **arg
,
710 const char *prefix
, void *opt
)
716 choice
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
720 if (!has_argument
&& (!arg
[1] || arg
[1][0] == '-')) {
721 unsigned u
= decl
->u
.choice
.default_selected
;
722 *(unsigned *)(((char *)opt
) + decl
->offset
) = u
;
723 if (decl
->u
.choice
.set
)
724 decl
->u
.choice
.set(opt
, u
);
732 for (i
= 0; decl
->u
.choice
.choice
[i
].name
; ++i
) {
735 if (strcmp(choice
, decl
->u
.choice
.choice
[i
].name
))
738 u
= decl
->u
.choice
.choice
[i
].value
;
739 *(unsigned *)(((char *)opt
) + decl
->offset
) = u
;
740 if (decl
->u
.choice
.set
)
741 decl
->u
.choice
.set(opt
, u
);
743 return has_argument
? 1 : 2;
749 static int set_flag(struct isl_arg
*decl
, unsigned *val
, const char *flag
,
754 for (i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
) {
755 if (strncmp(flag
, decl
->u
.flags
.flags
[i
].name
, len
))
758 *val
&= ~decl
->u
.flags
.flags
[i
].mask
;
759 *val
|= decl
->u
.flags
.flags
[i
].value
;
767 static int parse_flags_option(struct isl_arg
*decl
, char **arg
,
768 const char *prefix
, void *opt
)
775 flags
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
779 if (!has_argument
&& !arg
[1])
787 while ((comma
= strchr(flags
, ',')) != NULL
) {
788 if (!set_flag(decl
, &val
, flags
, comma
- flags
))
792 if (!set_flag(decl
, &val
, flags
, strlen(flags
)))
795 *(unsigned *)(((char *)opt
) + decl
->offset
) = val
;
797 return has_argument
? 1 : 2;
800 static int parse_bool_option(struct isl_arg
*decl
, char **arg
,
801 const char *prefix
, void *opt
)
804 unsigned *p
= (unsigned *)(((char *)opt
) + decl
->offset
);
806 if (skip_name(decl
, arg
[0], prefix
, 0, NULL
)) {
807 if ((decl
->flags
& ISL_ARG_BOOL_ARG
) && arg
[1]) {
809 int val
= strtol(arg
[1], &endptr
, 0);
810 if (*endptr
== '\0' && (val
== 0 || val
== 1)) {
811 if (decl
->offset
!= (size_t) -1)
814 decl
->u
.b
.set(opt
, val
);
818 if (decl
->offset
!= (size_t) -1)
821 decl
->u
.b
.set(opt
, 1);
826 if (!decl
->long_name
)
829 name
= skip_dash_dash(decl
, arg
[0]);
834 size_t prefix_len
= strlen(prefix
);
835 if (strncmp(name
, prefix
, prefix_len
) == 0 &&
836 name
[prefix_len
] == '-') {
837 name
+= prefix_len
+ 1;
842 if (strncmp(name
, "no-", 3))
847 size_t prefix_len
= strlen(prefix
);
848 if (strncmp(name
, prefix
, prefix_len
) == 0 &&
849 name
[prefix_len
] == '-')
850 name
+= prefix_len
+ 1;
853 if (match_long_name(decl
, name
, name
+ strlen(name
))) {
854 if (decl
->offset
!= (size_t) -1)
857 decl
->u
.b
.set(opt
, 0);
865 static int parse_str_option(struct isl_arg
*decl
, char **arg
,
866 const char *prefix
, void *opt
)
870 char **p
= (char **)(((char *)opt
) + decl
->offset
);
872 s
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
891 static int isl_arg_str_list_append(struct isl_arg
*decl
, void *opt
,
894 int *n
= (int *)(((char *) opt
) + decl
->u
.str_list
.offset_n
);
895 char **list
= *(char ***)(((char *) opt
) + decl
->offset
);
897 list
= realloc(list
, (*n
+ 1) * sizeof(char *));
900 *(char ***)(((char *) opt
) + decl
->offset
) = list
;
901 list
[*n
] = strdup(s
);
906 static int parse_str_list_option(struct isl_arg
*decl
, char **arg
,
907 const char *prefix
, void *opt
)
912 s
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
917 isl_arg_str_list_append(decl
, opt
, s
);
922 isl_arg_str_list_append(decl
, opt
, arg
[1]);
929 static int parse_int_option(struct isl_arg
*decl
, char **arg
,
930 const char *prefix
, void *opt
)
935 int *p
= (int *)(((char *)opt
) + decl
->offset
);
937 val
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
947 int i
= strtol(arg
[1], &endptr
, 0);
948 if (*endptr
== '\0') {
957 static int parse_long_option(struct isl_arg
*decl
, char **arg
,
958 const char *prefix
, void *opt
)
963 long *p
= (long *)(((char *)opt
) + decl
->offset
);
965 val
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
970 long l
= strtol(val
, NULL
, 0);
973 decl
->u
.l
.set(opt
, l
);
978 long l
= strtol(arg
[1], &endptr
, 0);
979 if (*endptr
== '\0') {
982 decl
->u
.l
.set(opt
, l
);
987 if (decl
->u
.l
.default_value
!= decl
->u
.l
.default_selected
) {
988 *p
= decl
->u
.l
.default_selected
;
990 decl
->u
.l
.set(opt
, decl
->u
.l
.default_selected
);
997 static int parse_ulong_option(struct isl_arg
*decl
, char **arg
,
998 const char *prefix
, void *opt
)
1003 unsigned long *p
= (unsigned long *)(((char *)opt
) + decl
->offset
);
1005 val
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
1010 *p
= strtoul(val
, NULL
, 0);
1015 unsigned long ul
= strtoul(arg
[1], &endptr
, 0);
1016 if (*endptr
== '\0') {
1025 static int parse_option(struct isl_arg
*decl
, char **arg
,
1026 const char *prefix
, void *opt
);
1028 static int parse_child_option(struct isl_arg
*decl
, char **arg
,
1029 const char *prefix
, void *opt
)
1033 if (decl
->offset
== (size_t) -1)
1036 child
= *(void **)(((char *)opt
) + decl
->offset
);
1037 prefix
= decl
->long_name
;
1039 return parse_option(decl
->u
.child
.child
->args
, arg
, prefix
, child
);
1042 static int parse_option(struct isl_arg
*decl
, char **arg
,
1043 const char *prefix
, void *opt
)
1047 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
1049 switch (decl
[i
].type
) {
1050 case isl_arg_choice
:
1051 parsed
= parse_choice_option(&decl
[i
], arg
, prefix
, opt
);
1054 parsed
= parse_flags_option(&decl
[i
], arg
, prefix
, opt
);
1057 parsed
= parse_int_option(&decl
[i
], arg
, prefix
, opt
);
1060 parsed
= parse_long_option(&decl
[i
], arg
, prefix
, opt
);
1063 parsed
= parse_ulong_option(&decl
[i
], arg
, prefix
, opt
);
1066 parsed
= parse_bool_option(&decl
[i
], arg
, prefix
, opt
);
1069 parsed
= parse_str_option(&decl
[i
], arg
, prefix
, opt
);
1071 case isl_arg_str_list
:
1072 parsed
= parse_str_list_option(&decl
[i
], arg
, prefix
,
1076 parsed
= parse_child_option(&decl
[i
], arg
, prefix
, opt
);
1080 case isl_arg_footer
:
1082 case isl_arg_version
:
1093 static void print_version(struct isl_arg
*decl
)
1097 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
1098 switch (decl
[i
].type
) {
1099 case isl_arg_version
:
1100 decl
[i
].u
.version
.print_version();
1103 print_version(decl
[i
].u
.child
.child
->args
);
1111 static void print_version_and_exit(struct isl_arg
*decl
)
1113 print_version(decl
);
1118 static int drop_argument(int argc
, char **argv
, int drop
, int n
)
1120 for (; drop
< argc
; ++drop
)
1121 argv
[drop
] = argv
[drop
+ n
];
1126 static int n_arg(struct isl_arg
*arg
)
1131 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
)
1132 if (arg
[i
].type
== isl_arg_arg
)
1138 static int next_arg(struct isl_arg
*arg
, int a
)
1140 for (++a
; arg
[a
].type
!= isl_arg_end
; ++a
)
1141 if (arg
[a
].type
== isl_arg_arg
)
1147 /* Unless ISL_ARG_SKIP_HELP is set, check if "arg" is
1148 * equal to "--help" and if so call print_help_and_exit.
1150 static void check_help(struct isl_args
*args
, char *arg
, char *prog
, void *opt
,
1153 if (ISL_FL_ISSET(flags
, ISL_ARG_SKIP_HELP
))
1156 if (strcmp(arg
, "--help") == 0)
1157 print_help_and_exit(args
->args
, prog
, opt
);
1160 int isl_args_parse(struct isl_args
*args
, int argc
, char **argv
, void *opt
,
1168 n
= n_arg(args
->args
);
1170 for (i
= 1; i
< argc
; ++i
) {
1171 if ((strcmp(argv
[i
], "--version") == 0 ||
1172 strcmp(argv
[i
], "-V") == 0) && any_version(args
->args
))
1173 print_version_and_exit(args
->args
);
1176 while (argc
> 1 + skip
) {
1178 if (argv
[1 + skip
][0] != '-') {
1179 a
= next_arg(args
->args
, a
);
1182 p
= (char **)(((char *)opt
)+args
->args
[a
].offset
);
1184 *p
= strdup(argv
[1 + skip
]);
1185 argc
= drop_argument(argc
, argv
, 1 + skip
, 1);
1187 } else if (ISL_FL_ISSET(flags
, ISL_ARG_ALL
)) {
1188 fprintf(stderr
, "%s: extra argument: %s\n",
1189 prog_name(argv
[0]), argv
[1 + skip
]);
1195 check_help(args
, argv
[1 + skip
], argv
[0], opt
, flags
);
1196 parsed
= parse_option(args
->args
, &argv
[1 + skip
], NULL
, opt
);
1198 argc
= drop_argument(argc
, argv
, 1 + skip
, parsed
);
1199 else if (ISL_FL_ISSET(flags
, ISL_ARG_ALL
)) {
1200 fprintf(stderr
, "%s: unrecognized option: %s\n",
1201 prog_name(argv
[0]), argv
[1 + skip
]);
1208 fprintf(stderr
, "%s: expecting %d more argument(s)\n",
1209 prog_name(argv
[0]), n
);