2 * Copyright 2008-2009 Katholieke Universiteit Leuven
4 * Use of this software is governed by the GNU LGPLv2.1 license
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
17 static void set_default_choice(struct isl_arg
*arg
, void *opt
)
19 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.choice
.default_value
;
22 static void set_default_flags(struct isl_arg
*arg
, void *opt
)
24 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.flags
.default_value
;
27 static void set_default_bool(struct isl_arg
*arg
, void *opt
)
29 *(unsigned *)(((char *)opt
) + arg
->offset
) = arg
->u
.b
.default_value
;
32 static void set_default_child(struct isl_arg
*arg
, void *opt
)
34 void *child
= calloc(1, arg
->u
.child
.size
);
37 isl_arg_set_defaults(arg
->u
.child
.child
, child
);
39 *(void **)(((char *)opt
) + arg
->offset
) = child
;
42 static void set_default_user(struct isl_arg
*arg
, void *opt
)
44 arg
->u
.user
.init(((char *)opt
) + arg
->offset
);
47 static void set_default_long(struct isl_arg
*arg
, void *opt
)
49 *(long *)(((char *)opt
) + arg
->offset
) = arg
->u
.l
.default_value
;
52 static void set_default_ulong(struct isl_arg
*arg
, void *opt
)
54 *(unsigned long *)(((char *)opt
) + arg
->offset
) = arg
->u
.ul
.default_value
;
57 static void set_default_str(struct isl_arg
*arg
, void *opt
)
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
;
65 void isl_arg_set_defaults(struct isl_arg
*arg
, void *opt
)
69 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
70 switch (arg
[i
].type
) {
72 set_default_choice(&arg
[i
], opt
);
75 set_default_flags(&arg
[i
], opt
);
78 set_default_bool(&arg
[i
], opt
);
81 set_default_child(&arg
[i
], opt
);
84 set_default_user(&arg
[i
], opt
);
87 set_default_long(&arg
[i
], opt
);
90 set_default_ulong(&arg
[i
], opt
);
94 set_default_str(&arg
[i
], opt
);
103 void isl_arg_free(struct isl_arg
*arg
, void *opt
)
110 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
111 switch (arg
[i
].type
) {
113 isl_arg_free(arg
[i
].u
.child
.child
,
114 *(void **)(((char *)opt
) + arg
[i
].offset
));
118 free(*(char **)(((char *)opt
) + arg
[i
].offset
));
121 if (arg
[i
].u
.user
.clear
)
122 arg
[i
].u
.user
.clear(((char *)opt
) + arg
[i
].offset
);
129 case isl_arg_version
:
138 static int print_arg_help(struct isl_arg
*decl
, const char *prefix
, int no
)
142 if (!decl
->long_name
) {
143 printf(" -%c", decl
->short_name
);
147 if (decl
->short_name
)
148 printf(" -%c, --", decl
->short_name
);
154 printf("%s-", prefix
);
155 len
+= strlen(prefix
) + 1;
161 printf("%s", decl
->long_name
);
162 len
+= strlen(decl
->long_name
);
167 const void *isl_memrchr(const void *s
, int c
, size_t n
)
176 static int print_help_msg(struct isl_arg
*decl
, int pos
)
185 printf("\n%30s", "");
187 printf("%*s", 30 - pos
, "");
192 const char *space
= isl_memrchr(s
, ' ', 45);
196 space
= strchr(s
+ 45, ' ');
200 printf("%.*s", l
, s
);
203 printf("\n%30s", "");
210 static void print_default(struct isl_arg
*decl
, const char *def
, int pos
)
213 const char *default_prefix
= "[default: ";
214 const char *default_suffix
= "]";
217 len
= strlen(default_prefix
) + strlen(def
) + strlen(default_suffix
);
219 if (!decl
->help_msg
) {
221 printf("\n%30s", "");
223 printf("%*s", 30 - pos
, "");
227 printf("\n%30s", "");
231 printf("%s%s%s", default_prefix
, def
, default_suffix
);
234 static void print_default_choice(struct isl_arg
*decl
, int pos
)
237 const char *s
= "none";
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
;
245 print_default(decl
, s
, pos
);
248 static void print_choice_help(struct isl_arg
*decl
, const char *prefix
)
253 pos
= print_arg_help(decl
, prefix
, 0);
257 for (i
= 0; decl
->u
.choice
.choice
[i
].name
; ++i
) {
262 printf("%s", decl
->u
.choice
.choice
[i
].name
);
263 pos
+= strlen(decl
->u
.choice
.choice
[i
].name
);
266 pos
= print_help_msg(decl
, pos
);
267 print_default_choice(decl
, pos
);
272 static void print_default_flags(struct isl_arg
*decl
, int pos
)
275 const char *default_prefix
= "[default: ";
276 const char *default_suffix
= "]";
277 int len
= strlen(default_prefix
) + strlen(default_suffix
);
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
);
284 if (!decl
->help_msg
) {
286 printf("\n%30s", "");
288 printf("%*s", 30 - pos
, "");
292 printf("\n%30s", "");
296 printf("%s", default_prefix
);
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
) {
303 printf("%s", decl
->u
.flags
.flags
[i
].name
);
307 printf("%s", default_suffix
);
310 static void print_flags_help(struct isl_arg
*decl
, const char *prefix
)
315 pos
= print_arg_help(decl
, prefix
, 0);
319 for (i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
) {
325 decl
->u
.flags
.flags
[j
].mask
== decl
->u
.flags
.flags
[i
].mask
;
331 printf("%s", decl
->u
.flags
.flags
[j
].name
);
332 pos
+= strlen(decl
->u
.flags
.flags
[j
].name
);
337 pos
= print_help_msg(decl
, pos
);
338 print_default_flags(decl
, pos
);
343 static void print_bool_help(struct isl_arg
*decl
, const char *prefix
)
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
);
353 static int print_argument_name(struct isl_arg
*decl
, const char *name
, int pos
)
355 printf("%c<%s>", decl
->long_name
? '=' : ' ', name
);
356 return pos
+ 3 + strlen(name
);
359 static void print_long_help(struct isl_arg
*decl
, const char *prefix
)
362 pos
= print_arg_help(decl
, prefix
, 0);
363 if (decl
->u
.l
.default_value
!= decl
->u
.l
.default_selected
) {
369 if (decl
->u
.l
.default_value
!= decl
->u
.l
.default_selected
) {
373 print_help_msg(decl
, pos
);
377 static void print_ulong_help(struct isl_arg
*decl
, const char *prefix
)
380 pos
= print_arg_help(decl
, prefix
, 0);
383 print_help_msg(decl
, pos
);
387 static void print_str_help(struct isl_arg
*decl
, const char *prefix
)
390 const char *a
= decl
->argument_name
? decl
->argument_name
: "string";
391 pos
= print_arg_help(decl
, prefix
, 0);
392 pos
= print_argument_name(decl
, a
, pos
);
393 print_help_msg(decl
, pos
);
397 static void print_help(struct isl_arg
*arg
, const char *prefix
)
401 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
402 switch (arg
[i
].type
) {
404 print_flags_help(&arg
[i
], prefix
);
407 print_choice_help(&arg
[i
], prefix
);
410 print_bool_help(&arg
[i
], prefix
);
413 print_long_help(&arg
[i
], prefix
);
416 print_ulong_help(&arg
[i
], prefix
);
419 print_str_help(&arg
[i
], prefix
);
421 case isl_arg_version
:
422 printf(" -V, --version\n");
432 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
433 if (arg
[i
].type
!= isl_arg_child
)
438 printf(" %s\n", arg
[i
].help_msg
);
439 print_help(arg
[i
].u
.child
.child
, arg
[i
].long_name
);
443 static const char *prog_name(const char *prog
)
447 slash
= strrchr(prog
, '/');
450 if (strncmp(prog
, "lt-", 3) == 0)
456 static void print_help_and_exit(struct isl_arg
*arg
, const char *prog
)
460 printf("Usage: %s [OPTION...]", prog_name(prog
));
462 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
)
463 if (arg
[i
].type
== isl_arg_arg
)
464 printf(" %s", arg
[i
].argument_name
);
468 print_help(arg
, NULL
);
473 static const char *skip_name(struct isl_arg
*decl
, const char *arg
,
474 const char *prefix
, int need_argument
, int *has_argument
)
480 if (arg
[0] == '-' && arg
[1] && arg
[1] == decl
->short_name
) {
481 if (need_argument
&& !arg
[2])
484 *has_argument
= arg
[2] != '\0';
487 if (!decl
->long_name
)
490 if (strncmp(arg
, "--", 2))
494 equal
= strchr(name
, '=');
495 if (need_argument
&& !equal
)
499 *has_argument
= !!equal
;
500 end
= equal
? equal
: name
+ strlen(name
);
503 size_t prefix_len
= strlen(prefix
);
504 if (strncmp(name
, prefix
, prefix_len
) == 0 &&
505 name
[prefix_len
] == '-')
506 name
+= prefix_len
+ 1;
509 if (end
- name
!= strlen(decl
->long_name
) ||
510 strncmp(name
, decl
->long_name
, end
- name
))
513 return equal
? equal
+ 1 : end
;
516 static int parse_choice_option(struct isl_arg
*decl
, char **arg
,
517 const char *prefix
, void *opt
)
523 choice
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
527 if (!has_argument
&& (!arg
[1] || arg
[1][0] == '-')) {
528 unsigned u
= decl
->u
.choice
.default_selected
;
529 if (decl
->u
.choice
.set
)
530 decl
->u
.choice
.set(opt
, u
);
532 *(unsigned *)(((char *)opt
) + decl
->offset
) = u
;
540 for (i
= 0; decl
->u
.choice
.choice
[i
].name
; ++i
) {
543 if (strcmp(choice
, decl
->u
.choice
.choice
[i
].name
))
546 u
= decl
->u
.choice
.choice
[i
].value
;
547 if (decl
->u
.choice
.set
)
548 decl
->u
.choice
.set(opt
, u
);
550 *(unsigned *)(((char *)opt
) + decl
->offset
) = u
;
552 return has_argument
? 1 : 2;
558 static int set_flag(struct isl_arg
*decl
, unsigned *val
, const char *flag
,
563 for (i
= 0; decl
->u
.flags
.flags
[i
].name
; ++i
) {
564 if (strncmp(flag
, decl
->u
.flags
.flags
[i
].name
, len
))
567 *val
&= ~decl
->u
.flags
.flags
[i
].mask
;
568 *val
|= decl
->u
.flags
.flags
[i
].value
;
576 static int parse_flags_option(struct isl_arg
*decl
, char **arg
,
577 const char *prefix
, void *opt
)
584 flags
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
588 if (!has_argument
&& !arg
[1])
594 val
= *(unsigned *)(((char *)opt
) + decl
->offset
);
596 while ((comma
= strchr(flags
, ',')) != NULL
) {
597 if (!set_flag(decl
, &val
, flags
, comma
- flags
))
601 if (!set_flag(decl
, &val
, flags
, strlen(flags
)))
604 *(unsigned *)(((char *)opt
) + decl
->offset
) = val
;
606 return has_argument
? 1 : 2;
609 static int parse_bool_option(struct isl_arg
*decl
, const char *arg
,
610 const char *prefix
, void *opt
)
612 if (skip_name(decl
, arg
, prefix
, 0, NULL
)) {
613 *(unsigned *)(((char *)opt
) + decl
->offset
) = 1;
618 if (!decl
->long_name
)
621 if (strncmp(arg
, "--", 2))
626 size_t prefix_len
= strlen(prefix
);
627 if (strncmp(arg
, prefix
, prefix_len
) == 0 &&
628 arg
[prefix_len
] == '-') {
629 arg
+= prefix_len
+ 1;
634 if (strncmp(arg
, "no-", 3))
639 size_t prefix_len
= strlen(prefix
);
640 if (strncmp(arg
, prefix
, prefix_len
) == 0 &&
641 arg
[prefix_len
] == '-')
642 arg
+= prefix_len
+ 1;
645 if (!strcmp(arg
, decl
->long_name
)) {
646 *(unsigned *)(((char *)opt
) + decl
->offset
) = 0;
654 static int parse_str_option(struct isl_arg
*decl
, char **arg
,
655 const char *prefix
, void *opt
)
659 char **p
= (char **)(((char *)opt
) + decl
->offset
);
661 s
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
678 static int parse_long_option(struct isl_arg
*decl
, char **arg
,
679 const char *prefix
, void *opt
)
684 long *p
= (long *)(((char *)opt
) + decl
->offset
);
686 val
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
691 long l
= strtol(val
, NULL
, 0);
693 decl
->u
.l
.set(opt
, l
);
700 long l
= strtol(arg
[1], &endptr
, 0);
701 if (*endptr
== '\0') {
703 decl
->u
.l
.set(opt
, l
);
710 if (decl
->u
.l
.default_value
!= decl
->u
.l
.default_selected
) {
712 decl
->u
.l
.set(opt
, decl
->u
.l
.default_selected
);
714 *p
= decl
->u
.l
.default_selected
;
721 static int parse_ulong_option(struct isl_arg
*decl
, char **arg
,
722 const char *prefix
, void *opt
)
727 unsigned long *p
= (unsigned long *)(((char *)opt
) + decl
->offset
);
729 val
= skip_name(decl
, arg
[0], prefix
, 0, &has_argument
);
734 *p
= strtoul(val
, NULL
, 0);
739 unsigned long ul
= strtoul(arg
[1], &endptr
, 0);
740 if (*endptr
== '\0') {
749 static int parse_option(struct isl_arg
*decl
, char **arg
,
750 const char *prefix
, void *opt
);
752 static int parse_child_option(struct isl_arg
*decl
, char **arg
, void *opt
)
754 return parse_option(decl
->u
.child
.child
, arg
, decl
->long_name
,
755 *(void **)(((char *)opt
) + decl
->offset
));
758 static int parse_option(struct isl_arg
*decl
, char **arg
,
759 const char *prefix
, void *opt
)
763 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
765 switch (decl
[i
].type
) {
767 parsed
= parse_choice_option(&decl
[i
], arg
, prefix
, opt
);
770 parsed
= parse_flags_option(&decl
[i
], arg
, prefix
, opt
);
773 parsed
= parse_long_option(&decl
[i
], arg
, prefix
, opt
);
776 parsed
= parse_ulong_option(&decl
[i
], arg
, prefix
, opt
);
779 parsed
= parse_bool_option(&decl
[i
], *arg
, prefix
, opt
);
782 parsed
= parse_str_option(&decl
[i
], arg
, prefix
, opt
);
785 parsed
= parse_child_option(&decl
[i
], arg
, opt
);
789 case isl_arg_version
:
800 static int any_version(struct isl_arg
*decl
)
804 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
805 switch (decl
[i
].type
) {
806 case isl_arg_version
:
809 if (any_version(decl
[i
].u
.child
.child
))
820 static void print_version(struct isl_arg
*decl
)
824 for (i
= 0; decl
[i
].type
!= isl_arg_end
; ++i
) {
825 switch (decl
[i
].type
) {
826 case isl_arg_version
:
827 decl
[i
].u
.version
.print_version();
830 print_version(decl
[i
].u
.child
.child
);
838 static void print_version_and_exit(struct isl_arg
*decl
)
845 static int drop_argument(int argc
, char **argv
, int drop
, int n
)
847 for (; drop
< argc
; ++drop
)
848 argv
[drop
] = argv
[drop
+ n
];
853 static int n_arg(struct isl_arg
*arg
)
858 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
)
859 if (arg
[i
].type
== isl_arg_arg
)
865 int isl_arg_parse(struct isl_arg
*arg
, int argc
, char **argv
, void *opt
,
874 for (i
= 1; i
< argc
; ++i
) {
875 if (strcmp(argv
[i
], "--help") == 0)
876 print_help_and_exit(arg
, argv
[0]);
879 for (i
= 1; i
< argc
; ++i
) {
880 if ((strcmp(argv
[i
], "--version") == 0 ||
881 strcmp(argv
[i
], "-V") == 0) && any_version(arg
))
882 print_version_and_exit(arg
);
885 while (argc
> 1 + skip
) {
887 if (argv
[1 + skip
][0] != '-')
889 parsed
= parse_option(arg
, &argv
[1 + skip
], NULL
, opt
);
891 argc
= drop_argument(argc
, argv
, 1 + skip
, parsed
);
892 else if (ISL_FL_ISSET(flags
, ISL_ARG_ALL
)) {
893 fprintf(stderr
, "%s: unrecognized option: %s\n",
894 prog_name(argv
[0]), argv
[1 + skip
]);
900 if (ISL_FL_ISSET(flags
, ISL_ARG_ALL
) ? argc
!= 1 + n
901 : argc
< 1 + skip
+ n
) {
902 fprintf(stderr
, "%s: expecting %d arguments\n",
903 prog_name(argv
[0]), n
);
907 for (i
= 0; arg
[i
].type
!= isl_arg_end
; ++i
) {
909 if (arg
[i
].type
!= isl_arg_arg
)
911 str
= strdup(argv
[1 + skip
]);
912 *(const char **)(((char *)opt
) + arg
[i
].offset
) = str
;
913 argc
= drop_argument(argc
, argv
, 1 + skip
, 1);