circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-12-25 10:58:48 +00:00
Code Issues Projects Releases Wiki Activity

Hide struct args behind a couple of accessor functions.

Browse Source
This commit is contained in:
nicm 2021-08-20 19:50:16 +00:00
parent de94a344f6
commit 5f32b7d961
41 changed files with 355 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
arguments.c
View File

@ -38,6 +38,12 @@ struct args_entry {
RB_ENTRY(args_entry) entry; RB_ENTRY(args_entry) entry;
}; };
struct args {
struct args_tree tree;
int argc;
char **argv;
};
static struct args_entry *args_find(struct args *, u_char); static struct args_entry *args_find(struct args *, u_char);
static int args_cmp(struct args_entry *, struct args_entry *); static int args_cmp(struct args_entry *, struct args_entry *);
@ -73,7 +79,7 @@ args_create(void)
/* Parse an argv and argc into a new argument set. */ /* Parse an argv and argc into a new argument set. */
struct args * struct args *
args_parse(const char *template, int argc, char **argv) args_parse(const char *template, int argc, char **argv, int lower, int upper)
{ {
struct args *args; struct args *args;
int opt; int opt;
@ -99,6 +105,10 @@ args_parse(const char *template, int argc, char **argv)
args->argc = argc; args->argc = argc;
args->argv = cmd_copy_argv(argc, argv); args->argv = cmd_copy_argv(argc, argv);
if ((lower != -1 && argc < lower) || (upper != -1 && argc > upper)) {
args_free(args);
return (NULL);
}
return (args); return (args);
} }
@ -126,6 +136,14 @@ args_free(struct args *args)
free(args); free(args);
} }
/* Convert arguments to vector. */
void
args_vector(struct args *args, int *argc, char ***argv)
{
*argc = args->argc;
*argv = cmd_copy_argv(args->argc, args->argv);
}
/* Add to string. */ /* Add to string. */
static void printflike(3, 4) static void printflike(3, 4)
args_print_add(char **buf, size_t *len, const char *fmt, ...) args_print_add(char **buf, size_t *len, const char *fmt, ...)
@ -145,23 +163,6 @@ args_print_add(char **buf, size_t *len, const char *fmt, ...)
free(s); free(s);
} }
/* Add value to string. */
static void
args_print_add_value(char **buf, size_t *len, struct args_entry *entry,
struct args_value *value)
{
char *escaped;
if (**buf != '\0')
args_print_add(buf, len, " -%c ", entry->flag);
else
args_print_add(buf, len, "-%c ", entry->flag);
escaped = args_escape(value->value);
args_print_add(buf, len, "%s", escaped);
free(escaped);
}
/* Add argument to string. */ /* Add argument to string. */
static void static void
args_print_add_argument(char **buf, size_t *len, const char *argument) args_print_add_argument(char **buf, size_t *len, const char *argument)
@ -203,8 +204,13 @@ args_print(struct args *args)
/* Then the flags with arguments. */ /* Then the flags with arguments. */
RB_FOREACH(entry, args_tree, &args->tree) { RB_FOREACH(entry, args_tree, &args->tree) {
TAILQ_FOREACH(value, &entry->values, entry) TAILQ_FOREACH(value, &entry->values, entry) {
args_print_add_value(&buf, &len, entry, value); if (*buf != '\0')
args_print_add(&buf, &len, " -%c", entry->flag);
else
args_print_add(&buf, &len, "-%c", entry->flag);
args_print_add_argument(&buf, &len, value->value);
}
} }
/* And finally the argument vector. */ /* And finally the argument vector. */
@ -330,6 +336,22 @@ args_next(struct args_entry **entry)
return ((*entry)->flag); return ((*entry)->flag);
} }
/* Get argument count. */
u_int
args_count(struct args *args)
{
return (args->argc);
}
/* Return argument as string. */
const char *
args_string(struct args *args, u_int idx)
{
if (idx >= (u_int)args->argc)
return (NULL);
return (args->argv[idx]);
}
/* Get first value in argument. */ /* Get first value in argument. */
struct args_value * struct args_value *
args_first_value(struct args *args, u_char flag) args_first_value(struct args *args, u_char flag)

20
cmd-bind-key.c
View File

