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);