X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_arg.c;h=0963aa126c8fbec8160158bc8ddad2025f0196f3;hb=db282322bea9eb89e9141849a430c32fcb94ad58;hp=75c22fc5d036f1e3c57aca4593244cc5ea884831;hpb=b3a1c1aad05e4336458b5edadad6a1cdbc4c9cd5;p=platform%2Fupstream%2Fisl.git

diff --git a/isl_arg.c b/isl_arg.c
index 75c22fc..0963aa1 100644
--- a/isl_arg.c
+++ b/isl_arg.c
@@ -1,7 +1,7 @@
 /*
  * 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
@@ -16,7 +16,6 @@
 
 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)
@@ -43,12 +42,12 @@ static void set_default_child(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)
@@ -79,39 +78,48 @@ static void set_default_str(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:
@@ -122,6 +130,34 @@ void isl_arg_set_defaults(struct isl_arg *arg, void *opt)
 	}
 }
 
+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;
@@ -129,19 +165,17 @@ static void free_args(struct isl_arg *arg, void *opt)
 	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:
@@ -158,12 +192,12 @@ static void free_args(struct isl_arg *arg, void *opt)
 	}
 }
 
-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);
 }
@@ -471,6 +505,16 @@ static void print_str_help(struct isl_arg *decl, const char *prefix, void *opt)
 	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);
+	printf("\n");
+}
+
 static void print_help(struct isl_arg *arg, const char *prefix, void *opt)
 {
 	int i;
@@ -508,6 +552,10 @@ static void print_help(struct isl_arg *arg, const char *prefix, void *opt)
 			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:
 		case isl_arg_version:
 		case isl_arg_arg:
@@ -535,7 +583,7 @@ static void print_help(struct isl_arg *arg, const char *prefix, void *opt)
 			child = opt;
 		else
 			child = *(void **)(((char *) opt) + arg[i].offset);
-		print_help(arg[i].u.child.child, arg[i].long_name, child);
+		print_help(arg[i].u.child.child->args, arg[i].long_name, child);
 		any = 1;
 	}
 }
@@ -562,7 +610,7 @@ static int any_version(struct isl_arg *decl)
 		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:
@@ -678,10 +726,9 @@ static int parse_choice_option(struct isl_arg *decl, char **arg,
 
 	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;
 	}
@@ -696,10 +743,9 @@ static int parse_choice_option(struct isl_arg *decl, char **arg,
 			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;
 	}
@@ -743,7 +789,7 @@ static int parse_flags_option(struct isl_arg *decl, char **arg,
 	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))
@@ -769,17 +815,17 @@ static int parse_bool_option(struct isl_arg *decl, char **arg,
 			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;
 	}
@@ -812,10 +858,10 @@ static int parse_bool_option(struct isl_arg *decl, char **arg,
 	}
 
 	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;
 	}
@@ -849,6 +895,44 @@ static int parse_str_option(struct isl_arg *decl, char **arg,
 	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)
 {
@@ -891,29 +975,26 @@ static int parse_long_option(struct isl_arg *decl, char **arg,
 
 	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;
 	}
 
@@ -962,7 +1043,7 @@ static int parse_child_option(struct isl_arg *decl, char **arg,
 		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,
@@ -994,6 +1075,10 @@ 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;
@@ -1022,7 +1107,7 @@ static void print_version(struct isl_arg *decl)
 			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;
@@ -1039,7 +1124,7 @@ static void print_version_and_exit(struct isl_arg *decl)
 
 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;
@@ -1066,7 +1151,20 @@ static int next_arg(struct isl_arg *arg, int a)
 	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;
@@ -1074,26 +1172,21 @@ int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
 	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], opt);
-	}
+	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);
@@ -1106,7 +1199,8 @@ int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
 				++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)) {