===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/tmux/arguments.c,v
retrieving revision 1.42
retrieving revision 1.43
diff -u -r1.42 -r1.43
--- src/usr.bin/tmux/arguments.c	2021/08/21 18:39:07	1.42
+++ src/usr.bin/tmux/arguments.c	2021/08/21 20:46:43	1.43
@@ -1,4 +1,4 @@
-/* $OpenBSD: arguments.c,v 1.42 2021/08/21 18:39:07 nicm Exp $ */
+/* $OpenBSD: arguments.c,v 1.43 2021/08/21 20:46:43 nicm Exp $ */
 
 /*
  * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -40,8 +40,8 @@
 
 struct args {
 	struct args_tree	  tree;
-	int			  argc;
-	char			**argv;
+	u_int			 count;
+	struct args_value	*values;
 };
 
 static struct args_entry	*args_find(struct args *, u_char);
@@ -66,17 +66,37 @@
 	return (RB_FIND(args_tree, &args->tree, &entry));
 }
 
+/* Copy value. */
+static void
+args_copy_value(struct args_value *to, struct args_value *from)
+{
+	to->type = from->type;
+	switch (from->type) {
+	case ARGS_NONE:
+		break;
+	case ARGS_COMMANDS:
+		to->cmdlist = from->cmdlist;
+		to->cmdlist->references++;
+		break;
+	case ARGS_STRING:
+		to->string = xstrdup(from->string);
+		break;
+	}
+}
+
 /* Get value as string. */
-static char *
+static const char *
 args_value_as_string(struct args_value *value)
 {
 	switch (value->type) {
 	case ARGS_NONE:
-		return (xstrdup(""));
+		return ("");
 	case ARGS_COMMANDS:
-		return (cmd_list_print(value->cmdlist, 0));
+		if (value->cached == NULL)
+			value->cached = cmd_list_print(value->cmdlist, 0);
+		return (value->cached);
 	case ARGS_STRING:
-		return (xstrdup(value->string));
+		return (value->string);
 	}
 }
 
@@ -98,10 +118,9 @@
 {
 	struct args		*args;
 	u_int		 	 i;
-	struct args_value	*value;
+	struct args_value	*value, *new;
 	u_char			 flag, argument;
-	const char		*found, *string;
-	char			*s;
+	const char		*found, *string, *s;
 
 	if (count == 0)
 		return (args_create());
@@ -109,11 +128,6 @@
 	args = args_create();
 	for (i = 1; i < count; /* nothing */) {
 		value = &values[i];
-
-		s = args_value_as_string(value);
-		log_debug("%s: %u = %s", __func__, i, s);
-		free(s);
-
 		if (value->type != ARGS_STRING)
 			break;
 
@@ -143,18 +157,20 @@
 				args_set(args, flag, NULL);
 				continue;
 			}
-			if (*string != '\0')
-				s = xstrdup(string);
-			else {
+			new = xcalloc(1, sizeof *value);
+			if (*string != '\0') {
+				new->type = ARGS_STRING;
+				new->string = xstrdup(string);
+			} else {
 				if (i == count) {
 					args_free(args);
 					return (NULL);
 				}
-				s = args_value_as_string(&values[i++]);
+				args_copy_value(new, &values[i++]);
 			}
+			s = args_value_as_string(new);
 			log_debug("%s: add -%c = %s", __func__, flag, s);
-			args_set(args, flag, s);
-			free(s);
+			args_set(args, flag, new);
 			break;
 		}
 	}
@@ -165,13 +181,15 @@
 
 			s = args_value_as_string(value);
 			log_debug("%s: %u = %s", __func__, i, s);
-			cmd_append_argv(&args->argc, &args->argv, s);
-			free(s);
+
+			args->values = xrecallocarray(args->values,
+			    args->count, args->count + 1, sizeof *args->values);
+			args_copy_value(&args->values[args->count++], value);
 		}
 	}
 
-	if ((parse->lower != -1 && args->argc < parse->lower) ||
-	    (parse->upper != -1 && args->argc > parse->upper)) {
+	if ((parse->lower != -1 && args->count < (u_int)parse->lower) ||
+	    (parse->upper != -1 && args->count > (u_int)parse->upper)) {
 		args_free(args);
 		return (NULL);
 	}
@@ -192,6 +210,7 @@
 		cmd_list_free(value->cmdlist);
 		break;
 	}
+	free(value->cached);
 }
 
 /* Free an arguments set. */
