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 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 void isl_args_set_defaults(struct isl_args *args, void *opt)
85 for (i = 0; args->args[i].type != isl_arg_end; ++i) {
86 switch (args->args[i].type) {
88 set_default_choice(&args->args[i], opt);
91 set_default_flags(&args->args[i], opt);
94 set_default_bool(&args->args[i], opt);
97 set_default_child(&args->args[i], opt);
100 set_default_user(&args->args[i], opt);
103 set_default_int(&args->args[i], opt);
106 set_default_long(&args->args[i], opt);
109 set_default_ulong(&args->args[i], opt);
113 set_default_str(&args->args[i], opt);
117 case isl_arg_version:
124 static void free_args(struct isl_arg *arg, void *opt)
128 for (i = 0; arg[i].type != isl_arg_end; ++i) {
129 switch (arg[i].type) {
131 if (arg[i].offset == (size_t) -1)
132 free_args(arg[i].u.child.child->args, opt);
134 isl_args_free(arg[i].u.child.child,
135 *(void **)(((char *)opt) + arg[i].offset));
139 free(*(char **)(((char *)opt) + arg[i].offset));
142 if (arg[i].u.user.clear)
143 arg[i].u.user.clear(((char *)opt) + arg[i].offset);
152 case isl_arg_version:
160 void isl_args_free(struct isl_args *args, void *opt)
165 free_args(args->args, opt);
170 static int print_arg_help(struct isl_arg *decl, const char *prefix, int no)
174 if (!decl->long_name) {
175 printf(" -%c", decl->short_name);
179 if (decl->short_name) {
180 printf(" -%c, --", decl->short_name);
182 } else if (decl->flags & ISL_ARG_SINGLE_DASH) {
191 printf("%s-", prefix);
192 len += strlen(prefix) + 1;
198 printf("%s", decl->long_name);
199 len += strlen(decl->long_name);
201 while ((++decl)->type == isl_arg_alias) {
208 printf("%s", decl->long_name);
209 len += strlen(decl->long_name);
215 const void *isl_memrchr(const void *s, int c, size_t n)
224 static int wrap_msg(const char *s, int indent, int pos)
227 int wrap_len = 75 - indent;
229 if (pos + 1 >= indent)
230 printf("\n%*s", indent, "");
232 printf("%*s", indent - pos, "");
235 while (len > wrap_len) {
236 const char *space = isl_memrchr(s, ' ', wrap_len);
240 space = strchr(s + wrap_len, ' ');
244 printf("%.*s", l, s);
247 printf("\n%*s", indent, "");
254 static int print_help_msg(struct isl_arg *decl, int pos)
259 return wrap_msg(decl->help_msg, 30, pos);
262 static void print_default(struct isl_arg *decl, const char *def, int pos)
264 const char *default_prefix = "[default: ";
265 const char *default_suffix = "]";
268 len = strlen(default_prefix) + strlen(def) + strlen(default_suffix);
270 if (!decl->help_msg) {
272 printf("\n%30s", "");
274 printf("%*s", 30 - pos, "");
278 printf("\n%30s", "");
282 printf("%s%s%s", default_prefix, def, default_suffix);
285 static void print_default_choice(struct isl_arg *decl, void *opt, int pos)
288 const char *s = "none";
291 p = (unsigned *)(((char *) opt) + decl->offset);
292 for (i = 0; decl->u.choice.choice[i].name; ++i)
293 if (decl->u.choice.choice[i].value == *p) {
294 s = decl->u.choice.choice[i].name;
298 print_default(decl, s, pos);
301 static void print_choice_help(struct isl_arg *decl, const char *prefix,
307 pos = print_arg_help(decl, prefix, 0);
311 for (i = 0; decl->u.choice.choice[i].name; ++i) {
316 printf("%s", decl->u.choice.choice[i].name);
317 pos += strlen(decl->u.choice.choice[i].name);
320 pos = print_help_msg(decl, pos);
321 print_default_choice(decl, opt, pos);
326 static void print_default_flags(struct isl_arg *decl, void *opt, int pos)
329 const char *default_prefix = "[default: ";
330 const char *default_suffix = "]";
331 int len = strlen(default_prefix) + strlen(default_suffix);
334 p = (unsigned *)(((char *) opt) + decl->offset);
335 for (i = 0; decl->u.flags.flags[i].name; ++i)
336 if ((*p & decl->u.flags.flags[i].mask) ==
337 decl->u.flags.flags[i].value)
338 len += strlen(decl->u.flags.flags[i].name);
340 if (!decl->help_msg) {
342 printf("\n%30s", "");
344 printf("%*s", 30 - pos, "");
348 printf("\n%30s", "");
352 printf("%s", default_prefix);
354 for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
355 if ((*p & decl->u.flags.flags[i].mask) ==
356 decl->u.flags.flags[i].value) {
359 printf("%s", decl->u.flags.flags[i].name);
363 printf("%s", default_suffix);
366 static void print_flags_help(struct isl_arg *decl, const char *prefix,
372 pos = print_arg_help(decl, prefix, 0);
376 for (i = 0; decl->u.flags.flags[i].name; ++i) {
382 decl->u.flags.flags[j].mask == decl->u.flags.flags[i].mask;
388 printf("%s", decl->u.flags.flags[j].name);
389 pos += strlen(decl->u.flags.flags[j].name);
394 pos = print_help_msg(decl, pos);
395 print_default_flags(decl, opt, pos);
400 static void print_bool_help(struct isl_arg *decl, const char *prefix, void *opt)
403 unsigned *p = opt ? (unsigned *)(((char *) opt) + decl->offset) : NULL;
404 int no = p ? *p == 1 : 0;
405 pos = print_arg_help(decl, prefix, no);
406 pos = print_help_msg(decl, pos);
407 if (decl->offset != (size_t) -1)
408 print_default(decl, no ? "yes" : "no", pos);
412 static int print_argument_name(struct isl_arg *decl, const char *name, int pos)
414 printf("%c<%s>", decl->long_name ? '=' : ' ', name);
415 return pos + 3 + strlen(name);
418 static void print_int_help(struct isl_arg *decl, const char *prefix, void *opt)
422 int *p = (int *)(((char *) opt) + decl->offset);
423 pos = print_arg_help(decl, prefix, 0);
424 pos = print_argument_name(decl, decl->argument_name, pos);
425 pos = print_help_msg(decl, pos);
426 snprintf(val, sizeof(val), "%d", *p);
427 print_default(decl, val, pos);
431 static void print_long_help(struct isl_arg *decl, const char *prefix, void *opt)
434 long *p = (long *)(((char *) opt) + decl->offset);
435 pos = print_arg_help(decl, prefix, 0);
436 if (*p != decl->u.l.default_selected) {
442 if (*p != decl->u.l.default_selected) {
446 print_help_msg(decl, pos);
450 static void print_ulong_help(struct isl_arg *decl, const char *prefix)
453 pos = print_arg_help(decl, prefix, 0);
456 print_help_msg(decl, pos);
460 static void print_str_help(struct isl_arg *decl, const char *prefix, void *opt)
463 const char *a = decl->argument_name ? decl->argument_name : "string";
464 const char **p = (const char **)(((char *) opt) + decl->offset);
465 pos = print_arg_help(decl, prefix, 0);
466 pos = print_argument_name(decl, a, pos);
467 pos = print_help_msg(decl, pos);
469 print_default(decl, *p, pos);
473 static void print_help(struct isl_arg *arg, const char *prefix, void *opt)
478 for (i = 0; arg[i].type != isl_arg_end; ++i) {
479 if (arg[i].flags & ISL_ARG_HIDDEN)
481 switch (arg[i].type) {
483 print_flags_help(&arg[i], prefix, opt);
487 print_choice_help(&arg[i], prefix, opt);
491 print_bool_help(&arg[i], prefix, opt);
495 print_int_help(&arg[i], prefix, opt);
499 print_long_help(&arg[i], prefix, opt);
503 print_ulong_help(&arg[i], prefix);
507 print_str_help(&arg[i], prefix, opt);
511 case isl_arg_version:
521 for (i = 0; arg[i].type != isl_arg_end; ++i) {
524 if (arg[i].type != isl_arg_child)
526 if (arg[i].flags & ISL_ARG_HIDDEN)
532 printf(" %s\n", arg[i].help_msg);
533 if (arg[i].offset == (size_t) -1)
536 child = *(void **)(((char *) opt) + arg[i].offset);
537 print_help(arg[i].u.child.child->args, arg[i].long_name, child);
542 static const char *prog_name(const char *prog)
546 slash = strrchr(prog, '/');
549 if (strncmp(prog, "lt-", 3) == 0)
555 static int any_version(struct isl_arg *decl)
559 for (i = 0; decl[i].type != isl_arg_end; ++i) {
560 switch (decl[i].type) {
561 case isl_arg_version:
564 if (any_version(decl[i].u.child.child->args))
575 static void print_help_and_exit(struct isl_arg *arg, const char *prog,
580 printf("Usage: %s [OPTION...]", prog_name(prog));
582 for (i = 0; arg[i].type != isl_arg_end; ++i)
583 if (arg[i].type == isl_arg_arg)
584 printf(" %s", arg[i].argument_name);
588 print_help(arg, NULL, opt);
590 if (any_version(arg))
591 printf(" -V, --version\n");
592 print_bool_help(help_arg, NULL, NULL);
594 for (i = 0; arg[i].type != isl_arg_end; ++i) {
595 if (arg[i].type != isl_arg_footer)
597 wrap_msg(arg[i].help_msg, 0, 0);
604 static int match_long_name(struct isl_arg *decl,
605 const char *start, const char *end)
608 if (end - start == strlen(decl->long_name) &&
609 !strncmp(start, decl->long_name, end - start))
611 } while ((++decl)->type == isl_arg_alias);
616 static const char *skip_dash_dash(struct isl_arg *decl, const char *arg)
618 if (!strncmp(arg, "--", 2))
620 if ((decl->flags & ISL_ARG_SINGLE_DASH) && arg[0] == '-')
625 static const char *skip_name(struct isl_arg *decl, const char *arg,
626 const char *prefix, int need_argument, int *has_argument)
632 if (arg[0] == '-' && arg[1] && arg[1] == decl->short_name) {
633 if (need_argument && !arg[2])
636 *has_argument = arg[2] != '\0';
639 if (!decl->long_name)
642 name = skip_dash_dash(decl, arg);
646 equal = strchr(name, '=');
647 if (need_argument && !equal)
651 *has_argument = !!equal;
652 end = equal ? equal : name + strlen(name);
655 size_t prefix_len = strlen(prefix);
656 if (strncmp(name, prefix, prefix_len) == 0 &&
657 name[prefix_len] == '-')
658 name += prefix_len + 1;
661 if (!match_long_name(decl, name, end))
664 return equal ? equal + 1 : end;
667 static int parse_choice_option(struct isl_arg *decl, char **arg,
668 const char *prefix, void *opt)
674 choice = skip_name(decl, arg[0], prefix, 0, &has_argument);
678 if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
679 unsigned u = decl->u.choice.default_selected;
680 if (decl->u.choice.set)
681 decl->u.choice.set(opt, u);
683 *(unsigned *)(((char *)opt) + decl->offset) = u;
691 for (i = 0; decl->u.choice.choice[i].name; ++i) {
694 if (strcmp(choice, decl->u.choice.choice[i].name))
697 u = decl->u.choice.choice[i].value;
698 if (decl->u.choice.set)
699 decl->u.choice.set(opt, u);
701 *(unsigned *)(((char *)opt) + decl->offset) = u;
703 return has_argument ? 1 : 2;
709 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
714 for (i = 0; decl->u.flags.flags[i].name; ++i) {
715 if (strncmp(flag, decl->u.flags.flags[i].name, len))
718 *val &= ~decl->u.flags.flags[i].mask;
719 *val |= decl->u.flags.flags[i].value;
727 static int parse_flags_option(struct isl_arg *decl, char **arg,
728 const char *prefix, void *opt)
735 flags = skip_name(decl, arg[0], prefix, 0, &has_argument);
739 if (!has_argument && !arg[1])
745 val = *(unsigned *)(((char *)opt) + decl->offset);
747 while ((comma = strchr(flags, ',')) != NULL) {
748 if (!set_flag(decl, &val, flags, comma - flags))
752 if (!set_flag(decl, &val, flags, strlen(flags)))
755 *(unsigned *)(((char *)opt) + decl->offset) = val;
757 return has_argument ? 1 : 2;
760 static int parse_bool_option(struct isl_arg *decl, char **arg,
761 const char *prefix, void *opt)
764 unsigned *p = (unsigned *)(((char *)opt) + decl->offset);
766 if (skip_name(decl, arg[0], prefix, 0, NULL)) {
767 if ((decl->flags & ISL_ARG_BOOL_ARG) && arg[1]) {
769 int val = strtol(arg[1], &endptr, 0);
770 if (*endptr == '\0' && (val == 0 || val == 1)) {
772 decl->u.b.set(opt, val);
773 else if (decl->offset != (size_t) -1)
779 decl->u.b.set(opt, 1);
780 else if (decl->offset != (size_t) -1)
786 if (!decl->long_name)
789 name = skip_dash_dash(decl, arg[0]);
794 size_t prefix_len = strlen(prefix);
795 if (strncmp(name, prefix, prefix_len) == 0 &&
796 name[prefix_len] == '-') {
797 name += prefix_len + 1;
802 if (strncmp(name, "no-", 3))
807 size_t prefix_len = strlen(prefix);
808 if (strncmp(name, prefix, prefix_len) == 0 &&
809 name[prefix_len] == '-')
810 name += prefix_len + 1;
813 if (match_long_name(decl, name, name + strlen(name))) {
815 decl->u.b.set(opt, 0);
816 else if (decl->offset != (size_t) -1)
825 static int parse_str_option(struct isl_arg *decl, char **arg,
826 const char *prefix, void *opt)
830 char **p = (char **)(((char *)opt) + decl->offset);
832 s = skip_name(decl, arg[0], prefix, 0, &has_argument);
851 static int parse_int_option(struct isl_arg *decl, char **arg,
852 const char *prefix, void *opt)
857 int *p = (int *)(((char *)opt) + decl->offset);
859 val = skip_name(decl, arg[0], prefix, 0, &has_argument);
869 int i = strtol(arg[1], &endptr, 0);
870 if (*endptr == '\0') {
879 static int parse_long_option(struct isl_arg *decl, char **arg,
880 const char *prefix, void *opt)
885 long *p = (long *)(((char *)opt) + decl->offset);
887 val = skip_name(decl, arg[0], prefix, 0, &has_argument);
892 long l = strtol(val, NULL, 0);
894 decl->u.l.set(opt, l);
901 long l = strtol(arg[1], &endptr, 0);
902 if (*endptr == '\0') {
904 decl->u.l.set(opt, l);
911 if (decl->u.l.default_value != decl->u.l.default_selected) {
913 decl->u.l.set(opt, decl->u.l.default_selected);
915 *p = decl->u.l.default_selected;
922 static int parse_ulong_option(struct isl_arg *decl, char **arg,
923 const char *prefix, void *opt)
928 unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
930 val = skip_name(decl, arg[0], prefix, 0, &has_argument);
935 *p = strtoul(val, NULL, 0);
940 unsigned long ul = strtoul(arg[1], &endptr, 0);
941 if (*endptr == '\0') {
950 static int parse_option(struct isl_arg *decl, char **arg,
951 const char *prefix, void *opt);
953 static int parse_child_option(struct isl_arg *decl, char **arg,
954 const char *prefix, void *opt)
958 if (decl->offset == (size_t) -1)
961 child = *(void **)(((char *)opt) + decl->offset);
962 prefix = decl->long_name;
964 return parse_option(decl->u.child.child->args, arg, prefix, child);
967 static int parse_option(struct isl_arg *decl, char **arg,
968 const char *prefix, void *opt)
972 for (i = 0; decl[i].type != isl_arg_end; ++i) {
974 switch (decl[i].type) {
976 parsed = parse_choice_option(&decl[i], arg, prefix, opt);
979 parsed = parse_flags_option(&decl[i], arg, prefix, opt);
982 parsed = parse_int_option(&decl[i], arg, prefix, opt);
985 parsed = parse_long_option(&decl[i], arg, prefix, opt);
988 parsed = parse_ulong_option(&decl[i], arg, prefix, opt);
991 parsed = parse_bool_option(&decl[i], arg, prefix, opt);
994 parsed = parse_str_option(&decl[i], arg, prefix, opt);
997 parsed = parse_child_option(&decl[i], arg, prefix, opt);
1001 case isl_arg_footer:
1003 case isl_arg_version:
1014 static void print_version(struct isl_arg *decl)
1018 for (i = 0; decl[i].type != isl_arg_end; ++i) {
1019 switch (decl[i].type) {
1020 case isl_arg_version:
1021 decl[i].u.version.print_version();
1024 print_version(decl[i].u.child.child->args);
1032 static void print_version_and_exit(struct isl_arg *decl)
1034 print_version(decl);
1039 static int drop_argument(int argc, char **argv, int drop, int n)
1041 for (; drop < argc; ++drop)
1042 argv[drop] = argv[drop + n];
1047 static int n_arg(struct isl_arg *arg)
1052 for (i = 0; arg[i].type != isl_arg_end; ++i)
1053 if (arg[i].type == isl_arg_arg)
1059 static int next_arg(struct isl_arg *arg, int a)
1061 for (++a; arg[a].type != isl_arg_end; ++a)
1062 if (arg[a].type == isl_arg_arg)
1068 int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
1076 n = n_arg(args->args);
1078 for (i = 1; i < argc; ++i) {
1079 if (strcmp(argv[i], "--help") == 0)
1080 print_help_and_exit(args->args, argv[0], opt);
1083 for (i = 1; i < argc; ++i) {
1084 if ((strcmp(argv[i], "--version") == 0 ||
1085 strcmp(argv[i], "-V") == 0) && any_version(args->args))
1086 print_version_and_exit(args->args);
1089 while (argc > 1 + skip) {
1091 if (argv[1 + skip][0] != '-') {
1092 a = next_arg(args->args, a);
1095 p = (char **)(((char *)opt)+args->args[a].offset);
1097 *p = strdup(argv[1 + skip]);
1098 argc = drop_argument(argc, argv, 1 + skip, 1);
1100 } else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1101 fprintf(stderr, "%s: extra argument: %s\n",
1102 prog_name(argv[0]), argv[1 + skip]);
1108 parsed = parse_option(args->args, &argv[1 + skip], NULL, opt);
1110 argc = drop_argument(argc, argv, 1 + skip, parsed);
1111 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1112 fprintf(stderr, "%s: unrecognized option: %s\n",
1113 prog_name(argv[0]), argv[1 + skip]);
1120 fprintf(stderr, "%s: expecting %d more argument(s)\n",
1121 prog_name(argv[0]), n);