/*
* Copyright 2008-2009 Katholieke Universiteit Leuven
*
- * Use of this software is governed by the GNU LGPLv2.1 license
+ * Use of this software is governed by the MIT license
*
* Written by Sven Verdoolaege, K.U.Leuven, Departement
* Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
static struct isl_arg help_arg[] = {
ISL_ARG_PHANTOM_BOOL('h', "help", NULL, "print this help, then exit")
-ISL_ARG_END
};
static void set_default_choice(struct isl_arg *arg, void *opt)
if (arg->offset == (size_t) -1)
child = opt;
else {
- child = calloc(1, arg->u.child.size);
+ child = calloc(1, arg->u.child.child->options_size);
*(void **)(((char *)opt) + arg->offset) = child;
}
if (child)
- isl_arg_set_defaults(arg->u.child.child, child);
+ isl_args_set_defaults(arg->u.child.child, child);
}
static void set_default_user(struct isl_arg *arg, void *opt)
*(const char **)(((char *)opt) + arg->offset) = str;
}
-void isl_arg_set_defaults(struct isl_arg *arg, void *opt)
+static void set_default_str_list(struct isl_arg *arg, void *opt)
+{
+ *(const char ***)(((char *) opt) + arg->offset) = NULL;
+ *(int *)(((char *) opt) + arg->u.str_list.offset_n) = 0;
+}
+
+void isl_args_set_defaults(struct isl_args *args, void *opt)
{
int i;
- for (i = 0; arg[i].type != isl_arg_end; ++i) {
- switch (arg[i].type) {
+ for (i = 0; args->args[i].type != isl_arg_end; ++i) {
+ switch (args->args[i].type) {
case isl_arg_choice:
- set_default_choice(&arg[i], opt);
+ set_default_choice(&args->args[i], opt);
break;
case isl_arg_flags:
- set_default_flags(&arg[i], opt);
+ set_default_flags(&args->args[i], opt);
break;
case isl_arg_bool:
- set_default_bool(&arg[i], opt);
+ set_default_bool(&args->args[i], opt);
break;
case isl_arg_child:
- set_default_child(&arg[i], opt);
+ set_default_child(&args->args[i], opt);
break;
case isl_arg_user:
- set_default_user(&arg[i], opt);
+ set_default_user(&args->args[i], opt);
break;
case isl_arg_int:
- set_default_int(&arg[i], opt);
+ set_default_int(&args->args[i], opt);
break;
case isl_arg_long:
- set_default_long(&arg[i], opt);
+ set_default_long(&args->args[i], opt);
break;
case isl_arg_ulong:
- set_default_ulong(&arg[i], opt);
+ set_default_ulong(&args->args[i], opt);
break;
case isl_arg_arg:
case isl_arg_str:
- set_default_str(&arg[i], opt);
+ set_default_str(&args->args[i], opt);
+ break;
+ case isl_arg_str_list:
+ set_default_str_list(&args->args[i], opt);
break;
case isl_arg_alias:
case isl_arg_footer:
}
}
+static void free_args(struct isl_arg *arg, void *opt);
+
+static void free_child(struct isl_arg *arg, void *opt)
+{
+ if (arg->offset == (size_t) -1)
+ free_args(arg->u.child.child->args, opt);
+ else
+ isl_args_free(arg->u.child.child,
+ *(void **)(((char *)opt) + arg->offset));
+}
+
+static void free_str_list(struct isl_arg *arg, void *opt)
+{
+ int i;
+ int n = *(int *)(((char *) opt) + arg->u.str_list.offset_n);
+ char **list = *(char ***)(((char *) opt) + arg->offset);
+
+ for (i = 0; i < n; ++i)
+ free(list[i]);
+ free(list);
+}
+
+static void free_user(struct isl_arg *arg, void *opt)
+{
+ if (arg->u.user.clear)
+ arg->u.user.clear(((char *)opt) + arg->offset);
+}
+
static void free_args(struct isl_arg *arg, void *opt)
{
int i;
for (i = 0; arg[i].type != isl_arg_end; ++i) {
switch (arg[i].type) {
case isl_arg_child:
- if (arg[i].offset == (size_t) -1)
- free_args(arg[i].u.child.child, opt);
- else
- isl_arg_free(arg[i].u.child.child,
- *(void **)(((char *)opt) + arg[i].offset));
+ free_child(&arg[i], opt);
break;
case isl_arg_arg:
case isl_arg_str:
free(*(char **)(((char *)opt) + arg[i].offset));
break;
+ case isl_arg_str_list:
+ free_str_list(&arg[i], opt);
+ break;
case isl_arg_user:
- if (arg[i].u.user.clear)
- arg[i].u.user.clear(((char *)opt) + arg[i].offset);
+ free_user(&arg[i], opt);
break;
case isl_arg_alias:
case isl_arg_bool:
}
}
-void isl_arg_free(struct isl_arg *arg, void *opt)
+void isl_args_free(struct isl_args *args, void *opt)
{
if (!opt)
return;
- free_args(arg, opt);
+ free_args(args->args, opt);
free(opt);
}
printf("%s%s%s", default_prefix, def, default_suffix);
}
-static void print_default_choice(struct isl_arg *decl, int pos)
+static void print_default_choice(struct isl_arg *decl, void *opt, int pos)
{
int i;
const char *s = "none";
+ unsigned *p;
+ p = (unsigned *)(((char *) opt) + decl->offset);
for (i = 0; decl->u.choice.choice[i].name; ++i)
- if (decl->u.choice.choice[i].value == decl->u.choice.default_value) {
+ if (decl->u.choice.choice[i].value == *p) {
s = decl->u.choice.choice[i].name;
break;
}
print_default(decl, s, pos);
}
-static void print_choice_help(struct isl_arg *decl, const char *prefix)
+static void print_choice_help(struct isl_arg *decl, const char *prefix,
+ void *opt)
{
int i;
int pos;
}
pos = print_help_msg(decl, pos);
- print_default_choice(decl, pos);
+ print_default_choice(decl, opt, pos);
printf("\n");
}
-static void print_default_flags(struct isl_arg *decl, int pos)
+static void print_default_flags(struct isl_arg *decl, void *opt, int pos)
{
int i, first;
const char *default_prefix = "[default: ";
const char *default_suffix = "]";
int len = strlen(default_prefix) + strlen(default_suffix);
+ unsigned *p;
+ p = (unsigned *)(((char *) opt) + decl->offset);
for (i = 0; decl->u.flags.flags[i].name; ++i)
- if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
+ if ((*p & decl->u.flags.flags[i].mask) ==
decl->u.flags.flags[i].value)
len += strlen(decl->u.flags.flags[i].name);
printf("%s", default_prefix);
for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
- if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
+ if ((*p & decl->u.flags.flags[i].mask) ==
decl->u.flags.flags[i].value) {
if (!first)
printf(",");
printf("%s", default_suffix);
}
-static void print_flags_help(struct isl_arg *decl, const char *prefix)
+static void print_flags_help(struct isl_arg *decl, const char *prefix,
+ void *opt)
{
int i, j;
int pos;
}
pos = print_help_msg(decl, pos);
- print_default_flags(decl, pos);
+ print_default_flags(decl, opt, pos);
printf("\n");
}
-static void print_bool_help(struct isl_arg *decl, const char *prefix)
+static void print_bool_help(struct isl_arg *decl, const char *prefix, void *opt)
{
int pos;
- int no = decl->u.b.default_value == 1;
+ unsigned *p = opt ? (unsigned *)(((char *) opt) + decl->offset) : NULL;
+ int no = p ? *p == 1 : 0;
pos = print_arg_help(decl, prefix, no);
pos = print_help_msg(decl, pos);
if (decl->offset != (size_t) -1)
return pos + 3 + strlen(name);
}
-static void print_int_help(struct isl_arg *decl, const char *prefix)
+static void print_int_help(struct isl_arg *decl, const char *prefix, void *opt)
{
int pos;
char val[20];
+ int *p = (int *)(((char *) opt) + decl->offset);
pos = print_arg_help(decl, prefix, 0);
pos = print_argument_name(decl, decl->argument_name, pos);
pos = print_help_msg(decl, pos);
- snprintf(val, sizeof(val), "%d", decl->u.i.default_value);
+ snprintf(val, sizeof(val), "%d", *p);
print_default(decl, val, pos);
printf("\n");
}
-static void print_long_help(struct isl_arg *decl, const char *prefix)
+static void print_long_help(struct isl_arg *decl, const char *prefix, void *opt)
{
int pos;
+ long *p = (long *)(((char *) opt) + decl->offset);
pos = print_arg_help(decl, prefix, 0);
- if (decl->u.l.default_value != decl->u.l.default_selected) {
+ if (*p != decl->u.l.default_selected) {
printf("[");
pos++;
}
printf("=long");
pos += 5;
- if (decl->u.l.default_value != decl->u.l.default_selected) {
+ if (*p != decl->u.l.default_selected) {
printf("]");
pos++;
}
printf("\n");
}
-static void print_str_help(struct isl_arg *decl, const char *prefix)
+static void print_str_help(struct isl_arg *decl, const char *prefix, void *opt)
+{
+ int pos;
+ const char *a = decl->argument_name ? decl->argument_name : "string";
+ const char **p = (const char **)(((char *) opt) + decl->offset);
+ pos = print_arg_help(decl, prefix, 0);
+ pos = print_argument_name(decl, a, pos);
+ pos = print_help_msg(decl, pos);
+ if (*p)
+ print_default(decl, *p, pos);
+ printf("\n");
+}
+
+static void print_str_list_help(struct isl_arg *decl, const char *prefix)
{
int pos;
const char *a = decl->argument_name ? decl->argument_name : "string";
pos = print_arg_help(decl, prefix, 0);
pos = print_argument_name(decl, a, pos);
pos = print_help_msg(decl, pos);
- if (decl->u.str.default_value)
- print_default(decl, decl->u.str.default_value, pos);
printf("\n");
}
-static void print_help(struct isl_arg *arg, const char *prefix)
+static void print_help(struct isl_arg *arg, const char *prefix, void *opt)
{
int i;
int any = 0;
continue;
switch (arg[i].type) {
case isl_arg_flags:
- print_flags_help(&arg[i], prefix);
+ print_flags_help(&arg[i], prefix, opt);
any = 1;
break;
case isl_arg_choice:
- print_choice_help(&arg[i], prefix);
+ print_choice_help(&arg[i], prefix, opt);
any = 1;
break;
case isl_arg_bool:
- print_bool_help(&arg[i], prefix);
+ print_bool_help(&arg[i], prefix, opt);
any = 1;
break;
case isl_arg_int:
- print_int_help(&arg[i], prefix);
+ print_int_help(&arg[i], prefix, opt);
any = 1;
break;
case isl_arg_long:
- print_long_help(&arg[i], prefix);
+ print_long_help(&arg[i], prefix, opt);
any = 1;
break;
case isl_arg_ulong:
any = 1;
break;
case isl_arg_str:
- print_str_help(&arg[i], prefix);
+ print_str_help(&arg[i], prefix, opt);
+ any = 1;
+ break;
+ case isl_arg_str_list:
+ print_str_list_help(&arg[i], prefix);
any = 1;
break;
case isl_arg_alias:
}
for (i = 0; arg[i].type != isl_arg_end; ++i) {
+ void *child;
+
if (arg[i].type != isl_arg_child)
continue;
if (arg[i].flags & ISL_ARG_HIDDEN)
printf("\n");
if (arg[i].help_msg)
printf(" %s\n", arg[i].help_msg);
- print_help(arg[i].u.child.child, arg[i].long_name);
+ if (arg[i].offset == (size_t) -1)
+ child = opt;
+ else
+ child = *(void **)(((char *) opt) + arg[i].offset);
+ print_help(arg[i].u.child.child->args, arg[i].long_name, child);
any = 1;
}
}
case isl_arg_version:
return 1;
case isl_arg_child:
- if (any_version(decl[i].u.child.child))
+ if (any_version(decl[i].u.child.child->args))
return 1;
break;
default:
return 0;
}
-static void print_help_and_exit(struct isl_arg *arg, const char *prog)
+static void print_help_and_exit(struct isl_arg *arg, const char *prog,
+ void *opt)
{
int i;
printf("\n\n");
- print_help(arg, NULL);
+ print_help(arg, NULL, opt);
printf("\n");
if (any_version(arg))
printf(" -V, --version\n");
- print_bool_help(help_arg, NULL);
+ print_bool_help(help_arg, NULL, NULL);
for (i = 0; arg[i].type != isl_arg_end; ++i) {
if (arg[i].type != isl_arg_footer)
if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
unsigned u = decl->u.choice.default_selected;
+ *(unsigned *)(((char *)opt) + decl->offset) = u;
if (decl->u.choice.set)
decl->u.choice.set(opt, u);
- else
- *(unsigned *)(((char *)opt) + decl->offset) = u;
return 1;
}
continue;
u = decl->u.choice.choice[i].value;
+ *(unsigned *)(((char *)opt) + decl->offset) = u;
if (decl->u.choice.set)
decl->u.choice.set(opt, u);
- else
- *(unsigned *)(((char *)opt) + decl->offset) = u;
return has_argument ? 1 : 2;
}
if (!has_argument)
flags = arg[1];
- val = *(unsigned *)(((char *)opt) + decl->offset);
+ val = 0;
while ((comma = strchr(flags, ',')) != NULL) {
if (!set_flag(decl, &val, flags, comma - flags))
char *endptr;
int val = strtol(arg[1], &endptr, 0);
if (*endptr == '\0' && (val == 0 || val == 1)) {
+ if (decl->offset != (size_t) -1)
+ *p = val;
if (decl->u.b.set)
decl->u.b.set(opt, val);
- else if (decl->offset != (size_t) -1)
- *p = val;
return 2;
}
}
+ if (decl->offset != (size_t) -1)
+ *p = 1;
if (decl->u.b.set)
decl->u.b.set(opt, 1);
- else if (decl->offset != (size_t) -1)
- *p = 1;
return 1;
}
}
if (match_long_name(decl, name, name + strlen(name))) {
+ if (decl->offset != (size_t) -1)
+ *p = 0;
if (decl->u.b.set)
decl->u.b.set(opt, 0);
- else if (decl->offset != (size_t) -1)
- *p = 0;
return 1;
}
return 0;
}
+static int isl_arg_str_list_append(struct isl_arg *decl, void *opt,
+ const char *s)
+{
+ int *n = (int *)(((char *) opt) + decl->u.str_list.offset_n);
+ char **list = *(char ***)(((char *) opt) + decl->offset);
+
+ list = realloc(list, (*n + 1) * sizeof(char *));
+ if (!list)
+ return -1;
+ *(char ***)(((char *) opt) + decl->offset) = list;
+ list[*n] = strdup(s);
+ (*n)++;
+ return 0;
+}
+
+static int parse_str_list_option(struct isl_arg *decl, char **arg,
+ const char *prefix, void *opt)
+{
+ int has_argument;
+ const char *s;
+
+ s = skip_name(decl, arg[0], prefix, 0, &has_argument);
+ if (!s)
+ return 0;
+
+ if (has_argument) {
+ isl_arg_str_list_append(decl, opt, s);
+ return 1;
+ }
+
+ if (arg[1]) {
+ isl_arg_str_list_append(decl, opt, arg[1]);
+ return 2;
+ }
+
+ return 0;
+}
+
static int parse_int_option(struct isl_arg *decl, char **arg,
const char *prefix, void *opt)
{
if (has_argument) {
long l = strtol(val, NULL, 0);
+ *p = l;
if (decl->u.l.set)
decl->u.l.set(opt, l);
- else
- *p = l;
return 1;
}
if (arg[1]) {
long l = strtol(arg[1], &endptr, 0);
if (*endptr == '\0') {
+ *p = l;
if (decl->u.l.set)
decl->u.l.set(opt, l);
- else
- *p = l;
return 2;
}
}
if (decl->u.l.default_value != decl->u.l.default_selected) {
+ *p = decl->u.l.default_selected;
if (decl->u.l.set)
decl->u.l.set(opt, decl->u.l.default_selected);
- else
- *p = decl->u.l.default_selected;
return 1;
}
child = *(void **)(((char *)opt) + decl->offset);
prefix = decl->long_name;
}
- return parse_option(decl->u.child.child, arg, prefix, child);
+ return parse_option(decl->u.child.child->args, arg, prefix, child);
}
static int parse_option(struct isl_arg *decl, char **arg,
case isl_arg_str:
parsed = parse_str_option(&decl[i], arg, prefix, opt);
break;
+ case isl_arg_str_list:
+ parsed = parse_str_list_option(&decl[i], arg, prefix,
+ opt);
+ break;
case isl_arg_child:
parsed = parse_child_option(&decl[i], arg, prefix, opt);
break;
decl[i].u.version.print_version();
break;
case isl_arg_child:
- print_version(decl[i].u.child.child);
+ print_version(decl[i].u.child.child->args);
break;
default:
break;
static int drop_argument(int argc, char **argv, int drop, int n)
{
- for (; drop < argc; ++drop)
+ for (; drop + n < argc; ++drop)
argv[drop] = argv[drop + n];
return argc - n;
return -1;
}
-int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
+/* Unless ISL_ARG_SKIP_HELP is set, check if "arg" is
+ * equal to "--help" and if so call print_help_and_exit.
+ */
+static void check_help(struct isl_args *args, char *arg, char *prog, void *opt,
+ unsigned flags)
+{
+ if (ISL_FL_ISSET(flags, ISL_ARG_SKIP_HELP))
+ return;
+
+ if (strcmp(arg, "--help") == 0)
+ print_help_and_exit(args->args, prog, opt);
+}
+
+int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
unsigned flags)
{
int a = -1;
int i;
int n;
- n = n_arg(arg);
-
- for (i = 1; i < argc; ++i) {
- if (strcmp(argv[i], "--help") == 0)
- print_help_and_exit(arg, argv[0]);
- }
+ n = n_arg(args->args);
for (i = 1; i < argc; ++i) {
if ((strcmp(argv[i], "--version") == 0 ||
- strcmp(argv[i], "-V") == 0) && any_version(arg))
- print_version_and_exit(arg);
+ strcmp(argv[i], "-V") == 0) && any_version(args->args))
+ print_version_and_exit(args->args);
}
while (argc > 1 + skip) {
int parsed;
if (argv[1 + skip][0] != '-') {
- a = next_arg(arg, a);
+ a = next_arg(args->args, a);
if (a >= 0) {
char **p;
- p = (char **)(((char *)opt)+arg[a].offset);
+ p = (char **)(((char *)opt)+args->args[a].offset);
free(*p);
*p = strdup(argv[1 + skip]);
argc = drop_argument(argc, argv, 1 + skip, 1);
++skip;
continue;
}
- parsed = parse_option(arg, &argv[1 + skip], NULL, opt);
+ check_help(args, argv[1 + skip], argv[0], opt, flags);
+ parsed = parse_option(args->args, &argv[1 + skip], NULL, opt);
if (parsed)
argc = drop_argument(argc, argv, 1 + skip, parsed);
else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
projects / platform / upstream / isl.git / blobdiff