@@ -202,8 +221,11 @@
 	struct args_entry	*entry1;
 	struct args_value	*value;
 	struct args_value	*value1;
+	u_int			 i;
 
-	cmd_free_argv(args->argc, args->argv);
+	for (i = 0; i < args->count; i++)
+		args_free_value(&args->values[i]);
+	free(args->values);
 
 	RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
 		RB_REMOVE(args_tree, &args->tree, entry);
@@ -222,8 +244,16 @@
 void
 args_vector(struct args *args, int *argc, char ***argv)
 {
-	*argc = args->argc;
-	*argv = cmd_copy_argv(args->argc, args->argv);
+	struct args_value	*value;
+	u_int			 i;
+
+	*argc = 0;
+	*argv = NULL;
+
+	for (i = 0; i < args->count; i++) {
+		value = &args->values[i];
+		cmd_append_argv(argc, argv, args_value_as_string(value));
+	}
 }
 
 /* Add to string. */
@@ -245,18 +275,28 @@
 	free(s);
 }
 
-/* Add argument to string. */
+/* Add value to string. */
 static void
-args_print_add_argument(char **buf, size_t *len, const char *argument)
+args_print_add_value(char **buf, size_t *len, struct args_value *value)
 {
-	char	*escaped;
+	char	*expanded = NULL;
 
 	if (**buf != '\0')
 		args_print_add(buf, len, " ");
 
-	escaped = args_escape(argument);
-	args_print_add(buf, len, "%s", escaped);
-	free(escaped);
+	switch (value->type) {
+	case ARGS_NONE:
+		break;
+	case ARGS_COMMANDS:
+		expanded = cmd_list_print(value->cmdlist, 0);
+		args_print_add(buf, len, "{ %s }", expanded);
+		break;
+	case ARGS_STRING:
+		expanded = args_escape(value->string);
+		args_print_add(buf, len, "%s", expanded);
+		break;
+	}
+	free(expanded);
 }
 
 /* Print a set of arguments. */
@@ -265,8 +305,7 @@
 {
 	size_t			 len;
 	char			*buf;
-	int			 i;
-	u_int			 j;
+	u_int			 i, j;
 	struct args_entry	*entry;
 	struct args_value	*value;
 
@@ -291,13 +330,13 @@
 				args_print_add(&buf, &len, " -%c", entry->flag);
 			else
 				args_print_add(&buf, &len, "-%c", entry->flag);
-			args_print_add_argument(&buf, &len, value->string);
+			args_print_add_value(&buf, &len, value);
 		}
 	}
 
 	/* And finally the argument vector. */
-	for (i = 0; i < args->argc; i++)
-		args_print_add_argument(&buf, &len, args->argv[i]);
+	for (i = 0; i < args->count; i++)
+		args_print_add_value(&buf, &len, &args->values[i]);
 
 	return (buf);
 }
@@ -363,10 +402,9 @@
 
 /* Set argument value in the arguments tree. */
 void
-args_set(struct args *args, u_char flag, const char *s)
+args_set(struct args *args, u_char flag, struct args_value *value)
 {
 	struct args_entry	*entry;
-	struct args_value	*value;
 
 	entry = args_find(args, flag);
 	if (entry == NULL) {
@@ -377,12 +415,8 @@
 		RB_INSERT(args_tree, &args->tree, entry);
 	} else
 		entry->count++;
-
-	if (s != NULL) {
-		value = xcalloc(1, sizeof *value);
-		value->string = xstrdup(s);
+	if (value != NULL && value->type != ARGS_NONE)
 		TAILQ_INSERT_TAIL(&entry->values, value, entry);
-	}
 }
 
 /* Get argument value. Will be NULL if it isn't present. */
@@ -422,16 +456,25 @@
 u_int
 args_count(struct args *args)
 {
-	return (args->argc);
+	return (args->count);
 }
 
+/* Get argument value. */
+struct args_value *
+args_value(struct args *args, u_int idx)
+{
+	if (idx >= args->count)
+		return (NULL);
+	return (&args->values[idx]);
+}
+
 /* Return argument as string. */
 const char *
 args_string(struct args *args, u_int idx)
 {
-	if (idx >= (u_int)args->argc)
+	if (idx >= (u_int)args->count)
 		return (NULL);
-	return (args->argv[idx]);
+	return (args_value_as_string(&args->values[idx]));
 }
 
 /* Get first value in argument. */