@ -48,12 +48,13 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
key_code key; key_code key;
const char *tablename, *note = args_get(args, 'N'); const char *tablename, *note = args_get(args, 'N');
struct cmd_parse_result *pr; struct cmd_parse_result *pr;
char **argv = args->argv; char **argv;
int argc = args->argc, repeat; int argc, repeat;
u_int count = args_count(args);
key = key_string_lookup_string(argv[0]); key = key_string_lookup_string(args_string(args, 0));
if (key == KEYC_NONE || key == KEYC_UNKNOWN) { if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
cmdq_error(item, "unknown key: %s", argv[0]); cmdq_error(item, "unknown key: %s", args_string(args, 0));
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -65,11 +66,14 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
tablename = "prefix"; tablename = "prefix";
repeat = args_has(args, 'r'); repeat = args_has(args, 'r');
if (argc != 1) { if (count != 1) {
if (argc == 2) if (count == 2)
pr = cmd_parse_from_string(argv[1], NULL); pr = cmd_parse_from_string(args_string(args, 1), NULL);
else else {
args_vector(args, &argc, &argv);
pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL); pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL);
cmd_free_argv(argc, argv);
}
switch (pr->status) { switch (pr->status) {
case CMD_PARSE_EMPTY: case CMD_PARSE_EMPTY:
cmdq_error(item, "empty command"); cmdq_error(item, "empty command");

31
cmd-command-prompt.c
View File

@ -71,9 +71,10 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
const char *inputs, *prompts, *type; const char *inputs, *prompts, *type, *s;
struct cmd_command_prompt_cdata *cdata; struct cmd_command_prompt_cdata *cdata;
char *prompt, *ptr, *input = NULL; char *prompt, *comma, *input = NULL;
u_int count = args_count(args);
size_t n; size_t n;
int wait = !args_has(args, 'b'); int wait = !args_has(args, 'b');
@ -94,28 +95,30 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
if (wait) if (wait)
cdata->item = item; cdata->item = item;
if (args->argc != 0 && args_has(args, 'F')) if (count != 0) {
cdata->template = format_single_from_target(item, args->argv[0]); s = args_string(args, 0);
else if (args->argc != 0) if (args_has(args, 'F'))
cdata->template = xstrdup(args->argv[0]); cdata->template = format_single_from_target(item, s);
else else
cdata->template = xstrdup(s);
} else
cdata->template = xstrdup("%1"); cdata->template = xstrdup("%1");
if ((prompts = args_get(args, 'p')) != NULL) if ((prompts = args_get(args, 'p')) != NULL)
cdata->prompts = xstrdup(prompts); cdata->prompts = xstrdup(prompts);
else if (args->argc != 0) { else if (count != 0) {
n = strcspn(cdata->template, " ,"); n = strcspn(cdata->template, " ,");
xasprintf(&cdata->prompts, "(%.*s) ", (int) n, cdata->template); xasprintf(&cdata->prompts, "(%.*s) ", (int)n, cdata->template);
} else } else
cdata->prompts = xstrdup(":"); cdata->prompts = xstrdup(":");
/* Get first prompt. */ /* Get first prompt. */
cdata->next_prompt = cdata->prompts; cdata->next_prompt = cdata->prompts;
ptr = strsep(&cdata->next_prompt, ","); comma = strsep(&cdata->next_prompt, ",");
if (prompts == NULL) if (prompts == NULL)
prompt = xstrdup(ptr); prompt = xstrdup(comma);
else else
xasprintf(&prompt, "%s ", ptr); xasprintf(&prompt, "%s ", comma);
/* Get initial prompt input. */ /* Get initial prompt input. */
if ((inputs = args_get(args, 'I')) != NULL) { if ((inputs = args_get(args, 'I')) != NULL) {
@ -157,7 +160,7 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
int done) int done)
{ {
struct cmd_command_prompt_cdata *cdata = data; struct cmd_command_prompt_cdata *cdata = data;
char *new_template, *prompt, *ptr, *error; char *new_template, *prompt, *comma, *error;
char *input = NULL; char *input = NULL;
struct cmdq_item *item = cdata->item; struct cmdq_item *item = cdata->item;
enum cmd_parse_status status; enum cmd_parse_status status;
@ -177,8 +180,8 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
* Check if there are more prompts; if so, get its respective input * Check if there are more prompts; if so, get its respective input
* and update the prompt data. * and update the prompt data.
*/ */
if (done && (ptr = strsep(&cdata->next_prompt, ",")) != NULL) { if (done && (comma = strsep(&cdata->next_prompt, ",")) != NULL) {
xasprintf(&prompt, "%s ", ptr); xasprintf(&prompt, "%s ", comma);
input = strsep(&cdata->next_input, ","); input = strsep(&cdata->next_input, ",");
status_prompt_update(c, prompt, input); status_prompt_update(c, prompt, input);

12
cmd-confirm-before.c
View File

@ -59,22 +59,22 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_confirm_before_data *cdata; struct cmd_confirm_before_data *cdata;
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
char *cmd, *copy, *new_prompt, *ptr; char *cmd, *copy, *new_prompt, *tmp;
const char *prompt; const char *prompt;
int wait = !args_has(args, 'b'); int wait = !args_has(args, 'b');
cdata = xcalloc(1, sizeof *cdata);
cdata->cmd = xstrdup(args_string(args, 0));
if ((prompt = args_get(args, 'p')) != NULL) if ((prompt = args_get(args, 'p')) != NULL)
xasprintf(&new_prompt, "%s ", prompt); xasprintf(&new_prompt, "%s ", prompt);
else { else {
ptr = copy = xstrdup(args->argv[0]); tmp = copy = xstrdup(cdata->cmd);
cmd = strsep(&ptr, " \t"); cmd = strsep(&tmp, " \t");
xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd); xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd);
free(copy); free(copy);
} }
cdata = xcalloc(1, sizeof *cdata);
cdata->cmd = xstrdup(args->argv[0]);
cmd_get_source(self, &cdata->pi.file, &cdata->pi.line); cmd_get_source(self, &cdata->pi.file, &cdata->pi.line);
if (wait) if (wait)
cdata->pi.item = item; cdata->pi.item = item;

52
cmd-display-menu.c
View File

@ -261,10 +261,10 @@ cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct menu *menu = NULL; struct menu *menu = NULL;
struct menu_item menu_item; struct menu_item menu_item;
const char *key; const char *key, *name;
char *title, *name; char *title;
int flags = 0, i; int flags = 0;
u_int px, py; u_int px, py, i, count = args_count(args);
if (tc->overlay_draw != NULL) if (tc->overlay_draw != NULL)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
@ -275,24 +275,24 @@ cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
title = xstrdup(""); title = xstrdup("");
menu = menu_create(title); menu = menu_create(title);
for (i = 0; i != args->argc; /* nothing */) { for (i = 0; i != count; /* nothing */) {
name = args->argv[i++]; name = args_string(args, i++);
if (*name == '\0') { if (*name == '\0') {
menu_add_item(menu, NULL, item, tc, target); menu_add_item(menu, NULL, item, tc, target);
continue; continue;
} }
if (args->argc - i < 2) { if (count - i < 2) {
cmdq_error(item, "not enough arguments"); cmdq_error(item, "not enough arguments");
free(title); free(title);
menu_free(menu); menu_free(menu);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
key = args->argv[i++]; key = args_string(args, i++);
menu_item.name = name; menu_item.name = name;
menu_item.key = key_string_lookup_string(key); menu_item.key = key_string_lookup_string(key);
menu_item.command = args->argv[i++]; menu_item.command = args_string(args, i++);
menu_add_item(menu, &menu_item, item, tc, target); menu_add_item(menu, &menu_item, item, tc, target);
} }
@ -329,11 +329,10 @@ cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
struct session *s = target->s; struct session *s = target->s;
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct tty *tty = &tc->tty; struct tty *tty = &tc->tty;
const char *value, *shell[] = { NULL, NULL }; const char *value, *shell, *shellcmd = NULL;
const char *shellcmd = NULL; char *cwd, *cause, **argv = NULL;
char *cwd, *cause, **argv = args->argv; int flags = 0, argc = 0;
int flags = 0, argc = args->argc; u_int px, py, w, h, count = args_count(args);
u_int px, py, w, h;
if (args_has(args, 'C')) { if (args_has(args, 'C')) {
server_client_clear_overlay(tc); server_client_clear_overlay(tc);
@ -374,18 +373,18 @@ cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
cwd = format_single_from_target(item, value); cwd = format_single_from_target(item, value);
else else
cwd = xstrdup(server_client_get_cwd(tc, s)); cwd = xstrdup(server_client_get_cwd(tc, s));
if (argc == 0) if (count == 0)
shellcmd = options_get_string(s->options, "default-command"); shellcmd = options_get_string(s->options, "default-command");
else if (argc == 1) else if (count == 1)
shellcmd = argv[0]; shellcmd = args_string(args, 0);
if (argc <= 1 && (shellcmd == NULL || *shellcmd == '\0')) { if (count <= 1 && (shellcmd == NULL || *shellcmd == '\0')) {
shellcmd = NULL; shellcmd = NULL;
shell[0] = options_get_string(s->options, "default-shell"); shell = options_get_string(s->options, "default-shell");
if (!checkshell(shell[0])) if (!checkshell(shell))
shell[0] = _PATH_BSHELL; shell = _PATH_BSHELL;
argc = 1; cmd_append_argv(&argc, &argv, shell);
argv = (char**)shell; } else
} args_vector(args, &argc, &argv);
if (args_has(args, 'E') > 1) if (args_has(args, 'E') > 1)
flags |= POPUP_CLOSEEXITZERO; flags |= POPUP_CLOSEEXITZERO;
@ -394,7 +393,10 @@ cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
if (args_has(args, 'B')) if (args_has(args, 'B'))
flags |= POPUP_NOBORDER; flags |= POPUP_NOBORDER;
if (popup_display(flags, item, px, py, w, h, shellcmd, argc, argv, cwd, if (popup_display(flags, item, px, py, w, h, shellcmd, argc, argv, cwd,
tc, s, NULL, NULL) != 0) tc, s, NULL, NULL) != 0) {
cmd_free_argv(argc, argv);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
}
cmd_free_argv(argc, argv);
return (CMD_RETURN_WAIT); return (CMD_RETURN_WAIT);
} }

11
cmd-display-message.c
View File

@ -68,9 +68,9 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
struct window_pane *wp = target->wp; struct window_pane *wp = target->wp;
const char *template; const char *template;
char *msg, *cause; char *msg, *cause;
int delay = -1; int delay = -1, flags;
struct format_tree *ft; struct format_tree *ft;
int flags; u_int count = args_count(args);
if (args_has(args, 'I')) { if (args_has(args, 'I')) {
if (wp == NULL) if (wp == NULL)
@ -83,7 +83,7 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_WAIT); return (CMD_RETURN_WAIT);
} }
if (args_has(args, 'F') && args->argc != 0) { if (args_has(args, 'F') && count != 0) {
cmdq_error(item, "only one of -F or argument must be given"); cmdq_error(item, "only one of -F or argument must be given");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -97,9 +97,10 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
} }
} }
if (count != 0)
template = args_string(args, 0);
else
template = args_get(args, 'F'); template = args_get(args, 'F');
if (args->argc != 0)
template = args->argv[0];
if (template == NULL) if (template == NULL)
template = DISPLAY_MESSAGE_TEMPLATE; template = DISPLAY_MESSAGE_TEMPLATE;

4
cmd-display-panes.c
View File

@ -276,8 +276,8 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
delay = options_get_number(s->options, "display-panes-time"); delay = options_get_number(s->options, "display-panes-time");
cdata = xmalloc(sizeof *cdata); cdata = xmalloc(sizeof *cdata);
if (args->argc != 0) if (args_count(args))
cdata->command = xstrdup(args->argv[0]); cdata->command = xstrdup(args_string(args, 0));
else else
cdata->command = xstrdup("select-pane -t '%%'"); cdata->command = xstrdup("select-pane -t '%%'");
if (args_has(args, 'b')) if (args_has(args, 'b'))

2
cmd-find-window.c
View File

@ -47,7 +47,7 @@ cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self), *new_args; struct args *args = cmd_get_args(self), *new_args;
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct window_pane *wp = target->wp; struct window_pane *wp = target->wp;
const char *s = args->argv[0], *suffix = ""; const char *s = args_string(args, 0), *suffix = "";
char *filter; char *filter;
int C, N, T; int C, N, T;

21
cmd-if-shell.c
View File

@ -65,21 +65,20 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct cmdq_state *state = cmdq_get_state(item); struct cmdq_state *state = cmdq_get_state(item);
struct cmd_if_shell_data *cdata; struct cmd_if_shell_data *cdata;
char *shellcmd, *cmd, *error; char *shellcmd, *error;
const char *file; const char *cmd = NULL, *file;
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct session *s = target->s; struct session *s = target->s;
struct cmd_parse_input pi; struct cmd_parse_input pi;
enum cmd_parse_status status; enum cmd_parse_status status;
u_int count = args_count(args);
shellcmd = format_single_from_target(item, args->argv[0]); shellcmd = format_single_from_target(item, args_string(args, 0));
if (args_has(args, 'F')) { if (args_has(args, 'F')) {
if (*shellcmd != '0' && *shellcmd != '\0') if (*shellcmd != '0' && *shellcmd != '\0')
cmd = args->argv[1]; cmd = args_string(args, 1);
else if (args->argc == 3) else if (count == 3)
cmd = args->argv[2]; cmd = args_string(args, 2);
else
cmd = NULL;
free(shellcmd); free(shellcmd);
if (cmd == NULL) if (cmd == NULL)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
@ -101,9 +100,9 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
cdata->cmd_if = xstrdup(args->argv[1]); cdata->cmd_if = xstrdup(args_string(args, 1));
if (args->argc == 3) if (count == 3)
cdata->cmd_else = xstrdup(args->argv[2]); cdata->cmd_else = xstrdup(args_string(args, 2));
if (!args_has(args, 'b')) if (!args_has(args, 'b'))
cdata->client = cmdq_get_client(item); cdata->client = cmdq_get_client(item);

17
cmd-list-keys.c
View File

@ -150,7 +150,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct key_table *table; struct key_table *table;
struct key_binding *bd; struct key_binding *bd;
const char *tablename, *r; const char *tablename, *r, *keystr;
char *key, *cp, *tmp, *start, *empty; char *key, *cp, *tmp, *start, *empty;
key_code prefix, only = KEYC_UNKNOWN; key_code prefix, only = KEYC_UNKNOWN;
int repeat, width, tablewidth, keywidth, found = 0; int repeat, width, tablewidth, keywidth, found = 0;
@ -159,10 +159,10 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
if (cmd_get_entry(self) == &cmd_list_commands_entry) if (cmd_get_entry(self) == &cmd_list_commands_entry)
return (cmd_list_keys_commands(self, item)); return (cmd_list_keys_commands(self, item));
if (args->argc != 0) { if ((keystr = args_string(args, 0)) != NULL) {
only = key_string_lookup_string(args->argv[0]); only = key_string_lookup_string(keystr);
if (only == KEYC_UNKNOWN) { if (only == KEYC_UNKNOWN) {
cmdq_error(item, "invalid key: %s", args->argv[0]); cmdq_error(item, "invalid key: %s", keystr);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
only &= (KEYC_MASK_KEY|KEYC_MASK_MODIFIERS); only &= (KEYC_MASK_KEY|KEYC_MASK_MODIFIERS);
@ -243,6 +243,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
tmpsize = 256; tmpsize = 256;
tmp = xmalloc(tmpsize); tmp = xmalloc(tmpsize);
table = key_bindings_first_table(); table = key_bindings_first_table();
while (table != NULL) { while (table != NULL) {
if (tablename != NULL && strcmp(table->name, tablename) != 0) { if (tablename != NULL && strcmp(table->name, tablename) != 0) {
@ -307,7 +308,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
out: out:
if (only != KEYC_UNKNOWN && !found) { if (only != KEYC_UNKNOWN && !found) {
cmdq_error(item, "unknown key: %s", args->argv[0]); cmdq_error(item, "unknown key: %s", args_string(args, 0));
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
@ -320,12 +321,9 @@ cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
const struct cmd_entry **entryp; const struct cmd_entry **entryp;
const struct cmd_entry *entry; const struct cmd_entry *entry;
struct format_tree *ft; struct format_tree *ft;
const char *template, *s, *command = NULL; const char *template, *s, *command;
char *line; char *line;
if (args->argc != 0)
command = args->argv[0];
if ((template = args_get(args, 'F')) == NULL) { if ((template = args_get(args, 'F')) == NULL) {
template = "#{command_list_name}" template = "#{command_list_name}"
"#{?command_list_alias, (#{command_list_alias}),} " "#{?command_list_alias, (#{command_list_alias}),} "
@ -335,6 +333,7 @@ cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0); ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
format_defaults(ft, NULL, NULL, NULL, NULL); format_defaults(ft, NULL, NULL, NULL, NULL);
command = args_string(args, 0);
for (entryp = cmd_table; *entryp != NULL; entryp++) { for (entryp = cmd_table; *entryp != NULL; entryp++) {
entry = *entryp; entry = *entryp;
if (command != NULL && if (command != NULL &&

2
cmd-load-buffer.c
View File

@ -105,7 +105,7 @@ cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
cdata->client->references++; cdata->client->references++;
} }
path = format_single_from_target(item, args->argv[0]); path = format_single_from_target(item, args_string(args, 0));
file_read(cmdq_get_client(item), path, cmd_load_buffer_done, cdata); file_read(cmdq_get_client(item), path, cmd_load_buffer_done, cdata);
free(path); free(path);

14
cmd-new-session.c
View File

@ -79,8 +79,8 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
char *cause, *cwd = NULL, *cp, *newname = NULL; char *cause, *cwd = NULL, *cp, *newname = NULL;
char *name, *prefix = NULL; char *name, *prefix = NULL;
int detached, already_attached, is_control = 0; int detached, already_attached, is_control = 0;
u_int sx, sy, dsx, dsy; u_int sx, sy, dsx, dsy, count = args_count(args);
struct spawn_context sc; struct spawn_context sc = { 0 };
enum cmd_retval retval; enum cmd_retval retval;
struct cmd_find_state fs; struct cmd_find_state fs;
struct args_value *av; struct args_value *av;
@ -93,7 +93,7 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }
if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n'))) { if (args_has(args, 't') && (count != 0 || args_has(args, 'n'))) {
cmdq_error(item, "command or window name given with target"); cmdq_error(item, "command or window name given with target");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -277,15 +277,13 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
s = session_create(prefix, newname, cwd, env, oo, tiop); s = session_create(prefix, newname, cwd, env, oo, tiop);
/* Spawn the initial window. */ /* Spawn the initial window. */
memset(&sc, 0, sizeof sc);
sc.item = item; sc.item = item;
sc.s = s; sc.s = s;
if (!detached) if (!detached)
sc.tc = c; sc.tc = c;
sc.name = args_get(args, 'n'); sc.name = args_get(args, 'n');
sc.argc = args->argc; args_vector(args, &sc.argc, &sc.argv);
sc.argv = args->argv;
sc.idx = -1; sc.idx = -1;
sc.cwd = args_get(args, 'c'); sc.cwd = args_get(args, 'c');
@ -358,12 +356,16 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
cmd_find_from_session(&fs, s, 0); cmd_find_from_session(&fs, s, 0);
cmdq_insert_hook(s, item, &fs, "after-new-session"); cmdq_insert_hook(s, item, &fs, "after-new-session");
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
free(cwd); free(cwd);
free(newname); free(newname);
free(prefix); free(prefix);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
fail: fail:
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
free(cwd); free(cwd);
free(newname); free(newname);
free(prefix); free(prefix);

13
cmd-new-window.c
View File

@ -55,12 +55,11 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
struct client *c = cmdq_get_client(item); struct client *c = cmdq_get_client(item);
struct cmd_find_state *current = cmdq_get_current(item); struct cmd_find_state *current = cmdq_get_current(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct spawn_context sc; struct spawn_context sc = { 0 };
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct session *s = target->s; struct session *s = target->s;
struct winlink *wl = target->wl; struct winlink *wl = target->wl, *new_wl = NULL;
int idx = target->idx, before; int idx = target->idx, before;
struct winlink *new_wl = NULL;
char *cause = NULL, *cp; char *cause = NULL, *cp;
const char *template, *name; const char *template, *name;
struct cmd_find_state fs; struct cmd_find_state fs;
@ -101,14 +100,12 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
idx = target->idx; idx = target->idx;
} }
memset(&sc, 0, sizeof sc);
sc.item = item; sc.item = item;
sc.s = s; sc.s = s;
sc.tc = tc; sc.tc = tc;
sc.name = args_get(args, 'n'); sc.name = args_get(args, 'n');
sc.argc = args->argc; args_vector(args, &sc.argc, &sc.argv);
sc.argv = args->argv;
sc.environ = environ_create(); sc.environ = environ_create();
av = args_first_value(args, 'e'); av = args_first_value(args, 'e');
@ -129,6 +126,8 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
if ((new_wl = spawn_window(&sc, &cause)) == NULL) { if ((new_wl = spawn_window(&sc, &cause)) == NULL) {
cmdq_error(item, "create window failed: %s", cause); cmdq_error(item, "create window failed: %s", cause);
free(cause); free(cause);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -150,6 +149,8 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
cmd_find_from_winlink(&fs, new_wl, 0); cmd_find_from_winlink(&fs, new_wl, 0);
cmdq_insert_hook(s, item, &fs, "after-new-window"); cmdq_insert_hook(s, item, &fs, "after-new-window");
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }

4
cmd-pipe-pane.c
View File

@ -82,7 +82,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
} }
/* If no pipe command, that is enough. */ /* If no pipe command, that is enough. */
if (args->argc == 0 || *args->argv[0] == '\0') if (args_count(args) == 0 || *args_string(args, 0) == '\0')
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
/* /*
@ -112,7 +112,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
/* Expand the command. */ /* Expand the command. */
ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0); ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
format_defaults(ft, tc, s, wl, wp); format_defaults(ft, tc, s, wl, wp);
cmd = format_expand_time(ft, args->argv[0]); cmd = format_expand_time(ft, args_string(args, 0));
format_free(ft); format_free(ft);
/* Fork the child. */ /* Fork the child. */

6
cmd-queue.c
View File

@ -357,7 +357,7 @@ cmdq_insert_hook(struct session *s, struct cmdq_item *item,
struct options *oo; struct options *oo;
va_list ap; va_list ap;
char *name, tmp[32], flag, *arguments; char *name, tmp[32], flag, *arguments;
int i; u_int i;
const char *value; const char *value;
struct cmdq_item *new_item; struct cmdq_item *new_item;
struct cmdq_state *new_state; struct cmdq_state *new_state;
@ -394,9 +394,9 @@ cmdq_insert_hook(struct session *s, struct cmdq_item *item,
cmdq_add_format(new_state, "hook_arguments", "%s", arguments); cmdq_add_format(new_state, "hook_arguments", "%s", arguments);
free(arguments); free(arguments);
for (i = 0; i < args->argc; i++) { for (i = 0; i < args_count(args); i++) {
xsnprintf(tmp, sizeof tmp, "hook_argument_%d", i); xsnprintf(tmp, sizeof tmp, "hook_argument_%d", i);
cmdq_add_format(new_state, tmp, "%s", args->argv[i]); cmdq_add_format(new_state, tmp, "%s", args_string(args, i));
} }
flag = args_first(args, &ae); flag = args_first(args, &ae);
while (flag != 0) { while (flag != 0) {

5
cmd-refresh-client.c
View File

@ -127,10 +127,11 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
args_has(args, 'U') || args_has(args, 'U') ||
args_has(args, 'D')) args_has(args, 'D'))
{ {
if (args->argc == 0) if (args_count(args) == 0)
adjust = 1; adjust = 1;
else { else {
adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr); adjust = strtonum(args_string(args, 0), 1, INT_MAX,
&errstr);
if (errstr != NULL) { if (errstr != NULL) {
cmdq_error(item, "adjustment %s", errstr); cmdq_error(item, "adjustment %s", errstr);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);

2
cmd-rename-session.c
View File

@ -51,7 +51,7 @@ cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
struct session *s = target->s; struct session *s = target->s;
char *newname, *tmp; char *newname, *tmp;
tmp = format_single_from_target(item, args->argv[0]); tmp = format_single_from_target(item, args_string(args, 0));
newname = session_check_name(tmp); newname = session_check_name(tmp);
if (newname == NULL) { if (newname == NULL) {
cmdq_error(item, "invalid session: %s", tmp); cmdq_error(item, "invalid session: %s", tmp);

2
cmd-rename-window.c
View File

@ -50,7 +50,7 @@ cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
struct winlink *wl = target->wl; struct winlink *wl = target->wl;
char *newname; char *newname;
newname = format_single_from_target(item, args->argv[0]); newname = format_single_from_target(item, args_string(args, 0));
window_set_name(wl->window, newname); window_set_name(wl->window, newname);
options_set_number(wl->window->options, "automatic-rename", 0); options_set_number(wl->window->options, "automatic-rename", 0);

5
cmd-resize-pane.c
View File

@ -95,10 +95,11 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
} }
server_unzoom_window(w); server_unzoom_window(w);
if (args->argc == 0) if (args_count(args) == 0)
adjust = 1; adjust = 1;
else { else {
adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr); adjust = strtonum(args_string(args, 0), 1, INT_MAX,
&errstr);
if (errstr != NULL) { if (errstr != NULL) {
cmdq_error(item, "adjustment %s", errstr); cmdq_error(item, "adjustment %s", errstr);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);

5
cmd-resize-window.c
View File

@ -56,10 +56,11 @@ cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
u_int adjust, sx, sy; u_int adjust, sx, sy;
int xpixel = -1, ypixel = -1; int xpixel = -1, ypixel = -1;
if (args->argc == 0) if (args_count(args) == 0)
adjust = 1; adjust = 1;
else { else {
adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr); adjust = strtonum(args_string(args, 0), 1, INT_MAX,
&errstr);
if (errstr != NULL) { if (errstr != NULL) {
cmdq_error(item, "adjustment %s", errstr); cmdq_error(item, "adjustment %s", errstr);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);

10
cmd-respawn-pane.c
View File

@ -49,14 +49,13 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
{ {
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct spawn_context sc; struct spawn_context sc = { 0 };
struct session *s = target->s; struct session *s = target->s;
struct winlink *wl = target->wl; struct winlink *wl = target->wl;
struct window_pane *wp = target->wp; struct window_pane *wp = target->wp;
char *cause = NULL; char *cause = NULL;
struct args_value *av; struct args_value *av;
memset(&sc, 0, sizeof sc);
sc.item = item; sc.item = item;
sc.s = s; sc.s = s;
sc.wl = wl; sc.wl = wl;
@ -65,8 +64,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
sc.lc = NULL; sc.lc = NULL;
sc.name = NULL; sc.name = NULL;
sc.argc = args->argc; args_vector(args, &sc.argc, &sc.argv);
sc.argv = args->argv;
sc.environ = environ_create(); sc.environ = environ_create();
av = args_first_value(args, 'e'); av = args_first_value(args, 'e');
@ -85,6 +83,8 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
if (spawn_pane(&sc, &cause) == NULL) { if (spawn_pane(&sc, &cause) == NULL) {
cmdq_error(item, "respawn pane failed: %s", cause); cmdq_error(item, "respawn pane failed: %s", cause);
free(cause); free(cause);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -93,6 +93,8 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
server_redraw_window_borders(wp->window); server_redraw_window_borders(wp->window);
server_status_window(wp->window); server_status_window(wp->window);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }

10
cmd-respawn-window.c
View File

@ -49,22 +49,20 @@ cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
{ {
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct spawn_context sc; struct spawn_context sc = { 0 };
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct session *s = target->s; struct session *s = target->s;
struct winlink *wl = target->wl; struct winlink *wl = target->wl;
char *cause = NULL; char *cause = NULL;
struct args_value *av; struct args_value *av;
memset(&sc, 0, sizeof sc);
sc.item = item; sc.item = item;
sc.s = s; sc.s = s;
sc.wl = wl; sc.wl = wl;
sc.tc = tc; sc.tc = tc;
sc.name = NULL; sc.name = NULL;
sc.argc = args->argc; args_vector(args, &sc.argc, &sc.argv);
sc.argv = args->argv;
sc.environ = environ_create(); sc.environ = environ_create();
av = args_first_value(args, 'e'); av = args_first_value(args, 'e');
@ -83,12 +81,16 @@ cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
if (spawn_window(&sc, &cause) == NULL) { if (spawn_window(&sc, &cause) == NULL) {
cmdq_error(item, "respawn window failed: %s", cause); cmdq_error(item, "respawn window failed: %s", cause);
free(cause); free(cause);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
server_redraw_window(wl->window); server_redraw_window(wl->window);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }

7
cmd-run-shell.c
View File

@ -104,6 +104,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
double d; double d;
struct timeval tv; struct timeval tv;
char *end; char *end;
const char *cmd = args_string(args, 0);
int wait = !args_has(args, 'b'); int wait = !args_has(args, 'b');
if ((delay = args_get(args, 'd')) != NULL) { if ((delay = args_get(args, 'd')) != NULL) {
@ -112,12 +113,12 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
cmdq_error(item, "invalid delay time: %s", delay); cmdq_error(item, "invalid delay time: %s", delay);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
} else if (args->argc == 0) } else if (args_count(args) == 0)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
if (args->argc != 0) if (cmd != NULL)
cdata->cmd = format_single_from_target(item, args->argv[0]); cdata->cmd = format_single_from_target(item, cmd);
cdata->shell = !args_has(args, 'C'); cdata->shell = !args_has(args, 'C');
if (!cdata->shell) { if (!cdata->shell) {

2
cmd-save-buffer.c
View File

@ -105,7 +105,7 @@ cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
} }
path = xstrdup("-"); path = xstrdup("-");
} else } else
path = format_single_from_target(item, args->argv[0]); path = format_single_from_target(item, args_string(args, 0));
if (args_has(args, 'a')) if (args_has(args, 'a'))
flags = O_APPEND; flags = O_APPEND;
else else

18
cmd-select-layout.c
View File

@ -105,24 +105,24 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
goto changed; goto changed;
} }
if (args_count(args) != 0)
layoutname = args_string(args, 0);
else if (args_has(args, 'o'))
layoutname = oldlayout;
else
layoutname = NULL;
if (!args_has(args, 'o')) { if (!args_has(args, 'o')) {
if (args->argc == 0) if (layoutname == NULL)
layout = w->lastlayout; layout = w->lastlayout;
else else
layout = layout_set_lookup(args->argv[0]); layout = layout_set_lookup(layoutname);
if (layout != -1) { if (layout != -1) {
layout_set_select(w, layout); layout_set_select(w, layout);
goto changed; goto changed;
} }
} }
if (args->argc != 0)
layoutname = args->argv[0];
else if (args_has(args, 'o'))
layoutname = oldlayout;
else
layoutname = NULL;
if (layoutname != NULL) { if (layoutname != NULL) {
if (layout_parse(w, layoutname) == -1) { if (layout_parse(w, layoutname) == -1) {
cmdq_error(item, "can't set layout: %s", layoutname); cmdq_error(item, "can't set layout: %s", layoutname);

10
cmd-send-keys.c
View File

@ -90,7 +90,7 @@ static struct cmdq_item *
cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after, cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after,
struct args *args, int i) struct args *args, int i)
{ {
const char *s = args->argv[i]; const char *s = args_string(args, i);
struct utf8_data *ud, *loop; struct utf8_data *ud, *loop;
utf8_char uc; utf8_char uc;
key_code key; key_code key;
@ -145,9 +145,9 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
struct mouse_event *m = &event->m; struct mouse_event *m = &event->m;
struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes); struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
struct cmdq_item *after = item; struct cmdq_item *after = item;
int i;
key_code key; key_code key;
u_int np = 1; u_int i, np = 1;
u_int count = args_count(args);
char *cause = NULL; char *cause = NULL;
if (args_has(args, 'N')) { if (args_has(args, 'N')) {
@ -157,7 +157,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
free(cause); free(cause);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
if (wme != NULL && (args_has(args, 'X') || args->argc == 0)) { if (wme != NULL && (args_has(args, 'X') || count == 0)) {
if (wme->mode->command == NULL) { if (wme->mode->command == NULL) {
cmdq_error(item, "not in a mode"); cmdq_error(item, "not in a mode");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
@ -203,7 +203,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
} }
for (; np != 0; np--) { for (; np != 0; np--) {
for (i = 0; i < args->argc; i++) { for (i = 0; i < count; i++) {
after = cmd_send_keys_inject_string(item, after, args, after = cmd_send_keys_inject_string(item, after, args,
i); i);
} }

6
cmd-set-buffer.c
View File

@ -94,11 +94,11 @@ cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }
if (args->argc != 1) { if (args_count(args) != 1) {
cmdq_error(item, "no data specified"); cmdq_error(item, "no data specified");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
if ((newsize = strlen(args->argv[0])) == 0) if ((newsize = strlen(args_string(args, 0))) == 0)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
bufsize = 0; bufsize = 0;
@ -111,7 +111,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
} }
bufdata = xrealloc(bufdata, bufsize + newsize); bufdata = xrealloc(bufdata, bufsize + newsize);
memcpy(bufdata + bufsize, args->argv[0], newsize); memcpy(bufdata + bufsize, args_string(args, 0), newsize);
bufsize += newsize; bufsize += newsize;
if (paste_set(bufdata, bufsize, bufname, &cause) != 0) { if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {

19
cmd-set-environment.c
View File

@ -49,11 +49,11 @@ cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct environ *env; struct environ *env;
const char *name, *value, *tflag; const char *name = args_string(args, 0), *value;
char *expand = NULL; const char *tflag;
char *expanded = NULL;
enum cmd_retval retval = CMD_RETURN_NORMAL; enum cmd_retval retval = CMD_RETURN_NORMAL;
name = args->argv[0];
if (*name == '\0') { if (*name == '\0') {
cmdq_error(item, "empty variable name"); cmdq_error(item, "empty variable name");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
@ -63,13 +63,14 @@ cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
if (args->argc < 2) if (args_count(args) < 2)
value = NULL; value = NULL;
else if (args_has(args, 'F'))
value = expand = format_single_from_target(item, args->argv[1]);
else else
value = args->argv[1]; value = args_string(args, 1);
if (value != NULL && args_has(args, 'F')) {
expanded = format_single_from_target(item, value);
value = expanded;
}
if (args_has(args, 'g')) if (args_has(args, 'g'))
env = global_environ; env = global_environ;
else { else {
@ -113,6 +114,6 @@ cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
} }
out: out:
free(expand); free(expanded);
return (retval); return (retval);
} }

20
cmd-set-option.c
View File

@ -77,14 +77,16 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
struct window_pane *loop; struct window_pane *loop;
struct options *oo; struct options *oo;
struct options_entry *parent, *o, *po; struct options_entry *parent, *o, *po;
char *name, *argument, *value = NULL, *cause; char *name, *argument, *expanded = NULL;
char *cause;
const char *value;
int window, idx, already, error, ambiguous; int window, idx, already, error, ambiguous;
int scope; int scope;
window = (cmd_get_entry(self) == &cmd_set_window_option_entry); window = (cmd_get_entry(self) == &cmd_set_window_option_entry);
/* Expand argument. */ /* Expand argument. */
argument = format_single_from_target(item, args->argv[0]); argument = format_single_from_target(item, args_string(args, 0));
/* If set-hook -R, fire the hook straight away. */ /* If set-hook -R, fire the hook straight away. */
if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'R')) { if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'R')) {
@ -104,12 +106,14 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
cmdq_error(item, "invalid option: %s", argument); cmdq_error(item, "invalid option: %s", argument);
goto fail; goto fail;
} }
if (args->argc < 2) if (args_count(args) < 2)
value = NULL; value = NULL;
else if (args_has(args, 'F'))
value = format_single_from_target(item, args->argv[1]);
else else
value = xstrdup(args->argv[1]); value = args_string(args, 1);
if (value != NULL && args_has(args, 'F')) {
expanded = format_single_from_target(item, value);
value = expanded;
}
/* Get the scope and table for the option .*/ /* Get the scope and table for the option .*/
scope = options_scope_from_name(args, window, name, target, &oo, scope = options_scope_from_name(args, window, name, target, &oo,
@ -211,13 +215,13 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
out: out:
free(argument); free(argument);
free(value); free(expanded);
free(name); free(name);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
fail: fail:
free(argument); free(argument);
free(value); free(expanded);
free(name); free(name);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }

8
cmd-show-environment.c
View File

@ -101,7 +101,7 @@ cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct environ *env; struct environ *env;
struct environ_entry *envent; struct environ_entry *envent;
const char *tflag; const char *tflag, *name = args_string(args, 0);
if ((tflag = args_get(args, 't')) != NULL) { if ((tflag = args_get(args, 't')) != NULL) {
if (target->s == NULL) { if (target->s == NULL) {
@ -124,10 +124,10 @@ cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
env = target->s->environ; env = target->s->environ;
} }
if (args->argc != 0) { if (name != NULL) {
envent = environ_find(env, args->argv[0]); envent = environ_find(env, name);
if (envent == NULL) { if (envent == NULL) {
cmdq_error(item, "unknown variable: %s", args->argv[0]); cmdq_error(item, "unknown variable: %s", name);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
cmd_show_environment_print(self, item, envent); cmd_show_environment_print(self, item, envent);

4
cmd-show-options.c
View File

@ -86,7 +86,7 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
window = (cmd_get_entry(self) == &cmd_show_window_options_entry); window = (cmd_get_entry(self) == &cmd_show_window_options_entry);
if (args->argc == 0) { if (args_count(args) == 0) {
scope = options_scope_from_flags(args, window, target, &oo, scope = options_scope_from_flags(args, window, target, &oo,
&cause); &cause);
if (scope == OPTIONS_TABLE_NONE) { if (scope == OPTIONS_TABLE_NONE) {
@ -98,7 +98,7 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
} }
return (cmd_show_options_all(self, item, scope, oo)); return (cmd_show_options_all(self, item, scope, oo));
} }
argument = format_single_from_target(item, args->argv[0]); argument = format_single_from_target(item, args_string(args, 0));
name = options_match(argument, &idx, &ambiguous); name = options_match(argument, &idx, &ambiguous);
if (name == NULL) { if (name == NULL) {

20
cmd-source-file.c
View File

@ -129,11 +129,11 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_source_file_data *cdata; struct cmd_source_file_data *cdata;
struct client *c = cmdq_get_client(item); struct client *c = cmdq_get_client(item);
enum cmd_retval retval = CMD_RETURN_NORMAL; enum cmd_retval retval = CMD_RETURN_NORMAL;
char *pattern, *cwd, *expand = NULL; char *pattern, *cwd, *expanded = NULL;
const char *path, *error; const char *path, *error;
glob_t g; glob_t g;
int i, result; int result;
u_int j; u_int i, j;
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
cdata->item = item; cdata->item = item;
@ -147,13 +147,13 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB); utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB);
for (i = 0; i < args->argc; i++) { for (i = 0; i < args_count(args); i++) {
path = args_string(args, i);
if (args_has(args, 'F')) { if (args_has(args, 'F')) {
free(expand); free(expanded);
expand = format_single_from_target(item, args->argv[i]); expanded = format_single_from_target(item, path);
path = expand; path = expanded;
} else }
path = args->argv[i];
if (strcmp(path, "-") == 0) { if (strcmp(path, "-") == 0) {
cmd_source_file_add(cdata, "-"); cmd_source_file_add(cdata, "-");
continue; continue;
@ -180,7 +180,7 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
free(pattern); free(pattern);
continue; continue;
} }
free(expand); free(expanded);
free(pattern); free(pattern);
for (j = 0; j < g.gl_pathc; j++) for (j = 0; j < g.gl_pathc; j++)

17
cmd-split-window.c
View File

@ -56,7 +56,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct cmd_find_state *current = cmdq_get_current(item); struct cmd_find_state *current = cmdq_get_current(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct spawn_context sc; struct spawn_context sc = { 0 };
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct session *s = target->s; struct session *s = target->s;
struct winlink *wl = target->wl; struct winlink *wl = target->wl;
@ -69,6 +69,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
char *cause, *cp, *copy; char *cause, *cp, *copy;
size_t plen; size_t plen;
struct args_value *av; struct args_value *av;
u_int count = args_count(args);
if (args_has(args, 'h')) if (args_has(args, 'h'))
type = LAYOUT_LEFTRIGHT; type = LAYOUT_LEFTRIGHT;
@ -112,14 +113,14 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
size = -1; size = -1;
window_push_zoom(wp->window, 1, args_has(args, 'Z')); window_push_zoom(wp->window, 1, args_has(args, 'Z'));
input = (args_has(args, 'I') && args->argc == 0); input = (args_has(args, 'I') && count == 0);
flags = 0; flags = 0;
if (args_has(args, 'b')) if (args_has(args, 'b'))
flags |= SPAWN_BEFORE; flags |= SPAWN_BEFORE;
if (args_has(args, 'f')) if (args_has(args, 'f'))
flags |= SPAWN_FULLSIZE; flags |= SPAWN_FULLSIZE;
if (input || (args->argc == 1 && *args->argv[0] == '\0')) if (input || (count == 1 && *args_string(args, 0) == '\0'))
flags |= SPAWN_EMPTY; flags |= SPAWN_EMPTY;
lc = layout_split_pane(wp, type, size, flags); lc = layout_split_pane(wp, type, size, flags);
@ -128,7 +129,6 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
memset(&sc, 0, sizeof sc);
sc.item = item; sc.item = item;
sc.s = s; sc.s = s;
sc.wl = wl; sc.wl = wl;
@ -137,8 +137,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
sc.lc = lc; sc.lc = lc;
sc.name = NULL; sc.name = NULL;
sc.argc = args->argc; args_vector(args, &sc.argc, &sc.argv);
sc.argv = args->argv;
sc.environ = environ_create(); sc.environ = environ_create();
av = args_first_value(args, 'e'); av = args_first_value(args, 'e');
@ -159,6 +158,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
if ((new_wp = spawn_pane(&sc, &cause)) == NULL) { if ((new_wp = spawn_pane(&sc, &cause)) == NULL) {
cmdq_error(item, "create pane failed: %s", cause); cmdq_error(item, "create pane failed: %s", cause);
free(cause); free(cause);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -168,6 +169,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
window_remove_pane(wp->window, new_wp); window_remove_pane(wp->window, new_wp);
cmdq_error(item, "%s", cause); cmdq_error(item, "%s", cause);
free(cause); free(cause);
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@ -188,6 +191,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
cmd_find_from_winlink_pane(&fs, wl, new_wp, 0); cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
cmdq_insert_hook(s, item, &fs, "after-split-window"); cmdq_insert_hook(s, item, &fs, "after-split-window");
if (sc.argv != NULL)
cmd_free_argv(sc.argc, sc.argv);
environ_free(sc.environ); environ_free(sc.environ);
if (input) if (input)
return (CMD_RETURN_WAIT); return (CMD_RETURN_WAIT);

10
cmd-unbind-key.c
View File

@ -44,11 +44,11 @@ cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
{ {
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
key_code key; key_code key;
const char *tablename; const char *tablename, *keystr = args_string(args, 0);
int quiet = args_has(args, 'q'); int quiet = args_has(args, 'q');
if (args_has(args, 'a')) { if (args_has(args, 'a')) {
if (args->argc != 0) { if (keystr != NULL) {
if (!quiet) if (!quiet)
cmdq_error(item, "key given with -a"); cmdq_error(item, "key given with -a");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
@ -73,16 +73,16 @@ cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }
if (args->argc != 1) { if (keystr == NULL) {
if (!quiet) if (!quiet)
cmdq_error(item, "missing key"); cmdq_error(item, "missing key");
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
key = key_string_lookup_string(args->argv[0]); key = key_string_lookup_string(keystr);
if (key == KEYC_NONE || key == KEYC_UNKNOWN) { if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
if (!quiet) if (!quiet)
cmdq_error(item, "unknown key: %s", args->argv[0]); cmdq_error(item, "unknown key: %s", keystr);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }

8
cmd-wait-for.c
View File

@ -121,11 +121,11 @@ static enum cmd_retval
cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item) cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
{ {
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
const char *name = args->argv[0]; const char *name = args_string(args, 0);
struct wait_channel *wc, wc0; struct wait_channel *wc, find;
wc0.name = name; find.name = name;
wc = RB_FIND(wait_channels, &wait_channels, &wc0); wc = RB_FIND(wait_channels, &wait_channels, &find);
if (args_has(args, 'S')) if (args_has(args, 'S'))
return (cmd_wait_for_signal(item, name, wc)); return (cmd_wait_for_signal(item, name, wc));

7
cmd.c
View File

@ -518,13 +518,10 @@ cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
return (NULL); return (NULL);
cmd_log_argv(argc, argv, "%s: %s", __func__, entry->name); cmd_log_argv(argc, argv, "%s: %s", __func__, entry->name);
args = args_parse(entry->args.template, argc, argv); args = args_parse(entry->args.template, argc, argv, entry->args.lower,
entry->args.upper);
if (args == NULL) if (args == NULL)
goto usage; goto usage;
if (entry->args.lower != -1 && args->argc < entry->args.lower)
goto usage;
if (entry->args.upper != -1 && args->argc > entry->args.upper)
goto usage;
cmd = xcalloc(1, sizeof *cmd); cmd = xcalloc(1, sizeof *cmd);
cmd->entry = entry; cmd->entry = entry;

10
tmux.h
View File

@ -1364,11 +1364,6 @@ struct args_value {
/* Arguments set. */ /* Arguments set. */
struct args_entry; struct args_entry;
RB_HEAD(args_tree, args_entry); RB_HEAD(args_tree, args_entry);
struct args {
struct args_tree tree;
int argc;
char **argv;
};
/* Command find structures. */ /* Command find structures. */
enum cmd_find_type { enum cmd_find_type {
@ -2188,7 +2183,8 @@ int tty_keys_next(struct tty *);
/* arguments.c */ /* arguments.c */
void args_set(struct args *, u_char, const char *); void args_set(struct args *, u_char, const char *);
struct args *args_create(void); struct args *args_create(void);
struct args *args_parse(const char *, int, char **); struct args *args_parse(const char *, int, char **, int, int);
void args_vector(struct args *, int *, char ***);
void args_free(struct args *); void args_free(struct args *);
char *args_print(struct args *); char *args_print(struct args *);
char *args_escape(const char *); char *args_escape(const char *);
@ -2196,6 +2192,8 @@ int args_has(struct args *, u_char);
const char *args_get(struct args *, u_char); const char *args_get(struct args *, u_char);
u_char args_first(struct args *, struct args_entry **); u_char args_first(struct args *, struct args_entry **);
u_char args_next(struct args_entry **); u_char args_next(struct args_entry **);
u_int args_count(struct args *);
const char *args_string(struct args *, u_int);
struct args_value *args_first_value(struct args *, u_char); struct args_value *args_first_value(struct args *, u_char);
struct args_value *args_next_value(struct args_value *); struct args_value *args_next_value(struct args_value *);
long long args_strtonum(struct args *, u_char, long long, long long, long long args_strtonum(struct args *, u_char, long long, long long,

4
window-buffer.c
View File

@ -343,10 +343,10 @@ window_buffer_init(struct window_mode_entry *wme, struct cmd_find_state *fs,
data->key_format = xstrdup(WINDOW_BUFFER_DEFAULT_KEY_FORMAT); data->key_format = xstrdup(WINDOW_BUFFER_DEFAULT_KEY_FORMAT);
else else
data->key_format = xstrdup(args_get(args, 'K')); data->key_format = xstrdup(args_get(args, 'K'));
if (args == NULL || args->argc == 0) if (args == NULL || args_count(args) == 0)
data->command = xstrdup(WINDOW_BUFFER_DEFAULT_COMMAND); data->command = xstrdup(WINDOW_BUFFER_DEFAULT_COMMAND);
else else
data->command = xstrdup(args->argv[0]); data->command = xstrdup(args_string(args, 0));
data->data = mode_tree_start(wp, args, window_buffer_build, data->data = mode_tree_start(wp, args, window_buffer_build,
window_buffer_draw, window_buffer_search, window_buffer_menu, NULL, window_buffer_draw, window_buffer_search, window_buffer_menu, NULL,

4
window-client.c
View File

@ -303,10 +303,10 @@ window_client_init(struct window_mode_entry *wme,
data->key_format = xstrdup(WINDOW_CLIENT_DEFAULT_KEY_FORMAT); data->key_format = xstrdup(WINDOW_CLIENT_DEFAULT_KEY_FORMAT);
else else
data->key_format = xstrdup(args_get(args, 'K')); data->key_format = xstrdup(args_get(args, 'K'));
if (args == NULL || args->argc == 0) if (args == NULL || args_count(args) == 0)
data->command = xstrdup(WINDOW_CLIENT_DEFAULT_COMMAND); data->command = xstrdup(WINDOW_CLIENT_DEFAULT_COMMAND);
else else
data->command = xstrdup(args->argv[0]); data->command = xstrdup(args_string(args, 0));
data->data = mode_tree_start(wp, args, window_client_build, data->data = mode_tree_start(wp, args, window_client_build,
window_client_draw, NULL, window_client_menu, NULL, window_client_draw, NULL, window_client_menu, NULL,

153
window-copy.c
View File

@ -842,15 +842,14 @@ window_copy_expand_search_string(struct window_copy_cmd_state *cs)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
const char *argument; const char *ss = args_string(cs->args, 1);
char *expanded; char *expanded;
if (cs->args->argc == 2) { if (ss == NULL || *ss == '\0')
argument = cs->args->argv[1]; return (0);
if (*argument != '\0') {
if (args_has(cs->args, 'F')) { if (args_has(cs->args, 'F')) {
expanded = format_single(NULL, argument, NULL, expanded = format_single(NULL, ss, NULL, NULL, NULL, wme->wp);
NULL, NULL, wme->wp);
if (*expanded == '\0') { if (*expanded == '\0') {
free(expanded); free(expanded);
return (0); return (0);
@ -859,9 +858,7 @@ window_copy_expand_search_string(struct window_copy_cmd_state *cs)
data->searchstr = expanded; data->searchstr = expanded;
} else { } else {
free(data->searchstr); free(data->searchstr);
data->searchstr = xstrdup(argument); data->searchstr = xstrdup(ss);
}
}
} }
return (1); return (1);
} }
@ -963,24 +960,25 @@ window_copy_do_copy_end_of_line(struct window_copy_cmd_state *cs, int pipe,
int cancel) int cancel)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
int argc = cs->args->argc;
char **argv = cs->args->argv;
struct client *c = cs->c; struct client *c = cs->c;
struct session *s = cs->s; struct session *s = cs->s;
struct winlink *wl = cs->wl; struct winlink *wl = cs->wl;
struct window_pane *wp = wme->wp; struct window_pane *wp = wme->wp;
u_int count = args_count(cs->args);
u_int np = wme->prefix, ocx, ocy, ooy; u_int np = wme->prefix, ocx, ocy, ooy;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
char *prefix = NULL, *command = NULL; char *prefix = NULL, *command = NULL;
const char *arg1 = args_string(cs->args, 1);
const char *arg2 = args_string(cs->args, 2);
if (pipe) { if (pipe) {
if (argc == 3) if (count == 3)
prefix = format_single(NULL, argv[2], c, s, wl, wp); prefix = format_single(NULL, arg2, c, s, wl, wp);
if (s != NULL && argc > 1 && *argv[1] != '\0') if (s != NULL && count > 1 && *arg1 != '\0')
command = format_single(NULL, argv[1], c, s, wl, wp); command = format_single(NULL, arg1, c, s, wl, wp);
} else { } else {
if (argc == 2) if (count == 2)
prefix = format_single(NULL, argv[1], c, s, wl, wp); prefix = format_single(NULL, arg1, c, s, wl, wp);
} }
ocx = data->cx; ocx = data->cx;
@ -1044,24 +1042,25 @@ static enum window_copy_cmd_action
window_copy_do_copy_line(struct window_copy_cmd_state *cs, int pipe, int cancel) window_copy_do_copy_line(struct window_copy_cmd_state *cs, int pipe, int cancel)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
int argc = cs->args->argc;
char **argv = cs->args->argv;
struct client *c = cs->c; struct client *c = cs->c;
struct session *s = cs->s; struct session *s = cs->s;
struct winlink *wl = cs->wl; struct winlink *wl = cs->wl;
struct window_pane *wp = wme->wp; struct window_pane *wp = wme->wp;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
u_int count = args_count(cs->args);
u_int np = wme->prefix, ocx, ocy, ooy; u_int np = wme->prefix, ocx, ocy, ooy;
char *prefix = NULL, *command = NULL; char *prefix = NULL, *command = NULL;
const char *arg1 = args_string(cs->args, 1);
const char *arg2 = args_string(cs->args, 2);
if (pipe) { if (pipe) {
if (argc == 3) if (count == 3)
prefix = format_single(NULL, argv[2], c, s, wl, wp); prefix = format_single(NULL, arg2, c, s, wl, wp);
if (s != NULL && argc > 1 && *argv[1] != '\0') if (s != NULL && count > 1 && *arg1 != '\0')
command = format_single(NULL, argv[1], c, s, wl, wp); command = format_single(NULL, arg1, c, s, wl, wp);
} else { } else {
if (argc == 2) if (count == 2)
prefix = format_single(NULL, argv[1], c, s, wl, wp); prefix = format_single(NULL, arg1, c, s, wl, wp);
} }
ocx = data->cx; ocx = data->cx;
@ -1131,9 +1130,10 @@ window_copy_cmd_copy_selection_no_clear(struct window_copy_cmd_state *cs)
struct winlink *wl = cs->wl; struct winlink *wl = cs->wl;
struct window_pane *wp = wme->wp; struct window_pane *wp = wme->wp;
char *prefix = NULL; char *prefix = NULL;
const char *arg1 = args_string(cs->args, 1);
if (cs->args->argc == 2) if (arg1 != NULL)
prefix = format_single(NULL, cs->args->argv[1], c, s, wl, wp); prefix = format_single(NULL, arg1, c, s, wl, wp);
if (s != NULL) if (s != NULL)
window_copy_copy_selection(wme, prefix); window_copy_copy_selection(wme, prefix);
@ -1968,14 +1968,15 @@ window_copy_cmd_copy_pipe_no_clear(struct window_copy_cmd_state *cs)
struct session *s = cs->s; struct session *s = cs->s;
struct winlink *wl = cs->wl; struct winlink *wl = cs->wl;
struct window_pane *wp = wme->wp; struct window_pane *wp = wme->wp;
char *command = NULL; char *command = NULL, *prefix = NULL;
char *prefix = NULL; const char *arg1 = args_string(cs->args, 1);
const char *arg2 = args_string(cs->args, 2);
if (cs->args->argc == 3) if (arg2 != NULL)
prefix = format_single(NULL, cs->args->argv[2], c, s, wl, wp); prefix = format_single(NULL, arg2, c, s, wl, wp);
if (s != NULL && cs->args->argc > 1 && *cs->args->argv[1] != '\0') if (s != NULL && arg1 != NULL && *arg1 != '\0')
command = format_single(NULL, cs->args->argv[1], c, s, wl, wp); command = format_single(NULL, arg1, c, s, wl, wp);
window_copy_copy_pipe(wme, s, prefix, command); window_copy_copy_pipe(wme, s, prefix, command);
free(command); free(command);
@ -2012,9 +2013,10 @@ window_copy_cmd_pipe_no_clear(struct window_copy_cmd_state *cs)
struct winlink *wl = cs->wl; struct winlink *wl = cs->wl;
struct window_pane *wp = wme->wp; struct window_pane *wp = wme->wp;
char *command = NULL; char *command = NULL;
const char *arg1 = args_string(cs->args, 1);
if (s != NULL && cs->args->argc > 1 && *cs->args->argv[1] != '\0') if (s != NULL && arg1 != NULL && *arg1 != '\0')
command = format_single(NULL, cs->args->argv[1], c, s, wl, wp); command = format_single(NULL, arg1, c, s, wl, wp);
window_copy_pipe(wme, s, command); window_copy_pipe(wme, s, command);
free(command); free(command);
@ -2045,10 +2047,10 @@ static enum window_copy_cmd_action
window_copy_cmd_goto_line(struct window_copy_cmd_state *cs) window_copy_cmd_goto_line(struct window_copy_cmd_state *cs)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
if (*argument != '\0') if (*arg1 != '\0')
window_copy_goto_line(wme, argument); window_copy_goto_line(wme, arg1);
return (WINDOW_COPY_CMD_NOTHING); return (WINDOW_COPY_CMD_NOTHING);
} }
@ -2058,12 +2060,12 @@ window_copy_cmd_jump_backward(struct window_copy_cmd_state *cs)
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
u_int np = wme->prefix; u_int np = wme->prefix;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
if (*argument != '\0') { if (*arg1 != '\0') {
data->jumptype = WINDOW_COPY_JUMPBACKWARD; data->jumptype = WINDOW_COPY_JUMPBACKWARD;
free(data->jumpchar); free(data->jumpchar);
data->jumpchar = utf8_fromcstr(argument); data->jumpchar = utf8_fromcstr(arg1);
for (; np != 0; np--) for (; np != 0; np--)
window_copy_cursor_jump_back(wme); window_copy_cursor_jump_back(wme);
} }
@ -2076,12 +2078,12 @@ window_copy_cmd_jump_forward(struct window_copy_cmd_state *cs)
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
u_int np = wme->prefix; u_int np = wme->prefix;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
if (*argument != '\0') { if (*arg1 != '\0') {
data->jumptype = WINDOW_COPY_JUMPFORWARD; data->jumptype = WINDOW_COPY_JUMPFORWARD;
free(data->jumpchar); free(data->jumpchar);
data->jumpchar = utf8_fromcstr(argument); data->jumpchar = utf8_fromcstr(arg1);
for (; np != 0; np--) for (; np != 0; np--)
window_copy_cursor_jump(wme); window_copy_cursor_jump(wme);
} }
@ -2094,12 +2096,12 @@ window_copy_cmd_jump_to_backward(struct window_copy_cmd_state *cs)
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
u_int np = wme->prefix; u_int np = wme->prefix;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
if (*argument != '\0') { if (*arg1 != '\0') {
data->jumptype = WINDOW_COPY_JUMPTOBACKWARD; data->jumptype = WINDOW_COPY_JUMPTOBACKWARD;
free(data->jumpchar); free(data->jumpchar);
data->jumpchar = utf8_fromcstr(argument); data->jumpchar = utf8_fromcstr(arg1);
for (; np != 0; np--) for (; np != 0; np--)
window_copy_cursor_jump_to_back(wme); window_copy_cursor_jump_to_back(wme);
} }
@ -2112,12 +2114,12 @@ window_copy_cmd_jump_to_forward(struct window_copy_cmd_state *cs)
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
u_int np = wme->prefix; u_int np = wme->prefix;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
if (*argument != '\0') { if (*arg1 != '\0') {
data->jumptype = WINDOW_COPY_JUMPTOFORWARD; data->jumptype = WINDOW_COPY_JUMPTOFORWARD;
free(data->jumpchar); free(data->jumpchar);
data->jumpchar = utf8_fromcstr(argument); data->jumpchar = utf8_fromcstr(arg1);
for (; np != 0; np--) for (; np != 0; np--)
window_copy_cursor_jump_to(wme); window_copy_cursor_jump_to(wme);
} }
@ -2218,27 +2220,27 @@ window_copy_cmd_search_backward_incremental(struct window_copy_cmd_state *cs)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
const char *ss = data->searchstr; const char *ss = data->searchstr;
char prefix; char prefix;
enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING; enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING;
data->timeout = 0; data->timeout = 0;
log_debug("%s: %s", __func__, argument); log_debug("%s: %s", __func__, arg1);
prefix = *argument++; prefix = *arg1++;
if (data->searchx == -1 || data->searchy == -1) { if (data->searchx == -1 || data->searchy == -1) {
data->searchx = data->cx; data->searchx = data->cx;
data->searchy = data->cy; data->searchy = data->cy;
data->searcho = data->oy; data->searcho = data->oy;
} else if (ss != NULL && strcmp(argument, ss) != 0) { } else if (ss != NULL && strcmp(arg1, ss) != 0) {
data->cx = data->searchx; data->cx = data->searchx;
data->cy = data->searchy; data->cy = data->searchy;
data->oy = data->searcho; data->oy = data->searcho;
action = WINDOW_COPY_CMD_REDRAW; action = WINDOW_COPY_CMD_REDRAW;
} }
if (*argument == '\0') { if (*arg1 == '\0') {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
} }
@ -2248,7 +2250,7 @@ window_copy_cmd_search_backward_incremental(struct window_copy_cmd_state *cs)
data->searchtype = WINDOW_COPY_SEARCHUP; data->searchtype = WINDOW_COPY_SEARCHUP;
data->searchregex = 0; data->searchregex = 0;
free(data->searchstr); free(data->searchstr);
data->searchstr = xstrdup(argument); data->searchstr = xstrdup(arg1);
if (!window_copy_search_up(wme, 0)) { if (!window_copy_search_up(wme, 0)) {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
@ -2258,7 +2260,7 @@ window_copy_cmd_search_backward_incremental(struct window_copy_cmd_state *cs)
data->searchtype = WINDOW_COPY_SEARCHDOWN; data->searchtype = WINDOW_COPY_SEARCHDOWN;
data->searchregex = 0; data->searchregex = 0;
free(data->searchstr); free(data->searchstr);
data->searchstr = xstrdup(argument); data->searchstr = xstrdup(arg1);
if (!window_copy_search_down(wme, 0)) { if (!window_copy_search_down(wme, 0)) {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
@ -2273,27 +2275,27 @@ window_copy_cmd_search_forward_incremental(struct window_copy_cmd_state *cs)
{ {
struct window_mode_entry *wme = cs->wme; struct window_mode_entry *wme = cs->wme;
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
const char *argument = cs->args->argv[1]; const char *arg1 = args_string(cs->args, 1);
const char *ss = data->searchstr; const char *ss = data->searchstr;
char prefix; char prefix;
enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING; enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING;
data->timeout = 0; data->timeout = 0;
log_debug("%s: %s", __func__, argument); log_debug("%s: %s", __func__, arg1);
prefix = *argument++; prefix = *arg1++;
if (data->searchx == -1 || data->searchy == -1) { if (data->searchx == -1 || data->searchy == -1) {
data->searchx = data->cx; data->searchx = data->cx;
data->searchy = data->cy; data->searchy = data->cy;
data->searcho = data->oy; data->searcho = data->oy;
} else if (ss != NULL && strcmp(argument, ss) != 0) { } else if (ss != NULL && strcmp(arg1, ss) != 0) {
data->cx = data->searchx; data->cx = data->searchx;
data->cy = data->searchy; data->cy = data->searchy;
data->oy = data->searcho; data->oy = data->searcho;
action = WINDOW_COPY_CMD_REDRAW; action = WINDOW_COPY_CMD_REDRAW;
} }
if (*argument == '\0') { if (*arg1 == '\0') {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
} }
@ -2303,7 +2305,7 @@ window_copy_cmd_search_forward_incremental(struct window_copy_cmd_state *cs)
data->searchtype = WINDOW_COPY_SEARCHDOWN; data->searchtype = WINDOW_COPY_SEARCHDOWN;
data->searchregex = 0; data->searchregex = 0;
free(data->searchstr); free(data->searchstr);
data->searchstr = xstrdup(argument); data->searchstr = xstrdup(arg1);
if (!window_copy_search_down(wme, 0)) { if (!window_copy_search_down(wme, 0)) {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
@ -2313,7 +2315,7 @@ window_copy_cmd_search_forward_incremental(struct window_copy_cmd_state *cs)
data->searchtype = WINDOW_COPY_SEARCHUP; data->searchtype = WINDOW_COPY_SEARCHUP;
data->searchregex = 0; data->searchregex = 0;
free(data->searchstr); free(data->searchstr);
data->searchstr = xstrdup(argument); data->searchstr = xstrdup(arg1);
if (!window_copy_search_up(wme, 0)) { if (!window_copy_search_up(wme, 0)) {
window_copy_clear_marks(wme); window_copy_clear_marks(wme);
return (WINDOW_COPY_CMD_REDRAW); return (WINDOW_COPY_CMD_REDRAW);
@ -2342,8 +2344,8 @@ window_copy_cmd_refresh_from_pane(struct window_copy_cmd_state *cs)
static const struct { static const struct {
const char *command; const char *command;
int minargs; u_int minargs;
int maxargs; u_int maxargs;
enum window_copy_cmd_clear clear; enum window_copy_cmd_clear clear;
enum window_copy_cmd_action (*f)(struct window_copy_cmd_state *); enum window_copy_cmd_action (*f)(struct window_copy_cmd_state *);
} window_copy_cmd_table[] = { } window_copy_cmd_table[] = {
@ -2833,13 +2835,12 @@ window_copy_command(struct window_mode_entry *wme, struct client *c,
enum window_copy_cmd_action action; enum window_copy_cmd_action action;
enum window_copy_cmd_clear clear = WINDOW_COPY_CMD_CLEAR_NEVER; enum window_copy_cmd_clear clear = WINDOW_COPY_CMD_CLEAR_NEVER;
const char *command; const char *command;
u_int i; u_int i, count = args_count(args);
int keys; int keys;
if (args->argc == 0) if (count == 0)
return; return;
command = args->argv[0]; command = args_string(args, 0);
if (m != NULL && m->valid && !MOUSE_WHEEL(m->b)) if (m != NULL && m->valid && !MOUSE_WHEEL(m->b))
window_copy_move_mouse(m); window_copy_move_mouse(m);
@ -2854,8 +2855,8 @@ window_copy_command(struct window_mode_entry *wme, struct client *c,
action = WINDOW_COPY_CMD_NOTHING; action = WINDOW_COPY_CMD_NOTHING;
for (i = 0; i < nitems(window_copy_cmd_table); i++) { for (i = 0; i < nitems(window_copy_cmd_table); i++) {
if (strcmp(window_copy_cmd_table[i].command, command) == 0) { if (strcmp(window_copy_cmd_table[i].command, command) == 0) {
if (args->argc - 1 < window_copy_cmd_table[i].minargs || if (count - 1 < window_copy_cmd_table[i].minargs ||
args->argc - 1 > window_copy_cmd_table[i].maxargs) count - 1 > window_copy_cmd_table[i].maxargs)
break; break;
clear = window_copy_cmd_table[i].clear; clear = window_copy_cmd_table[i].clear;
action = window_copy_cmd_table[i].f(&cs); action = window_copy_cmd_table[i].f(&cs);
@ -5188,14 +5189,16 @@ window_copy_cursor_previous_word(struct window_mode_entry *wme,
const char *separators, int already) const char *separators, int already)
{ {
struct window_copy_mode_data *data = wme->data; struct window_copy_mode_data *data = wme->data;
struct window *w = wme->wp->window;
struct screen *back_s = data->backing; struct screen *back_s = data->backing;
struct grid_reader gr; struct grid_reader gr;
u_int px, py, oldy, hsize; u_int px, py, oldy, hsize;
int stop_at_eol; int stop_at_eol;
stop_at_eol = if (options_get_number(w->options, "mode-keys") == MODEKEY_EMACS)
options_get_number(wme->wp->window->options, "mode-keys") stop_at_eol = 1;
== MODEKEY_EMACS; else
stop_at_eol = 0;
px = data->cx; px = data->cx;
hsize = screen_hsize(back_s); hsize = screen_hsize(back_s);

4
window-tree.c
View File

@ -925,10 +925,10 @@ window_tree_init(struct window_mode_entry *wme, struct cmd_find_state *fs,
data->key_format = xstrdup(WINDOW_TREE_DEFAULT_KEY_FORMAT); data->key_format = xstrdup(WINDOW_TREE_DEFAULT_KEY_FORMAT);
else else
data->key_format = xstrdup(args_get(args, 'K')); data->key_format = xstrdup(args_get(args, 'K'));
if (args == NULL || args->argc == 0) if (args == NULL || args_count(args) == 0)
data->command = xstrdup(WINDOW_TREE_DEFAULT_COMMAND); data->command = xstrdup(WINDOW_TREE_DEFAULT_COMMAND);
else else
data->command = xstrdup(args->argv[0]); data->command = xstrdup(args_string(args, 0));
data->squash_groups = !args_has(args, 'G'); data->squash_groups = !args_has(args, 'G');
data->data = mode_tree_start(wp, args, window_tree_build, data->data = mode_tree_start(wp, args, window_tree_build,